Come completare il tab durante la digitazione del comando in tmux?


22

Alcuni comandi ( kill-sessione kill-server) hanno lo stesso prefisso.
Quando prefix:kill-seTabscrivo ( ), tmux non mi darà alcun risultato.
Esiste un'opzione per mostrare wildmenu per il completamento automatico all'interno di tmux?

Sto usando Ubuntu 12.04


Che shell stai usando? Puoi trovarlo con l'eco $ SHELL
éclairevoyant

1
È/bin/bash
kev

4
Come è correlata la shell? Quando digiti Ctrl + B ,: in tmux, ti viene dato un prompt dei comandi tmux (proprio come quando digiti: in VIM, non ti viene dato un prompt bash.) Questa è una domanda tmux, non una domanda shell.
bobpaul

La risposta di completamento bash è utile, ma non risponde alla domanda per l'uso all'interno di tmux. Immagino che dal momento che tmux non ha una linea extra di spazio verticale con cui lavorare, semplicemente non offre le opzioni di completamento delle schede come fa bash, anche se almeno completa ciò che stai scrivendo fino a quando non c'è ambiguità. Quindi la gente può usare l'opzione bash per imparare e usare l'opzione tmux per le sveltine dove sanno cosa vogliono.
nealmcb,

Risposte:


8

Il seguente script fornisce un completamento bash per tmux, e l'ho testato sulla mia scatola proprio ora, e funziona benissimo. Basta copiare lo script in un file sul tuo computer e metterlo

   source /path/to/tmux_completion.sh

nel tuo .bashrce dovresti essere pronto per partire.


#!/bin/bash

# tmux completion
# See: http://www.debian-administration.org/articles/317 for how to write more.
# Usage: Put "source bash_completion_tmux.sh" into your .bashrc
# Based upon the example at http://paste-it.appspot.com/Pj4mLycDE

_tmux_expand () 
{ 
    [ "$cur" != "${cur%\\}" ] && cur="$cur"'\';
    if [[ "$cur" == \~*/* ]]; then
        eval cur=$cur;
    else
        if [[ "$cur" == \~* ]]; then
            cur=${cur#\~};
            COMPREPLY=($( compgen -P '~' -u $cur ));
            return ${#COMPREPLY[@]};
        fi;
    fi
}

_tmux_filedir () 
{ 
    local IFS='
';
    _tmux_expand || return 0;
    if [ "$1" = -d ]; then
        COMPREPLY=(${COMPREPLY[@]} $( compgen -d -- $cur ));
        return 0;
    fi;
    COMPREPLY=(${COMPREPLY[@]} $( eval compgen -f -- \"$cur\" ))
}

function _tmux_complete_client() {
    local IFS=$'\n'
    local cur="${1}"
    COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "$(tmux -q list-clients | cut -f 1 -d ':')" -- "${cur}") )
}
function _tmux_complete_session() {
    local IFS=$'\n'
    local cur="${1}"
    COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "$(tmux -q list-sessions | cut -f 1 -d ':')" -- "${cur}") )
}
function _tmux_complete_window() {
    local IFS=$'\n'
    local cur="${1}"
    local session_name="$(echo "${cur}" | sed 's/\\//g' | cut -d ':' -f 1)"
    local sessions

    sessions="$(tmux -q list-sessions | sed -re 's/([^:]+:).*$/\1/')"
    if [[ -n "${session_name}" ]]; then
        sessions="${sessions}
$(tmux -q list-windows -t "${session_name}" | sed -re 's/^([^:]+):.*$/'"${session_name}"':\1/')"
    fi
    cur="$(echo "${cur}" | sed -e 's/:/\\\\:/')"
    sessions="$(echo "${sessions}" | sed -e 's/:/\\\\:/')"
    COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "${sessions}" -- "${cur}") )
}

_tmux() {
    local cur prev
    local i cmd cmd_index option option_index
    local opts=""
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    prev="${COMP_WORDS[COMP_CWORD-1]}"

    if [ ${prev} == -f ]; then
        _tmux_filedir
    else
    # Search for the command
    local skip_next=0
    for ((i=1; $i<=$COMP_CWORD; i++)); do
        if [[ ${skip_next} -eq 1 ]]; then
            #echo "Skipping"
            skip_next=0;
        elif [[ ${COMP_WORDS[i]} != -* ]]; then
            cmd="${COMP_WORDS[i]}"
            cmd_index=${i}
            break
        elif [[ ${COMP_WORDS[i]} == -f ]]; then
            skip_next=1
        fi
    done

    # Search for the last option command
    skip_next=0
    for ((i=1; $i<=$COMP_CWORD; i++)); do
        if [[ ${skip_next} -eq 1 ]]; then
            #echo "Skipping"
            skip_next=0;
        elif [[ ${COMP_WORDS[i]} == -* ]]; then
            option="${COMP_WORDS[i]}"
            option_index=${i}
            if [[ ${COMP_WORDS[i]} == -- ]]; then
                break;
            fi
        elif [[ ${COMP_WORDS[i]} == -f ]]; then
            skip_next=1
        fi
    done

    if [[ $COMP_CWORD -le $cmd_index ]]; then
        # The user has not specified a command yet
        local all_commands="$(tmux -q list-commands | cut -f 1 -d ' ')"
        COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "${all_commands}" -- "${cur}") )
    else        
        case ${cmd} in
            attach-session|attach)
            case "$prev" in
                -t) _tmux_complete_session "${cur}" ;;
                *) options="-t -d" ;;
            esac ;;
            detach-client|detach)
            case "$prev" in
                -t) _tmux_complete_client "${cur}" ;;
                *) options="-t" ;;
            esac ;;
            lock-client|lockc)
            case "$prev" in
                -t) _tmux_complete_client "${cur}" ;;
                *) options="-t" ;;
            esac ;;
            lock-session|locks)
            case "$prev" in
                -t) _tmux_complete_session "${cur}" ;;
                *) options="-t -d" ;;
            esac ;;
            new-session|new)
            case "$prev" in
                -t) _tmux_complete_session "${cur}" ;;
                -[n|d|s]) options="-d -n -s -t --" ;;
                *) 
                if [[ ${COMP_WORDS[option_index]} == -- ]]; then
                    _command_offset ${option_index}
                else
                    options="-d -n -s -t --"
                fi
                ;;
            esac
            ;;
            refresh-client|refresh)
            case "$prev" in
                -t) _tmux_complete_client "${cur}" ;;
                *) options="-t" ;;
            esac ;;
            rename-session|rename)
            case "$prev" in
                -t) _tmux_complete_session "${cur}" ;;
                *) options="-t" ;;
            esac ;;
            source-file|source) _tmux_filedir ;;
            has-session|has|kill-session)
            case "$prev" in
                -t) _tmux_complete_session "${cur}" ;;
                *) options="-t" ;;
            esac ;;
            suspend-client|suspendc)
            case "$prev" in
                -t) _tmux_complete_client "${cur}" ;;
                *) options="-t" ;;
            esac ;;
            switch-client|switchc)
            case "$prev" in
                -c) _tmux_complete_client "${cur}" ;;
                -t) _tmux_complete_session "${cur}" ;;
                *) options="-l -n -p -c -t" ;;
            esac ;;

            send-keys|send)
            case "$option" in
                -t) _tmux_complete_window "${cur}" ;;
                *) options="-t" ;;
            esac ;;
          esac # case ${cmd}
        fi # command specified
      fi # not -f 

      if [[ -n "${options}" ]]; then
          COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "${options}" -- "${cur}") )
      fi

      return 0

}
complete -F _tmux tmux

# END tmux completion

Fonte dello script


5
Ho salvato questo script e lo ho estratto dal mio .bashrc. Ho iniziato tmux e ho premuto "Ctrl + B,:" e poi ho digitato "stacca-" e ho premuto il tasto tab. Niente. Ho aggiunto ac in modo che dicesse "staccare-c" e premere il tasto, ha completato a "staccare-client". Questo è esattamente lo stesso comportamento che ho provato prima della sceneggiatura. Nulla sembra essere cambiato.
bobpaul

6
@bobpaul sta chiedendo il completamento della scheda all'interno di tmux, non dalla shell come bash.
Jason Axelson,

1
@kev chiede anche il completamento della scheda all'interno di tmux, non da bash. E nota che un po 'di codice correlato (più vecchio?) Per questo approccio di completamento del comando bash è su github su github.com/aziz/dotfiles/blob/master/bash/completion/… ma non mi è chiaro come il loro comportamento differisca. Forse luolimao potrebbe voler offrire le differenze in una richiesta pull?
nealmcb,

Questo script di completamento automatico funziona alla grande in Bash !! Grazie @luolimao!
Trevor Sullivan,

2
Ho votato verso il basso la risposta perché l'OP chiede il completamento automatico all'interno di tmux, non per bash. Questa risposta potrebbe essere del tutto ragionevole per la seconda inchiesta (completamento per bash), ma fuorvia le persone che vengono qui attraverso i motori di ricerca per cercare di trovare un completamento all'interno di tmux.
thiagowfx,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.