¿Qué son los alias de Git?

Los alias de Git funcionan de manera similar a los alias normales en el shell, pero son específicos de los comandos de Git. Le permiten crear accesos directos para comandos más largos o crear comandos nuevos que no están disponibles de forma predeterminada.

Los alias se ejecutan en el mismo entorno de shell que otros comandos de git y se utilizan principalmente para simplificar los flujos de trabajo comunes.

Alias ​​simples

Los alias simples llaman a un único comando de Git con un conjunto de argumentos. Por ejemplo, puede crear un alias para mostrar el estado del repositorio ejecutando git status con el alias s:

[alias]
  s = status

Luego puedes ejecutar git s para mostrar el estado del repositorio. Debido a que configuramos el alias en ~/.gitconfig, está disponible para todos los repositorios del sistema.

Alias ​​más complejos

También puedes crear alias de git que ejecuten un comando de shell arbitrario. Para hacerlo, el alias debe comenzar con !. Esto le dice a git que ejecute el alias como si no fuera un subcomando de git. Por ejemplo, si desea ejecutar dos comandos de git en secuencia, puede crear un alias que ejecute un comando de shell:

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

Este alias ejecuta git fetch y git rebase origin/main en secuencia cuando ejecutas git my-alias.

Una limitación de los alias de git es que no se pueden establecer en un valor de varias líneas. Esto significa que para alias más complejos tendrás que minimizarlos.

Además, en un archivo INI un ; El carácter se utiliza para comentar el resto de la línea. Esto significa que no puedes usar ; en tus comandos de alias.

Estas dos limitaciones pueden dificultar la creación de alias más complejos utilizando la sintaxis estándar de alias de git, pero aún así se puede hacer. Por ejemplo, un alias que use if to bifurcar puede verse así:

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

Estos límites hacen que sea mucho más complejo crear y mantener alias que tengan algún tipo de flujo de control dentro de ellos. Aquí es donde entran en juego las secuencias de comandos.

Configurar alias con scripts

Puedes escribir un gitalias usando cualquier lenguaje de programación que desees. Si está familiarizado con las secuencias de comandos bash y desea utilizarlas, puede crear una secuencia de comandos bash que ejecute los comandos git deseados. La verdad es que soy mucho más fuerte con JavaScript, así que eso es lo que usaré.

Otro beneficio importante es que al utilizar un lenguaje de secuencias de comandos, sus alias pueden tomar y operar con argumentos mucho más fácilmente. Git reenviará cualquier argumento que pase a la CLI a su alias agregándolo al final de su comando. Como tal, su script debería poder leerlos sin problemas. Por ejemplo, en Node JS puedes acceder a los argumentos pasados ​​al script directamente en process.argv.

Los pasos básicos para configurar esto no cambian según el idioma elegido. Necesitarás:

• Cree un script que ejecute los comandos git deseados
• Escribe un alias que ejecute el script

Estudio de caso: Rebase principal/maestro

En los últimos años, el nombre de la rama predeterminada para los nuevos repositorios ha cambiado de maestro a principal. Esto significa que cuando clonas un nuevo repositorio, la rama predeterminada puede ser principal en lugar de maestra. Ya no existe un nombre súper consistente, pues el ecosistema está en transición. En general, esto es algo bueno, pero significa que nuestro alias anterior para rebase no funcionará en todos los casos.

Necesitamos actualizar nuestro alias para verificar si la rama es principal o maestra y luego cambiar la base de la rama correcta. Este es un caso de uso perfecto para 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'});

Actualmente, para ejecutar el script necesitaríamos ejecutar el nodo ~/gitaliases/git-rebase-main.js. Esto no es ideal y no es algo que alguna vez tengas el hábito de hacer. Podemos hacer esto más fácil creando un alias de git que ejecute el script.

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

Ahora puedes ejecutar git rebase-main para rebase la rama correcta, independientemente de si es principal o maestra.

Estudio de caso: Enmendar

Otro alias que configuro en todas mis máquinas es modificar la última confirmación. Este es un flujo de trabajo muy común para mí y me gusta tenerlo como un solo comando. Este es un excelente caso de uso para un script, ya que es un comando simple que quiero ejecutar con frecuencia.

#!/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 es un poco más complejo que el anterior, ya que tiene cierto flujo de control. Verificará si otras ramas confían en la confirmación actual y, si es así, saldrá con un error. Esto es para evitar que modifiques una confirmación en la que confían otras ramas, ya que hacerlo causaría problemas al intentar fusionar cualquier rama que dependa de la confirmación.

Para configurar el alias, puedes usar el mismo método que antes:

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

Ahora puedes ejecutar git amend para modificar la última modificación, o git amend undo para deshacer la última modificación. Este es un script que inicialmente escribí en línea en mi gitconfig, pero a medida que creció en complejidad lo moví a un archivo de script. Esta es una excelente manera de gestionar la complejidad de sus alias. A modo de comparación, aquí está el 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 también podría haberse extraído a un archivo .sh, pero mantener las cosas en el nodo reduce la carga de mantenimiento para mí personalmente. En el pasado, cada vez que necesitaba actualizar este alias tenía que pegarlo en un bash linter, hacer mis cambios, minimizarlo y luego volver a pegarlo en mi gitconfig. Esto era una molestia y, a menudo, evitaba actualizar el alias debido a ello. Ahora que está en un archivo de script, puedo actualizarlo como cualquier otro script.

Algunas advertencias

Configurar alias como scripts puede desbloquear un nivel completamente nuevo de poder en tus alias de git. Sin embargo, hay algunas cosas que debes tener en cuenta al hacer esto.

Al configurar alias como este, es importante recordar que el cwd del script será el directorio de trabajo actual del shell que ejecuta el script. Cualquier ruta de archivo relativa en el script se tratará como relativa al cwd del shell, no a la ubicación del script. Esto es muy útil a veces y muy doloroso en otras. Sin embargo, para nuestro script rebase-main no es un problema, y ​​la única indicación de que esto está sucediendo es que usamos ~ en la ruta del archivo para hacer referencia a la ubicación del script como una ruta absoluta.

Introducir scripts en tus alias de git también puede hacer que sea tentador agregar más y más lógica a tus alias. Esto puede hacer que sean más difíciles de mantener y comprender, pero también de recordar. No vale la pena mantener un alias súper complejo, ya que de todos modos será menos probable que lo uses. Además, debe tener cuidado de no introducir nada que pueda tardar demasiado en aparecer en sus alias. Si está ejecutando un script que tarda mucho en ejecutarse, es posible que desee considerar si es el lugar adecuado para ello.

Conclusión

Espero que este artículo te haya mostrado el poder de las secuencias de comandos en tus alias de git. Al utilizar scripts, puede crear alias más complejos que sean más fáciles de mantener y comprender. Esto puede hacer que su flujo de trabajo de git sea más eficiente y agradable. Para obtener más ejemplos de alias de git, puedes consultar mi proyecto dotfiles. Contiene gran parte de la configuración que mantengo en todas mis máquinas, incluidos mis alias de git.