bash завершение табуляции с пробелами

Если вам нужно обработать данные из строки, вы можете использовать встроенный в Bash оператор замены строки.

function _test() {
    local iter use cur
    cur=${COMP_WORDS[COMP_CWORD]}
    use="nick\ mason syd-barrett david_gilmour roger\ waters richard\ wright"
    # swap out escaped spaces temporarily
    use="${use//\\ /___}"
    # split on all spaces
    for iter in $use; do
        # only reply with completions
        if [[ $iter =~ ^$cur ]]; then
            # swap back our escaped spaces
            COMPREPLY+=( "${iter//___/ }" )
        fi
    done
}

Пользовательские слова, завершающие табуляцию, которые могут включать пробелы, раздражающе сложны. И, насколько я знаю, элегантного решения нет. Возможно, какая-то будущая версия compgen будет достаточно любезна, чтобы создавать массив, а не выводить возможности по одной строке за раз, и даже принимать аргумент списка слов из массива. Но до тех пор может помочь следующий подход.

Важно понимать проблему, заключающуюся в том, что ( $(compgen ... ) ) представляет собой массив, полученный путем разделения вывода команды compgen на символы в $IFS, которые по умолчанию представляют собой любые пробельные символы. Итак, если compgen возвращает:

roger waters
richard wright

тогда COMPREPLY будет фактически установлен в массив (roger waters richard wright), всего четыре возможных завершения. Если вместо этого вы используете ( "$(compgen ...)"), то COMPREPLY будет установлен в массив ($'roger waters\nrichard wright'), который имеет только одно возможное завершение (с новой строкой внутри завершения). Ни то, ни другое не то, что вы хотите.

Если ни одно из возможных завершений не имеет символа новой строки, вы можете договориться о том, чтобы возврат compgen был разделен на символ новой строки, временно сбросив IFS, а затем восстановив его. Но я думаю, что более элегантным решением будет просто использовать mapfile:

_test () { 
    cur=${COMP_WORDS[COMP_CWORD]};
    use=`pink`;
    ## See note at end of answer w.r.t. "$cur" ##
    mapfile -t COMPREPLY < <( compgen -W "$use" -- "$cur" )
}

Команда mapfile помещает строки, отправленные compgen в stdout, в массив COMPREPLY. (Опция -t приводит к удалению завершающей новой строки из каждой строки, что почти всегда требуется при использовании mapfile. Дополнительные параметры см. в help mapfile.)

Это не решает другую раздражающую часть проблемы, заключающуюся в преобразовании списка слов в форму, приемлемую для compgen. Поскольку compgen не допускает множественных опций -W и не принимает массив, единственным вариантом является форматирование строки таким образом, чтобы bash разбиение на слова (с кавычками и всем остальным) генерировало желаемый список. По сути, это означает добавление escape-последовательности вручную, как вы сделали в своей функции pink:

pink() {
    echo "nick\ mason syd-barrett david_gilmour roger\ waters richard\ wright"
}

Но это подвержено несчастным случаям и раздражает. Лучшее решение позволило бы напрямую указывать альтернативы, особенно если альтернативы генерируются каким-то образом. Хороший способ создания альтернатив, которые могут включать пробелы, — поместить их в массив. Имея массив, вы можете эффективно использовать формат %q printf для создания входной строки с правильными кавычками для compgen -W:

# This is a proxy for a database query or some such which produces the alternatives
cat >/tmp/pink <<EOP
nick mason
syd-barrett
david_gilmour
roger waters
richard wright
EOP

# Generate an array with the alternatives
mapfile -t pink </tmp/pink

# Use printf to turn the array into a quoted string:
_test () { 
    mapfile -t COMPREPLY < <( compgen -W "$(printf '%q ' "${pink[@]}")" -- "$2" )
}

Как написано, эта функция завершения не выводит завершения в форме, которая будет принята bash как отдельные слова. Другими словами, завершение roger waters генерируется как roger waters вместо roger\ waters. В (вероятном) случае, когда цель состоит в том, чтобы создать правильно цитируемые завершения, необходимо добавить escape-последовательности во второй раз после того, как compgen отфильтрует список завершения:

_test () {
    declare -a completions
    mapfile -t completions < <( compgen -W "$(printf '%q ' "${pink[@]}")" -- "$2" )
    local comp
    COMPREPLY=()
    for comp in "${completions[@]}"; do
        COMPREPLY+=("$(printf "%q" "$comp")")
    done
}

Примечание. Я заменил вычисление $cur на $2, так как функция, вызываемая через complete -F, получает команду как $1, а слово завершается как $2. (Предыдущее слово также передается как $3.) Кроме того, важно заключать его в кавычки, чтобы оно не разделялось на слова на пути к compgen.

Окей, эта сумасшедшая штуковина во многом опирается на решение rici и не только полностью работает, но и цитирует любые дополнения, которые в ней нуждаются, и только.

pink() {
    # simulating actual awk output
    echo "nick mason"
    echo "syd-barrett"
    echo "david_gilmour"
    echo "roger waters"
    echo "richard wright"
}

_test() {
  cur=${COMP_WORDS[COMP_CWORD]}
  mapfile -t patterns < <( pink )
  mapfile -t COMPREPLY < <( compgen -W "$( printf '%q ' "${patterns[@]}" )" -- "$cur" | awk '/ / { print "\""$0"\"" } /^[^ ]+$/ { print $0 }' )
}

complete -F _test test

Насколько я мог его протестировать, он полностью реализует ls-подобное поведение, за исключением частей, специфичных для пути.

Подробный пример

Вот более подробная версия функции _test, чтобы она стала более понятной:

_test() {
  local cur escapedPatterns
  cur=${COMP_WORDS[COMP_CWORD]}
  mapfile -t patterns < <( pink )
  escapedPatterns="$( printf '%q ' "${patterns[@]}" )"
  mapfile -t COMPREPLY < <( compgen -W "$escapedPatterns" -- "$cur" | quoteIfNeeded )
}

quoteIfNeeded() {
  # Only if it contains spaces. Otherwise return as-is.
  awk '/ / { print "\""$0"\"" } /^[^ ]+$/ { print $0 }'
}

Ничто из этого даже отдаленно не оптимизировано для эффективности. Опять же, это только завершение табуляции, и оно не вызывает заметной задержки для любого достаточно большого списка завершений.

Он работает:

1. Извлечение вывода awk в массив с использованием mapfile.
2. Экранирование массива и помещение его в строку.
3. Наличие одного пробела за %q в качестве маркера разделения.
4. Цитирую $cur, Очень важно!
5. Цитируя вывод compgen. И только если он содержит пробелы.
6. Передача этого вывода в COMPREPLY с использованием еще одного вызова mapfile.
7. Не использовать -o filenames.

И это только работает со всеми этими трюками. Это терпит неудачу, если хотя бы один отсутствует. Поверьте мне; Я пробовал. ;)

У меня нет mapfile в наличии. Следующее кажется немного проще, чем другие ответы, и у меня отлично сработало:

_completion() {
  local CUR=${COMP_WORDS[COMP_CWORD]}
  local OPT
  local -a OPTS

  while read -r OPT; do
    local OPT_ESC
    OPT_ESC="$(printf '%q' "$OPT")"
    [[ -z "$CUR" ]] || [[ "$OPT_ESC" == "$CUR"* ]] && \
      COMPREPLY+=("$OPT_ESC")
  done < "${TOKEN_FILE}"
}

• Каждая строка в TOKEN_FILE является вариантом завершения.
• Замените "${TOKEN_FILE}" на <(token_generator), где token_genorator — это какая-то команда, которая генерирует токены завершения, в режиме онлайн за раз.
• printf '%q' дает нам строку с экранированием bash, подходящую для использования в командной строке в качестве отдельного токена.

So, if TOKEN_FILE is:

option a
another option
an option with many spaces

Затем завершение табуляции напечатает:

an\ option\ with\ many\ spaces     another\ option
option\ a