Add implementation of min and max for Cyclomatic

Author: giovannitangredi

src/metrics/cyclomatic.rs

@@ -1,22 +1,27 @@
+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 {
+    self_cyclomatic: f64,
     cyclomatic: f64,
     n: usize,
+    cyclomatic_max: f64,
+    cyclomatic_min: f64,
 }
 
 impl Default for Stats {
     fn default() -> Self {
         Self {
+            self_cyclomatic: 1.,
             cyclomatic: 1.,
             n: 1,
+            cyclomatic_max: 0.,
+            cyclomatic_min: f64::MAX,
         }
     }
 }
@@ -29,6 +34,8 @@ impl Serialize for Stats {
         let mut st = serializer.serialize_struct("cyclomatic", 2)?;
         st.serialize_field("sum", &self.cyclomatic())?;
         st.serialize_field("average", &self.cyclomatic_average())?;
+        st.serialize_field("min", &self.cyclomatic_min())?;
+        st.serialize_field("max", &self.cyclomatic_max())?;
         st.end()
     }
 }
@@ -37,9 +44,11 @@ impl fmt::Display for Stats {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "sum: {}, average: {}",
+            "sum: {}, average: {}, min: {}, max: {}",
             self.cyclomatic(),
-            self.cyclomatic_average()
+            self.cyclomatic_average(),
+            self.cyclomatic_min(),
+            self.cyclomatic_max()
         )
     }
 }
@@ -49,6 +58,17 @@ impl Stats {
     pub fn merge(&mut self, other: &Stats) {
         self.cyclomatic += other.cyclomatic;
         self.n += other.n;
+
+        //Calculate minimum and maximum values
+        if other.n == 1 {
+            self.cyclomatic_max = self.cyclomatic_max.max(other.cyclomatic);
+            self.cyclomatic_min = self.cyclomatic_min.min(other.cyclomatic);
+        } else {
+            self.cyclomatic_max = self.cyclomatic_max.max(other.cyclomatic_max);
+            self.cyclomatic_min = self.cyclomatic_min.min(other.cyclomatic_min);
+            self.cyclomatic_max = self.cyclomatic_max.max(other.self_cyclomatic);
+            self.cyclomatic_min = self.cyclomatic_min.min(other.self_cyclomatic);
+        }
     }
 
     /// Returns the `Cyclomatic` metric value
@@ -63,6 +83,19 @@ impl Stats {
     pub fn cyclomatic_average(&self) -> f64 {
         self.cyclomatic() / self.n as f64
     }
+    /// Returns the `Cyclomatic` maximum value
+    pub fn cyclomatic_max(&self) -> f64 {
+        self.cyclomatic_max
+    }
+    /// Returns the `Cyclomatic` minimum value
+    pub fn cyclomatic_min(&self) -> f64 {
+        self.cyclomatic_min
+    }
+    /// Last step for computing minimum and maximum valus
+    pub fn compute_minmax(&mut self) {
+        self.cyclomatic_max = self.cyclomatic_max.max(self.self_cyclomatic);
+        self.cyclomatic_min = self.cyclomatic_min.min(self.self_cyclomatic);
+    }
 }
 
 #[doc(hidden)]
@@ -80,10 +113,12 @@ impl Cyclomatic for PythonCode {
         match node.object().kind_id().into() {
             If | Elif | For | While | Except | With | Assert | And | Or => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             Else => {
                 if has_ancestors!(node, ForStatement | WhileStatement, ElseClause) {
                     stats.cyclomatic += 1.;
+                    stats.self_cyclomatic += 1.;
                 }
             }
             _ => {}
@@ -98,6 +133,7 @@ impl Cyclomatic for MozjsCode {
         match node.object().kind_id().into() {
             If | For | While | Case | Catch | TernaryExpression | AMPAMP | PIPEPIPE => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             _ => {}
         }
@@ -111,6 +147,7 @@ impl Cyclomatic for JavascriptCode {
         match node.object().kind_id().into() {
             If | For | While | Case | Catch | TernaryExpression | AMPAMP | PIPEPIPE => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             _ => {}
         }
@@ -124,6 +161,7 @@ impl Cyclomatic for TypescriptCode {
         match node.object().kind_id().into() {
             If | For | While | Case | Catch | TernaryExpression | AMPAMP | PIPEPIPE => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             _ => {}
         }
@@ -137,6 +175,7 @@ impl Cyclomatic for TsxCode {
         match node.object().kind_id().into() {
             If | For | While | Case | Catch | TernaryExpression | AMPAMP | PIPEPIPE => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             _ => {}
         }
@@ -150,6 +189,7 @@ impl Cyclomatic for RustCode {
         match node.object().kind_id().into() {
             If | For | While | Loop | MatchArm | MatchArm2 | QMARK | AMPAMP | PIPEPIPE => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             _ => {}
         }
@@ -163,6 +203,7 @@ impl Cyclomatic for CppCode {
         match node.object().kind_id().into() {
             If | For | While | Case | Catch | ConditionalExpression | AMPAMP | PIPEPIPE => {
                 stats.cyclomatic += 1.;
+                stats.self_cyclomatic += 1.;
             }
             _ => {}
         }
@@ -192,7 +233,9 @@ mod tests {
             cyclomatic,
             [(cyclomatic, 6, usize)],
             [
-                (cyclomatic_average, 3.0) // nspace = 2 (func and unit)
+                (cyclomatic_average, 3.0), // nspace = 2 (func and unit)
+                (cyclomatic_max, 5.0),
+                (cyclomatic_min, 1.0)
             ]
         );
     }
@@ -209,7 +252,9 @@ mod tests {
             cyclomatic,
             [(cyclomatic, 4, usize)],
             [
-                (cyclomatic_average, 2.0) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.0), // nspace = 2 (func and unit)
+                (cyclomatic_max, 3.0),
+                (cyclomatic_min, 1.0)
             ]
         );
     }
@@ -230,7 +275,9 @@ mod tests {
             cyclomatic,
             [(cyclomatic, 5, usize)],
             [
-                (cyclomatic_average, 2.5) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.5), // nspace = 2 (func and unit)
+                (cyclomatic_max, 4.0),
+                (cyclomatic_min, 1.0)
             ]
         );
     }
@@ -259,7 +306,9 @@ mod tests {
             cyclomatic,
             [(cyclomatic, 5, usize)],
             [
-                (cyclomatic_average, 2.5) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.5), // nspace = 2 (func and unit)
+                (cyclomatic_max, 4.0),
+                (cyclomatic_min, 1.0)
             ]
         );
     }
@@ -284,7 +333,83 @@ mod tests {
             cyclomatic,
             [(cyclomatic, 5, usize)],
             [
-                (cyclomatic_average, 2.5) // nspace = 2 (func and unit)
+                (cyclomatic_average, 2.5), // nspace = 2 (func and unit)
+                (cyclomatic_max, 4.0),
+                (cyclomatic_min, 1.0)
+            ]
+        );
+    }
+    #[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, 7, usize)],
+            [
+                (cyclomatic_average, 3.5), // nspace = 2 (func and unit)
+                (cyclomatic_max, 4.0),
+                (cyclomatic_min, 3.0)
+            ]
+        );
+    }
+
+    #[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, 7, usize)],
+            [
+                (cyclomatic_average, 3.5), // nspace = 2 (func and unit)
+                (cyclomatic_max, 4.0),
+                (cyclomatic_min, 3.0)
             ]
         );
     }

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() {
@@ -205,6 +209,7 @@ fn finalize<T: ParserTrait>(state_stack: &mut Vec<State>, diff_level: usize) {
             let mut last_state = state_stack.last_mut().unwrap();
             compute_halstead_and_mi::<T>(&mut last_state);
             compute_averages(&mut last_state);
+            compute_minmax(&mut last_state);
             break;
         } else {
             let mut state = state_stack.pop().unwrap();