---
# System prepended metadata

title: TP-6 FlorianGERARD LorisBENOIT

---



# TP-6 FlorianGERARD LorisBENOIT

Etudiants | Date | Sujet
:---|:---|:---
Florian GERARD et Loris Benoit | 10/03/2020 | TP-6


> Vous devez :
> * structurer votre document, c'est la table des matières que je regarde en premier
> * mettre des copies de code en précisant son type (pas des copies d'écran du code)
> * toujours rendre les fichiers sources des programmes
> * utiliser que ce que [Markdonw GFM](https://guides.github.com/features/mastering-markdown/) vous permet pour la mise en forme (pas d'HTML et CSS)
> * utiliser les [Emoji](https://www.webfx.com/tools/emoji-cheat-sheet/) avec discernement
> * ne pas hésiter à utiliser $\LaTeX$ pour les [formules mathématiques](https://fr.wikibooks.org/wiki/LaTeX/Écrire_des_mathématiques)
> * ne pas utiliser la mise en forme Quote qui m'est réservée

# Introduction
Ceci est le sixième Tp de Techniques de Tests. Dans ce Tp, nous nous intéressons aux erreurs communes dans la programmation ainsi que des outils qui permettent de les détecter et de les corriger avant que ces problèmes ne posent d'autres soucis par la suite lors du développement du soft.

Nous devons donc réaliser ce TP à l'aide des outils PHP Mess Detector ainsi que PHP Depend. Ces outils nous permettent de réaliser des mesures sur un code donné, et d'établir des régles afin d'avertir le developpeur si une mauvaise conception du code à été fournis.

# Objectif A
## Méthodologie

Après avoir installé les utilitaires et téléchargé le code à annalyser, nous avons lancer une série de commandes pour apprendre à nous servir de ces outils pour réaliser au mieux l'annalyse.

La librairie ```phpmd``` permet de générer un fichier répertoriant les erreurs/warnings présent dans un fichier/dossier en fonction des **rules** qui sont fournis. La syntaxe de la commande se présente comme ceci: ```$ phpmd [filename|directory] [report format] [ruleset file] > [generated file]```.

Dans notre cas, il nous est demandé de fournir les 3 métriques suivantes:

- Executable Lines of Code
- Extended Cyclomatic Complexity Number
- NPath Complexity

Ces trois métriques sont toutes comprises dans la rule ```codesize```.

**$ phpmd Form.php text codesize > errors**


```
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:40    The class Form has an overall complexity of 83 which is very high. The configured complexity threshold is 50.
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:89    The method compile() has a Cyclomatic Complexity of 34. The configured cyclomatic complexity threshold is 10.
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:89    The method compile() has an NPath complexity of 115017408. The configured NPath complexity threshold is 200.
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:89    The method compile() has 159 lines of code. Current threshold is set to 100. Avoid really long methods.
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:254    The method processFormData() has a Cyclomatic Complexity of 39. The configured cyclomatic complexity threshold is 10.
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:254    The method processFormData() has an NPath complexity of 181740336. The configured NPath complexity threshold is 200.
/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php:254    The method processFormData() has 209 lines of code. Current threshold is set to 100. Avoid really long methods.
```

**$ phpmd Form.php xml codesize > errors.xml**


```xml
<?xml version="1.0" encoding="UTF-8" ?>
<pmd version="@project.version@" timestamp="2020-05-13T13:39:38+00:00">
  <file name="/home/loris/M1/Tests/TP-6/AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php">
    <violation beginline="40" endline="516" rule="ExcessiveClassComplexity" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#excessiveclasscomplexity" class="Form" priority="3">
      The class Form has an overall complexity of 83 which is very high. The configured complexity threshold is 50.
    </violation>
    <violation beginline="89" endline="247" rule="CyclomaticComplexity" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#cyclomaticcomplexity" class="Form" method="compile" priority="3">
      The method compile() has a Cyclomatic Complexity of 34. The configured cyclomatic complexity threshold is 10.
    </violation>
    <violation beginline="89" endline="247" rule="NPathComplexity" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#npathcomplexity" class="Form" method="compile" priority="3">
      The method compile() has an NPath complexity of 115017408. The configured NPath complexity threshold is 200.
    </violation>
    <violation beginline="89" endline="247" rule="ExcessiveMethodLength" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#excessivemethodlength" class="Form" method="compile" priority="3">
      The method compile() has 159 lines of code. Current threshold is set to 100. Avoid really long methods.
    </violation>
    <violation beginline="254" endline="462" rule="CyclomaticComplexity" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#cyclomaticcomplexity" class="Form" method="processFormData" priority="3">
      The method processFormData() has a Cyclomatic Complexity of 39. The configured cyclomatic complexity threshold is 10.
    </violation>
    <violation beginline="254" endline="462" rule="NPathComplexity" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#npathcomplexity" class="Form" method="processFormData" priority="3">
      The method processFormData() has an NPath complexity of 181740336. The configured NPath complexity threshold is 200.
    </violation>
    <violation beginline="254" endline="462" rule="ExcessiveMethodLength" ruleset="Code Size Rules" package="Controller" externalInfoUrl="http://phpmd.org/rules/codesize.html#excessivemethodlength" class="Form" method="processFormData" priority="3">
      The method processFormData() has 209 lines of code. Current threshold is set to 100. Avoid really long methods.
    </violation>
  </file>
</pmd>

```

En utilisant le fichier au format ```xml``` nous pouvons utiliser la librairie ```pdepend``` afin de générer deux graphiques, l'un réprésentant les dépendances entre les packages et l'autre un résumé visuel du code source analysé. La commande permettant de générer ces deux graphiques est la suivante: ```$ pdepend --summary-xml=errors.xml --jdepend-chart=jdepend.svg --overview-pyramid=pyramid.svg AllFormClasses-DatabaseClass-FormClass/FormClass/```

![](https://i.imgur.com/rfKfsAS.jpg)

![](https://i.imgur.com/ucTUO9H.jpg)



## Analyse des données

Voici donc le résultat suites aux annalyses du code par les outils PHP Mess Detector et PHP Depend. On peut apercevoir que chaque méthode contient trop de lignes comparées à la limite conséillée de base. De même pour la compléxité cyclomatique, qui est au dessus de la règle.

 |  | Lines of code | Compléxité cyclomatique| NPath 
:---|:---|:---|:---
compile()| 159 | 34 | 115017408
processFormData()| 209 | 39 | 181740336
Maximum| 100 | 10 | 200

La représentation de ce tableau en histogrammes :

![](https://i.imgur.com/z9Wcm9W.png)

Nous avons inclus ici la variable NPath, qui est extrement grande comparé aux autres et à sa limite qui est de seulement 200. Pour pouvoir réaliser un graphique compréhensible, nous avons donc choisi de représenter ces graphiques avec une échelle logarithmique. Ce graphique reste donc lisible et montre les valeures énormes du NPath pour compile et processFormData.

![](https://i.imgur.com/GRliQJI.png)


## Analyse des résultats

### Commentaires

Sur nos impressions, nous pensons que ces graphiques montrent que le code ici annalysé ne respecte pas les règles par defaults des outils d'annalyses. Les méthodes sont donc trop longs et trop complexes pour être acceptable et il faut donc revoir ces codes afin qu'ils puissent rentrer dans les standards des outils.

### Modifications proposées

Pour réduire la compléxité du code, nous proposons de revoir l'algorithmie générale du programme afin de réduire sa compléxitée. Nous pouvons aussi diviser les méthodes en plusieures méthodes annexes. En effet quand une méthode est trop longue, c'est qu'elle effectue plus d'une tache différente, et chacune des taches peuvent donc êtres isolées pour réduire la compléxitée.

# Objectif B

## Méthodologie

Pour automatiser l'éxécution d'un contrôle sur la qualité du code à l'aide de l'outil ```phpmd```, on créé un script bash comme suit:

```shell
#!/bin/bash

rm -r FormReport
mkdir FormReport
phpmd AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php html codesize > reportCodesize.html
phpmd AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php html cleancode > reportCleancode.html
phpmd AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php html controversial > reportControversial.html
phpmd AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php html design > reportDesign.html
phpmd AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php html naming > reportNaming.html
phpmd AllFormClasses-DatabaseClass-FormClass/FormClass/Form.php html unusedcode > reportUnused.html
```

Un utilitaire comme jenkins aurait pu être un bon outil pour automatiser les annalyse avec des pipes d'éxécutions ! Ainsi, plus besoin de faire des annalyses à la main, mais des analyses régulières peuvent être automatisées, et ainsi des relevés réguliers.


## Form et database

Le script suivant génère un dossier 'NomDuDossierPasséEnParametre'Report qui contient 6 fichier html report pour chaque règle éxistante dans l'outil ```phpmd``` soit: cleancode, codesize, controversial, design, naming et unusedcode

```bash
#!/bin/bash

rm -r $1Report
mkdir $1Report/
phpmd AllFormClasses-DatabaseClass-FormClass/$1 html codesize > $1Report/reportCodesize.html
phpmd AllFormClasses-DatabaseClass-FormClass/$1 html cleancode > $1Report/reportCleancode.html
phpmd AllFormClasses-DatabaseClass-FormClass/$1 html controversial > $1Report/reportControversial.html
phpmd AllFormClasses-DatabaseClass-FormClass/$1 html design > $1Report/reportDesign.html
phpmd AllFormClasses-DatabaseClass-FormClass/$1 html naming > $1Report/reportNaming.html
phpmd AllFormClasses-DatabaseClass-FormClass/$1 html unusedcode > $1Report/reportUnused.html
```




# Conclusion
Dans ce Tp, nous avons vu les processuss qui permettent une annalyse sur la qualité du code, autant dans sa compléxité que dans sa quantité. Grace à ces outils, les développeurs peuvent rectifier leurs erreurs qui peuvent êtres fatales au fil du temps et des ajouts de fonctionnalitées dans le code. Ces outils sont personalisables et donc facilement ajustable à chaque entreprise, chaque équipe, chaque projet. Chaque language à ses propres outils, et on peut citer sonar² pour le java par exemple qui repère les petites erreurs comme les plus critiques.