Alias ​​do Git com parâmetros posicionais

Basicamente, eu estou tentando alias:

git files 9fa3

... para executar o comando:

git diff --name-status 9fa3^ 9fa3

mas o git não parece passar parâmetros posicionais para o comando alias. Eu tentei:

[alias]
    files = "!git diff --name-status $1^ $1"
    files = "!git diff --name-status {1}^ {1}"

... e alguns outros, mas esses não funcionaram.

O caso degenerado seria:

$ git echo_reverse_these_params a b c d e
e d c b a

... como posso fazer isso funcionar?

A maneira mais óbvia é usar uma função shell:

[alias]
    files = "!f() { git diff --name-status \"$1^\" \"$1\"; }; f"

Um alias sem !é tratado como um comando Git; por exemplocommit-all = commit -a .

Com o !, ele é executado como seu próprio comando no shell, permitindo que você use uma magia mais forte como esta.

UPD
Como os comandos são executados na raiz do repositório, você pode usar a ${GIT_PREFIX}variável ao se referir aos nomes dos arquivos nos comandos

Você também pode fazer referência shdiretamente (em vez de criar uma função):

[alias]
        files = !sh -c 'git diff --name-status $1^ $1' -

(Observe o traço no final da linha - você precisará disso.)

O alias que você está procurando é:

files = "!git diff --name-status \"$1\"^ \"$1\" #"

Com validação de argumento:

files = "!cd -- \"${GIT_PREFIX:-.}\" && [ x$# != x1 ] && echo commit-ish required >&2 || git diff --name-status \"$1\"^ \"$1\" #"

A final# é importante - impede que todos os argumentos fornecidos pelo usuário sejam processados ​​pelo shell (os comenta).

Nota: git coloca todos os argumentos fornecidos pelo usuário no final da linha de comando. Para ver isso em ação, tente:GIT_TRACE=2 git files a b c d

As aspas escapadas (devido ao aninhamento) são importantes para nomes de arquivos que contêm espaços ou "; rm -rf --no-preserve-root /;)

Use GIT_TRACE = 1 descrito na página de manual do git para tornar transparente o processamento do alias:

$ git config alias.files
!git diff --name-status $1^ $1
$ GIT_TRACE=1 git files 1d49ec0
trace: exec: 'git-files' '1d49ec0'
trace: run_command: 'git-files' '1d49ec0'
trace: run_command: 'git diff --name-status $1^ $1' '1d49ec0'
trace: exec: '/bin/sh' '-c' 'git diff --name-status $1^ $1 "$@"' 'git diff --name-status $1^ $1' '1d49ec0'
trace: built-in: git 'diff' '--name-status' '1d49ec0^' '1d49ec0' '1d49ec0'
trace: run_command: 'less -R'
trace: exec: '/bin/sh' '-c' 'less -R' 'less -R'
MM      TODO

Seus comandos originais funcionam com a versão 1.8.3.4 do git (o Eimantas notou que isso foi alterado na 1.8.2.1).

As opções sh -c '..' --e f() {..}; fmanipulam de maneira limpa os parâmetros "$ @" de diferentes maneiras (veja em GIT_TRACE). Anexar "#" a um alias também permitiria parâmetros posicionais sem sair dos finais.

Como afirmado por Drealmer acima :

" Seja cuidadoso, ! será executado na raiz do repositório, portanto, usar caminhos relativos ao chamar seu alias não fornecerá os resultados que você pode esperar. - Drealmer 8/08/13 às 16:28 »

GIT_PREFIX sendo definido pelo git para o subdiretório em que você está, você pode contornar isso alterando primeiro o diretório:

git config --global alias.ls '! cd "$ {GIT_PREFIX: -.}"; ls -al '

Eu queria fazer isso com um alias que faz isso:

git checkout $1;
git merge --ff-only $2;
git branch -d $2;

No final, criei um script de shell chamado git-m que tem este conteúdo:

#!/bin/bash -x
set -e

#by naming this git-m and putting it in your PATH, git will be able to run it when you type "git m ..."

if [ "$#" -ne 2 ]
then
  echo "Wrong number of arguments. Should be 2, was $#";
  exit 1;
fi

git checkout $1;
git merge --ff-only $2;
git branch -d $2;

Isso tem o benefício de ser muito mais legível porque está em várias linhas. Além disso, eu gosto de poder chamar o bash com -xeset -e . Você provavelmente pode fazer tudo isso como um apelido, mas seria super feio e difícil de manter.

Como o arquivo é nomeado, git-mvocê pode executá-lo assim:git m foo bar

Apenas esbarrei em algo semelhante; espero que esteja tudo bem em publicar minhas anotações. Uma coisa que me confunde sobre gitaliases com argumentos, provavelmente vem do git help config(eu tenho a versão 1.7.9.5 do git):

Se a expansão do alias for prefixada com um ponto de exclamação, ela será tratada como um comando shell. Por exemplo, definindo "alias.new =! Gitk --all --not ORIG_HEAD", a chamada "git new" é equivalente a executar o comando do shell "gitk --all --not ORIG_HEAD". Observe que os comandos do shell serão executados no diretório de nível superior de um repositório, que pode não ser necessariamente o diretório atual. [...]

Do jeito que eu vejo - se um apelido "será tratado como um comando de shell" quando prefixado com ponto de exclamação - por que eu precisaria usar uma função ou sh -ccom argumentos; por que não apenas escrever meu comando como está?

Ainda não sei a resposta - mas acho que, na verdade, há uma pequena diferença no resultado. Aqui está um pequeno teste - jogue isso no seu .git/configou no seu ~/.gitconfig:

[alias]
  # ...
  ech = "! echo rem: "
  shech = "! sh -c 'echo rem:' "
  fech = "! f() { echo rem: ; }; f " # must have ; after echo!
  echargs = "! echo 0[[\"$0\"]] 1-\"$1\"/ A-"$@"/ "
  fechargs = "! f() { echo 0[[\"$0\"]] 1-\"$1\"/ A-"$@"/ ; }; f "

Aqui está o que eu recebo executando esses aliases:

$ git ech word1 word2
rem: word1 word2

$ git shech word1 word2
rem:

$ git fech word1 word2
rem:

$ git echargs word1 word2
0[[ echo 0[["$0"]] 1-"$1"/ A-$@/ ]] 1-word1/ A-word1 word2/ word1 word2

$ git fechargs word1 word2
0[[ f() { echo 0[["$0"]] 1-"$1"/ A-$@/ ; }; f ]] 1-word1/ A-word1 word2/

... ou: quando você estiver usando um comando "simples" após o !"no estado em que está" em um gitalias - gitanexará automaticamente a lista de argumentos a esse comando! Uma maneira de evitá-lo é chamar seu script como uma função - ou como argumento sh -c.

Outra coisa interessante aqui (para mim) é que, em um script de shell, normalmente se espera que a variável automática $0seja o nome do arquivo do script. Mas para uma gitfunção de alias, o $0argumento é, basicamente, o conteúdo de toda a cadeia que especifica esse comando (conforme digitado no arquivo de configuração).

Por isso, eu acho, se você citar incorretamente - no caso abaixo, isso estaria escapando das aspas duplas externas:

[alias]
  # ...
  fail = ! \"echo 'A' 'B'\"

... - então gitfalharia com (pelo menos para mim) a mensagem um tanto enigmática:

$ git fail
 "echo 'A' 'B'": 1: echo 'A' 'B': not found
fatal: While expanding alias 'fail': ' "echo 'A' 'B'"': No such file or directory

Eu acho que, uma vez que git"via" uma string inteira como apenas um argumento para !- tentava executá-la como um arquivo executável; e correspondentemente falhou ao encontrar "echo 'A' 'B'"como um arquivo.

De qualquer forma, no contexto da git help configcitação acima, eu especularia que é mais preciso afirmar algo como: " ... a invocação" git new "é equivalente a executar o comando shell" gitk --all --not ORIG_HEAD $ @ ", onde $ @ são os argumentos passados ​​para o alias do comando git na linha de comando no tempo de execução. ... ". Eu acho que isso também explicaria por que a abordagem "direta" no OP não funciona com parâmetros posicionais.