Manejar los espacios y las comillas correctamente en la finalización de bash

Question

¿Cuál es la forma correcta/mejor de manejar espacios y comillas en la finalización de bash?

Aquí hay un ejemplo simple. Tengo un comando llamado words (por ejemplo, un programa de búsqueda de diccionario) que toma varias palabras como argumentos. Las 'palabras' apoyados en realidad pueden contener espacios, y se define en un archivo llamado words.dat:

foo 
bar one 
bar two 

Aquí está mi primera solución sugerida:

_find_words() 
{ 
search="$cur" 
grep -- "^$search" words.dat 
} 

_words_complete() 
{ 
local IFS=$'\n' 

COMPREPLY=() 
cur="${COMP_WORDS[COMP_CWORD]}" 

COMPREPLY=($(compgen -W "$(_find_words)" -- "$cur")) 

} 
complete -F _words_complete words 

Typing ‘words f<tab>’ completa correctamente el comando para ‘words foo ’ (con una espacio final), que es bueno, pero para ‘words b<tab>’ sugiere ‘words bar ’. La finalización correcta sería ‘words bar\ ’. Y para ‘words "b<tab>’ y ‘words 'b<tab>’ no ofrece sugerencias.

Esta última parte que he podido resolver. Es posible usar eval para analizar correctamente los caracteres (escapados). Sin embargo, eval no es aficionado a las frases que faltan, así que para obtener todo funcione, he tenido que cambiar el search="$cur" a

search=$(eval echo "$cur" 2>/dev/null || 
eval echo "$cur'" 2>/dev/null || 
eval echo "$cur\"" 2>/dev/null || "") 

Esto funciona en realidad. Ambos ‘words "b<tab>’ y ‘words 'b<tab>’ se autocompletan correctamente, y si agrego un ‘o’ y presiono <tab> nuevamente, en realidad completa la palabra y agrega la cita de cierre correcta. Sin embargo, si intento completar ‘words b<tab>’ o incluso ‘words bar\ <tab>’, se autocompleta a ‘words bar ’ en lugar de ‘words bar\ ’, y al agregar, por ejemplo, ‘one’, se produce un error cuando se ejecuta el programa words.

Ahora, obviamente es es posible manejar esto correctamente. Por ejemplo, el comando ls puede hacerlo para los archivos námned ‘foo’‘bar one’ y ‘bar two’ (aunque tiene problemas con algunas formas de expresar los nombres de archivo cuando se usa una combinación (válida) de ", ' y varios escapes). Sin embargo, no pude entender cómo lo hace ls leyendo el código de finalización de bash.

Entonces, ¿alguien sabe cómo manejar esto correctamente? Las cotizaciones de entrada reales no necesitan conservarse; Estaría contento con una solución que cambia ‘words "b<tab>’, ‘words 'b<tab>’ y ‘words b<tab>’ a ‘words bar\ ’, por ejemplo, (aunque preferiría omitir las comillas, como en este ejemplo, en lugar de agregarlas).

Answer 1

Esta solución de posprocesamiento no demasiado elegante parece funcionar para mí (GNU bash, versión 3.1.17 (6) -release (i686-pc-cygwin)). (A menos que no haya probado algunos casos de borde como de costumbre :))

No es necesario evaluar cosas, solo hay 2 tipos de citas.

Dado que compgen no quiere escapar espacios para nosotros, los escaparemos nosotros mismos (solo si la palabra no comenzó con un presupuesto). Esto tiene un efecto secundario de la lista completa (en la doble pestaña) que también tiene valores de escape. No estoy seguro si eso es bueno o no, ya que ls no lo hace ...

EDITAR: Se corrigió para manejar los qoutes simples y dobles dentro de las palabras. Esencialmente tenemos que pasar 3 descubrimientos :).Primero para grep, segundo para compgen, y último para palabras en sí mismo cuando se completa la autocompletación.

_find_words() 
{ 
    search=$(eval echo "$cur" 2>/dev/null || eval echo "$cur'" 2>/dev/null || eval echo "$cur\"" 2>/dev/null || "") 
    grep -- "^$search" words.dat | sed -e "{" -e 's#\\#\\\\#g' -e "s#'#\\\'#g" -e 's#"#\\\"#g' -e "}" 
} 

_words_complete() 
{ 
    local IFS=$'\n' 

    COMPREPLY=() 
    local cur="${COMP_WORDS[COMP_CWORD]}" 

    COMPREPLY=($(compgen -W "$(_find_words)" -- "$cur")) 

    local escaped_single_qoute="'\''" 
    local i=0 
    for entry in ${COMPREPLY[*]} 
    do 
     if [[ "${cur:0:1}" == "'" ]] 
     then 
      # started with single quote, escaping only other single quotes 
      # [']bla'bla"bla\bla bla --> [']bla'\''bla"bla\bla bla 
      COMPREPLY[$i]="${entry//\'/${escaped_single_qoute}}" 
     elif [[ "${cur:0:1}" == "\"" ]] 
     then 
      # started with double quote, escaping all double quotes and all backslashes 
      # ["]bla'bla"bla\bla bla --> ["]bla'bla\"bla\\bla bla 
      entry="${entry//\\/\\\\}" 
      COMPREPLY[$i]="${entry//\"/\\\"}" 
     else 
      # no quotes in front, escaping _everything_ 
      # [ ]bla'bla"bla\bla bla --> [ ]bla\'bla\"bla\\bla\ bla 
      entry="${entry//\\/\\\\}" 
      entry="${entry//\'/\'}" 
      entry="${entry//\"/\\\"}" 
      COMPREPLY[$i]="${entry// /\\ }" 
     fi 
     ((i++)) 
    done 
} 

Answer 2

Me encontré en una situación similar y busqué alto y bajo para la respuesta a esta discrepancia. Aquí está la respuesta que se me ocurrió.

ls, o más bien, la rutina de finalización predeterminado lo hace utilizando la funcionalidad -o filenames, que realiza:. procesamiento-nombre de archivo específico (como la adición de una barra de nombres de directorio o suprimir los espacios finales

por ejemplo

$ foo() { COMPREPLY=("bar one" "bar two"); } 
$ complete -o filenames -F foo words 
$ words ░ 

Tab

$ words bar\ ░   # Ex.1: notice the space is completed escaped 

Tab Tab

bar one bar two  # Ex.2: notice the spaces are displayed unescaped 
$ words bar\ ░ 

Teniendo en cuenta la situación de la OP, la elección parece ser:

1. Uso -o filenames. Sin embargo, si hay un directorio con el mismo nombre que la palabra correspondiente, la palabra completa tendrá una barra arbitraria al final. (por ejemplo, bar\ one/)
2. Escapar manualmente como en la respuesta de @ Eugene, y aceptar que los candidatos se mostrarán como escapados.

Por cierto, hay una manera más fácil para escapar de palabras a partir de printf "%q":

por ejemplo, 2

$ bar() { 
>  foo 
>  local IFS=$'\n' 
>  COMPREPLY=($(printf "%q\n" "${COMPREPLY[@]}")) 
> } 
$ complete -F bar words 
$ words ░ 

Tab

$ words bar\ ░ 

TabTab

bar\ one bar\ two  # Ex.3: notice the spaces are displayed escaped 
$ words bar\ ░ 

Answer 3

_foo() 
{ 
    words="bar one"$'\n'"bar two" 
    COMPREPLY=() 
    cur=${COMP_WORDS[COMP_CWORD]} 
    prev=${COMP_WORDS[COMP_CWORD-1]} 
    cur=${cur//\./\\\.} 

    local IFS=$'\n' 
    COMPREPLY=($(grep -i "^$cur" <(echo "$words") | sed -e 's/ /\\ /g')) 
    return 0 
} 

complete -o bashdefault -o default -o nospace -F _foo words 

Answer 4

Pipe _find_words º áspero sed y haga que encierre cada línea entre comillas. Y al escribir una línea de comando, asegúrese de poner " o ' antes de una palabra para completar con pestañas, de lo contrario, este método no funcionará.línea de

_find_words() { cat words.dat; } 

_words_complete() 
{ 

    COMPREPLY=() 
    cur="${COMP_WORDS[COMP_CWORD]}" 

    local IFS=$'\n' 
    COMPREPLY=($(compgen -W "$(_find_words | sed 's/^/\x27/; s/$/\x27/')" \ 
         -- "$cur")) 

} 

complete -F _words_complete words 

Comando:

$ words "ba░ 

pestaña

$ words "bar ░ 

pestañapestaña

bar one bar two 
$ words "bar o░ 

pestaña

$ words "bar one" ░ 

Answer 5

He resuelto mediante la creación de mi propia compgen2 función que maneja el procesamiento adicional cuando la palabra actual no comienza con un carácter de comillas. de lo contrario, funciona de manera similar a compgen -W.

compgen2() { 
    local IFS=$'\n' 
    local a=($(compgen -W "$1" -- "$2")) 
    local i="" 
    if [ "${2:0:1}" = "\"" -o "${2:0:1}" = "'" ]; then 
     for i in "${a[@]}"; do 
      echo "$i" 
     done 
    else 
     for i in "${a[@]}"; do 
      printf "%q\n" "$i" 
     done 
    fi 
} 

_foo() { 
    local cur=${COMP_WORDS[COMP_CWORD]} 
    local prev=${COMP_WORDS[COMP_CWORD-1]} 
    local words=$(cat words.dat) 
    local IFS=$'\n' 
    COMPREPLY=($(compgen2 "$words" "$cur")) 
} 

echo -en "foo\nbar one\nbar two\n" > words.dat 
complete -F _foo foo