Wie berechnet man zyklomatische Komplexität eines Projekts (keine Klasse/Funktion)?

Question

Wie berechnet man cyclomatic complexity des gesamten Java-Projekts? Ich habe für jede Methode Komplexitäten, aber wie kann ich sie alle zu einer numerischen Metrik zusammenfassen? Irgendwelche Ideen oder bestehende Methoden?

Ich bin nicht auf der Suche nach einem Werkzeug, aber für einen Algorithmus.

Einfache Durchschnitt funktioniert kaum, weil es viele 1-Komplexitätsmethoden gibt, die nicht wirklich von geringer Komplexität sind, aber von geringer Bedeutung für die Code-Basis (in den meisten Fällen).

Answer 1

fand ich, dass die Formel:

TCC = Sum(CC) - Count(CC) + 1 
TCC: Total CC 
Sum(CC): Sum of CC of all functions 
Count(CC): Number of functions 

Quelle: http://www.aivosto.com/project/help/pm-complexity.html

Aber vielleicht ist es zu begrenzt.

Eine andere Idee wäre, den Aufruf-Graph des Programms als ein Programm selbst zu betrachten und die CC des Call-Graphen zu berechnen. Die Knoten werden mit ihrem CC gewichtet. (Ich habe keine Ahnung, ob es machbar ist, es ist nur eine Idee)

Answer 2

Ich weiß nicht, ob das helfen wird, aber ich wollte nur sagen, was ich dachte. Sie können einen globalen Tiefenzähler verwenden, um Methodenaufruftiefen abzurufen und sie bei jedem Methodenaufruf zu aktualisieren. Sie sehen, dass in jede Methode das gleiche Snippet manuell eingefügt wird, aber es könnte eine Lösung für die automatische Injektion des Codes in alle Methoden geben. Mit der Stack-Trace-Länge können Sie die aggregierte Komplexität berechnen, denke ich.

public class Cyclomatic 
{ 
    public static int max = Integer.MIN_VALUE; 

    static void a() 
    { 
     b(); 
     int temp = Thread.currentThread().getStackTrace().length; 
     if (temp > max) 
      max = temp; 
    } 

    static void b() 
    { 
     c(); 
     int temp = Thread.currentThread().getStackTrace().length; 
     if (temp > max) 
      max = temp; 
    } 

    static void c() 
    { 
     int temp = Thread.currentThread().getStackTrace().length; 
     if (temp > max) 
      max = temp; 
    } 

    public static void main(String[] args) 
    { 
     a(); 
     System.out.println(max); 
    } 
} 

Ausgang:

5 

Answer 3

Ganze Bücher wurden auf Code-Metriken geschrieben worden ist, so dass Sie haben Glück, dass Sie eine spezifischere Frage sind gefragt. Für die zyklomatische Komplexität von Java könnten Sie die Anzahl der Methoden finden, die eine zyklomatische Komplexität von 5 oder 6 überschreiten (Sie wählen die Zahl hier aus). Wenn diese Anzahl mehr als einen bestimmten Prozentsatz Ihrer Anzahl an Methoden übersteigt, ist die gesamte zyklomatische Komplexität gering. Eine gute Zahl für den Prozentsatz hängt ausschließlich von der Größe des Projekts ab. Daher können Sie vielleicht nicht nur durch die Anzahl der Methoden dividieren, sondern auch die Anzahl der Methoden in der Division verringern, indem Sie sie langsam für große Zahlen wie z eine Quadratwurzel oder einen Logarithmus, um zu versuchen, es stabiler zu machen, wenn das Projekt wächst.

Vielleicht so etwas wie folgt aus:

public double evaluateCyclomaticComplexity(List<MethodStat> methodStats) { 
    int bad = 0; 
    for (MethodStat methodStat : methodStats) 
     if (methodStat.getCyclomaticComplexity() >= 6) 
      bad++; 

    double denominator = Math.sqrt(methodStats.size()); 
    return bad * 100.0/denominator; 
} 

Je kleiner die Zahl hier zurückgekehrt, desto besser. Für wirklich schlechtes Projekt, wird dies etwas größer als 100 zurückgeben.

Die Nenner-Funktion sollte darstellen, wie schnell Sie in Ordnung mit der Komplexität sind, wächst mit der Code-Basis wächst. Normalerweise möchten Sie, dass der CC pro Funktion niedriger wird, da der Code wächst, so dass er beibehalten werden kann. Daher ist es am besten, wenn die Projektgröße zunimmt.

Testen, zwicken, etc. Letztlich sind Code-Metriken schwer zu bekommen, was ich bestätigen kann, nachdem ich mehrere Zeitschriftenartikel über Open-Source-Software gelesen habe, die Zahlen für "Wartbarkeit" verwenden. Alles, was wir hier erreichen können, wird wahrscheinlich erheblich verbessert, wenn genug Zeit dafür aufgewendet wird.