Início / unix / Perguntas / 774159
Accepted
dhm
Asked: 2024-04-09 15:05:23 +0800 CST

Como colocar meus próprios trechos de código na linha de comando à la história?

  • 772

Tenho centenas de comandos e trechos testados e testados, salvos em vários arquivos de texto. Quando preciso reutilizar um, localizo e copio/colo na linha de comando. Embora confiável, este é um método desajeitado. Compare isso com a maneira elegante como podemos recuperar um comando antigo do arquivo de histórico diretamente na linha de comando e pronto para editar e usar. Como posso emular esse recurso e usar minha própria coleção de comandos?

Tenho scripts para pesquisar (usando fzf), localizar e anexar meus próprios comandos ao arquivo de histórico. Isso funciona bem. Mas isso desorganiza o arquivo de histórico.

Aqui está meu roteiro:

find ~ -type f | fzf --preview-window=up:50% --header "ENTER:less; ^s:snip to history" --bind "enter:execute(less {})"  --bind "ctrl-s:execute(cat {} | fzf -m --preview-window=:hidden  >>~/.bash_history)"; history -n
command-line

3 respostas

  1. Uma engenhoca rápida e suja para Bash interativo (minhas bash --versionimpressões 5.2.15):

    1. Coloque os comandos desejados (linha única) no arquivo ~/.commands.

    2. Defina a seguinte função auxiliar:

      _get_command () {
   READLINE_LINE="$(<~/.commands fzf -1 --query="$READLINE_LINE")" &&
   READLINE_POINT="${#READLINE_LINE}"
}

    3. Vincular a uma chave (sequência de teclas):

      bind -x '"\C-x\C-r":_get_command'

    4. Comece a usar Ctrl+ x, Ctrl+ r.

    Notas:

    • READLINE_POINT="${#READLINE_LINE}"deve colocar o cursor bem no final. Bash 5 quer o comprimento em caracteres e o código acima funciona; mas o Bash 4 quer bytes. Para lidar com texto não ASCII no Bash 4, use

      READLINE_POINT="$(printf '%s' "$READLINE_LINE" | wc -c)"

      (Aprendi com esta resposta ).

    • Pois ~/.commandsvocê pode inventar seu próprio formato que especifica ou codifica a posição desejada do cursor para cada comando. Melhore a função auxiliar para definir READLINE_LINEe READLINE_POINTde acordo com seu formato.

      Por outro lado, ~/.commandsarmazenar apenas comandos literais é simples e funciona bem com arquivos --query="$READLINE_LINE".

    • Para comandos multilinhas, você precisa fzf --read0de entradas terminadas em nulo em arquivos ~/.commands. Manter esse formato será mais difícil do que editar entradas terminadas em nova linha.

    Depois de escrever o texto acima, decidi que quero essa funcionalidade. Aqui está minha solução mais complexa (para colocar ~/.bashrc):

    export SNIPPETFILE

_del_snippet () {
   SNIPPETFILE="${SNIPPETFILE:-"$HOME/.snippets"}"
   printf '%s\0' "$1" | sort -zm -- "$SNIPPETFILE" - | uniq -zu >"$SNIPPETFILE"~ \
   && mv -- "$SNIPPETFILE"~ "$SNIPPETFILE"
   cat -- "$SNIPPETFILE"
}
export -f _del_snippet

_get_snippet () {
   SNIPPETFILE="${SNIPPETFILE:-"$HOME/.snippets"}"
   local line
   line="$(<"$SNIPPETFILE" fzf -1 --read0 --query="$READLINE_LINE" \
      --border top --border-label 'Enter to confirm, Ctrl+y to delete entry, Ctrl+c to abort' \
      --bind 'ctrl-y:reload-sync(exec bash -c "_del_snippet \"\$1\"" bash {})')" \
   && READLINE_LINE="$line" \
   && READLINE_POINT="${#READLINE_LINE}"
}
bind -x '"\C-x\C-r":_get_snippet'

_put_snippet () {
   [[ "$READLINE_LINE" =~ ^[[:space:]]*$ ]] && return 0
   SNIPPETFILE="${SNIPPETFILE:-"$HOME/.snippets"}"
   if
      touch -- "$SNIPPETFILE" \
      && printf '%s\0' "$READLINE_LINE" | sort -zum -- "$SNIPPETFILE" - >"$SNIPPETFILE"~ \
      && mv -- "$SNIPPETFILE"~ "$SNIPPETFILE"
   then
      printf 'command stored in `%s'\''\n' "$SNIPPETFILE" >&2
   else
      printf 'storing in `%s'\'' failed\n' "$SNIPPETFILE" >&2
      return 1
   fi
}
bind -x '"\C-x\C-m":_put_snippet'

    Uso:

    • Armazene a linha de comando atual com Ctrl+ x, Ctrl+ m.

    • Use Ctrl+ x, Ctrl+ rpara escolher na lista de comandos armazenados. Se houver exatamente uma correspondência com o que você já digitou, ela será levada para a linha de comando. Se houver mais, você poderá escolher de forma interativa.

    • Ao escolher interativamente, Ctrl+ yexclui a entrada destacada.

    Notas:

    • Comandos multilinhas são suportados, mas para armazená-los corretamente você não deve clicar Enter(dentro das aspas ou depois de \) para que um prompt secundário apareça. Você precisa trazer um comando multilinha do histórico ou criar um comando multilinha pressionando Ctrl+ v, Ctrl+ j, para que nenhum prompt secundário apareça e você ainda possa editar o comando inteiro. Então Ctrl+ x, Ctrl+ mserá capaz de armazenar todo o comando multilinha.

      Essas linhas não parecerão comandos multilinhas quando você as escolher interativamente, mas serão trazidas para a linha de comando como multilinhas.

      Isso cria um efeito colateral interessante: você pode armazenar comandos rotulados. Este

      # description (label) here
:
actual_command args

      ficará assim na lista:

      # description (label) here : actual_command args

      e ainda assim funcionará depois de ser escolhido.

    • O arquivo padrão é $HOME/.snippets. Você pode usar outro nome de caminho definindo e exportexecutando a variável chamada SNIPPETFILE. O nome do caminho com til pós-anexado (por exemplo, $HOME/.snippets~) também será usado para manutenção.

    • Testado no Bash 5.2.15 com GNU sorte GNU uniq(opções não portáteis usadas).

    • Ainda pode haver bugs.

    • 4
  2. Best Answer

    Pode valer a pena explorar o xdotool para resolver seu problema.

    De acordo com a página de manual:

    xdotool permite simular programaticamente (ou manualmente) a entrada do teclado e a atividade do mouse, mover e redimensionar janelas, etc.

    Então o que você pode fazer é definir um alias que ajude você a encontrar seu comando favorito e diga ao xdotool para colocá-lo na linha de comando. Por exemplo:

    $ alias my_command='stty -echo &&  xdotool type "$(cat any_list | fzf)" ; stty echo'

    Isso permitiria extrair qualquer linha de texto de um arquivo "any_list" e colocá-la na linha de comando. Se esse texto for um de seus comandos antigos, você estará pronto para editá-lo e executá-lo.

    Você já pode ter o xdotool em sua configuração atual. Caso contrário, é muito fácil baixá-lo e instalá-lo - por exemplo https://installati.one/install-xdotool-debian-12

    • 2

  3. in bash, shell-expand-line(atalho de teclado M-C-e, geralmente ALT+ CTRL+ e) irá "Expandir a linha como o shell faz. Isso executa a expansão de alias e histórico, bem como todas as expansões de palavras do shell".

    Portanto, a maneira mais fácil de conseguir o que deseja é atribuir o comando que deseja inserir na linha de comando a alguma variável, escrever o nome da variável e pressionar esta sequência de teclas para expandir seu conteúdo.

    Por exemplo:

    $ COMMAND="echo hello world"

    Agora na linha de comando escreva o nome da variável, $COMMANDneste caso, e pressione ALT+ CTRL+ e. $COMMANDserá automaticamente substituído na sua linha atual pelo seu conteúdo.

    $ echo hello world

    Alternativamente, você pode substituir sua linha de comando pela saída do comando anterior escrevendo $(!!)e clicando na sequência. Por exemplo:

    $ grep ps .snippets
ps -fp $$
$ $(!!)

    Clicar em ALT+ CTRL+ eno ponto substituirá a linha de comando pela saída do seu grepcomando.

    $ ps -fp $$
    • 1

relate perguntas