Annotations pour appliquer la complexité cyclomatique et les contraintes LCOM

Question

Au travail, nous utilisons plusieurs outils pour capturer plusieurs métriques (principalement la complexité cyclomatique et la LCOM). Nous les utilisons pour obtenir des drapeaux d'avertissement et guider les efforts de refactoring préventifs. Cela a été très bénéfique pour augmenter la qualité du code.

Cependant, le processus n'est pas lié au processus de construction. Il est mené séparément. De plus, je cherche quelque chose qui peut être rendu intrinsèque au code source (par opposition à un processus externe exécuté dessus.)

Quelqu'un at-il connaissance d'un groupe d'annotations et de processeurs d'annotation configurables qui peuvent être exécuté à partir du compilateur, et qui va faire échouer la construction si le code n'est pas conforme aux métriques cyclomatic/LCOM de seuil? Je suppose que je pourrais lancer ckjm, checkstyle et pmd à partir de maven/ant, MAIS certains travaillent sur le code source, et d'autres fonctionnent sur le bytecode. Ce serait bien d'avoir un outil consolidé qui fonctionne sur le code source avant le début de la compilation.

L'autre chose est que ce serait bien s'il y a des ensembles d'annotations qui pourraient conduire ce (pour permettre la personnalisation qui sera être nécessaire inévitablement pour les cas d'angle.)

@LCOM3(Threshold=1.5) 
public class SomeDumbPojo {... buch of gets/sets...} 

// by default would be measured against a strict LCOM3 
public class ActualBizClass 
{ 
    @CYCLOMATIC_COMPLEXITY(Threshold=15) 
    public void someFatIrreducibleMethod(){...} 
} 

Puis, quand nous Exécuter l'outil, par défaut, applique un seuil de métrique strict (et configurable) sauf sur les artefacts qui sont annotés avec des seuils plus souples (espérons documentés et légitimes). Pour certaines méthodes qui ne peuvent/ne doivent pas être réduites, une complexité cyclomatique relaxée est logique. Pour les POJO simples sans comportement, les LCOM doivent être assouplies ... et ainsi de suite.

En regardant et googling comme je pourrais, je n'ai pas été en mesure de trouver quelque chose (espérons open source). Mais je pourrais aussi bien demander ici au cas où quelqu'un serait au courant de quelque chose du genre.

Merci.

Answer 1

Il serait bien d'avoir un outil consolidé qui fonctionne sur le code source avant le début de la compilation.

Je ne suis pas sûr de ce que cela signifie que le code doit être compilé dans quelque chose pour que l'analyse statique fonctionne. Tous ces outils doivent être capables de compiler votre code soit en bytecode, soit en un arbre de syntaxe.

Je suggère de rester simple: configurer PMD pour échouer la construction si des avertissements pour la complexité cyclomatique ou d'autres métriques franchissent un seuil donné. Au lieu d'annoter la méthode avec la complexité permise (comment dériver une valeur acceptée?), Annoter pour supprimer complètement l'avertissement

@SuppressWarnings("PMD.CyclomaticComplexity") 
public void someFatIrreducibleMethod() { ... } 

Et puis régulièrement vous pouvez rechercher votre base de code pour les méthodes avec des avertissements supprimés que vous pourriez vouloir supprimer et refactoriser.

Alternativement, PMD a la possibilité de laisser des commentaires dans le code dans une certaine syntaxe pour marquer qui a audité l'avertissement et quand, si vous souhaitez fournir une sorte de traçabilité.

Answer 2

L'outil SD Java Metrics calcule la plupart des métriques de base (pas LCOM mais certainement complexité cyclomatique), et s'exécute à partir de la ligne de commande.

Il produit un fichier de sortie XML, avec des métriques détaillées sur les méthodes et les récapitulatifs de cumul pour les hiérarchies supérieures (classe, package, sous-système). Utiliser XLST (ou awk ou perl ou ...) Il serait très facile d'extraire la métrique que vous voulez pour le résumé complet ou pour une méthode individuelle, et vérifier par rapport à votre seuil.