golongfuncs
1.0.0
golongfuncs est un outil pour rechercher des fonctions "longues" par diverses mesures (et combinaisons de mesures).
Cet outil peut vous aider à répondre aux questions de la ligne:
En d'autres termes, cela vous aidera à filtrer les fonctions longues et complexes de ceux qui sont juste longs .
go install github.com/tkrajina/golongfuncs/...
Cet outil peut calculer les mesures de "longueur" et de "complexité" suivantes:
lines : nombre de lignes sans lignes vides, lignes terminant les blocs (contenant uniquement } ) et commentaires ,total_lines : Nombre de lignes , y compris les lignes vides et les commentaires ,len : Nombre de caractères dans la fonction (sans commentaires et lignes vides).total_len : nombre de caractères dans la fonction (avec des commentaires et des lignes vides).comments : Nombre de commentaires. Les commentaires multilines sont comptés une fois,comment_lines : nombre de lignes de commentaires,complexity : complexité cyclomatique (à partir de gocyclo),max_nesting : la profondeur des blocs imbriqués max (note, les initialisations de structure ne sont pas comptées),total_nesting : nidification totale (en d'autres termes, si le code est formaté correctement - chaque onglet d'indentation est compté une fois)in_params : le nombre de paramètres d'entrée de fonctionout_params : le nombre de paramètres de sortie de fonctionvariables : le nombre de variables dans la portée de la fonction (sans arguments de fonction et récepteurs de fonction)assignments : le nombre de missions dans la fonction (y compris les déclarations de variables , := , = , += , -= ...)control : Le nombre d'instructions de flux de contrôle ( if , else , switch , case , default , select et defer )todos : le nombre de balises "TODO" trouvées dans les commentaires (y compris le corps de la fonction et le recommandation précédant la fonction). Les balises sont HACK , TODO , NOTE , FIXME , ASAP , ISSUE , BUG et WTF .En plus de ceux-ci, vous pouvez combiner des mesures. Par exemple:
complexity/lines : calcule la complexité moyenne par ligne de code.total_nesting/total_lines : calcule la nidification moyenne (indentation) par ligne.comment_lines/total_lines : calcule des lignes de fonctions par ligne.Pour calculer l'une de ces mesures pour votre code Golang:
$ golongfuncs +variable
$ golongfuncs +total_nesting
$ golongfuncs +lines
$ golongfuncs +lines,complexity
$ golongfuncs +lines,complexity,complexity/lines
Appeler simplement golongfuncs (sans arguments) est un alias pour golongfuncs +lines .
$ golongfuncs [flags] +[types] [paths...]
Trouver les fonctions les plus longues:
$ golongfuncs <go_file>
$ golongfuncs <directory>
$ golongfuncs <directory>/...
Si le chemin n'est pas spécifié, Golongfuncs suppose qu'il est ./...
Afficher plusieurs mesures:
$ golongfuncs +lines
$ golongfuncs +lines,in_params
$ golongfuncs +lines,in_params,complexity/lines
$ golongfuncs +lines +in_params +complexity/lines
Si plusieurs mesures sont spécifiées, les résultats sont triés par la première colonne (dans cet exemple lines ):
Par défaut, le résultat ne montre que les 20 meilleurs résultats. Changez cela avec -top :
$ golongfuncs -top 50
Par défaut, les fonctions de moins de 10 lignes sont ignorées. Vous pouvez changer cela avec -min-lines <n> .
Les 100 fonctions les plus complexes:
$ golongfuncs -top 100 +complexity ./...
Les fonctions les plus complexes de plus de 50 lignes:
$ golongfuncs -min-lines 50 +complexity ./...
Trouvez de longues fonctions, mais calculez également leur complexité, leur complexité AVG et leur nidification AVG:
$ golongfuncs +lines,complexity,complexity/lines,total_nesting/total_lines .
ExampleVeryLongfunction golongfuncs/runner_test.go:118:1 lines=305.0 complexity=1.0 complexity/lines=0.1 total_nesting/total_lines=1.0
ExampleVeryComplexFunction golongfuncs/runner_test.go:10:1 lines=69.0 complexity=44.0 complexity/lines=0.6 total_nesting/total_lines=6.7
printStats main.go:54:1 lines=21.0 complexity=9.0 complexity/lines=0.4 total_nesting/total_lines=2.5
main main.go:12:1 lines=19.0 complexity=3.0 complexity/lines=0.2 total_nesting/total_lines=1.0
TestLines golongfuncs/runner_test.go:476:1 lines=15.0 complexity=2.0 complexity/lines=0.1 total_nesting/total_lines=0.9
NewVisitor golongfuncs/runner.go:94:1 lines=15.0 complexity=3.0 complexity/lines=0.2 total_nesting/total_lines=1.0
Get golongfuncs/models.go:34:1 lines=15.0 complexity=7.0 complexity/lines=0.5 total_nesting/total_lines=1.7
TestNesting golongfuncs/runner_test.go:438:1 lines=15.0 complexity=2.0 complexity/lines=0.1 total_nesting/total_lines=0.9
Vous pouvez voir que ExampleVeryLongfunction est longue (305 lignes), mais la complexité moyenne est faible (0,1) et la nidification AVG est de 1,0. AVG Nesting 1.0 signifie qu'il n'y a pas de blocs imbriqués dans cette fonction. Si la moitié des lignes étaient dans un bloc imbriqué (par exemple un grand bloc de if <expr> { ...code... } de code AVG serait 1,5.
L' ExampleVeryComplexFunction est plus court (69 lignes) mais avec une complexité moyenne (par ligne de code) de 0,6 et AVG nicheur 6,7 et c'est probablement un bon indice que la fonction a besoin de refactorisation.
Trouvez des fonctions de plus de 5 lignes avec nidification AVG (par ligne de code) plus grande que 5 et incluez le nombre total de lignes et le nombre de lignes:
$ golongfuncs +total_nesting/total_lines,total_lines,lines -threshold 5 .
ExampleVeryComplexFunction golongfuncs/runner_test.go:10:1 total_nesting/total_lines=6.7 total_lines=108.0 lines=69.0
Trouver des fonctions avec la longueur moyenne de ligne la plus longue:
$ golongfuncs +len/lines ./...
$ golongfuncs +total_len/total_lines ./...
Les tests et les fichiers vendus sont ignorés, utilisez -include-tests et -include-vendor si vous souhaitez les mesurer.
Les fichiers arbitraires / répertoires peuvent être ignorés avec -ignore "<regexp>" . Par exemple, si vous souhaitez ignorer les fichiers Golang contenant _generated.go : -ignore "^.*_generated.go$" .
Les fonctions peuvent être ignorées avec -ignore-func "regexp" .
Cet outil est sous licence Apache, version 2.0
