Comment puis-je faire avancer rapidement un seul commit git, par programmation?

J'ai régulièrement un message à partir de git qui ressemblent à ceci:

Your branch is behind the tracked remote branch 'local-master/master' 
by 3 commits, and can be fast-forwarded.

J'aimerais être capable d'écrire des commandes dans un shell script qui peut faire ce qui suit:

  1. Comment puis-je savoir si ma branche peut être l'avance rapide de la télécommande branche il est suivi?
  2. Comment puis-je savoir combien de livraisons "derrière" ma branche?
  3. Comment puis-je avancer rapidement par juste un s'engager, de sorte que, par exemple, ma branche locale de la "derrière par 3 s'engage" à "derrière par 2 s'engage"?

(Pour ceux qui sont intéressés, je suis en train de mettre ensemble une qualité git/darcs miroir.)

source d'informationauteur Norman Ramsey | 2010-05-23

  1. 9

    La branche distante peut être rapidement transmis à l'agence si le commit courant est l'ancêtre de la branche à distance de la tête. En d'autres termes, si le "one-direction générale de l'histoire" de la branche distante contient le commit courant (parce que si c'est le cas, il est certain que les nouveaux commits ont été commis "sur" le commit courant)

    Donc un moyen sûr de déterminer si la branche à distance peut être rapide transmise:

    # Convert reference names to commit IDs
current_commit=$(git rev-parse HEAD)
remote_commit=$(git rev-parse remote_name/remote_branch_name)

# Call git log so that it prints only commit IDs
log=$(git log --topo-order --format='%H' $remote_commit | grep $current_commit)

# Check the existence of the current commit in the log
if [ ! -z "$log" ]
  then echo 'Remote branch can be fast-forwarded!'
fi

    Noter que la commande git log a été appelé sans le --tous les paramètres (ce qui serait la liste de toutes les branches), de sorte qu'il n'est pas possible que le commit est sur une "branche" et est toujours imprimé sur la sortie.

    Le nombre de commits avant de le commit courant est égal au nombre de lignes dans le journal de $avant $current_commit.

    Si vous voulez avancer rapidement dans un seul commit, vous prenez la ligne précédente pour le commit courant (avec grep -B 1, par exemple), et de réinitialiser la branche locale de ce commit.

    Mise à JOUR: vous pouvez utiliser git log commit1..commit2 pour déterminer le nombre de fast-transfert s'engage à:

    if [ ! -z "$log" ]
then
  # print the number of commits ahead of the current commit
  ff_commits=$(git log --topo-order --format='%H' \
    $current_commit..$remote_commit | wc -l)
  echo "Number of fast-forwarding commits: $ff_commits"

  # fast-forward only one commit
  if [ $ff_commits -gt 1 ]
  then
    next_commit=$(git log --topo-order --format='%H' \
      $current_commit..$remote_commit | tail -1)
    git reset --hard $next_commit
  fi
fi

    Bien sûr, vous pouvez le faire avec un git log appeler si vous enregistrez le résultat du premier appel dans un fichier.

  2. 10

    D'Autres Approches

    Vous mentionnez que vous travaillez sur une sorte de miroir pour Git et Darcs. Au lieu de glisser d'un arbre de travail à travers l'histoire, vous devriez plutôt chercher à le git fast-import et git fast-export commandes pour voir si elles offrent une meilleure façon de gérer les données dont vous avez besoin pour extraire/fournir.

    Comment faire pour savoir Si une Branche Peut Avancer Rapidement à Son Amont de la Branche

    Il y a deux parties. Tout d'abord, vous devez connaître ou déterminer quelle branche est la branche courante est “en amont”. Ensuite, une fois que vous savez comment faire reportez-vous à l'amont, vous vérifiez la capacité de l'avance rapide.

    Trouver Amont pour une Branche

    Git 1.7.0 a un moyen pratique de requête qui branche une branche de pistes (son “en amont” de la branche). Le @{upstream} objet de spécification de la syntaxe peut être utilisée comme une branche spécificateur. Comme un simple nom, il se réfère à l'amont de la branche, pour la direction, qui est en cours d'extraction. Comme un suffixe, il peut être utilisé pour trouver l'amont de la branche pour les branches qui ne sont pas en cours d'extraction.

    Pour Gits plus tôt que la version 1.7.0, vous devrez analyser la branche des options de configuration vous-même (branch.name.remote et branch.name.merge). Sinon, si vous avez une convention de nommage, vous pouvez simplement utiliser pour déterminer un nom pour l'amont de la branche.

    Dans cette réponse, je vais écrire upstream à se référer à la livraison à l'extrémité de la branche qui est en amont de la branche courante.

    La vérification de Capacité pour effectuer une avance Rapide

    Une branche à commettre Un peut être rapidement transmis à commettre B si et seulement si A est un ancêtre de B.

    gyim montre une façon de vérifier cette condition (la liste de tous les commits accessible à partir de B et de vérifier dans la liste). Peut-être un moyen plus simple de vérifier cette condition est de vérifier que l'Un est la fusion de la base de A et de B.

    can_ff() {
    a="$(git rev-parse "$1")" &&
    test "$(git merge-base "$a" "$2")" = "$a"
}
if can_ff HEAD local-master/master; then
    echo can ff to local-master/master
else
    echo CAN NOT ff to local-master/master
fi

    Trouver le Nombre de “s'Engage Derrière”

    git rev-list ^HEAD upstream | wc -l

    Cela ne nécessite pas que la TÊTE peut avancer rapidement à en amont (il ne compte à quelle distance de la TÊTE est derrière en amont, pas loin en amont est derrière la TÊTE).

    Aller de l'Avant par Un Commit

    En général, un fast-forward-mesure de l'histoire peut ne pas être linéaire. Dans l'histoire DAG ci-dessous, maître pourrait avancer rapidement à en amontmais à la fois A et B sont “un commit de l'avant” de l' maître sur le chemin vers la en amont.

    ---o---o                      master
       |\
       | A--o--o--o--o--o--o  upstream
        \                 /
         B---o---o---o---o

    Vous pouvez suivre un côté comme si c'était une histoire linéaire, mais seulement jusqu'à l'ancêtre immédiat de la fusion de la validation.

    La révision de la marche les commandes ont un --first-parent option qui le rend facile à suivre seulement les changements qui conduisent à la première parent de fusion s'engage. Combinez cela avec git reset et vous pouvez faire glisser une branche “en avant, un commit à un moment”.

    git reset --hard "$(git rev-list --first-parent --topo-order --reverse ^HEAD upstream | head -1)"

    Dans un commentaire sur une autre réponse, vous exprimer de peur de git reset. Si vous êtes inquiet au sujet de corrompre certains de branche, vous pouvez alors soit utiliser une temporaire de branche ou d'utiliser un décollement de la TÊTE comme une nouvelle branche. Tant que votre arbre de travail est propre et que vous n'avez pas l'esprit le déplacement d'une branche (ou le détachement de la TÊTE), git reset --hard ne sera pas trash quoi que ce soit. Si vous êtes inquiet, vous devriez étudier sérieusement en utilisant git fast-export où vous n'avez pas à toucher à l'arbre de travail.

    À la suite d'un autre parent serait plus difficile. Vous seriez probablement avoir à écrire votre propre histoire walker, de sorte que vous pourriez donner des conseils quant à la “direction” que vous vouliez aller pour chaque fusion.

    Lorsque vous avez déplacé vers l'avant à un point juste en deçà de la fusion, le groupe va ressembler à ceci (la topologie est la même qu'avant, c'est seulement la maître étiquette qui a déplacé):

    ---o---o--A--o--o--o--o--o    master
       |                  \
       |                   o  upstream
        \                 /
         B---o---o---o---o

    À ce stade, si vous “aller de l'avant un commit”, vous passez à la fusion. Ce sera aussi “apporter” (rendre accessible à partir de maître) tous les commits de B jusqu'à la fusion de la validation. Si vous supposez que “aller de l'avant un commit” ne fera qu'ajouter un commit à l'histoire DAG, alors cette étape, ne pas violer cette hypothèse.

    Vous allez probablement vouloir examiner attentivement ce que vous voulez vraiment faire dans ce cas. C'est OK pour simplement faire glisser supplémentaires s'engage comme cela, ou devrait-il y avoir un mécanisme pour “remonter” vers le parent de B et d'avancer sur la branche avant le processus de fusion s'engager?

  3. 7

    Ce n'est probablement pas le plus élégant, mais il fonctionne:

    $ git fetch 
$ git status | sed -n 2p 
# Votre branche est derrière 'origin/master' 23 engage, et peut être l'avance rapide. 
$ git reset origin/master~22 > /dev/null 
$ git status | sed -n 2p 
# Votre branche est derrière 'origin/master' 22 s'engage, et peut être l'avance rapide.