Cosa sono commit-ish e tree-ish in Git?

La domanda

Quali sono gli esempi specifici di commit-ish e tree-ish in Git?

La domanda Stack Overflow “Cosa significa tree-ish in git?” si occupa specificamente di tree-ish, ma voglio capire di più su entrambi .

sfondo

Usi nella documentazione

La documentazione di Git fa diversi riferimenti a “commit-ish” e “tree-ish”. Ad esempio, se stai esaminando il codice sorgente Git :

$ git grep --files-with-matches --extended-regexp "commit(-)*ish" config.txt git-describe.txt git-fast-import.txt git-name-rev.txt git-push.txt git-rebase.txt git-rev-parse.txt git.txt gitcli.txt glossary-content.txt howto/revert-branch-rebase.txt revisions.txt 

e

 $ git grep --files-with-matches --extended-regexp "tree(-)*ish" | \ $ grep --invert-match RelNotes diff-format.txt diff-generate-patch.txt git-archive.txt git-cat-file.txt git-checkout.txt git-diff-index.txt git-diff-tree.txt git-ls-files.txt git-ls-tree.txt git-merge-tree.txt git-read-tree.txt git-reset.txt git-svn.txt git.txt gitcli.txt gittutorial-2.txt glossary-content.txt revisions.txt 

definizioni

La documentazione di Git definisce cosa sono “commit-ish” e “tree-ish” :

  

Indica un nome object albero.

  

Indica un nome dell’object commit.

  

Indica una struttura ad albero, commessa o tagga il nome dell’object. Un comando che accetta un argomento fine vuole operare su un object ma automaticamente dereferenzia e oggetti che puntano a un .

  

Indica un nome di commit o di un object tag. Un comando che accetta un argomento fine vuole operare su un object ma automaticamente dereferenzia oggetti che puntano a un .

La documentazione non è abbastanza chiara

Anche se la documentazione sopra definisce cosa sono “commit-ish” e “tree-ish”, trovo che sia troppo vago e poco chiaro.

Quali sono esempi specifici di “commit-ish” e “tree-ish”, e in che modo sono diversi l’uno dall’altro?

La risposta breve (TL; DR)

Ecco una lista completa di identificatori di commit-ish e tree-ish (dalla documentazione di Git revisions ):

 ---------------------------------------------------------------------- | Commit-ish/Tree-ish | Examples ---------------------------------------------------------------------- | 1.  | dae86e1950b1277e545cee180551750029cfe735 | 2.  | v1.7.4.2-679-g3bee7fb | 3.  | master, heads/master, refs/heads/master | 4. @{} | [email protected]{yesterday}, [email protected]{5 minutes ago} | 5. @{} | [email protected]{1} | 6. @{} | @{1} | 7. @{-} | @{-1} | 8. @{upstream} | [email protected]{upstream}, @{u} | 9. ^ | HEAD^, v1.5.1^0 | 10. ~ | master~3 | 11. ^{} | v0.99.8^{commit} | 12. ^{} | v0.99.8^{} | 13. ^{/} | HEAD^{/fix nasty bug} | 14. :/ | :/fix nasty bug ---------------------------------------------------------------------- | Tree-ish only | Examples ---------------------------------------------------------------------- | 15. : | HEAD:README.txt, master:sub-directory/ ---------------------------------------------------------------------- | Tree-ish? | Examples ---------------------------------------------------------------------- | 16. :: | :0:README, :README ---------------------------------------------------------------------- 

Gli identificatori # 1-14 sono tutti “commit-ish”, perché portano tutti a commit, ma poiché commettono anche puntare ad alberi di directory, tutti alla fine portano a (sotto) oggetti ad albero di directory e possono quindi anche essere usati come “albero” -ish”.

# 15 può anche essere usato come tree-ish quando si riferisce a una (sotto) directory, ma può anche essere usato per identificare file specifici. Quando si riferisce ai file, non sono sicuro che sia ancora considerato “tree-ish”, o se agisce più come “blob-ish” (Git si riferisce ai file come “blob”).

La lunga risposta

Commits e Directory Trees in Git

Ai suoi livelli più bassi, Git tiene traccia del codice sorgente utilizzando quattro oggetti fondamentali:

  1. Tag annotati, che puntano al commit.
  2. Commits, che puntano all’albero della directory radice del progetto.
  3. Alberi, che sono directory e sottodirectory.
  4. Blob, che sono file.

Ognuno di questi oggetti ha il proprio ID hash sha1, poiché Linus Torvalds ha progettato Git come un filesystem indirizzabile dal contenuto , ovvero i file possono essere recuperati in base al loro contenuto (gli ID sha1 sono generati dal contenuto del file). Il libro Pro Git fornisce questo diagramma di esempio :

Figura 9-3 dal libro Pro Git

Commit-ish vs Tree-ish

Molti comandi Git possono accettare identificatori speciali per commit e (sotto) alberi di directory:

  • “Commit-ish” sono identificatori che alla fine portano a un object commit. Per esempio,

    tag -> commit

  • “Tree-ish” sono identificatori che alla fine portano a oggetti tree (ie directory).

    tag -> commit -> project-root-directory

Poiché gli oggetti commit puntano sempre su un object tree della directory (la directory root del progetto), qualsiasi identificatore che sia “commit-ish” è, per definizione, anche “tree-ish”. In altre parole, qualsiasi identificatore che porta ad un object di commit può anche essere utilizzato per portare a un (sotto) object ad albero di directory .

Ma dal momento che gli oggetti della directory tree non puntano mai al commit nel sistema di versioning di Git, non tutti gli identificatori che puntano a un albero di directory (sotto) possono essere usati anche per puntare a un commit. In altre parole, l’insieme degli identificatori “commit-ish” è un sottoinsieme rigido dell’insieme di identificatori “tree-ish”.

L’insieme di identificatori tree-ish che non possono essere usati come commit-ish lo sono

  1. : , che conduce direttamente agli alberi delle directory, non agli oggetti commit. Ad esempio, HEAD:subdirectory .

  2. Identificatori Sha1 degli oggetti dell’albero delle directory .

Nota per i diffusori di inglese non nativo [sic!]: “-Ish” è un suffisso che può essere applicato a un aggettivo per indicare “avere qualità come” o “leggermente” – vedi http://chambers.co.uk / Ricerca /? query = ish & title = 21

Quindi “tree-ish” – come un “albero” …. “commit-ish” – come un “commit”

es. “Marte appare come una stella rossastra” (“d” è raddoppiata!); “il cibo sul piatto non era caldo, ma caldo”

Credo che questo aiuti a spiegare “cosa sono …” meglio, in quanto spiega l’uso della lingua.