Que sont les alias Git

Les alias Git fonctionnent de la même manière que les alias classiques dans le shell, mais ils sont spécifiques aux commandes Git. Ils vous permettent de créer des raccourcis pour des commandes plus longues ou de créer de nouvelles commandes qui ne sont pas disponibles par défaut.

Les alias s'exécutent dans le même environnement shell que les autres commandes git et sont principalement utilisés pour simplifier les flux de travail courants.

Alias ​​simples

Les alias simples appellent une seule commande Git avec un ensemble d'arguments. Par exemple, vous pouvez créer un alias pour afficher l'état du référentiel en exécutant git status avec l'alias s :

[alias]
  s = status

Vous pouvez ensuite exécuter git s pour afficher l'état du référentiel. Parce que nous avons configuré l'alias dans ~/.gitconfig, il est disponible pour tous les référentiels du système.

Alias ​​plus complexes

Vous pouvez également créer des alias git qui exécutent une commande shell arbitraire. Pour ce faire, l'alias doit commencer par un !. Cela indique à git d'exécuter l'alias comme s'il ne s'agissait pas d'une sous-commande git. Par exemple, si vous souhaitez exécuter deux commandes git en séquence, vous pouvez créer un alias qui exécute une commande shell :

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

Cet alias exécute git fetch et git rebase origin/main dans l'ordre lorsque vous exécutez git my-alias.

Une limitation des alias git est qu'ils ne peuvent pas être définis sur une valeur multiligne. Cela signifie que pour les alias plus complexes, vous devrez les réduire.

De plus, dans un fichier INI un ; Le caractère est utilisé pour commenter le reste de la ligne. Cela signifie que vous ne pouvez pas utiliser ; dans vos commandes d'alias.

Ces deux limitations peuvent rendre difficile la création d'alias plus complexes à l'aide de la syntaxe d'alias git standard, mais cela peut toujours être fait. Par exemple, un alias utilisant if to branch peut ressembler à ceci :

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

Ces limites rendent beaucoup plus complexe la création et la maintenance d'alias contenant une forme de flux de contrôle. C'est là qu'interviennent les scripts.

Configuration d'alias avec des scripts

Vous pouvez scripter un gitalias en utilisant n'importe quel langage de programmation de votre choix. Si vous êtes familier avec les scripts bash et souhaitez l'utiliser, vous pouvez créer un script bash qui exécute les commandes git souhaitées. La vérité est que je suis beaucoup plus fort avec JavaScript, c'est donc ce que je vais utiliser.

Un autre avantage majeur est qu'en utilisant un langage de script, vos alias peuvent prendre et opérer sur des arguments beaucoup plus facilement. Git transmettra tous les arguments que vous transmettez sur la CLI à votre alias en les ajoutant à la fin de votre commande. En tant que tel, votre script devrait pouvoir les lire sans problème. Par exemple, dans Node JS, vous pouvez accéder aux arguments passés au script directement sur process.argv.

Les étapes de base pour configurer cela ne changent pas en fonction de la langue choisie. Vous devrez :

• Créez un script qui exécute les commandes git souhaitées
• Écrivez un alias qui exécute le script

Étude de cas : Rebase Main/master

Ces dernières années, le nom de branche par défaut pour les nouveaux référentiels est passé de maître à principal. Cela signifie que lorsque vous clonez un nouveau référentiel, la branche par défaut peut être main au lieu de master. Il n’y a plus de nom super cohérent, tant l’écosystème est en transition. C'est globalement une bonne chose, mais cela signifie que notre alias ci-dessus pour rebaser ne fonctionnera pas dans tous les cas.

Nous devons mettre à jour notre alias pour vérifier si la branche est principale ou principale, puis rebaser la bonne branche. Il s'agit d'un cas d'utilisation parfait pour un 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'});

Actuellement, pour exécuter le script, nous devons exécuter node ~/gitaliases/git-rebase-main.js. Ce n’est pas idéal et ce n’est pas quelque chose que vous prendriez l’habitude de faire. Nous pouvons rendre cela plus facile en créant un alias git qui exécute le script.

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

Vous pouvez désormais exécuter git rebase-main pour rebaser la branche correcte, qu'elle soit principale ou principale.

Étude de cas : Modifier

Un autre alias que j'ai configuré sur toutes mes machines consiste à modifier le dernier commit. Il s’agit d’un flux de travail très courant pour moi et j’aime l’avoir sous la forme d’une seule commande. Il s'agit d'un excellent cas d'utilisation pour un script, car il s'agit d'une commande simple que je souhaite exécuter souvent.

#!/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');
  }
})();

Ce script est un peu plus complexe que le précédent, car il contient un certain flux de contrôle. Il vérifiera si d'autres branches s'appuient sur le commit actuel, et si c'est le cas, il se terminera avec une erreur. Ceci a pour but de vous empêcher de modifier un commit sur lequel s'appuient d'autres branches, car cela entraînerait des problèmes lors de la tentative de fusion de la branche qui s'appuie sur le commit.

Pour configurer l'alias, vous pouvez utiliser la même méthode que précédemment :

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

Vous pouvez maintenant exécuter git amend pour modifier la dernière validation, ou git amend undo pour annuler la dernière modification. Il s'agit d'un script que j'ai initialement écrit en ligne dans mon gitconfig, mais à mesure qu'il devenait plus complexe, je l'ai déplacé vers un fichier de script. C'est un excellent moyen de gérer la complexité de vos alias. À titre de comparaison, voici l'alias d'origine :

[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'"

Ce script aurait également pu être extrait dans un fichier .sh, mais garder les éléments dans le nœud réduit le fardeau de maintenance pour moi personnellement. Dans le passé, chaque fois que j'avais besoin de mettre à jour cet alias, je devais le coller dans un linter bash, apporter mes modifications, le réduire, puis le recoller dans mon gitconfig. C'était pénible et j'évitais souvent de mettre à jour l'alias à cause de cela. Maintenant qu'il est dans un fichier script, je peux le mettre à jour comme n'importe quel autre script.

Quelques mises en garde

La configuration d'alias en tant que scripts peut débloquer un tout nouveau niveau de puissance dans vos alias git. Cependant, il y a certaines choses à prendre en compte lors de cette opération.

Lors de la configuration d'alias comme celui-ci, il est important de se rappeler que le cwd du script sera le répertoire de travail actuel du shell qui exécute le script. Tous les chemins de fichiers relatifs dans le script seront traités comme relatifs au cwd du shell, et non à l'emplacement du script. C’est parfois très utile et très pénible à d’autres. Pour notre script rebase-main, ce n'est pas un problème, et la seule indication que cela se produit est que nous avons utilisé ~ dans le chemin du fichier pour référencer l'emplacement du script en tant que chemin absolu.

L'introduction de scripts dans vos alias git peut également rendre tentant d'ajouter de plus en plus de logique à vos alias. Cela peut les rendre plus difficiles à maintenir et à comprendre, mais également plus difficiles à mémoriser. Cela ne vaut pas la peine de conserver un alias super complexe, car vous serez de toute façon moins susceptible de l'utiliser. De plus, vous devez faire attention à ne pas introduire quoi que ce soit qui puisse mettre trop de temps à se retrouver dans vos alias. Si vous exécutez un script qui prend beaucoup de temps, vous souhaiterez peut-être vous demander si c'est le bon endroit pour l'exécuter.

Conclusion

J'espère que cet article vous a montré la puissance des scripts dans vos alias git. En utilisant des scripts, vous pouvez créer des alias plus complexes, plus faciles à gérer et à comprendre. Cela peut rendre votre flux de travail git plus efficace et plus agréable. Pour plus d'exemples d'alias git, vous pouvez consulter mon projet dotfiles. Il contient une grande partie de la configuration que je conserve sur toutes mes machines, y compris mes alias git.