Introduction
CLOC (Compter les lignes de code) est un outil en ligne de commande qui analyse les fichiers d'un répertoire et compte le nombre de lignes de code, de commentaires et de lignes vides dans une grande variété de langages de programmation. C'est une ressource inestimable pour les développeurs qui cherchent à comprendre la composition de leurs projets, mesurer leur productivité ou estimer la complexité d'un projet.
Comprendre CLOC et son utilisation de base
CLOC (Compter les lignes de code) est un outil puissant qui aide les développeurs à analyser leur base de code en comptant les lignes de code, les commentaires et les lignes vides dans plusieurs langages de programmation.
Dans cette étape, nous allons apprendre à utiliser CLOC avec sa syntaxe de base pour analyser un projet.
Commande de base de CLOC
La syntaxe de base pour utiliser CLOC est la suivante :
cloc [options] <file/directory>
Utilisons CLOC pour analyser le projet Flask qui a été cloné lors de la configuration :
- Ouvrez le terminal en cliquant sur l'icône du terminal dans la barre des tâches.
- Accédez au répertoire du projet Flask :
cd ~/project/flask
- Exécutez la commande de base de CLOC pour analyser l'ensemble du projet :
cloc .
Le . représente le répertoire actuel, donc cette commande demande à CLOC d'analyser tous les fichiers dans le répertoire actuel et ses sous-répertoires.
Comprendre la sortie
Après avoir exécuté la commande, CLOC affichera un tableau avec les informations suivantes :
- Langage : Langages de programmation détectés dans le projet
- Fichiers : Nombre de fichiers pour chaque langage
- Vides : Nombre de lignes vides
- Commentaires : Nombre de lignes de commentaires
- Code : Nombre de lignes de code
La sortie devrait ressembler à ceci :
56 text files.
56 unique files.
16 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.11 s (428.1 files/s, 72093.6 lines/s)
--------------------------------------------------------------------------------
Language files blank comment code
--------------------------------------------------------------------------------
Python 41 3061 2088 7012
Markdown 5 175 0 314
YAML 2 10 3 84
make 1 21 30 46
TOML 1 6 0 19
--------------------------------------------------------------------------------
SUM: 50 3273 2121 7475
--------------------------------------------------------------------------------
Cette sortie vous donne un aperçu complet de la composition de la base de code du projet Flask.
Analyser des types de fichiers spécifiques avec CLOC
CLOC vous permet d'analyser des types de fichiers spécifiques ou d'exclure certains fichiers de votre analyse. Cela est particulièrement utile lorsque vous travaillez sur de grands projets contenant plusieurs langages de programmation.
Analyser des extensions de fichiers spécifiques
Pour analyser uniquement les fichiers avec des extensions spécifiques, vous pouvez utiliser l'option --include-ext suivie d'une liste d'extensions de fichiers séparées par des virgules :
- Accédez au répertoire du projet Flask si vous n'y êtes pas déjà :
cd ~/project/flask
- Exécutez CLOC pour analyser uniquement les fichiers Python dans le projet :
cloc --include-ext=py .
La sortie affichera maintenant uniquement des informations sur les fichiers Python dans le projet :
41 text files.
41 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.05 s (886.0 files/s, 264066.7 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 41 3061 2088 7012
-------------------------------------------------------------------------------
SUM: 41 3061 2088 7012
-------------------------------------------------------------------------------
Exclure des répertoires spécifiques
Vous pouvez également exclure des répertoires spécifiques de votre analyse en utilisant l'option --exclude-dir :
cloc --exclude-dir=tests .
Cette commande analyse le projet Flask mais exclut le répertoire tests. La sortie affichera les statistiques pour tous les fichiers du projet, sauf ceux du répertoire tests :
34 text files.
34 unique files.
14 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.07 s (372.3 files/s, 45941.8 lines/s)
--------------------------------------------------------------------------------
Language files blank comment code
--------------------------------------------------------------------------------
Python 25 1546 1103 3421
Markdown 5 175 0 314
YAML 2 10 3 84
make 1 21 30 46
TOML 1 6 0 19
--------------------------------------------------------------------------------
SUM: 34 1758 1136 3884
--------------------------------------------------------------------------------
En utilisant ces options de filtrage, vous pouvez concentrer votre analyse sur les parties spécifiques de la base de code qui sont les plus pertinentes pour vos besoins.
Comparer des projets et générer des rapports
CLOC propose des fonctionnalités pour comparer différents projets et générer des rapports dans divers formats. Ces capacités sont particulièrement utiles pour suivre les modifications au fil du temps ou comparer différentes bases de code.
Comparer deux répertoires
Créons un simple projet à comparer avec Flask :
- Accédez au répertoire du projet :
cd ~/project
- Créez un nouveau répertoire pour un simple projet Python :
mkdir sample_project
cd sample_project
- Créez quelques fichiers Python avec du code :
echo 'def hello_world():
"""
A simple function that prints Hello World
"""
print("Hello, World!")
if __name__ == "__main__":
hello_world()' > main.py
echo 'class Calculator:
"""A simple calculator class"""
def add(self, a, b):
"""Add two numbers"""
return a + b
def subtract(self, a, b):
"""Subtract b from a"""
return a - b' > calculator.py
- Maintenant, comparons ce projet d'exemple avec le projet Flask en utilisant la fonctionnalité de comparaison (
diff) de CLOC :
cd ~/project
cloc --diff flask sample_project
La sortie affichera la différence dans les métriques de code entre les deux projets :
2 text files.
2 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.01 s (195.2 files/s, 1756.8 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 2 3 4 11
-------------------------------------------------------------------------------
SUM: 2 3 4 11
-------------------------------------------------------------------------------
Diff by file type:
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 39 3058 2084 7001
Markdown 5 175 0 314
YAML 2 10 3 84
make 1 21 30 46
TOML 1 6 0 19
-------------------------------------------------------------------------------
SUM: 48 3270 2117 7464
-------------------------------------------------------------------------------
Générer des rapports dans différents formats
CLOC peut générer des rapports dans divers formats, notamment CSV et XML. Créons un rapport CSV pour le projet Flask :
- Accédez au projet Flask :
cd ~/project/flask
- Générez un rapport CSV :
cloc --csv --out=flask_stats.csv .
- Affichez le contenu du rapport généré :
cat flask_stats.csv
Vous devriez voir l'analyse CLOC au format CSV :
files,language,blank,comment,code,"github.com/AlDanial/cloc v 1.90 T=0.09 s (571.3 files/s, 96263.8 lines/s)"
41,Python,3061,2088,7012
5,Markdown,175,0,314
2,YAML,10,3,84
1,make,21,30,46
1,TOML,6,0,19
50,SUM,3273,2121,7475
Ce format CSV est particulièrement utile pour l'importation dans des tableurs ou d'autres outils d'analyse de données.
De même, vous pouvez générer un rapport XML :
cloc --xml --out=flask_stats.xml .
Ces capacités de génération de rapports font de CLOC un outil polyvalent pour l'analyse de code et la gestion de projets.
Options Avancées de CLOC pour une Analyse Détaillée
CLOC offre plusieurs options avancées pour une analyse plus détaillée et personnalisée. Ces options vous permettent d'obtenir des informations plus approfondies sur votre base de code.
Affichage de la progression pendant l'analyse
Lors de l'analyse de projets volumineux, il est utile de voir la progression. Utilisez l'option --progress-rate pour afficher les mises à jour de la progression :
cd ~/project/flask
cloc --progress-rate=10 .
Cette commande affichera une mise à jour de la progression après le traitement de chaque tranche de 10 fichiers.
Analyse des fichiers correspondant à un motif
Vous pouvez analyser les fichiers qui correspondent à un motif spécifique en utilisant l'option --match-f :
cloc --match-f='test_.*\.py$' .
Cette commande compte les lignes de code uniquement dans les fichiers Python qui commencent par "test_". La sortie affichera les statistiques pour les fichiers de test dans le projet Flask :
15 text files.
15 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.03 s (541.8 files/s, 155547.1 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 15 1337 736 3193
-------------------------------------------------------------------------------
SUM: 15 1337 736 3193
-------------------------------------------------------------------------------
Cette fonctionnalité est particulièrement utile lorsque vous souhaitez vous concentrer sur des motifs de fichiers spécifiques au sein d'un projet volumineux.
Affichage des résultats par fichier
Pour voir une ventilation de l'analyse par fichiers individuels plutôt que par langage, utilisez l'option --by-file :
cloc --by-file --include-ext=py src/
Cette commande analyse les fichiers Python dans le répertoire src et affiche les résultats pour chaque fichier individuellement :
7 text files.
7 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.01 s (648.3 files/s, 180431.1 lines/s)
-------------------------------------------------------------------------------
File blank comment code
-------------------------------------------------------------------------------
src/flask/ctx.py 123 193 539
src/flask/app.py 284 490 999
src/flask/blueprints.py 100 191 421
src/flask/cli.py 126 188 557
src/flask/helpers.py 136 227 538
src/flask/templating.py 28 60 123
src/flask/globals.py 22 63 74
-------------------------------------------------------------------------------
SUM: 819 1412 3251
-------------------------------------------------------------------------------
Cette vue détaillée vous aide à identifier les fichiers spécifiques qui contribuent le plus à la taille de votre base de code.
Ces options avancées font de CLOC un outil polyvalent pour une analyse de code complète dans divers scénarios.
Résumé
Dans ce laboratoire, vous avez appris à utiliser CLOC (Count Lines of Code - Compter les lignes de code) pour analyser des bases de code et obtenir des informations précieuses sur la composition des projets. Voici un résumé de ce que vous avez accompli :
Utilisation de base : Vous avez appris à utiliser la commande de base
clocpour analyser des répertoires et compter le nombre de lignes de code, de commentaires et de lignes vides dans différents langages de programmation.Filtrage et ciblage : Vous avez exploré comment concentrer votre analyse sur des types de fichiers spécifiques en utilisant
--include-extet comment exclure des répertoires avec--exclude-dir.Comparaison et génération de rapports : Vous avez appris à comparer différentes bases de code en utilisant l'option
--diffet à générer des rapports dans divers formats tels que CSV et XML.Analyse avancée : Vous avez découvert des options avancées qui fournissent des informations plus détaillées, telles que le suivi de la progression, la détection de fichiers dupliqués, la correspondance de motifs et l'analyse fichier par fichier.
CLOC est un outil puissant pour les développeurs, les gestionnaires de projet et les auditeurs de code afin de quantifier la taille et la complexité des bases de code. En utilisant efficacement CLOC, vous pouvez :
- Comprendre la composition de vos projets
- Suivre la productivité de codage
- Estimer la complexité du projet
- Prendre des décisions éclairées concernant l'architecture et la maintenance du code
- Générer des rapports pour la documentation et l'analyse
Ces capacités font de CLOC un outil essentiel dans la boîte à outils de tout développeur pour l'analyse de code et la gestion de projet.
