Constatation où la source est ramifiée à partir de git

Question

J'ai un dépôt git (couvrant plus ou moins historique du projet) et des sources séparées (juste un peu avec les fichiers tarball) qui ont bifurqué il y a quelque temps (en fait quelque part en 2004 ou 2005).

Les sources de tarball ont subi beaucoup de changements dont je voudrais intégrer certains. Maintenant, la question est -. Comment savoir ce qui était en fait le point de branchement pour les sources modifiées pour obtenir diff minimum de ce qui est arrivé il y a

Alors, ce que je veux essentiellement est de trouver une place dans l'histoire git, où le code est plus semblable à la tarball des sources que j'ai. Et je ne veux pas le faire manuellement.

Il est également à noter que les sources modifiées ne comprennent que sous-ensemble de fichiers et ont divisé certains fichiers en plus. Toutefois, le code qui est là-bas semblent obtenir que de petites modifications et plusieurs ajouts.

Si vous voulez jouer avec vous-même, avec des sources tarball est ici et Git est hébergé à Gitorious : git://gitorious.org/gammu/mainline.git

Answer 1

Dans le cas général, vous auriez fait d'examiner chaque commettras, parce que vous avez aucun moyen de savoir si vous pourriez avoir un énorme diff dans un petit diff l'autre, puis une autre grande diff, puis un support diff ...

Votre meilleur pari va probablement être de vous limiter aux fichiers spécifiques. Si l'on considère un seul fichier, il ne devrait pas prendre de temps pour parcourir toutes les versions de ce fichier (utilisation git rev-list <path> pour obtenir une liste, de sorte que vous n'avez pas à tester tous les commits). Pour chaque commit qui a modifié le fichier, vous pouvez vérifier la taille de la diff, et assez rapidement trouver un minimum. Est-ce que cela pour une poignée de fichiers, ils sont d'accord, espérons!

La meilleure façon de vous mettre en place pour le diffing est de faire un temporaire commettras en copiant simplement dans votre fichier tar, vous pouvez donc avoir une branche appelée tarball à comparer. De cette façon, vous pouvez faire ceci:

git rev-list path/to/file | while read hash; do echo -n "$hash "; git diff --numstat tarball $hash path/to/file; done

pour obtenir une liste de belle de tous les commits avec leurs tailles diff (seront SHA1, nombre de lignes ajoutées, et le nombre de lignes supprimées les trois premières colonnes). Ensuite, vous pouvez juste conduite sur en awk '{print $1,$2+$3}' | sort -n -k 2, et vous auriez une liste triée des commits et leurs tailles diff!

Si vous ne pouvez pas vous limiter à une petite poignée de fichiers à tester, je pourrais être tenté de mettre en œuvre la main quelque chose de similaire à git-bisect - juste essayer de réduire votre chemin vers le bas à une petite diff, en faisant l'hypothèse que tous les vraisemblance, commits près de votre meilleur cas aura également diffs plus petits, et commits loin de là aura diffs plus grandes. (Quelque part entre la méthode de Newton et une recherche binaire complet sur / réseau, probablement?)

Edit: Une autre possibilité, suggérée dans la réponse de Douglas , si vous pensez que certains fichiers peuvent être identiques à ceux de certains commettent, est de les utiliser hachage git-hash-object , puis voir ce qui engage dans votre histoire ont cette blob. Il y a une question d'excellentes réponses sur la façon de le faire. Si vous faites cela avec une poignée de fichiers - de préférence ceux qui ont changé fréquemment -. Vous pourriez être en mesure d'affiner la cible engager assez rapidement

Answer 2

Pas une excellente solution, mais pour obtenir une estimation dont les révisions qu'il pourrait être: On suppose que certains des fichiers dans la boule de goudron n'ont pas été modifiés depuis leur ramifiés. Exécuter git objet hachage contre chaque fichier dans la boule de goudron, puis recherchez les fichiers dans le référentiel en utilisant git show . Ensuite, essayez de trouver les commits dans lesquelles ces fichiers ont été inclus, éventuellement à l'aide git WhatChanged . La réponse à votre question pourrait alors être le commettras avec les fichiers les plus courants, mais il sera toujours un peu hasardeux.

Answer 3

basé sur ce que araqnid a dit que je suis venu avec 9c6c864426bf88429e77c7e22b5aa78e9295b97a (juste demandé des choses entre 0.61.0 et HEAD) ce qui est probablement le meilleur) que vous pourriez faire mieux avec quelque chose comme

git rev-list --no-merges --all | while read rev; do patchsize=$(git diff $rev | wc -c); echo $patchsize $rev; done | sort -n | less

en supposant que vous avez importé le tarball dans git et ont cette révision vérifié (je l'ai fait par décompressé l'archive puis

git init
git add .
git commit -m "import tarball"
git remote add origin git://gitorious.org/gammu/mainline.git

Une fois que vous faites cela et la course qui précède, il devrait afficher la taille de tous les diffs dans l'ordre croissant de patchsize (le premier sera de 0 car il va trouver la tête en cours), il va prendre beaucoup de temps ... mais il faut trouver le plus petit diff ...

Answer 4

comment était la fourche fait? était un clone que quelqu'un d'autre a fait et fait leur propre travail? si oui, alors cela est vraiment facile. tout ce que vous devez faire est de créer une branche locale qui tire dans le code de la fourche. git verra l'origine du pointage de branche fourchue à l'un des commits de votre référentiel d'origine et « relier les points » pour ainsi dire ... il se reconnecte l'histoire de votre référentiel d'origine à la fourche.

vous devriez être en mesure de le faire:

git remote add thefork git://wherever.it.lives/thefork.git

git fetch thefork

git branch -f thefork-branch thefork/branchname

git checkout thefork-branch

à ce stade, vous pouvez exécuter gitk et voir l'histoire complète de la branche fourchue et votre dépôt local, et voir si elles se connectent ou non.

Answer 5

Importer que les fichiers dans l'archive en une révision git, sur une branche séparée ou un tout nouveau:. La position dans le graphique de révision n'a pas d'importance, nous voulons juste disponible comme un arbre

Pour chaque révision en maître, juste diff contre cet arbre / révision ( « importé ») et la sortie juste la taille de la diff est. Quelque chose comme:

git rev-list master | while read rev; do patchsize=$(git diff $rev imported | wc -c); echo $rev $patchsize; done

la révision avec la plus petite taille de patch sera le plus « proche », par une règle très approximative du pouce. (Une révision identique produira une taille de parcelle de 0, et toute autre chose sera certainement non nulle, et plus qui a changé, plus).

Answer 6

Si vous avez une idée approximative de l'endroit où la fourche a eu lieu, envisager d'utiliser git meld de Will Manley . (Voir aussi: Voir les différences de branches avec meld ?).

Pour ce faire, ajoutez le contenu de tarball à votre dépôt (que vous allez faire de toute façon). Après avoir installé Meld et git-meld, exécutez

git meld branch_from_tarball commit_to_check &

sur différents commits jusqu'à ce que vous trouviez celui avec le moins de différences. Cette commande ouvrira meld et afficher les modifications dans l'arborescence des répertoires entre les commits spécifiés, avec des fichiers identiques cachés. Exemples d'écrans:

Meld montrant deux commits très différentes:

Affichage deux commits similaires: