7

我想知道这在 Bash 中是否可行，但我想使用制表符完成来完全替换正在扩展的当前参数。我举个例子：我想有一个函数可以在树中向上移动任意数量的级别，所以我可以调用 2 这将 cd 我向上 2 个目录。但是，我想这样做，如果在数字 2 处，我按下制表符，它将将该数字扩展为路径（相对或绝对，都可以）。我几乎使用完整的内置函数来工作，除了它只会附加文本，所以它会像 up 2/Volumes/Dev/

是否可以替换已完成的符号？

提前致谢 ：）

更新：

非常感谢 chepner，因为实际上检查我的代码会发现我的错误在哪里。我正在与错误的 var 进行比较，而我的调试代码导致该值无法替换。

对于任何感兴趣的人，这是代码（可能有更好的方法来完成此操作）：

# Move up N levels of the directory tree
# Or by typing in some dir in the PWD
# eg. Assuming your PWD is "/Volumes/Users/natecavanaugh/Documents/stuff"
#     `up 2` moves up 2 directories to "/Volumes/Users/natecavanaugh"
#     `up 2/` and pressing tab will autocomplete the dirs in "/Volumes/Users/natecavanaugh"
#     `up Users` navigate to "/Volumes/Users"
#     `up us` and pressing tab will autocomplete to "/Volumes/Users"
function up {
    dir="../"
    if [ -n "$1" ]; then
        if [[ $1 =~ ^[0-9]+$ ]]; then
            strpath=$( printf "%${1}s" );
            dir=" ${strpath// /$dir}"
        else
            dir=${PWD%/$1/*}/$1
        fi
    fi

    cd $dir
}

function _get_up {
    local cur
    local dir
    local results
    COMPREPLY=()
    #Variable to hold the current word
    cur="${COMP_WORDS[COMP_CWORD]}"

    local lower_cur=`echo ${cur##*/} | tr [:upper:] [:lower:]`

    # Is the arg a number or number followed by a slash
    if [[ $cur =~ ^[0-9]+/? ]]; then
        dir="../"
        strpath=$( printf "%${cur%%/*}s" );
        dir=" ${strpath// /$dir}"

        # Is the arg just a number?
        if [[ $cur =~ ^[0-9]+$ ]]; then
            COMPREPLY=($(compgen -W "${dir}"))
        else
            if [[ $cur =~ /.*$ ]]; then
                cur="${cur##*/}"
            fi

            results=$(for t in `cd $dir && ls -d */`; do if [[ `echo $t | tr [:upper:] [:lower:]` == "$lower_cur"* ]]; then echo "${t}"; fi done)

            COMPREPLY=($(compgen -P "$dir" -W "${results}"))
        fi
    else
        # Is the arg a word that we can look for in the PWD
        results=$(for t in `echo $PWD | tr "/" "\n"`; do if [[ `echo $t | tr [:upper:] [:lower:]` == "$lower_cur"* ]]; then echo "${t}"; fi; done)

        COMPREPLY=($(compgen -W "${results}"))
    fi  
}

#Assign the auto-completion function _get for our command get.
complete -F _get_up up
4

2 回答 2

3

可以用一个新词完全替换当前词。使用我的 bash 4.2.29，我可以这样做：

_xxx() { COMPREPLY=( foo ); }
complete -F _xxx x
x bar # pressing tab turns this into x foo

但是，如果有多个可能的补全，并且您希望获得公共前缀的部分补全，则会遇到问题。然后我的实验表明 bash 将尝试将可用的完成匹配到您输入的前缀。

所以一般来说，如果某个东西是唯一定义的，你可能应该只用完全不同的东西替换当前参数。否则，您应该生成与当前前缀匹配的补全，让用户从中进行选择。在您的情况下，您可以使用COMPREPLY=($(compgen -P "$dir" -W "${results}"))以下内容替换它：

local IFS=$'\n'
COMPREPLY=( $(find "${dir}" -maxdepth 1 -type d -iname "${cur#*/}*" -printf "%P\n") )
if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
    COMPREPLY=( "${dir}${COMPREPLY[0]}" )
fi

但是，在这种特定情况下，最好只用适当的路径替换前缀数字，并将其他所有内容留给默认的 bash 完成：

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

    if [[ ${cur} =~ ^[0-9]+/? ]]; then
        # Starting with a number, possibly followed by a slash
        dir=$( printf "%${cur%%/*}s" );
        dir="${dir// /../}"
        if [[ ${cur} == */* ]]; then
            dir="${dir}${cur#*/}"
        fi
        COMPREPLY=( "${dir}" "${dir}." ) # hack to suppress trailing space
    elif [[ ${cur} != */* ]]; then
        # Not a digit, and no slash either, so search parent directories
        COMPREPLY=( $(IFS='/'; compgen -W "${PWD}" "${cur}") )
        if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
            dir="${PWD%${COMPREPLY[0]}/*}${COMPREPLY[0]}/"
            COMPREPLY=( "${dir}" "${dir}." ) # hack as above
        fi
    fi
}

complete -F _up_prefix -o dirnames up

代码变得更容易阅读和维护，而且启动效率更高。唯一的缺点是，在某些情况下，您必须比以前多按一次 tab：一次替换前缀，再按两次才能真正看到可能的完成列表。你的选择是否可以接受。

还有一件事：完成会将参数转换为常规路径，但您的 up 函数不接受这些。因此，也许您应该通过检查来启动该功能[[ -d $1 ]]，并简单地 cd 到该目录（如果存在）。否则，您的完成将生成被调用函数不可接受的参数。

于 2012-06-25T08:43:00.853 回答
3

以下内容基于问题中 OP 自己的代码，并且：

  • 提高健壮性：正确处理需要\-转义的目录名称-例如，带有嵌入空格的名称；如果指定了无效的目录名，则报告错误（未完成）
  • 修改命令完成方法：在命令完成时，级别编号/名称前缀扩展为带有终止符的相应绝对路径，因此如果需要，可以立即执行基于子目录的进一步完成。/

修改后的例子是：

# Assume that the working directory is '/Users/jdoe/Documents/Projects/stuff'.
#  `up 2` moves 2 levels up to '/Users/jdoe/Documents'
#  `up 2<tab>` completes to `up /Users/jdoe/Documents/`
#     Hit enter to change to that path or [type additional characters and]
#     press tab again to complete based on subdirectories.
#  `up Documents` or `up documents` changes to '/Users/jdoe/Documents'
#  `up Doc<tab>` or `up doc<tab>` completes to `up /Users/jdoe/Documents/`
#     Hit enter to change to that path or [type additional characters and]
#     press tab again to complete based on subdirectories.
#     Note: Case-insensitive completion is only performed if it is turned on
#     globally via the completion-ignore-case Readline option
#     (configured, for instance, via ~/.inputrc or /etc/inputrc).

这是完整的代码（请注意，语法着色表明代码格式错误，但事实并非如此）：

# Convenience function for moving up levels in the path to the current working directory.
# Synopsis:
#     `up [n]` moves n levels up in the directory hierarchy; default is 1.
#     `up dirname` changes to the closest ancestral directory by that name, regardless of case.
#     `up absolutepath` changes to the specified absolute path; primarily used with command completion (see below).
# Additionally, if command completion via _complete_up() is in effect (<tab> represents pressing the tab key):
#      `up [n]<tab>` replaces n with the absolute path of the directory n levels up (default is 1).
#      `up dirnameprefix<tab>` replaces dirnameprefix with the absolute path of the closest ancestral directory whose name starts with the specified name prefix, terminated with '/'.
#         Whether dirnameprefix is matched case-insensitively or not depends on whether case-insensitive command completion is turned on globally via ~/.inputrc or /etc/inputrc.
#       In both cases the completed absolute path ends in '/', allowing you to optionally continue completion based on that path's subdirectories.
# Notes:
#   - Directory names with characters that need escaping when unquoted (such as spaces) are handled correctly.
#   - For command completion, to specify names that need escaping when unquoted, specify them escaped rather than quoted;
#     e.g., `up my \di<tab>' to match 'my dir' in the ancestral path.
function up {

    local dir='../'   # By default, go up 1 level.

    [[ "$1" == '-h' || "$1" == '--help' ]] && { echo -e "usage:\n\t$FUNCNAME [n]\n\t$FUNCNAME dirname\n  Moves up N levels in the path to the current working directory, 1 by default.\n  If DIRNAME is given, it must be the full name of an ancestral directory (case does not matter).\n  If there are multiple matches, the one *lowest* in the hierarchy is changed to." && return 0; }

    if [[ -n "$1" ]]; then
        if [[ $1 =~ ^[0-9]+$ ]]; then   # A number, specifying the number of levels to go up.            
            local strpath=$( printf "%${1}s" ) # This creates a string with as many spaces as levels were specified.
            dir=${strpath// /$dir}  # Create the go-up-multiple-levels cd expression by replacing each space with '../'
        elif [[ $1 =~ ^/ ]]; then  # Already an absolute path? Use as is. (Typically, this happens as a result of command-line completion invoked via _complete_up().)
            dir=$1
        else # Assumed to be the full name of an ancestral directory (regardless of level), though the case needn't match.
            # Note: On case-insensitive HFS+ volumes on a Mac (the default), you can actually use case-insensitive names with 'cd' and the resulting working directory will be reported in that case(!).
            #       This behavior is NOT related to whether case-insensitivity is turned on for command completion or not.
            # !! Strangely, the 'nocasematch' shopt setting has no effect on variable substitution, so we need to roll our own case-insensitive substitution logic here.
            local wdLower=$(echo -n "$PWD" | tr '[:upper:]' '[:lower:]')
            local tokenLower=$(echo -n "$1" | tr '[:upper:]' '[:lower:]')
            local newParentDirLower=${wdLower%/$tokenLower/*}   # If the specified token is a full ancestral directory name (irrespective of case), this substitution will give us its parent path.
            [[ "$newParentDirLower" == "$wdLower"  ]] && { echo "$FUNCNAME: No ancestral directory named '$1' found." 1>&2; return 1; }
            local targetDirPathLength=$(( ${#newParentDirLower} + 1 + ${#tokenLower} ))
            # Get the target directory's name in the exact case it's defined.
            dir=${PWD:0:$targetDirPathLength}
        fi
    fi

    # Change to target directory; use of 'pushd' allows use of 'popd' to return to previous working directory.
    pushd "$dir" 1>/dev/null
}

# Companion function to up(), used for command completion.
# To install it, run (typically in your bash profile):
# `complete -o filenames -F _complete_up up`
# Note: The '-o filenames' option ensures that:
#   (a) paths of directories returned via $COMPREPLY leave the cursor at the terminating "/" for potential further completion
#   (b) paths with embeddes spaces and other characters requiring \-escaping are properly escaped.
function _complete_up {

    COMPREPLY=() # Initialize the array variable through which completions must be passed out.

    # Retrieve the current command-line token, i.e., the one on which completion is being invoked.
    local curToken=${COMP_WORDS[COMP_CWORD]}
    # Remove \ chars., presumed to be escape characters in the current token, which is presumed to be *unquoted*. This allows invoking completion on a token with embedded space, e.g., '$FUNCNAME some\ directory'
    # !! Strictly speaking, we'd have to investigate whether the token was specified with quotes on the command line and, if quoted,  NOT unescape. Given that the purpose of this function is expedience, we
    # !! assume that the token is NOT quoted and that all backslashes are therefore escape characters to be removed.
    curToken=${curToken//'\'}

    if [[ $curToken =~ ^/ ]]; then # Token is an absolute path (typically as a result of a previous completion) -> complete with directory names, similar to 'cd' (although the latter, curiously, also completes *file* names).

        local IFS=$'\n' # Make sure that the output of compgen below is only split along lines, not also along spaces (which the default $IFS would do).
        COMPREPLY=($(compgen -o dirnames -- "$curToken"))

    elif [[ $curToken =~ ^[0-9]+/? ]]; then # Token is a number (optionally followed by a slash) -> replace the token to be completed with the absolute path of the directory N levels above, where N is the number specified.

        # Create a go-up-multiple-levels cd expression that corresponds to the number of levels specified.
        local strpath=$( printf "%${curToken%%/*}s" ) # This creates a string with as many spaces as levels were specified.
        local upDirSpec=${strpath// /../}  # Create the go-up-multiple-levels cd expression by replacing each space with '../'        

        # Expand to absolute path (ending in '/' to facilitate optional further completion) and return.
        local dir=$(cd "$upDirSpec"; echo -n "$PWD/")
        if [[ "$dir" == '//' ]]; then dir='/'; fi # In case the target dir turns out to be the root dir, we've accidentally created '//' in the previous statement; fix it.
        # !! Note that the path will appear *unquoted* on the command line and must therefore be properly \-escaped (e.g., a ' '  as '\ ').
        # !! Escaping is performed automatially by virtue of defining the compspec with '-o filenames' (passed to 'complete').
        COMPREPLY=("$dir") 

    else # Token is a name -> look for a prefix match among all the ancestral path components; use the first match found (i.e., the next match up in the hierarchy).

        # Determine if we should do case-insensitive matching or not, depending on whether cases-insensitive completion was turned on globally via ~/.inputrc or /etc/inputrc.
        # We do this to be consistent with the default command completion behavior.
        local caseInsensitive=0        
        bind -v | egrep -i '\bcompletion-ignore-case[[:space:]]+on\b' &>/dev/null && caseInsensitive=1

        # If we need to do case-INsensitive matching in this function, we need to make sure the 'nocasematch' shell option is (temporarily) turned on.
        local nocasematchWasOff=0
        if (( caseInsensitive )); then
            nocasematchWasOff=1
            shopt nocasematch >/dev/null && nocasematchWasOff=0
            (( nocasematchWasOff )) && shopt -s nocasematch >/dev/null
        fi

        local pathSoFar=''
        local matchingPath=''
        # Note: By letting the loop iterate over ALL components starting at the root, we end up with the *last* match, i.e. the one *lowest* in the hierarchy (closed to the current working folder).
        # !! We COULD try to return multiple matches, if applicable, but in practice we assume that there'll rarely be paths whose components have identical names or prefixes.
        # !! Thus, should there be multiple matches, the user can reinvoke the same command to change to the next-higher match (though the command must be typed again), and so forth.
        local parentPath=${PWD%/*}
        local IFS='/' # This will break our parent path into components in the 'for' loop below.
        local name
        for name in ${parentPath:1}; do
            pathSoFar+=/$name
            if [[ "$name" == "$curToken"* ]]; then
                matchingPath="$pathSoFar/"
            fi
        done

        # Restore the state of 'nocasematch', if necessary.
        (( caseInsensitive && nocasematchWasOff )) && shopt -u nocasematch >/dev/null

        # If match was found, return its absolute path (ending in / to facilitate optional further completion).
        # !! Note that the path will appear *unquoted* on the command line and must therefore be properly \-escaped (e.g., a ' '  as '\ ').
        # !! Escaping is performed automatially by virtue of defining the compspec with '-o filenames' (passed to 'complete').
        [[ -n "$matchingPath" ]] && COMPREPLY=("$matchingPath")

    fi  
}

# Assign the auto-completion function for up().
complete -o filenames -F _complete_up up
于 2012-06-11T05:38:44.890 回答