Implement relational cohesion metric.

Author: Barnabás Domozi

plugins/cpp_metrics/model/include/model/cppcohesionmetrics.h

@@ -25,6 +25,16 @@ struct CohesionCppRecordView
   CppAstNodeId astNodeId;
 };
 
+#pragma db view \
+  object(CppRecord) \
+  object(CppAstNode : CppRecord::astNodeId == CppAstNode::id) \
+  object(File : CppAstNode::location.file)
+struct CohesionCppRecord_Count
+{
+  #pragma db column("count(" + CppEntity::id + ")")
+  std::size_t count;
+};
+
 #pragma db view \
   object(CppMemberType) \
   object(CppAstNode : CppMemberType::memberAstNode) \

plugins/cpp_metrics/model/include/model/cppfilemetrics.h

@@ -13,7 +13,8 @@ struct CppFileMetrics
 {
   enum Type
   {
-    EFFERENT_MODULE
+    EFFERENT_MODULE,
+    RELATIONAL_COHESION_MODULE
   };
 
   #pragma db id auto
@@ -26,7 +27,7 @@ struct CppFileMetrics
   Type type;
 
   #pragma db not_null
-  unsigned value;
+  double value;
 };
 
 #pragma db view \
@@ -44,7 +45,7 @@ struct CppModuleMetricsForPathView
   CppFileMetrics::Type type;
 
   #pragma db column(CppFileMetrics::value)
-  unsigned value;
+  double value;
 };
 
 #pragma db view \

plugins/cpp_metrics/model/include/model/cpptypedependencymetrics.h

@@ -49,6 +49,20 @@ struct CppTypeDependencyMetricsPathView
   std::string dependencyPath;
 };
 
+#pragma db view \
+  object(CppTypeDependencyMetrics) \
+  object(CppAstNode = EntityAstNode : CppTypeDependencyMetrics::entityHash == EntityAstNode::entityHash \
+    && EntityAstNode::astType == cc::model::CppAstNode::AstType::Definition) \
+  object(File = EntityFile : EntityAstNode::location.file == EntityFile::id) \
+  object(CppAstNode = DependencyAstNode : CppTypeDependencyMetrics::dependencyHash == DependencyAstNode::entityHash \
+    && DependencyAstNode::astType == cc::model::CppAstNode::AstType::Definition) \
+  object(File = DependencyFile : DependencyAstNode::location.file == DependencyFile::id)
+struct CppTypeDependencyMetrics_Count
+{
+  #pragma db column("count(" + CppTypeDependencyMetrics::id + ")")
+  std::size_t count;
+};
+
 #pragma db view \
   object(CppTypeDependencyMetrics) \
   object(CppAstNode = EntityAstNode : CppTypeDependencyMetrics::entityHash == EntityAstNode::entityHash \

plugins/cpp_metrics/parser/include/cppmetricsparser/cppmetricsparser.h

@@ -82,6 +82,8 @@ class CppMetricsParser : public AbstractParser
   void afferentTypeLevel();
   // Calculate the efferent coupling at module level.
   void efferentModuleLevel();
+  // Calculate relational cohesion at module level.
+  void relationalCohesionModuleLevel();
   // Returns module path query based on parser configuration.
   odb::query<model::File> getModulePathsQuery();
 
@@ -207,6 +209,7 @@ class CppMetricsParser : public AbstractParser
   static const int efferentCouplingTypesPartitionMultiplier = 5;
   static const int afferentCouplingTypesPartitionMultiplier = 5;
   static const int efferentCouplingModulesPartitionMultiplier = 5;
+  static const int relationalCohesionPartitionMultiplier = 5;
 };
 
 } // parser

plugins/cpp_metrics/parser/src/cppmetricsparser.cpp

@@ -576,6 +576,53 @@ void CppMetricsParser::efferentModuleLevel()
   });
 }
 
+void CppMetricsParser::relationalCohesionModuleLevel()
+{
+  // Compute relational cohesion defined by CppDepend:
+  // https://www.cppdepend.com/documentation/code-metrics#RelationalCohesion
+
+  parallelCalcMetric<model::File>(
+    "Relational cohesion at module level",
+    _threadCount * relationalCohesionPartitionMultiplier,// number of jobs; adjust for granularity
+    getModulePathsQuery(),
+    [&, this](const MetricsTasks<model::File>& tasks)
+    {
+      util::OdbTransaction{_ctx.db}([&, this]
+      {
+        typedef odb::query<model::CppTypeDependencyMetrics_Count> TypeDependencyQuery;
+        typedef model::CppTypeDependencyMetrics_Count TypeDependencyResult;
+        typedef odb::query<model::CohesionCppRecord_Count> RecordQuery;
+        typedef model::CohesionCppRecord_Count RecordResult;
+
+        for (const model::File& file : tasks)
+        {
+          TypeDependencyResult dependencies = _ctx.db->query_value<model::CppTypeDependencyMetrics_Count>(
+            TypeDependencyQuery::EntityFile::path.like(file.path + '%') &&
+            TypeDependencyQuery::DependencyFile::path.like(file.path + '%'));
+
+          // Let R be the number of type relationships that are internal to a module
+          // (i.e that do not connect to types outside the module)
+          const std::size_t r = dependencies.count;
+
+          RecordResult types = _ctx.db->query_value<model::CohesionCppRecord_Count>(
+            RecordQuery::File::path.like(file.path + '%'));
+
+          // Let N be the number of types within the module.
+          const std::size_t n = types.count;
+
+          // Relational cohesion
+          const double h = (n != 0) ? (double)(r + 1) / n : 0;
+
+          model::CppFileMetrics metric;
+          metric.file = file.id;
+          metric.type = model::CppFileMetrics::Type::RELATIONAL_COHESION_MODULE;
+          metric.value = h;
+          _ctx.db->persist(metric);
+        }
+      });
+  });
+}
+
 bool CppMetricsParser::parse()
 {
   LOG(info) << "[cppmetricsparser] Computing function parameter count metric.";
@@ -594,6 +641,8 @@ bool CppMetricsParser::parse()
   afferentTypeLevel();
   LOG(info) << "[cppmetricsparser] Computing efferent coupling metric at module level.";
   efferentModuleLevel(); // This metric needs to be calculated after efferentTypeLevel
+  LOG(info) << "[cppmetricsparser] Computing relational cohesion metric at module level.";
+  relationalCohesionModuleLevel(); // This metric needs to be calculated after efferentTypeLevel
   return true;
 }