Add cyclomatic_sum field, fix issues related to this change

Author: giovannitangredi

src/metrics/cyclomatic.rs

@@ -1,20 +1,21 @@
+use crate::checker::Checker;
+use crate::*;
 use serde::ser::{SerializeStruct, Serializer};
 use serde::Serialize;
 use std::fmt;
 
-use crate::checker::Checker;
-use crate::*;
-
 /// The `Cyclomatic` metric.
 #[derive(Debug, Clone)]
 pub struct Stats {
+    cyclomatic_sum: f64,
     cyclomatic: f64,
     n: usize,
 }
 
 impl Default for Stats {
     fn default() -> Self {
         Self {
+            cyclomatic_sum: 0.,
             cyclomatic: 1.,
             n: 1,
         }
@@ -27,7 +28,7 @@ impl Serialize for Stats {
         S: Serializer,
     {
         let mut st = serializer.serialize_struct("cyclomatic", 2)?;
-        st.serialize_field("sum", &self.cyclomatic())?;
+        st.serialize_field("sum", &self.cyclomatic_sum())?;
         st.serialize_field("average", &self.cyclomatic_average())?;
         st.end()
     }
@@ -38,30 +39,39 @@ impl fmt::Display for Stats {
         write!(
             f,
             "sum: {}, average: {}",
-            self.cyclomatic(),
-            self.cyclomatic_average()
+            self.cyclomatic_sum(),
+            self.cyclomatic_average(),
         )
     }
 }
 
 impl Stats {
     /// Merges a second `Cyclomatic` metric into the first one
     pub fn merge(&mut self, other: &Stats) {
-        self.cyclomatic += other.cyclomatic;
+        self.cyclomatic_sum += other.cyclomatic_sum;
         self.n += other.n;
     }
 
     /// Returns the `Cyclomatic` metric value
     pub fn cyclomatic(&self) -> f64 {
         self.cyclomatic
     }
+    /// Returns the sum
+    pub fn cyclomatic_sum(&self) -> f64 {
+        self.cyclomatic_sum
+    }
 
     /// Returns the `Cyclomatic` metric average value
     ///
     /// This value is computed dividing the `Cyclomatic` value for the
     /// number of spaces.
     pub fn cyclomatic_average(&self) -> f64 {
-        self.cyclomatic() / self.n as f64
+        self.cyclomatic_sum() / self.n as f64
+    }
+
+    /// Last step for computing minimum and maximum value and update cyclomatic_sum
+    pub fn compute_minmax(&mut self) {
+        self.cyclomatic_sum += self.cyclomatic;
     }
 }
 
@@ -190,9 +200,9 @@ mod tests {
             "foo.py",
             PythonParser,
             cyclomatic,
-            [(cyclomatic, 6, usize)],
+            [(cyclomatic_sum, 6, usize)],
             [
-                (cyclomatic_average, 3.0) // nspace = 2 (func and unit)
+                (cyclomatic_average, 3.0), // nspace = 2 (func and unit)        
             ]
         );
     }
@@ -207,9 +217,9 @@ mod tests {
             "foo.py",
             PythonParser,
             cyclomatic,
-            [(cyclomatic, 4, usize)],
+            [(cyclomatic_sum, 4, usize)],
             [
-                (cyclomatic_average, 2.0) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.0), // nspace = 2 (func and unit)
             ]
         );
     }
@@ -228,9 +238,9 @@ mod tests {
             "foo.rs",
             RustParser,
             cyclomatic,
-            [(cyclomatic, 5, usize)],
+            [(cyclomatic_sum, 5, usize)],
             [
-                (cyclomatic_average, 2.5) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.5), // nspace = 2 (func and unit) 
             ]
         );
     }
@@ -257,9 +267,9 @@ mod tests {
             "foo.c",
             CppParser,
             cyclomatic,
-            [(cyclomatic, 5, usize)],
+            [(cyclomatic_sum, 5, usize)],
             [
-                (cyclomatic_average, 2.5) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.5), // nspace = 2 (func and unit)
             ]
         );
     }
@@ -282,9 +292,81 @@ mod tests {
             "foo.c",
             CppParser,
             cyclomatic,
-            [(cyclomatic, 5, usize)],
+            [(cyclomatic_sum, 5, usize)],
+            [
+                (cyclomatic_average, 2.5), // nspace = 2 (func and unit)
+            ]
+        );
+    }
+    #[test]
+    fn c_unit_before() {
+        check_metrics!(
+            "
+            int a=42;
+            if(a==42) //+2(+1 unit space)
+            {
+
+            }
+            if(a==34) //+1
+            {
+                
+            }
+            int sumOfPrimes(int max) { // +1 
+                 int total = 0;
+                 OUT: for (int i = 1; i <= max; ++i) { // +1
+                   for (int j = 2; j < i; ++j) { // +1
+                       if (i % j == 0) { // +1
+                          continue OUT;
+                       }
+                   }
+                   total += i;
+                 }
+                 return total;
+            }",
+            "foo.c",
+            CppParser,
+            cyclomatic,
+            [(cyclomatic_sum, 7, usize)],
+            [
+                (cyclomatic_average, 3.5), // nspace = 2 (func and unit)
+            ]
+        );
+    }
+    /// Test to handle the case of min and max when merge happen before the final value of one module are setted.
+    /// In this case the min value should be 3 because the unit space has 2 branches and a complexity of 3
+    /// while the function sumOfPrimes has a complexity of 4.
+    #[test]
+    fn c_unit_after() {
+        check_metrics!(
+            "
+            int sumOfPrimes(int max) { // +1 
+                 int total = 0;
+                 OUT: for (int i = 1; i <= max; ++i) { // +1
+                   for (int j = 2; j < i; ++j) { // +1
+                       if (i % j == 0) { // +1
+                          continue OUT;
+                       }
+                   }
+                   total += i;
+                 }
+                 return total;
+            }
+            
+            int a=42;
+            if(a==42) //+2(+1 unit space)
+            {
+
+            }
+            if(a==34) //+1
+            {
+                
+            }",
+            "foo.c",
+            CppParser,
+            cyclomatic,
+            [(cyclomatic_sum, 7, usize)],
             [
-                (cyclomatic_average, 2.5) // nspace = 2 (func and unit)
+                (cyclomatic_average, 3.5), // nspace = 2 (func and unit)
             ]
         );
     }

src/metrics/mi.rs

@@ -96,7 +96,7 @@ where
         stats.halstead_length = halstead.length();
         stats.halstead_vocabulary = halstead.vocabulary();
         stats.halstead_volume = halstead.volume();
-        stats.cyclomatic = cyclomatic.cyclomatic();
+        stats.cyclomatic = cyclomatic.cyclomatic_sum();
         stats.sloc = loc.sloc();
         stats.comments_percentage = loc.cloc() / stats.sloc;
     }

src/spaces.rs

@@ -195,6 +195,10 @@ fn compute_averages(state: &mut State) {
         .nargs
         .finalize(nom_functions, nom_closures);
 }
+#[inline(always)]
+fn compute_minmax(state: &mut State) {
+    state.space.metrics.cyclomatic.compute_minmax();
+}
 
 fn finalize<T: ParserTrait>(state_stack: &mut Vec<State>, diff_level: usize) {
     if state_stack.is_empty() {
@@ -203,14 +207,15 @@ fn finalize<T: ParserTrait>(state_stack: &mut Vec<State>, diff_level: usize) {
     for _ in 0..diff_level {
         if state_stack.len() == 1 {
             let mut last_state = state_stack.last_mut().unwrap();
+            compute_minmax(&mut last_state);
             compute_halstead_and_mi::<T>(&mut last_state);
             compute_averages(&mut last_state);
             break;
         } else {
             let mut state = state_stack.pop().unwrap();
+            compute_minmax(&mut state);
             compute_halstead_and_mi::<T>(&mut state);
             compute_averages(&mut state);
-
             let mut last_state = state_stack.last_mut().unwrap();
             last_state.halstead_maps.merge(&state.halstead_maps);
             compute_halstead_and_mi::<T>(&mut last_state);