Sublime Text 2 es un editor extensible con una API de Python . Puede crear nuevos comandos (llamados complementos ) y ponerlos a disposición desde la interfaz de usuario.
Agregar un complemento de filtrado de texto básico a TextCommand
En Sublime Text 2, seleccione Tools »New Plugin e ingrese el siguiente texto:
import sublime, sublime_plugin
def filter(v, e, needle):
# get non-empty selections
regions = [s for s in v.sel() if not s.empty()]
# if there's no non-empty selection, filter the whole document
if len(regions) == 0:
regions = [ sublime.Region(0, v.size()) ]
for region in reversed(regions):
lines = v.split_by_newlines(region)
for line in reversed(lines):
if not needle in v.substr(line):
v.erase(e, v.full_line(line))
class FilterCommand(sublime_plugin.TextCommand):
def run(self, edit):
def done(needle):
e = self.view.begin_edit()
filter(self.view, e, needle)
self.view.end_edit(e)
cb = sublime.get_clipboard()
sublime.active_window().show_input_panel("Filter file for lines containing: ", cb, done, None, None)
Guardar como filter.pyen~/Library/Application Support/Sublime Text 2/Packages/User
Integración con UI
Para agregar este complemento al menú Editar , seleccione Preferencias ... »Buscar paquetes y abra la Usercarpeta. Si Main.sublime-menuno existe un archivo llamado , créelo. Agregue o establezca el siguiente texto en ese archivo:
[
{
"id": "edit",
"children":
[
{"id": "wrap"},
{ "command": "filter" }
]
}
]
Esto insertará la filterllamada al comando (esencialmente, filterse transforma FilterCommand().run(…)para la llamada del complemento y Filtro para la etiqueta del menú) justo debajo del wrapcomando. Vea el paso 11 aquí para obtener una explicación más detallada de por qué.
Para asignar un atajo de teclado, abra y edite el archivo Default (OSX).sublime-keymapen OS X, o el equivalente para otros sistemas, e ingrese lo siguiente:
[
{
"keys": ["ctrl+shift+f"], "command": "filter"
}
]
Esto asignará el acceso directo ⌃⇧Fa este comando.
Para que el comando aparezca en la Paleta de comandos , debe crear un archivo llamado Default.sublime-commands(o editar uno existente) en la Usercarpeta. La sintaxis es similar al archivo de menú que acaba de editar:
[
{ "caption": "Filter Lines in File", "command": "filter" }
]
Las entradas múltiples (encerradas entre llaves) deben estar separadas por comas.
Capturas de pantalla de comportamiento e integración de UI
El comando, tal como se implementa, filtrará todas las líneas que forman parte de una selección (las líneas completas, no solo las partes seleccionadas) o, si no existe una selección, el búfer completo, para una subcadena que se ingresa en el campo de entrada ( el valor predeterminado es el portapapeles de varias líneas, posiblemente inútil, después de que se active el comando. Se puede ampliar fácilmente para, por ejemplo, admitir expresiones regulares, o solo dejar líneas que no coincidan con una determinada expresión.
Opción del menú
Entrada de paleta de comandos
Editor
Agregar soporte para expresiones regulares
Para agregar soporte para expresiones regulares, use los siguientes scripts y fragmentos en su lugar:
filter.py:
import sublime, sublime_plugin, re
def matches(needle, haystack, is_re):
if is_re:
return re.match(needle, haystack)
else:
return (needle in haystack)
def filter(v, e, needle, is_re = False):
# get non-empty selections
regions = [s for s in v.sel() if not s.empty()]
# if there's no non-empty selection, filter the whole document
if len(regions) == 0:
regions = [ sublime.Region(0, v.size()) ]
for region in reversed(regions):
lines = v.split_by_newlines(region)
for line in reversed(lines):
if not matches(needle, v.substr(line), is_re):
v.erase(e, v.full_line(line))
class FilterCommand(sublime_plugin.TextCommand):
def run(self, edit):
def done(needle):
e = self.view.begin_edit()
filter(self.view, e, needle)
self.view.end_edit(e)
cb = sublime.get_clipboard()
sublime.active_window().show_input_panel("Filter file for lines containing: ", cb, done, None, None)
class FilterUsingRegularExpressionCommand(sublime_plugin.TextCommand):
def run(self, edit):
def done(needle):
e = self.view.begin_edit()
filter(self.view, e, needle, True)
self.view.end_edit(e)
cb = sublime.get_clipboard()
sublime.active_window().show_input_panel("Filter file for lines matching: ", cb, done, None, None)
Main.sublime-menu:
[
{
"id": "edit",
"children":
[
{"id": "wrap"},
{ "command": "filter" },
{ "command": "filter_using_regular_expression" }
]
}
]
Default (OSX).sublime-keymap:
[
{
"keys": ["ctrl+shift+f"], "command": "filter"
},
{
"keys": ["ctrl+shift+option+f"], "command": "filter_using_regular_expression"
}
]
Se agregará un segundo comando de complemento, Filtro con expresión regular , debajo de la entrada del menú Filtro .
Default.sublime-commands:
[
{ "caption": "Filter Lines in File", "command": "filter" },
{ "caption": "Filter Lines in File Using Regular Expression", "command": "filter_using_regular_expression" }
]
También hay un algoritmo de filtrado de línea de un hombre pobre (¿o es vago?):
fuente
Ahora hay un complemento para filtrar líneas: https://github.com/davidpeckham/FilterLines
Permite el filtrado y el plegado de código en función de cadenas o expresiones regulares.
fuente
Puede usar las capacidades integradas de Sublime para hacer esto en 3 a 7 pulsaciones de teclas (sin incluir la expresión regular que se va a combinar).
Paso 1: seleccione varias líneas coincidentes
Opción 1: para seleccionar múltiples todas las líneas que contienen una subcadena
Opción 2: para seleccionar múltiples todas las líneas que coinciden con una expresión regular
Paso 2: haz algo con esas líneas
Opción 1: eliminar todas las líneas que no están seleccionadas
Opción 2: Para deshacerse de todas las líneas que se seleccionan
Opción 3: extraer líneas seleccionadas a un nuevo archivo
fuente