Was sind Git-Aliase?

Git-Aliase funktionieren ähnlich wie reguläre Aliase in der Shell, sind jedoch spezifisch für Git-Befehle. Sie ermöglichen Ihnen, Verknüpfungen für längere Befehle zu erstellen oder neue Befehle zu erstellen, die standardmäßig nicht verfügbar sind.

Aliase werden in derselben Shell-Umgebung wie andere Git-Befehle ausgeführt und werden hauptsächlich zur Vereinfachung allgemeiner Arbeitsabläufe verwendet.

Einfache Aliase

Einfache Aliase rufen einen einzelnen Git-Befehl mit einer Reihe von Argumenten auf. Sie können beispielsweise einen Alias ​​erstellen, um den Status des Repositorys anzuzeigen, indem Sie git status mit dem Alias ​​s ausführen:

[alias]
  s = status

Sie können dann git s ausführen, um den Status des Repositorys anzuzeigen. Da wir den Alias ​​in ~/.gitconfig konfiguriert haben, ist er für alle Repositorys auf dem System verfügbar.

Komplexere Aliase

Sie können auch Git-Aliase erstellen, die einen beliebigen Shell-Befehl ausführen. Dazu muss der Alias ​​mit einem ! beginnen. Dies weist Git an, den Alias ​​so auszuführen, als wäre es kein Git-Unterbefehl. Wenn Sie beispielsweise zwei Git-Befehle nacheinander ausführen möchten, können Sie einen Alias ​​erstellen, der einen Shell-Befehl ausführt:

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

Dieser Alias ​​führt git fetch und git rebase origin/main nacheinander aus, wenn Sie git my-alias ausführen.

Eine Einschränkung von Git-Aliassen besteht darin, dass sie nicht auf einen mehrzeiligen Wert festgelegt werden können. Das bedeutet, dass Sie komplexere Aliase minimieren müssen.

Zusätzlich kann in einer INI-Datei ein ; Mit dem Zeichen wird der Rest der Zeile auskommentiert. Das bedeutet, dass Sie ; nicht verwenden können. in Ihren Alias-Befehlen.

Diese beiden Einschränkungen können es schwierig machen, komplexere Aliase mit der Standard-Git-Alias-Syntax zu erstellen, aber es ist trotzdem möglich. Ein Alias, der if to branch verwendet, könnte beispielsweise so aussehen:

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

Diese Einschränkungen machen es viel komplexer, Aliase zu erstellen und zu verwalten, die irgendeine Form von Kontrollfluss enthalten. Hier kommt das Scripting ins Spiel.

Aliase mit Skripten einrichten

Sie können ein Gitalias mit jeder beliebigen Programmiersprache skripten. Wenn Sie mit Bash-Skripten vertraut sind und diese nutzen möchten, können Sie ein Bash-Skript erstellen, das die gewünschten Git-Befehle ausführt. Die Wahrheit ist, dass ich mit JavaScript viel besser umgehen kann, also werde ich es verwenden.

Ein weiterer großer Vorteil besteht darin, dass Ihre Aliase durch die Verwendung einer Skriptsprache Argumente viel einfacher annehmen und bearbeiten können. Git leitet alle Argumente, die Sie über die CLI übergeben, an Ihren Alias ​​weiter, indem es sie am Ende Ihres Befehls anhängt. Daher sollte Ihr Skript sie ohne Probleme lesen können. In Node JS können Sie beispielsweise direkt auf „process.argv“ auf die an das Skript übergebenen Argumente zugreifen.

Die grundlegenden Schritte zum Einrichten ändern sich nicht je nach gewählter Sprache. Sie müssen Folgendes tun:

• Erstellen Sie ein Skript, das die gewünschten Git-Befehle ausführt
• Schreiben Sie einen Alias, der das Skript ausführt

Fallstudie: Rebase Main / Master

In den letzten Jahren hat sich der Standardzweigname für neue Repositorys von „Master“ in „Main“ geändert. Das bedeutet, dass beim Klonen eines neuen Repositorys der Standardzweig möglicherweise „main“ statt „master“ ist. Es gibt keinen superkonsistenten Namen mehr, da sich das Ökosystem im Wandel befindet. Das ist insgesamt eine gute Sache, aber es bedeutet, dass unser oben genannter Alias ​​zum Rebase nicht in allen Fällen funktioniert.

Wir müssen unseren Alias ​​aktualisieren, um zu prüfen, ob der Zweig main oder master ist, und dann den richtigen Zweig umbasieren. Dies ist ein perfekter Anwendungsfall für ein Skript.

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

Derzeit müssten wir zum Ausführen des Skripts den Knoten ~/gitaliases/git-rebase-main.js ausführen. Das ist nicht ideal, und Sie werden es sich auch nicht zur Gewohnheit machen. Wir können dies einfacher machen, indem wir einen Git-Alias ​​erstellen, der das Skript ausführt.

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

Jetzt können Sie git rebase-main ausführen, um den richtigen Zweig neu zu starten, unabhängig davon, ob es sich um den Haupt- oder Masterzweig handelt.

Fallstudie: Änderung

Ein weiterer Alias, den ich auf allen meinen Maschinen eingerichtet habe, ist die Änderung des letzten Commits. Das ist für mich ein sehr verbreiteter Arbeitsablauf, und ich möchte ihn gerne als einen einzelnen Befehl haben. Dies ist ein großartiger Anwendungsfall für ein Skript, da es sich um einen einfachen Befehl handelt, den ich oft ausführen möchte.

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

Dieses Skript ist etwas komplexer als das letzte, da es einen gewissen Kontrollfluss enthält. Es prüft, ob andere Zweige auf den aktuellen Commit angewiesen sind, und wenn dies der Fall ist, wird der Vorgang mit einem Fehler beendet. Dies soll verhindern, dass Sie einen Commit ändern, auf den sich andere Branches verlassen, da dies zu Problemen führen würde, wenn Sie versuchen, den Branch zusammenzuführen, der auf dem Commit basiert.

Um den Alias ​​einzurichten, können Sie die gleiche Methode wie zuvor verwenden:

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

Jetzt können Sie git amend ausführen, um den letzten Commit zu ändern, oder git amend undo, um die letzte Änderung rückgängig zu machen. Dies ist ein Skript, das ich ursprünglich inline in meiner Gitconfig geschrieben habe, aber als es immer komplexer wurde, habe ich es in eine Skriptdatei verschoben. Dies ist eine großartige Möglichkeit, die Komplexität Ihrer Aliase zu verwalten. Zum Vergleich hier der ursprüngliche Alias:

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

Dieses Skript hätte auch in eine .sh-Datei extrahiert werden können, aber die Aufbewahrung der Dinge im Knoten verringert für mich persönlich den Wartungsaufwand. In der Vergangenheit musste ich diesen Alias ​​jedes Mal, wenn ich ihn aktualisieren musste, in einen Bash-Linter einfügen, meine Änderungen vornehmen, ihn minimieren und ihn dann wieder in meine Gitconfig einfügen. Das war mühsam und ich habe es deshalb oft vermieden, den Alias ​​zu aktualisieren. Da es sich nun in einer Skriptdatei befindet, kann ich es wie jedes andere Skript aktualisieren.

Einige Vorbehalte

Das Einrichten von Aliasen als Skripte kann eine völlig neue Leistungsstufe Ihrer Git-Aliase freischalten. Allerdings gibt es dabei einige Dinge zu beachten.

Beim Einrichten solcher Aliase ist es wichtig zu bedenken, dass das cwd des Skripts das aktuelle Arbeitsverzeichnis der Shell ist, die das Skript ausführt. Alle relativen Dateipfade im Skript werden als relativ zum cwd der Shell behandelt, nicht als relativ zum Speicherort des Skripts. Das ist manchmal sehr nützlich und manchmal sehr schmerzhaft. Für unser Rebase-Main-Skript stellt dies jedoch kein Problem dar, und der einzige Hinweis darauf, dass dies geschieht, ist, dass wir „~“ im Dateipfad verwendet haben, um den Skriptspeicherort als absoluten Pfad zu referenzieren.

Die Einführung von Skripten in Ihre Git-Aliase kann auch dazu verleiten, Ihren Aliasen immer mehr Logik hinzuzufügen. Dies kann es schwieriger machen, sie zu pflegen und zu verstehen, aber auch schwerer zu merken. Es lohnt sich nicht, einen superkomplexen Alias ​​beizubehalten, da die Wahrscheinlichkeit, dass Sie ihn sowieso verwenden, geringer ist. Darüber hinaus sollten Sie darauf achten, nichts einzuführen, was zu lange dauern könnte, bis es in Ihre Aliase gelangt. Wenn Sie ein Skript ausführen, dessen Ausführung lange dauert, sollten Sie überlegen, ob es der richtige Ort dafür ist.

Abschluss

Ich hoffe, dieser Artikel hat Ihnen die Leistungsfähigkeit der Skripterstellung in Ihren Git-Aliassen gezeigt. Durch die Verwendung von Skripten können Sie komplexere Aliase erstellen, die einfacher zu verwalten und zu verstehen sind. Dies kann Ihren Git-Workflow effizienter und angenehmer machen. Weitere Beispiele für Git-Aliase finden Sie in meinem Dotfiles-Projekt. Es enthält einen Großteil der Konfiguration, die ich auf allen meinen Maschinen behalte, einschließlich meiner Git-Aliase.