Implement efferent coupling at module level.

Author: Barnabás Domozi

plugins/cpp_metrics/model/CMakeLists.txt

@@ -5,11 +5,12 @@ include_directories(
 set(ODB_SOURCES
   include/model/cppastnodemetrics.h
   include/model/cppcohesionmetrics.h
-  include/model/cppfilemetrics.h)
+  include/model/cppfilemetrics.h
+  include/model/cpptypedependencymetrics.h)
 
 generate_odb_files("${ODB_SOURCES}" "cpp")
 
 add_odb_library(cppmetricsmodel ${ODB_CXX_SOURCES})
 target_link_libraries(cppmetricsmodel cppmodel)
 
-install_sql()
+install_sql()

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

@@ -13,7 +13,7 @@ struct CppFileMetrics
 {
   enum Type
   {
-    PLACEHOLDER
+    EFFERENT_MODULE
   };
 
   #pragma db id auto

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

@@ -0,0 +1,70 @@
+#ifndef CC_MODEL_CPPTYPEDEPENDENCYMETRICS_H
+#define CC_MODEL_CPPTYPEDEPENDENCYMETRICS_H
+
+#include <cstdint>
+#include <string>
+#include <model/cppentity.h>
+#include <model/cpprecord.h>
+#include <model/cppastnode.h>
+#include <model/file.h>
+
+namespace cc
+{
+namespace model
+{
+
+#pragma db object
+struct CppTypeDependencyMetrics
+{
+  #pragma db id auto
+  std::uint64_t id;
+
+  #pragma db not_null
+  std::uint64_t entityHash;
+
+  #pragma db not_null
+  std::uint64_t dependencyHash;
+};
+
+#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 CppTypeDependencyMetricsPathView
+{
+  #pragma db column(CppTypeDependencyMetrics::entityHash)
+  std::size_t entityHash;
+
+  #pragma db column(CppTypeDependencyMetrics::dependencyHash)
+  std::size_t dependencyHash;
+
+  #pragma db column(EntityFile::path)
+  std::string entityPath;
+
+  #pragma db column(DependencyFile::path)
+  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) \
+  query((?), distinct)
+struct CppDistinctTypeDependencyMetricsPathView
+{
+  #pragma db column(CppTypeDependencyMetrics::dependencyHash)
+  std::size_t dependencyHash;
+};
+
+} // model
+} // cc
+
+#endif // CC_MODEL_CPPTYPEDEPENDENCYMETRICS_H

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

@@ -80,7 +80,10 @@ class CppMetricsParser : public AbstractParser
   void efferentTypeLevel();
   // Calculate the afferent coupling of types.
   void afferentTypeLevel();
-
+  // Calculate the efferent coupling at module level.
+  void efferentModuleLevel();
+  // Returns module path query based on parser configuration.
+  odb::query<model::File> getModulePathsQuery();
 
   /// @brief Constructs an ODB query that you can use to filter only
   /// the database records of the given parameter type whose path
@@ -203,6 +206,7 @@ class CppMetricsParser : public AbstractParser
   static const int lackOfCohesionPartitionMultiplier = 25;
   static const int efferentCouplingTypesPartitionMultiplier = 5;
   static const int afferentCouplingTypesPartitionMultiplier = 5;
+  static const int efferentCouplingModulesPartitionMultiplier = 5;
 };
 
 } // parser

plugins/cpp_metrics/parser/src/cppmetricsparser.cpp

@@ -10,9 +10,12 @@
 #include <model/cppinheritance-odb.hxx>
 #include <model/cpprecord.h>
 #include <model/cpprecord-odb.hxx>
-
+#include <model/cpptypedependencymetrics.h>
+#include <model/cpptypedependencymetrics-odb.hxx>
 #include <model/cppastnode.h>
 #include <model/cppastnode-odb.hxx>
+#include <model/file.h>
+#include <model/file-odb.hxx>
 
 #include <boost/filesystem.hpp>
 
@@ -390,7 +393,7 @@ void CppMetricsParser::efferentTypeLevel()
           dependentTypes.clear();
 
           // Count parent types
-          auto inheritanceView = _ctx.db->query<model::CppInheritanceCount>(
+          auto inheritanceView = _ctx.db->query<model::CppInheritance>(
             InheritanceQuery::derived == type.entityHash);
 
           // Count unique attribute types
@@ -423,8 +426,26 @@ void CppMetricsParser::efferentTypeLevel()
           model::CppAstNodeMetrics metric;
           metric.astNodeId = type.astNodeId;
           metric.type = model::CppAstNodeMetrics::Type::EFFERENT_TYPE;
-          metric.value = inheritanceView.begin()->count + dependentTypes.size();
+          metric.value = inheritanceView.size() + dependentTypes.size();
           _ctx.db->persist(metric);
+
+          auto typeRelationInserter = [this](const std::uint64_t& entityHash, const std::uint64_t& dependencyHash)
+          {
+            model::CppTypeDependencyMetrics relation;
+            relation.entityHash = entityHash;
+            relation.dependencyHash = dependencyHash;
+            _ctx.db->persist(relation);
+          };
+
+          // Insert type dependency relations
+          for (const std::uint64_t& d : dependentTypes) {
+            typeRelationInserter(type.entityHash, d);
+          }
+
+          // Insert inheritance relations
+          for (const model::CppInheritance& d : inheritanceView) {
+            typeRelationInserter(type.entityHash, d.base);
+          }
         }
       });
   });
@@ -513,6 +534,46 @@ void CppMetricsParser::afferentTypeLevel()
   });
 }
 
+odb::query<model::File> CppMetricsParser::getModulePathsQuery()
+{
+  if (_ctx.moduleDirectories.empty()) {
+    // No module directories specified, compute for all directories
+    return odb::query<model::File>::type == cc::model::File::DIRECTORY_TYPE && getFilterPathsQuery<model::File>();
+  } else {
+    // Compute for module directories
+    return odb::query<model::File>::path.in_range(_ctx.moduleDirectories.begin(), _ctx.moduleDirectories.end());
+  }
+}
+
+void CppMetricsParser::efferentModuleLevel()
+{
+  parallelCalcMetric<model::File>(
+    "Efferent coupling at module level",
+    _threadCount * efferentCouplingModulesPartitionMultiplier,// number of jobs; adjust for granularity
+    getModulePathsQuery(),
+    [&, this](const MetricsTasks<model::File>& tasks)
+    {
+      util::OdbTransaction{_ctx.db}([&, this]
+      {
+        typedef odb::query<cc::model::CppDistinctTypeDependencyMetricsPathView> TypeDependencyQuery;
+        typedef odb::result<cc::model::CppDistinctTypeDependencyMetricsPathView> TypeDependencyResult;
+
+        for (const model::File& file : tasks)
+        {
+          TypeDependencyResult types = _ctx.db->query<model::CppDistinctTypeDependencyMetricsPathView>(
+            TypeDependencyQuery::EntityFile::path.like(file.path + '%') &&
+            !TypeDependencyQuery::DependencyFile::path.like(file.path + '%'));
+
+          model::CppFileMetrics metric;
+          metric.file = file.id;
+          metric.type = model::CppFileMetrics::Type::EFFERENT_MODULE;
+          metric.value = types.size();
+          _ctx.db->persist(metric);
+        }
+      });
+  });
+}
+
 bool CppMetricsParser::parse()
 {
   LOG(info) << "[cppmetricsparser] Computing function parameter count metric.";
@@ -529,6 +590,8 @@ bool CppMetricsParser::parse()
   efferentTypeLevel();
   LOG(info) << "[cppmetricsparser] Computing afferent coupling metric for types.";
   afferentTypeLevel();
+  LOG(info) << "[cppmetricsparser] Computing efferent coupling metric at module level.";
+  efferentModuleLevel(); // This metric needs to be calculated after efferentTypeLevel
   return true;
 }
 

util/CMakeLists.txt

@@ -18,6 +18,7 @@ add_library(util SHARED
   src/util.cpp)
 
 target_link_libraries(util
+  model
   gvc
   ${Boost_LIBRARIES})
 

util/include/util/dbutil.h

@@ -3,6 +3,8 @@
 
 #include <memory>
 #include <string>
+#include <model/file.h>
+#include <model/file-odb.hxx>
 
 #include <odb/database.hxx>
 
@@ -147,10 +149,15 @@ odb::query<TQueryParam> getFilterPathsQuery(
   TIter begin_,
   const TSentinel& end_)
 {
-  typedef typename odb::query<TQueryParam>::query_columns QParam;
-  const auto& QParamPath = QParam::File::path;
-  constexpr char ODBWildcard = '%';
+  const auto& QParamPath = [](){
+    if constexpr (std::is_same<TQueryParam, cc::model::File>::value) {
+      return odb::query<TQueryParam>::path;
+    } else {
+      return odb::query<TQueryParam>::query_columns::File::path;
+    }
+  }();
 
+  constexpr char ODBWildcard = '%';
   assert(begin_ != end_ && "At least one filter path must be provided.");
   odb::query<TQueryParam> query = QParamPath.like(*begin_ + ODBWildcard);
   while (++begin_ != end_)