web-dev-qa-db-fra.com

Que signifie tree-ish dans Git?

Je ne sais pas trop comment utiliser git archive.

J'ai un dépôt git avec le dossier Foo, Bar et Baz au niveau supérieur. J'ai besoin d'exporter le dossier Foo d'une manière SVN-ish pour un déploiement de test rapide.

J'ai appris que je pouvais utiliser git-archive dans un sorte d'exportation SVN-ish .

Mais voici la chose, Ce qui suit fonctionne très bien: 

git archive master | tar -x -C ~/destination

il en résulte Foo, Bar, Baz dossiers dans le dossier destination.

Cependant, ce qui suit entraînera une erreur avec fatal not a valid object name:

git archive master/foo | tar -x -C ~/destination

La documentation

Vous cherchez le synopsis du git archive programme Je vois que cela peut prendre un <tree-ish> [path] en tant que paramètre (résumé résumé dans les parties pertinentes):

git archive <tree-ish> [path...]

Si master/foo n'est pas tree-ish, alors qu'est-ce que c'est?

gitgit-archive
106
dkinzer

La réponse courte (TL; DR)

"Tree-ish" est un terme qui se réfère à tout identifiant (tel que spécifié dans la documentation des révisions Git ) qui mène finalement à une arborescence de répertoires (sous) (Git fait référence aux répertoires comme "arborescences" et " objets arborescents ").

Dans le cas de l'affiche originale, foo est un répertoire qu'il souhaite spécifier. La bonne façon de spécifier un (sous) répertoire dans Git est d'utiliser cette syntaxe "d'arborescence" (item # 15 de la documentation des révisions de Git ):

<rev>:<path>, par exemple. HEAD:README, :README, master:./README

Un suffixe : suivi d'un chemin nomme le blob ou l'arbre au chemin donné dans l'objet tree-ish nommé par la partie avant les deux points.

Donc, en d'autres termes, master:foo est la syntaxe correcte, pas master/foo.

Autre "Tree-ish" (Plus Commit-ish)

Voici une liste complète des identifiants commit-ish et tree-ish (de la documentation des révisions Git , merci à LopSae de l'avoir signalé ):

----------------------------------------------------------------------
|    Commit-ish/Tree-ish    |                Examples
----------------------------------------------------------------------
|  1. <sha1>                | dae86e1950b1277e545cee180551750029cfe735
|  2. <describeOutput>      | v1.7.4.2-679-g3bee7fb
|  3. <refname>             | master, heads/master, refs/heads/master
|  4. <refname>@{<date>}    | master@{yesterday}, HEAD@{5 minutes ago}
|  5. <refname>@{<n>}       | master@{1}
|  6. @{<n>}                | @{1}
|  7. @{-<n>}               | @{-1}
|  8. <refname>@{upstream}  | master@{upstream}, @{u}
|  9. <rev>^                | HEAD^, v1.5.1^0
| 10. <rev>~<n>             | master~3
| 11. <rev>^{<type>}        | v0.99.8^{commit}
| 12. <rev>^{}              | v0.99.8^{}
| 13. <rev>^{/<text>}       | HEAD^{/fix nasty bug}
| 14. :/<text>              | :/fix nasty bug
----------------------------------------------------------------------
|       Tree-ish only       |                Examples
----------------------------------------------------------------------
| 15. <rev>:<path>          | HEAD:README, :README, master:./README
----------------------------------------------------------------------
|         Tree-ish?         |                Examples
----------------------------------------------------------------------
| 16. :<n>:<path>           | :0:README, :README
----------------------------------------------------------------------

Les identificateurs # 1-14 sont tous "commit-ish", car ils conduisent tous à des validations, mais parce que les validations pointent également vers des arborescences de répertoires, ils conduisent tous finalement à des objets d'arborescence de (sous-) répertoires, et peuvent donc également être utilisés comme "arborescence" -ish ".

# 15 peut également être utilisé comme arborescence lorsqu'il fait référence à un (sous) répertoire, mais il peut également être utilisé pour identifier des fichiers spécifiques. Quand il fait référence à des fichiers, je ne sais pas s'il est toujours considéré comme "arbre-ish", ou s'il agit plutôt comme "blob-ish" (Git fait référence aux fichiers comme "blobs").

La réponse longue

À ses niveaux les plus bas, Git garde la trace du code source en utilisant quatre objets fondamentaux:

  1. Balises annotées, qui pointent vers des validations.
  2. Commits, qui pointent vers l'arborescence de répertoires racine de votre projet.
  3. Arbres, qui sont des répertoires et sous-répertoires.
  4. Blobs, qui sont des fichiers.

Chacun de ces objets a son propre ID de hachage sha1, car Linus Torvalds a conçu Git comme un système de fichiers adressable par le conten , c'est-à-dire que les fichiers peuvent être récupérés en fonction de leur contenu (les ID sha1 sont générés à partir du contenu du fichier). Le livre Pro Git donne cet exemple de diagramme :

Figure 9-3 from Pro Git book

De nombreuses commandes Git peuvent accepter des identifiants spéciaux pour les validations et les arborescences de répertoires (sous):

  • "Commit-ish" sont des identifiants qui conduisent finalement à un objet commit. Par exemple,

    tag -> commit

  • "Tree-ish" sont des identifiants qui conduisent finalement à des objets arborescents (c'est-à-dire répertoire).

    tag -> commit -> project-root-directory

Étant donné que les objets commit pointent toujours vers un objet arborescence de répertoires (le répertoire racine de votre projet), tout identificateur qui est "commit-ish" est, par définition, également "tree-ish". En d'autres termes, tout identifiant qui mène à un objet commit peut également être utilisé pour conduire à un objet d'arborescence de (sous-) répertoires.

Mais comme les objets de l'arborescence de répertoires ne pointent jamais vers des validations dans le système de gestion des versions de Git, tous les identifiants qui pointent vers une (sous) arborescence de répertoires ne peuvent pas également être utilisés pour pointer vers une validation. En d'autres termes, l'ensemble des identifiants "commit-ish" est un sous-ensemble strict de l'ensemble des identifiants "tree-ish".

Comme expliqué dans la documentation ( merci à Trebor de m'avoir aidé à le trouver ):

<tree>

Indique un nom d'objet d'arbre.

<commit>

Indique un nom d'objet de validation.

<tree-ish>

Indique un nom d'objet d'arborescence, de validation ou de balise. Une commande qui prend un <tree-ish> l'argument veut finalement fonctionner sur un <tree> objet mais déréférence automatiquement <commit> et <tag> objets pointant vers un <tree>.

<commit-ish>

Indique un nom d'objet de validation ou de balise. Une commande qui prend un <commit-ish> l'argument veut finalement fonctionner sur un <commit> objet mais déréférence automatiquement <tag> objets pointant vers un <commit>.

L'ensemble des identificateurs d'arborescence qui ne peut pas être utilisé comme commit-ish sont

  1. <rev>:<path>, ce qui conduit directement aux arborescences de répertoires, pas à valider les objets. Par exemple, HEAD:subdirectory.

  2. Identifiants Sha1 des objets arborescence de répertoires.

148
user456814

Une arborescence est un moyen de nommer un arbre spécifique qui peut être l'un des suivants:

  • Références comme:
    • HEAD
    • Mots clés
    • Noms des succursales
    • Noms de branche avec télécommandes, comme Origin/somebranch
  • Hacher
  • Hachage court

En plus de cela, tout ce qui précède peut être ajouté avec ^, ~. Les références peuvent également utiliser le @{} notation pour quelques fonctionnalités supplémentaires:

  • HEAD^ ou HEAD^1 sera résolu au premier parent de HEAD.
  • HEAD^2 va se résoudre au deuxième parent
  • HEAD^3 se résoudra au troisième parent et ainsi de suite, ce qui est plus rare et produit de fusionne avec la stratégie du poulpe .
  • HEAD~ ou HEAD~1 se résoudra au premier parent de la tête
  • HEAD~2 sera résolu en premier parent du premier parent de HEAD. Ce serait la même chose que HEAD^^
  • HEAD@{0} se résoudra en HEAD actuel
  • HEAD@{1} résoudra à la tête précédente. Cela ne peut être utilisé que par des références car il utilise le journal de référence. Dans le cas de HEAD chaque commit, fusion, checkout changera la valeur de HEAD et l'ajoutera donc au journal. git reflog HEAD affichera le journal de référence où vous pourrez voir tous les mouvements de HEAD et correctement ce que @{1} et ainsi de suite se résoudra en.

La plupart des éléments ci-dessus peuvent être combinés à condition que cela ait du sens dans votre référentiel, par exemple: HEAD@{2}~3, somebranch^2~4, c00e66e~4^2, anotherbranch~^~^~^.

Donc, l'une des descriptions ci-dessus, et ses combinaisons, est ce que l'on entend dans la documentation comme un arbre-ish, qui est juste un moyen de dire quel arbre (ou révision) est celui qui devrait être utilisé pour la plupart des commandes git.

Plus d'informations dans Revision Selection dans le livre Git .

47
LopSae

Tu veux probablement

git archive master foo | tar -x -C ~/destination

L'expression master/foo n'a pas de sens: master est un nom de branche et foo est un nom de répertoire, comme je suppose.

Modifier : (lien cassé supprimé. Voir les commentaires.)

11
Sven Marnach

Pour les définitions de <tree-ish> et <commit-ish> voir la page man git (1) . Vous devrez rechercher les termes. En général <tree-ish> signifie une référence à un objet d'arbre git, mais si vous passez un type d'objet qui fait référence à un arbre (comme une validation ou une branche), git utilisera automatiquement l'arbre référencé.

5
Trebor Rude

De Git Glossary tree-ish est "Un objet arbre ou un objet qui peut être déréférencé récursivement à un objet arbre." commit, HEAD et tag sont des exemples d'objets arborescents.

0
user2494386

Je suis un débutant dans le contrôle des sources et Git. Voilà ce que je sais. Une arborescence est la structure des fichiers dans un référentiel. C'est similaire à un répertoire dans un système de fichiers. Voir - Quel outil git a généré cette arborescence?

Tree-ish signifie comme un arbre. Il fait référence à une partie ou à la validation d'un arbre. Vous pouvez référencer une validation à l'aide de l'une d'entre elles: tout ou partie du hachage SHA-1 d'une validation, HEAD, référence de branche, référence de balise. Une autre méthode utilise l'une des méthodes mentionnées) ainsi que les ancêtres ou les parents d'un commit. Exemple d'ancêtres: enter image description here

0
stack1