Differenza tra autore e committer in Git?


237

Sto cercando di impegnarmi come

git commit --author="John Doe <john@doe.com>" -m "<the usual commit message>"

dove John Doe è un utente a nome del quale voglio effettuare il commit.

Sembra tutto a posto git log. Tuttavia, quando faccio un gitk, il nome dell'autore è corretto, ma il nome del committer viene scelto dalle mie impostazioni globali di configurazione git (ed è quindi impostato sul mio nome / e-mail).

Domande

  1. Qual è la differenza tra i due (committer vs autore)?

  2. Devo impostare il committer anche sull'altro utente?

  3. Se si, come?




Il committer Git è inserito nel file .gitconfig. Se --author è uguale al nome .gitconfig, ottieni solo l'autore nel messaggio di commit. Se sono diversi, ottieni entrambi.
dal

Risposte:


216

Il poster originale chiede:

Qual è la differenza tra i due (Committer vs autore)?

L'autore è la persona che ha originariamente scritto il codice. Si assume invece che il committer sia la persona che ha commesso il codice per conto dell'autore originale. Questo è importante in Git perché Git ti consente di riscrivere la cronologia o applicare patch per conto di un'altra persona. Il libro online Pro Git GRATUITO lo spiega in questo modo:

Ti starai chiedendo quale sia la differenza tra autore e committer . L' autore è la persona che ha originariamente scritto la patch, mentre il committer è la persona che ha applicato l'ultima patch. Pertanto, se invii una patch a un progetto e uno dei membri principali applica la patch, entrambi ottieni credito: tu come autore e il membro principale come committer.

Il poster originale chiede:

Devo impostare il committer anche sull'altro utente?

No, se vuoi essere onesto, non dovresti impostare il committer sull'autore, a meno che l'autore e il committer siano effettivamente la stessa persona.


1
Sono ancora confuso su questo. Ho avuto questo accadere, e nel mio caso, per quanto ne so, non si è mai verificata alcuna riscrittura di patch o cronologia (a meno che alcuni comandi git non creino e applichino patch, opzionalmente "sotto il cofano"). Sono davvero gli unici 2 modi in cui può succedere qualcosa del genere?
Cowlinator

2
Inoltre, chiamare l'autore "persona che ha scritto il codice" non ha senso. Come farebbe Git a sapere chi l'ha scritto? Quando si imposta git config usere quindi git adde git commit, quindi git saprebbe chi ha aggiunto e chi ha commesso, ma ancora non si sa chi l'ha scritto.
cowlinator

1
@cowlinator Non sa chi ha scritto il codice. Ecco perché devi dirlo, se non sei tu. Tieni presente che il precedente sistema di controllo della versione distribuita prima dell'invenzione di git stava inviando ~~ Linus ~~ e-mail al manutentore del progetto con patch da applicare. Questa funzionalità è presente quindi ~~ Linus ~~ il manutentore può applicare la tua patch mentre ti accredita ancora in modo "ufficiale", piuttosto che solo ad hoc nel messaggio di commit.
Finanzia la causa di Monica il

92

La mailing list + git format-patch+ git applypuò generare l'autore! = Committer

In progetti come il kernel Linux in cui le patch sono:

generare un nuovo nuovo commit con autori e committer diversi:

  • l'autore è chi ha scritto la patch
  • il committer è chi è un manutentore del progetto e chi ha unito la patch

Vedi ad esempio questa patch selezionata casualmente e il commit corrispondente:

Le interfacce web di Git come GitHub e GitLab possono o meno generare autore! = Committer

Poiché Git (Hub | Lab) contiene sia i repository upstream che quelli fork su una stessa macchina, possono automaticamente fare tutto ciò che si può fare anche localmente, incluso uno dei seguenti:

  • Crea un commit di unione.

    Non genera autore! = Committer.

    Mantiene intatto SHA o il nuovo commit e crea un nuovo commit:

    * Merge commit (committer == author == project maintainer)
    |\
    | * Feature commit (committer == author == contributor)
    |/
    * Old master (random committer and author)
    

    Storicamente, questo è stato il primo metodo disponibile su GitHub.

    A livello locale, questo viene fatto git merge --no-ff.

    Questo produce due commit per richiesta pull e mantiene un fork nella cronologia git.

  • rebase sopra master

    GitHub modifica anche gli commit per impostare committer == chiunque abbia premuto il pulsante Unisci. Questo non è obbligatorio e non è nemmeno eseguito di default localmente da git rebase, ma dà responsabilità al responsabile del progetto.

    L'albero git ora assomiglia a:

    * Feature commit (committer == maintainer, author == contributor)
    |
    * Old master (random committer and author)    
    

    che è esattamente come quello delle git applypatch di posta elettronica.

Su GitHub attualmente:

  • si sceglie il metodo durante l'unione tramite il menu a discesa sul pulsante Unisci
  • i metodi possono essere abilitati o disabilitati sulle impostazioni del repository dal proprietario

https://help.github.com/articles/about-merge-methods-on-github/

Come impostare il committer di un nuovo commit?

Il meglio che ho trovato è stato usare le variabili d'ambiente per sovrascrivere il committer:

GIT_COMMITTER_NAME='a' GIT_COMMITTER_EMAIL='a' git commit --author 'a <a>'

Come ottenere il committer e la data di commit di un determinato commit?

Solo i dati dell'autore vengono visualizzati per impostazione predefinita su git log.

Per vedere la data del committer puoi:

  • formattare il registro appositamente per quello:

    git log --pretty='%cn %cd' -n1 HEAD
    

    dove cne cdrappresentano Committer NameeCommitter Date

  • usa il fullerformato predefinito:

    git log --format=fuller
    

    Vedi anche: Come configurare 'git log' per mostrare 'commit date'

  • passare a un livello basso e mostrare tutti i dati di commit:

    git cat-file -p HEAD
    

Come impostare la data del committer di un nuovo commit?

git commit --date imposta solo la data dell'autore: per la data del committer il meglio che ho trovato è stato con la variabile d'ambiente:

GIT_COMMITTER_DATE='2000-01-01T00:00:00+0000' git commit --date='2000-01-01T00:00:00+0000'

Vedi anche: Qual è la differenza tra autore e committer in Git?

In che modo Git archivia internamente autore e committer?

Vedi: Qual è il formato del file di un oggetto commit git?

Fondamentalmente, il commit è un file di testo e contiene due campi separati da riga:

author {author_name} <{author_email}> {author_date_seconds} {author_date_timezone}
committer {committer_name} <{committer_email}> {committer_date_seconds} {committer_date_timezone}

Ciò chiarisce che entrambe sono due voci di dati completamente indipendenti nell'oggetto commit.


1
Nota che anche con le GIT_COMMITTER_*sostituzioni, git rifiuterà comunque di eseguire un commit se non hai impostato un committer predefinito usando git config.
Adelphus,

1
@adelphus su Git 2.5, funziona se si impostano entrambiGIT_{COMMITTER,AUTHOR}_EMAIL
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功

3

@Ciro Santilli 法轮功 改造 中心 六四 事件 法轮功 ha proposto di utilizzare

GIT_COMMITTER_NAME='a' GIT_COMMITTER_EMAIL='a' git commit --author 'a <a>'

Per evitare di ripetere il nome e l'e-mail, è possibile riutilizzarli

GIT_COMMITTER_NAME='a'; GIT_COMMITTER_EMAIL='a'; git commit --author "$GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL>"

che prima imposta le variabili in comandi separati, quindi le utilizza per la git commitchiamata (notare le doppie parentesi).

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.