O que são aliases do Git

Os aliases do Git funcionam de maneira semelhante aos aliases normais no shell, mas são específicos dos comandos do Git. Eles permitem que você crie atalhos para comandos mais longos ou crie novos comandos que não estão disponíveis por padrão.

Os aliases são executados no mesmo ambiente shell que outros comandos git e são usados ​​principalmente para simplificar fluxos de trabalho comuns.

Alias ​​simples

Aliases simples chamam um único comando Git com um conjunto de argumentos. Por exemplo, você pode criar um alias para mostrar o status do repositório executando git status com o alias:

[alias]
  s = status

Você pode então executar git s para mostrar o status do repositório. Como configuramos o alias em ~/.gitconfig, ele está disponível para todos os repositórios do sistema.

Aliases mais complexos

Você também pode criar aliases git que executam um comando shell arbitrário. Para fazer isso, o alias precisa começar com !. Isso diz ao git para executar o alias como se não fosse um subcomando do git. Por exemplo, se você quiser executar dois comandos git em sequência, poderá criar um alias que execute um comando shell:

[alias]
  my-alias = !git fetch && git rebase origin/master

Este alias executa git fetch e git rebase origin/main em sequência quando você executa git my-alias.

Uma limitação dos aliases do git é que eles não podem ser definidos como um valor multilinha. Isso significa que para aliases mais complexos você precisará reduzi-los.

Além disso, em um arquivo INI a ; caractere é usado para comentar o resto da linha. Isso significa que você não pode usar ; em seus comandos de alias.

Essas duas limitações podem dificultar a criação de aliases mais complexos usando a sintaxe de alias padrão do git, mas isso ainda pode ser feito. Por exemplo, um alias usando if to branch pode ser assim:

[alias]
  branch-if = !bash -c "'!f() { if [ -z \"$1\" ]; then echo \"Usage: git branch-if \"; else git checkout -b $1; fi; }; f'"

Esses limites tornam muito mais complexa a criação e manutenção de aliases que possuem qualquer forma de fluxo de controle dentro deles. É aqui que entra o script.

Configurando Aliases com Scripts

Você pode criar um script de gitalias usando qualquer linguagem de programação que desejar. Se você estiver familiarizado com scripts bash e quiser usá-los, poderá criar um script bash que execute os comandos git desejados. A verdade é que sou muito mais forte com JavaScript, então é isso que vou usar.

Um outro grande benefício é que, ao usar uma linguagem de script, seus aliases podem receber e operar argumentos muito com mais facilidade. O Git encaminhará quaisquer argumentos que você passar na CLI para o seu alias, anexando-os ao final do seu comando. Como tal, seu script deve ser capaz de lê-los sem problemas. Por exemplo, no Node JS você pode acessar os argumentos passados ​​para o script diretamente em process.argv.

As etapas básicas para configurar isso não mudam com base no idioma escolhido. Você precisará:

• Crie um script que execute os comandos git desejados
• Escreva um alias que execute o script

Estudo de caso: Rebase principal/mestre

Nos últimos anos, o nome do branch padrão para novos repositórios mudou de master para main. Isso significa que quando você clona um novo repositório, o branch padrão pode ser main em vez de master. Não existe mais um nome superconsistente, pois o ecossistema está em transição. No geral, isso é bom, mas significa que nosso alias acima para rebase não funcionará em todos os casos.

Precisamos atualizar nosso alias para verificar se o branch é principal ou master e então rebasear o branch correto. Este é um caso de uso perfeito para um script.

#!/usr/bin/env node

const { execSync } = require('child_process');

// We want to run some commands and not immediately fail if they fail
function tryExec(command) {
  try {
    return {
      status: 0
      stdout: execSync(command);
    }
  } catch (error) {
    return {
      status: error.status,
      stdout: error.stdout,
      stderr: error.stderr,
    }
  }
}

function getOriginRemoteName() {
  const { stdout, code } = tryExec("git remote", true);
  if (code !== 0) {
    throw new Error("Failed to get remote name. \n"   stdout);
  }
  // If there is an upstream remote, use that, otherwise use origin
  return stdout.includes("upstream") ? "upstream" : "origin";
}

// --verify returns code 0 if the branch exists, 1 if it does not
const hasMain = tryExec('git show-ref --verify refs/heads/main').status === 0;

// If main is present, we want to rebase main, otherwise rebase master
const branch = hasMain ? 'main' : 'master';

const remote = getOriginRemoteName()

// Updates the local branch with the latest changes from the remote
execSync(`git fetch ${remote} ${branch}`, {stdio: 'inherit'});
// Rebases the current branch on top of the remote branch
execSync(`git rebase ${remote}/${branch}`, {stdio: 'inherit'});

Atualmente, para executar o script, precisaríamos executar o node ~/gitaliases/git-rebase-main.js. Isso não é o ideal e não é algo que você tenha o hábito de fazer. Podemos tornar isso mais fácil criando um alias git que executa o script.

[alias]
  rebase-main = !node ~/gitaliases/git-rebase-main.js

Agora você pode executar git rebase-main para rebasear o branch correto, independentemente de ser principal ou master.

Estudo de caso: Alterar

Outro alias que configurei em todas as minhas máquinas é alterar o último commit. Este é um fluxo de trabalho muito comum para mim e gosto de tê-lo como um único comando. Este é um ótimo caso de uso para um script, pois é um comando simples que desejo executar com frequência.

#!/usr/bin/env node

// Usage: git amend [undo]
const tryExec = require('./utils/try-exec');

async function getBranchesPointingAtHead() {
  const { stdout, code } = await tryExec('git branch --points-at HEAD', true);
  if (code !== 0) {
    throw new Error('Failed to get branches pointing at HEAD. \n'   stdout);
  }
  return stdout.split('\n').filter(Boolean);
}

(async () => {
  const branches = await getBranchesPointingAtHead();
  if (branches.length !== 1) {
    console.log(
      'Current commit is relied on by other branches, avoid amending it.'
    );
    process.exit(1);
  }
  if (process.argv[2] === 'undo') {
    await tryExec('git reset --soft HEAD@{1}');
  } else {
    await tryExec('git commit --amend --no-edit');
  }
})();

Este script é um pouco mais complexo que o anterior, pois contém algum fluxo de controle. Ele verificará se o commit atual é confiável para outras ramificações e, se for, sairá com um erro. Isso evita que você altere um commit no qual outras ramificações dependem, pois isso causaria problemas ao tentar mesclar qualquer ramificação que dependa do commit.

Para configurar o alias, você pode usar o mesmo método de antes:

[alias]
  amend = !node ~/gitaliases/git-amend.js

Agora você pode executar git amend para alterar o último commit ou git amend undo para desfazer a última alteração. Este é um script que escrevi inicialmente em meu gitconfig, mas à medida que crescia em complexidade, movi-o para um arquivo de script. Esta é uma ótima maneira de gerenciar a complexidade em seus aliases. Para efeito de comparação, aqui está o alias original:

[alias]
  amend = !bash -c "'f() { if [ $(git branch --points-at HEAD | wc -l) != 1 ]; then echo Current commit is relied on by other branches, avoid amending it.; exit 1; fi; if [ \"$0\" = "undo" ]; then git reset --soft \"HEAD@{1}\"; else git commit --amend --no-edit; fi }; f'"

Este script também poderia ter sido extraído para um arquivo .sh, mas manter as coisas no nó reduz a carga de manutenção para mim pessoalmente. No passado, sempre que eu precisasse atualizar esse alias, eu teria que colá-lo em um bash linter, fazer minhas alterações, reduzi-lo e colá-lo novamente em meu gitconfig. Isso era uma dor, e muitas vezes eu evitava atualizar o alias por causa disso. Agora que está em um arquivo de script, posso atualizá-lo como qualquer outro script.

Algumas advertências

Configurar aliases como scripts pode desbloquear um novo nível de poder em seus aliases git. No entanto, há algumas coisas que você deve estar ciente ao fazer isso.

Ao configurar aliases como este, é importante lembrar que o cwd do script será o diretório de trabalho atual do shell que executa o script. Quaisquer caminhos de arquivo relativos no script serão tratados como relativos ao cwd do shell, não à localização do script. Isso é muito útil às vezes e muito doloroso em outras. Para o nosso script rebase-main, isso não é um problema, e a única indicação de que isso está acontecendo é que usamos ~ no caminho do arquivo para referenciar o local do script como um caminho absoluto.

Introduzir scripts em seus aliases git também pode tornar tentador adicionar mais e mais lógica a seus aliases. Isso pode torná-los mais difíceis de manter e compreender, mas também mais difíceis de lembrar. Não vale a pena manter um alias supercomplexo, pois será menos provável que você o use de qualquer maneira. Além disso, você deve ter cuidado para não introduzir nada que possa demorar muito para aparecer em seus aliases. Se você estiver executando um script que leva muito tempo para ser executado, considere se esse é o lugar certo para isso.

Conclusão

Espero que este artigo tenha mostrado o poder dos scripts em seus aliases git. Usando scripts você pode criar aliases mais complexos que são mais fáceis de manter e entender. Isso pode tornar seu fluxo de trabalho git mais eficiente e agradável. Para mais exemplos de aliases do git, você pode dar uma olhada no meu projeto dotfiles. Ele contém muitas configurações que mantenho em todas as minhas máquinas, incluindo meus aliases git.