Git - Comment afficher l'historique des modifications d'une méthode / fonction?

J'ai donc trouvé la question de savoir comment afficher l'historique des modifications d'un fichier, mais l'historique des modifications de ce fichier particulier est énorme et je ne m'intéresse vraiment qu'aux modifications d'une méthode particulière. Alors, serait-il possible de voir l'historique des modifications pour cette méthode en particulier?

Je sais que cela nécessiterait git d'analyser le code et que l'analyse serait différente pour différentes langues, mais les déclarations de méthode / fonction semblent très similaires dans la plupart des langues, alors j'ai pensé que quelqu'un a peut-être implémenté cette fonctionnalité.

Le langage avec lequel je travaille actuellement est Objective-C et le SCM que j'utilise actuellement est git, mais je serais intéressé de savoir si cette fonctionnalité existe pour n'importe quel SCM / langage.

Les versions récentes de git logappris une forme spéciale du -Lparamètre:

-L: <nomfonc>: ​​<fichier>

Tracez l'évolution de la plage de lignes donnée par "<start>,<end>"(ou le nom de la fonction regex <funcname>) dans le <file>. Vous ne pouvez pas donner de limiteurs de pathspec. Ceci est actuellement limité à une marche à partir d'une seule révision, c'est-à-dire que vous ne pouvez donner que zéro ou un argument de révision positif. Vous pouvez spécifier cette option plusieurs fois.
...
Si “:<funcname>”est donné à la place de <start>et <end>, c'est une expression régulière qui désigne la plage allant de la première ligne funcname qui correspond <funcname>, jusqu'à la ligne funcname suivante. “:<funcname>”recherche à partir de la fin de la -Lplage précédente , le cas échéant, sinon depuis le début du fichier. “^:<funcname>”recherche depuis le début du fichier.

En d'autres termes: si vous demandez à Git de le faire git log -L :myfunction:path/to/myfile.c, il affichera désormais avec plaisir l'historique des modifications de cette fonction.

L'utilisation git gui blameest difficile à utiliser dans les scripts, et bien git log -Gque git log --pickaxechacun puisse vous montrer quand la définition de la méthode est apparue ou a disparu, je n'ai trouvé aucun moyen de leur faire lister toutes les modifications apportées au corps de votre méthode.

Cependant, vous pouvez utiliser gitattributeset letextconv propriété pour reconstituer une solution qui fait exactement cela. Bien que ces fonctionnalités aient été initialement destinées à vous aider à travailler avec des fichiers binaires, elles fonctionnent tout aussi bien ici.

La clé est que Git supprime du fichier toutes les lignes sauf celles qui vous intéressent avant d'effectuer des opérations de comparaison. Alors git log,git diff etc. ne verront que la zone que vous intéresse.

Voici les grandes lignes de ce que je fais dans une autre langue; vous pouvez le modifier selon vos propres besoins.

• Écrivez un court script shell (ou un autre programme) qui prend un argument - le nom d'un fichier source - et ne produit que la partie intéressante de ce fichier (ou rien si rien de tout cela n'est intéressant). Par exemple, vous pouvez utiliser sedcomme suit:

  #!/bin/sh
  sed -n -e '/^int my_func(/,/^}/ p' "$1"

• Définir un Git textconv filtre pour votre nouveau script. (Voir la gitattributespage de manuel pour plus de détails.) Le nom du filtre et l'emplacement de la commande peuvent être tout ce que vous voulez.

  $ git config diff.my_filter.textconv /path/to/my_script

• Dites à Git d'utiliser ce filtre avant de calculer les différences pour le fichier en question.

  $ echo "my_file diff=my_filter" >> .gitattributes

• Maintenant, si vous utilisez -G.(notez le .) pour lister tous les commits qui produisent des changements visibles lorsque votre filtre est appliqué, vous aurez exactement ces commits qui vous intéressent. Toutes les autres options qui utilisent les routines de diff de Git, telles que--patch , obtenez également cette vue restreinte.

  $ git log -G. --patch my_file

• Voilà!

Une amélioration utile que vous voudrez peut-être apporter est que votre script de filtrage prenne un nom de méthode comme premier argument (et le fichier comme deuxième). Cela vous permet de spécifier une nouvelle méthode intéressante simplement en appelantgit config , plutôt que d'avoir à modifier votre script. Par exemple, vous pourriez dire:

$ git config diff.my_filter.textconv "/path/to/my_command other_func"

Bien sûr, le script de filtrage peut faire tout ce que vous voulez, prendre plus d'arguments ou autre: il y a beaucoup de flexibilité au-delà de ce que j'ai montré ici.

git log a une option '-G' qui peut être utilisée pour trouver toutes les différences.

-G Recherchez les différences dont la ligne ajoutée ou supprimée correspond à celle donnée <regex>.

Donnez-lui simplement une expression régulière du nom de la fonction qui vous intéresse. Par exemple,

$ git log --oneline -G'^int commit_tree'
40d52ff make commit_tree a library function
81b50f3 Move 'builtin-*' into a 'builtin/' subdirectory
7b9c0a6 git-commit-tree: make it usable from other builtins

La chose la plus proche que vous puissiez faire est de déterminer la position de votre fonction dans le fichier (par exemple, disons que votre fonction i_am_buggyest aux lignes 241 à 263 de foo/bar.c), puis exécutez quelque chose comme:

git log -p -L 200,300:foo/bar.c

Cela ouvrira moins (ou un téléavertisseur équivalent). Maintenant, vous pouvez taper/i_am_buggy (ou votre équivalent pager) et commencer à parcourir les modifications.

Cela peut même fonctionner, en fonction de votre style de code:

git log -p -L /int i_am_buggy\(/,+30:foo/bar.c

Cela limite la recherche à partir du premier hit de cette expression régulière (idéalement votre déclaration de fonction) à trente lignes après cela. L'argument de fin peut également être une expression rationnelle, bien que détecter cela avec les expressions rationnelles est une proposition plus incertaine.

La bonne façon est d'utiliser git log -L :function:path/to/filecomme expliqué dans la réponse eckes .

Mais en plus, si votre fonction est très longue, vous voudrez peut-être voir uniquement les changements introduits par divers commit, et non les lignes de fonction entières, incluses non modifiées, pour chaque commit qui ne touche peut-être qu'une de ces lignes. Comme une normale diff.

Normalement, git logpeut afficher les différences avec -p, mais cela ne fonctionne pas avec -L. Vous devez donc grep git log -Lafficher uniquement les lignes impliquées et l'en-tête commits / files pour les contextualiser. L'astuce ici est de faire correspondre uniquement les lignes colorées du terminal, en ajoutant un --colorcommutateur, avec une expression régulière. Finalement:

git log -L :function:path/to/file --color | grep --color=never -E -e "^(^[\[[0-9;]*[a-zA-Z])+" -3

Notez que cela ^[doit être réel, littéral ^[. Vous pouvez les saisir en appuyant sur ^ V ^ [en bash, c'est-à-dire Ctrl+ V, Ctrl+ [. Référence ici .

Dernier -3interrupteur également, permet d'imprimer 3 lignes de contexte de sortie, avant et après chaque ligne correspondante. Vous voudrez peut-être l'ajuster à vos besoins.

git blame vous montre qui a changé en dernier chaque ligne du fichier; vous pouvez spécifier les lignes à examiner afin d'éviter de récupérer l'historique des lignes en dehors de votre fonction.

1. Afficher l'historique des fonctions avec git log -L :<funcname>:<file>comme indiqué dans la réponse d'eckes et git doc

   S'il ne montre rien, reportez-vous à la section Définition d'un en-tête de morceau personnalisé pour ajouter quelque chose comme *.java diff=javaau .gitattributes fichier pour prendre en charge votre langue.

2. Afficher l'historique des fonctions entre les validations avec git log commit1..commit2 -L :functionName:filePath

3. Afficher l'historique des fonctions surchargées (il peut y avoir plusieurs fonctions avec le même nom, mais avec des paramètres différents) avec git log -L :sum\(double:filepath