Voglio elencare tutti i commit che fanno solo parte di un ramo specifico.

Con quanto segue, elenca tutti i commit dal ramo, ma anche dal genitore (master)

git log mybranch

L'altra opzione che ho trovato è stata quella di escludere gli commit raggiungibili dal master e mi dà quello che voglio, MA vorrei evitare la necessità di conoscere i nomi degli altri rami.

git log mybranch --not master

Stavo cercando di utilizzare git for-each-ref, ma elenca anche mybranch, quindi in realtà esclude tutto:

git log mybranch --not $(git for-each-ref --format '^%(refname:short)' refs/heads/)

Aggiornare:

Sto testando una nuova opzione che ho trovato qualche tempo fa e fino ad ora sembra che questo potrebbe essere quello che stavo cercando:

git log --walk-reflogs mybranch

Aggiornamento (2013-02-13T15: 08):

L'opzione --walk-reflogs è buona, ma ho verificato che ci sia una scadenza per i reflog (default 90 giorni, gc.reflogExpire ).

Penso di aver trovato la risposta che cercavo:

git log mybranch --not $(git for-each-ref --format='%(refname)' refs/heads/ | grep -v "refs/heads/mybranch")

Sto solo rimuovendo il ramo corrente dall'elenco dei rami disponibili e sto usando quell'elenco per essere escluso dal registro. In questo modo ottengo solo i commit che vengono raggiunti solo da Mybranch .

Da quello che sembra che dovresti usare cherry:

git cherry -v develop mybranch

Ciò mostrerebbe tutti i commit contenuti in mybranch , ma NON in fase di sviluppo . Se si interrompe l'ultima opzione ( mybranch ), verrà invece confrontato il ramo corrente.

Come ha sottolineato VonC, stai SEMPRE confrontando il tuo ramo con un altro ramo, quindi conosci i tuoi rami e quindi scegli quale confrontare.

MA vorrei evitare la necessità di conoscere i nomi degli altri rami.

Non credo sia possibile: un ramo in Git si basa sempre su un altro o almeno su un altro commit, come spiegato in " git diff non mostra abbastanza ":

È necessario un punto di riferimento per il registro per mostrare i giusti commit.

Come menzionato in " GIT - Da dove mi sono ramificato? ":

i rami sono semplicemente dei puntatori a determinati commit in un DAG

Quindi, anche se git log master..mybranchè una risposta, mostrerebbe comunque troppi commit, se mybranchbasato su myotherbranch, stesso basato su master.

Per trovare quel riferimento (l'origine del tuo ramo), puoi solo analizzare i commit e vedere in quale ramo sono, come si vede in:

• " Git: Trovare da quale ramo proviene un commit ".
• " Come posso vedere da quale ramo è stato biforcuto un altro ramo? "

Alla fine ho trovato il modo di fare ciò che voleva l'OP. È semplice come:

git log --graph [branchname]

Il comando visualizzerà tutti i commit raggiungibili dal ramo fornito nel formato del grafico. Tuttavia, puoi facilmente filtrare tutti i commit su quel ramo osservando il grafico dei commit il cui *primo carattere nella riga di commit.

Ad esempio, diamo un'occhiata al seguente estratto git log --graph mastersul repository GitHub di cakephp:

D:\Web Folder\cakephp>git log --graph master
*   commit 8314c2ff833280bbc7102cb6d4fcf62240cd3ac4
|\  Merge: c3f45e8 0459a35
| | Author: José Lorenzo Rodríguez <lorenzo@users.noreply.github.com>
| | Date:   Tue Aug 30 08:01:59 2016 +0200
| |
| |     Merge pull request #9367 from cakephp/fewer-allocations
| |
| |     Do fewer allocations for simple default values.
| |
| * commit 0459a35689fec80bd8dca41e31d244a126d9e15e
| | Author: Mark Story <mark@mark-story.com>
| | Date:   Mon Aug 29 22:21:16 2016 -0400
| |
| |     The action should only be defaulted when there are no patterns
| |
| |     Only default the action name when there is no default & no pattern
| |     defined.
| |
| * commit 80c123b9dbd1c1b3301ec1270adc6c07824aeb5c
| | Author: Mark Story <mark@mark-story.com>
| | Date:   Sun Aug 28 22:35:20 2016 -0400
| |
| |     Do fewer allocations for simple default values.
| |
| |     Don't allocate arrays when we are only assigning a single array key
| |     value.
| |
* |   commit c3f45e811e4b49fe27624b57c3eb8f4721a4323b
|\ \  Merge: 10e5734 43178fd
| |/  Author: Mark Story <mark@mark-story.com>
|/|   Date:   Mon Aug 29 22:15:30 2016 -0400
| |
| |       Merge pull request #9322 from cakephp/add-email-assertions
| |
| |       Add email assertions trait
| |
| * commit 43178fd55d7ef9a42706279fa275bb783063cf34
| | Author: Jad Bitar <jadbitar@mac.com>
| | Date:   Mon Aug 29 17:43:29 2016 -0400
| |
| |     Fix `@since` in new files docblocks
| |

Come puoi vedere, si impegna solo 8314c2ff833280bbc7102cb6d4fcf62240cd3ac4e c3f45e811e4b49fe27624b57c3eb8f4721a4323bha l' *essere il primo personaggio nelle righe di commit. Tali commit provengono dal ramo principale mentre gli altri quattro provengono da alcuni altri rami.

Il seguente comando shell dovrebbe fare quello che vuoi:

git log --all --not $(git rev-list --no-walk --exclude=refs/heads/mybranch --all)

Avvertenze

Se hai mybranchverificato, il comando sopra non funzionerà. Questo perché anche i commit mybranchsono raggiungibili HEAD, quindi Git non considera i commit unici mybranch. Per farlo funzionare quando mybranchè stato estratto, è inoltre necessario aggiungere un'esclusione per HEAD:

git log --all --not $(git rev-list --no-walk \
    --exclude=refs/heads/mybranch \
    --exclude=HEAD \
    --all)

Tuttavia, si dovrebbe non escludere HEADa meno che il mybranchè stato estratto, altrimenti si rischia di mostrare commit che non sono esclusiva mybranch.

Allo stesso modo, se si dispone di un ramo remoto denominato origin/mybranchche corrisponde al mybranchramo locale , è necessario escluderlo:

git log --all --not $(git rev-list --no-walk \
    --exclude=refs/heads/mybranch \
    --exclude=refs/remotes/origin/mybranch \
    --all)

E se il ramo remoto è il ramo predefinito per il repository remoto (di solito è vero solo per origin/master), dovrai anche escludere origin/HEAD:

git log --all --not $(git rev-list --no-walk \
    --exclude=refs/heads/mybranch \
    --exclude=refs/remotes/origin/mybranch \
    --exclude=refs/remotes/origin/HEAD \
    --all)

Se il ramo è stato estratto e c'è un ramo remoto e il ramo remoto è l'impostazione predefinita per il repository remoto, si finisce per escludere molto:

git log --all --not $(git rev-list --no-walk \
    --exclude=refs/heads/mybranch \
    --exclude=HEAD
    --exclude=refs/remotes/origin/mybranch \
    --exclude=refs/remotes/origin/HEAD \
    --all)

Spiegazione

Il git rev-listcomando è un comando di basso livello (idraulico) che accompagna le revisioni date e scarica gli identificatori SHA1 riscontrati. Pensalo equivalente a git logtranne che mostra solo SHA1: nessun messaggio di registro, nessun nome di autore, nessun timestamp, nessuna di quelle cose "fantasiose".

L' --no-walkopzione, come suggerisce il nome, impedisce git rev-listdi camminare sulla catena degli antenati. Quindi, se digiti git rev-list --no-walk mybranch, stamperà solo un identificatore SHA1: l'identificatore del commit tip del mybranchramo.

Gli --exclude=refs/heads/mybranch --allargomenti dicono git rev-listdi iniziare da ogni riferimento tranne che per refs/heads/mybranch.

Quindi, quando corri git rev-list --no-walk --exclude=refs/heads/mybranch --all, Git stampa l'identificatore SHA1 del commit tip di ogni ref tranne per refs/heads/mybranch. Questi commit e i loro antenati sono i commit che non ti interessano, questi sono i commit che non vuoi vedere.

Gli altri commit sono quelli che vuoi vedere, quindi raccogliamo l'output di git rev-list --no-walk --exclude=refs/heads/mybranch --alle diciamo a Git di mostrare tutto tranne quei commit e i loro antenati.

L' --no-walkargomento è necessario per i repository di grandi dimensioni (ed è un'ottimizzazione per i repository di piccole dimensioni): senza di essa, Git dovrebbe stampare e la shell dovrebbe raccogliere (e archiviare in memoria) molti più identificatori di commit del necessario. Con un repository di grandi dimensioni, il numero di commit raccolti potrebbe facilmente superare il limite dell'argomento della riga di comando della shell.

Bug bug?

Mi sarei aspettato che funzionasse:

git log --all --not --exclude=refs/heads/mybranch --all

ma non lo fa. Immagino che questo sia un bug in Git, ma forse è intenzionale.

Risposta veloce:

git log $(git merge-base master b2)..HEAD

Diciamo:

1. Che hai un ramo principale

2. Fai qualche commit

3. Hai creato un ramo chiamato b2

4. Fare git log -n1; l'id commit è la base di unione tra b2 e master

5. Effettua alcuni commit in b2

6. git log mostrerà la cronologia di log di b2 e master

7. Utilizza l'intervallo di commit, se non hai familiarità con il concetto, ti invito a cercarlo su Google o a sovrapporlo,

   Per il tuo contesto reale, puoi fare ad esempio

   git log commitID_FOO..comitID_BAR
   

   ".." è l'operatore di intervallo per il comando di registro.

   Ciò significa che, in una forma semplice, dammi tutti i registri più recenti di commitID_FOO ...

8. Guarda il punto 4, la base di unione

   Quindi: git log COMMITID_mergeBASE..HEADti mostrerà la differenza

9. Git può recuperare la base di unione per te in questo modo

   git merge-base b2 master
   

10. Finalmente puoi fare:

    git log $(git merge-base master b2)..HEAD
    

Potresti provare qualcosa del genere:

#!/bin/bash

all_but()
{
    target="$(git rev-parse $1)"
    echo "$target --not"
    git for-each-ref --shell --format="ref=%(refname)" refs/heads | \
    while read entry
    do
        eval "$entry"

        test "$ref" != "$target" && echo "$ref"
    done
}

git log $(all_but $1)

Oppure, prendendo in prestito dalla ricetta nel Manuale dell'utente di Git :

#!/bin/bash
git log $1 --not $( git show-ref --heads | cut -d' ' -f2 | grep -v "^$1" )

git rev-list --exclude=master --branches --no-walk

elencherà i suggerimenti di ogni ramo che non lo è master.

git rev-list master --not $(git rev-list --exclude=master --branches --no-walk)

elencherà ogni commit nella mastercronologia che non è nella storia di nessun altro ramo.

Il sequenziamento è importante per le opzioni che impostano la pipeline di filtri per la selezione del commit, quindi --branchesdeve seguire tutti i modelli di esclusione che dovrebbe applicare e --no-walkdeve seguire i filtri che forniscono commit rev-list non dovrebbe camminare.

Questo produrrà i commit sul ramo corrente. Se viene passato un argomento, genera solo gli hash.

git_show_all_commits_only_on_this_branch

#!/bin/bash
function show_help()
{
  ME=$(basename $0)
  IT=$(cat <<EOF
  
  usage: $ME {NEWER_BRANCH} {OLDER_BRANCH} {VERBOSE}
  
  Compares 2 different branches, and lists the commits found only 
  in the first branch (newest branch). 

  e.g. 
  
  $ME         -> default. compares current branch to master
  $ME B1      -> compares branch B1 to master
  $ME B1 B2   -> compares branch B1 to B2
  $ME B1 B2 V -> compares branch B1 to B2, and displays commit messages
  
  )
  echo "$IT"
  exit
}

if [ "$1" == "help" ]
then
  show_help
fi

# Show commit msgs if any arg passed for arg 3
if [ "$3" ]
then
  OPT="-v"
fi

# get branch names
OLDER_BRANCH=${2:-"master"}
if [ -z "$1" ]
then
  NEWER_BRANCH=$(git rev-parse --abbrev-ref HEAD)
else
  NEWER_BRANCH=$1
fi

if [ "$NEWER_BRANCH" == "$OLDER_BRANCH" ]
then
  echo "  Please supply 2 different branches to compare!"
  show_help
fi

OUT=$(\git cherry $OPT $OLDER_BRANCH $NEWER_BRANCH)

if [ -z "$OUT" ]
then
  echo "No differences found. The branches $NEWER_BRANCH and $OLDER_BRANCH are in sync."
  exit;
fi

if [ "$OPT" == "-v" ]
then
  echo "$OUT"
else
  echo "$OUT" | awk '{print $2}'
fi

Sto usando i seguenti comandi:

git shortlog --no-merges --graph --abbrev-commit master..<mybranch>

o

git log --no-merges --graph --oneline --decorate master..<mybranch>

Ho trovato questo approccio relativamente semplice.

Vai alla filiale e poi

1. Correre

   git rev-list --simplify-by-decoration -2 HEAD
   

Ciò fornirà solo due SHA:

1) ultimo commit della filiale [C1]

2) e affidare il genitore al primo commit del ramo [C2]

2. Adesso corri

   git log --decorate --pretty=oneline --reverse --name-status <C2>..<C1>
   

Qui C1 e C2 sono due stringhe che otterrai quando esegui il primo comando. Inserisci questi valori senza <> nel secondo comando.

Ciò fornirà un elenco di cronologia della modifica dei file all'interno del ramo.

Nella mia situazione, stiamo usando Git Flow e GitHub. Tutto ciò che devi fare è: confrontare il tuo ramo delle caratteristiche con il tuo ramo di sviluppo su GitHub.

Mostrerà i commit effettuati solo nel ramo della funzione.

Per esempio:

https://github.com/your_repo/compare/develop...feature_branch_name