Quiero enumerar todas las confirmaciones que son solo parte de una rama específica.

Con lo siguiente, enumera todos los commits de la rama, pero también del padre (maestro)

git log mybranch

La otra opción que encontré fue excluir los commits accesibles por master y me da lo que quiero, PERO me gustaría evitar la necesidad de conocer los nombres de otras ramas.

git log mybranch --not master

Estaba tratando de usar git for-each-ref, pero también está enumerando mybranch, por lo que en realidad está excluyendo todo:

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

Actualizar:

Estoy probando una nueva opción que encontré hace un tiempo, y hasta ahora parece que esto podría ser lo que estaba buscando:

git log --walk-reflogs mybranch

Actualización (2013-02-13T15: 08):

La opción --walk-reflogs es buena, pero verifiqué que hay una caducidad para los reflogs (por defecto 90 días, gc.reflogExpire ).

Creo que encontré la respuesta que estaba buscando:

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

Solo estoy eliminando la rama actual de la lista de ramas disponibles y estoy usando esa lista para excluirla del registro. De esta manera solo obtengo los commits que solo mybranch alcanza .

Por lo que parece que deberías estar usando cherry:

git cherry -v develop mybranch

Esto mostraría todos los commits que están contenidos dentro de mybranch , pero NO en desarrollo . Si deja la última opción ( mybranch ), comparará la rama actual en su lugar.

Como señaló VonC, SIEMPRE está comparando su rama con otra rama, así que conozca sus ramas y luego elija con cuál comparar.

PERO me gustaría evitar la necesidad de conocer los nombres de otras ramas.

No creo que esto sea posible: una rama en Git siempre se basa en otra o al menos en otra confirmación, como se explica en " git diff no muestra lo suficiente ":

Necesita un punto de referencia para que su registro muestre los commits correctos.

Como se menciona en " GIT - ¿De dónde me ramifiqué? ":

las ramas son simplemente punteros a ciertas confirmaciones en un DAG

Entonces, incluso si git log master..mybranches una respuesta, aún mostraría demasiados commits, si mybranchse basa en myotherbranchsí mismo master.

Para encontrar esa referencia (el origen de su rama), solo puede analizar las confirmaciones y ver en qué rama están, como se ve en:

• " Git: Encontrar de qué rama vino un commit ".
• " ¿Cómo puedo ver de qué rama se bifurcó otra rama? "

Finalmente encontré la manera de hacer lo que quería el OP. Es tan simple como:

git log --graph [branchname]

El comando mostrará todas las confirmaciones a las que se puede acceder desde la rama proporcionada en el formato de gráfico. Pero puede filtrar fácilmente todas las confirmaciones en esa rama mirando el gráfico de confirmaciones cuyo *es el primer carácter en la línea de confirmación.

Por ejemplo, echemos un vistazo al extracto de git log --graph masterrepositorio de GitHub de cakephp a continuación:

D:\Web Folder\cakephp>git log --graph master
*   commit 8314c2ff833280bbc7102cb6d4fcf62240cd3ac4
|\  Merge: c3f45e8 0459a35
| | Author: José Lorenzo Rodríguez <[email protected]>
| | 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 <[email protected]>
| | 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 <[email protected]>
| | 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 <[email protected]>
|/|   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 <[email protected]>
| | Date:   Mon Aug 29 17:43:29 2016 -0400
| |
| |     Fix `@since` in new files docblocks
| |

Como se puede ver, sólo compromete 8314c2ff833280bbc7102cb6d4fcf62240cd3ac4y c3f45e811e4b49fe27624b57c3eb8f4721a4323btener el *ser el primer carácter de la confirmación líneas. Esas confirmaciones son de la rama maestra, mientras que las otras cuatro son de otras ramas.

El siguiente comando de shell debe hacer lo que quieras:

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

Advertencias

Si ha mybranchdesprotegido, el comando anterior no funcionará. Esto se debe a que mybranchtambién se puede HEADacceder a los commits, por lo que Git no considera que los commits sean únicos mybranch. Para que funcione cuando mybranchestá desprotegido, también debe agregar una exclusión para HEAD:

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

Sin embargo, debe no excluir HEADa menos que la mybranchestá desprotegido, de lo contrario se corre el riesgo mostrando compromete a que no son exclusivos demybranch .

Del mismo modo, si tiene una rama remota llamada origin/mybranchque corresponde a la mybranchrama local , deberá excluirla:

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

Y si la rama remota es la rama predeterminada para el repositorio remoto (generalmente solo es cierto para origin/master), también deberá excluir 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)

Si tiene la rama desprotegida, y hay una rama remota, y la rama remota es la predeterminada para el repositorio remoto, entonces termina excluyendo mucho:

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)

Explicación

El git rev-listcomando es un comando de bajo nivel (plomería) que recorre las revisiones dadas y vuelca los identificadores SHA1 encontrados. Piense en ello como equivalente a git logexcepto que solo muestra el SHA1: sin mensaje de registro, sin nombre de autor, sin marca de tiempo, ninguna de esas cosas "elegantes".

La --no-walkopción, como su nombre lo indica, evita git rev-listcaminar por la cadena de ascendencia. Entonces, si escribe git rev-list --no-walk mybranch, solo imprimirá un identificador SHA1: el identificador de la confirmación de propinas de la mybranchrama.

Los --exclude=refs/heads/mybranch --allargumentos le dicen git rev-listque comience desde cada referencia, excepto para refs/heads/mybranch.

Entonces, cuando ejecutas git rev-list --no-walk --exclude=refs/heads/mybranch --all, Git imprime el identificador SHA1 de la confirmación de propinas de cada referencia a excepción de refs/heads/mybranch. Estas confirmaciones y sus antepasados ​​son las confirmaciones en las que no está interesado; estas son las confirmaciones que no desea ver.

Las otras confirmaciones son las que desea ver, por lo que recopilamos el resultado git rev-list --no-walk --exclude=refs/heads/mybranch --ally le decimos a Git que muestre todo menos esas confirmaciones y sus antepasados.

El --no-walkargumento es necesario para repositorios grandes (y es una optimización para repositorios pequeños): sin él, Git tendría que imprimir, y el shell tendría que recopilar (y almacenar en la memoria) muchos más identificadores de confirmación de los necesarios. Con un repositorio grande, el número de confirmaciones recopiladas podría superar fácilmente el límite de argumento de la línea de comandos del shell.

Git bug?

Hubiera esperado que funcionara lo siguiente:

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

Pero no lo hace. Supongo que esto es un error en Git, pero tal vez sea intencional.

Respuesta rápida:

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

Digamos:

1. Que tienes una rama maestra

2. Haz algunas confirmaciones

3. Creaste una rama llamada b2

4. Hacer git log -n1; el commit id es la base de fusión entre b2 y master

5. Haz algunas confirmaciones en b2

6. git log mostrará su historial de registro de b2 y master

7. Use el rango de confirmación, si no está familiarizado con el concepto, lo invito a buscarlo en Google o apilarlo,

   Para su contexto real, puede hacer por ejemplo

   git log commitID_FOO..comitID_BAR
   

   El ".." es el operador de rango para el comando de registro.

   Eso significa, en una forma simple, darme todos los registros más recientes que commitID_FOO ...

8. Mira el punto 4, la base de fusión

   Entonces: git log COMMITID_mergeBASE..HEADte mostrará la diferencia

9. Git puede recuperar la base de fusión para ti así

   git merge-base b2 master
   

10. Finalmente puedes hacer:

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

Podrías probar algo como esto:

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

O, tomando prestado de la receta en el Manual del usuario de 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

enumerará los consejos de cada rama que no lo es master.

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

enumerará todas las confirmaciones en masterel historial que no están en el historial de ninguna otra rama.

La secuencia es importante para las opciones que configuran la tubería de filtro para la selección de confirmación, por lo que --branchesdebe seguir los patrones de exclusión que se supone que debe aplicar, y --no-walkdebe seguir los filtros que suministran las confirmaciones que se supone que la lista de revoluciones no debe seguir.

Esto generará los commits en la rama actual. Si se pasa algún argumento, solo genera los hashes.

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

Estoy usando los siguientes comandos:

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

o

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

Encontré este enfoque relativamente fácil.

Pago a la sucursal y que

1. correr

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

Esto proporcionará solo dos SHA:

1) última confirmación de la rama [C1]

2) y comprometer padre a la primera confirmación de la rama [C2]

2. Ahora corre

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

Aquí C1 y C2 son dos cadenas que obtendrá cuando ejecute el primer comando. Ponga estos valores sin <> en el segundo comando.

Esto le dará una lista del historial de cambios de archivos dentro de la rama.

En mi situación, estamos usando Git Flow y GitHub. Todo lo que necesita hacer es: comparar su rama de características con su rama de desarrollo en GitHub.

Mostrará las confirmaciones realizadas solo en su rama de características.

Por ejemplo:

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