metrics: move up collect method in Metric

Signed-off-by: Alexandre Terrasa <alexandre@moz-code.org>

diff --git a/src/metrics/inheritance_metrics.nit b/src/metrics/inheritance_metrics.nit
index a9f3247..56ae196 100644 (file)
--- a/src/metrics/inheritance_metrics.nit
+++ b/src/metrics/inheritance_metrics.nit
@@ -37,12 +37,23 @@ private class InheritanceMetricsPhase
                print toolcontext.format_h1("\n# Inheritance metrics")
 
                var hmetrics = new InheritanceMetricSet
-               hmetrics.register(new MDUI, new MDUIC, new MDUII, new MIF, new MIFC, new MIFI)
-               
+               hmetrics.register(new MDUI(mainmodule))
+               hmetrics.register(new MDUIC(mainmodule))
+               hmetrics.register(new MDUII(mainmodule))
+               hmetrics.register(new MIF(mainmodule))
+               hmetrics.register(new MIFC(mainmodule))
+               hmetrics.register(new MIFI(mainmodule))
+
                var cmetrics = new MClassMetricSet
-               cmetrics.register(new CNOA, new CNOP, new CNOC, new CNODC)
-               cmetrics.register(new CNOA, new CNOP, new CNOC, new CNODI)
-               cmetrics.register(new CDIT, new CDITI)
+               cmetrics.register(new CNOAC(mainmodule))
+               cmetrics.register(new CNOPC(mainmodule))
+               cmetrics.register(new CNOCC(mainmodule))
+               cmetrics.register(new CNODC(mainmodule))
+               cmetrics.register(new CNOPI(mainmodule))
+               cmetrics.register(new CNOCI(mainmodule))
+               cmetrics.register(new CNODI(mainmodule))
+               cmetrics.register(new CDITC(mainmodule))
+               cmetrics.register(new CDITI(mainmodule))
 
                var model = toolcontext.modelbuilder.model
                var mmodules = new HashSet[MModule]
@@ -122,9 +133,7 @@ class InheritanceMetricSet
        fun collect(mmodules: Set[MModule], mainmodule: MModule) do
                clear
                for metric in metrics.values do
-                       for mmodule in mmodules do
-                               metric.collect(mmodule, mainmodule)
-                       end
+                       metric.collect(mmodules)
                end
        end
 end
@@ -138,15 +147,20 @@ class MDUI
        redef fun name do return "mdui"
        redef fun desc do return "proportion of mclass defined using inheritance (has other parent than Object)"
 
-       redef fun collect(mmodule, mainmodule) do
-               var count = 0
-               for mclass in mmodule.intro_mclasses do
-                       if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
-               end
-               if mmodule.intro_mclasses.is_empty then
-                       values[mmodule] = 0.0
-               else
-                       values[mmodule] = count.to_f / mmodule.intro_mclasses.length.to_f
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var count = 0
+                       for mclass in mmodule.intro_mclasses do
+                               if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
+                       end
+                       if mmodule.intro_mclasses.is_empty then
+                               values[mmodule] = 0.0
+                       else
+                               values[mmodule] = count.to_f / mmodule.intro_mclasses.length.to_f
+                       end
                end
        end
 end
@@ -160,19 +174,24 @@ class MDUIC
        redef fun name do return "mduic"
        redef fun desc do return "proportion of class_kind defined using inheritance"
 
-       redef fun collect(mmodule, mainmodule) do
-               var count = 0
-               var nb = 0
-               for mclass in mmodule.intro_mclasses do
-                       if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
-                               if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var count = 0
+                       var nb = 0
+                       for mclass in mmodule.intro_mclasses do
+                               if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
+                                       if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
+                               end
+                               nb += 1
+                       end
+                       if mmodule.intro_mclasses.is_empty then
+                               values[mmodule] = 0.0
+                       else
+                               values[mmodule] = count.to_f / nb.to_f
                        end
-                       nb += 1
-               end
-               if mmodule.intro_mclasses.is_empty then
-                       values[mmodule] = 0.0
-               else
-                       values[mmodule] = count.to_f / nb.to_f
                end
        end
 end
@@ -186,19 +205,24 @@ class MDUII
        redef fun name do return "mduii"
        redef fun desc do return "proportion of interface_kind defined using inheritance"
 
-       redef fun collect(mmodule, mainmodule) do
-               var count = 0
-               var nb = 0
-               for mclass in mmodule.intro_mclasses do
-                       if mclass.kind == interface_kind then
-                               if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var count = 0
+                       var nb = 0
+                       for mclass in mmodule.intro_mclasses do
+                               if mclass.kind == interface_kind then
+                                       if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
+                               end
+                               nb += 1
+                       end
+                       if mmodule.intro_mclasses.is_empty then
+                               values[mmodule] = 0.0
+                       else
+                               values[mmodule] = count.to_f / nb.to_f
                        end
-                       nb += 1
-               end
-               if mmodule.intro_mclasses.is_empty then
-                       values[mmodule] = 0.0
-               else
-                       values[mmodule] = count.to_f / nb.to_f
                end
        end
 end
@@ -212,15 +236,20 @@ class MIF
        redef fun name do return "mif"
        redef fun desc do return "proportion of mclass inherited from"
 
-       redef fun collect(mmodule, mainmodule) do
-               var count = 0
-               for mclass in mmodule.intro_mclasses do
-                       if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
-               end
-               if mmodule.intro_mclasses.is_empty then
-                       values[mmodule] = 0.0
-               else
-                       values[mmodule] = count.to_f / mmodule.intro_mclasses.length.to_f
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var count = 0
+                       for mclass in mmodule.intro_mclasses do
+                               if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
+                       end
+                       if mmodule.intro_mclasses.is_empty then
+                               values[mmodule] = 0.0
+                       else
+                               values[mmodule] = count.to_f / mmodule.intro_mclasses.length.to_f
+                       end
                end
        end
 end
@@ -234,19 +263,24 @@ class MIFC
        redef fun name do return "mifc"
        redef fun desc do return "proportion of class_kind inherited from"
 
-       redef fun collect(mmodule, mainmodule) do
-               var count = 0
-               var nb = 0
-               for mclass in mmodule.intro_mclasses do
-                       if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
-                               if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var count = 0
+                       var nb = 0
+                       for mclass in mmodule.intro_mclasses do
+                               if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
+                                       if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
+                               end
+                               nb += 1
+                       end
+                       if mmodule.intro_mclasses.is_empty then
+                               values[mmodule] = 0.0
+                       else
+                               values[mmodule] = count.to_f / nb.to_f
                        end
-                       nb += 1
-               end
-               if mmodule.intro_mclasses.is_empty then
-                       values[mmodule] = 0.0
-               else
-                       values[mmodule] = count.to_f / nb.to_f
                end
        end
 end
@@ -260,19 +294,24 @@ class MIFI
        redef fun name do return "mifi"
        redef fun desc do return "proportion of interface_kind inherited from"
 
-       redef fun collect(mmodule, mainmodule) do
-               var count = 0
-               var nb = 0
-               for mclass in mmodule.intro_mclasses do
-                       if mclass.kind == interface_kind then
-                               if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var count = 0
+                       var nb = 0
+                       for mclass in mmodule.intro_mclasses do
+                               if mclass.kind == interface_kind then
+                                       if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
+                               end
+                               nb += 1
+                       end
+                       if mmodule.intro_mclasses.is_empty then
+                               values[mmodule] = 0.0
+                       else
+                               values[mmodule] = count.to_f / nb.to_f
                        end
-                       nb += 1
-               end
-               if mmodule.intro_mclasses.is_empty then
-                       values[mmodule] = 0.0
-               else
-                       values[mmodule] = count.to_f / nb.to_f
                end
        end
 end
@@ -286,15 +325,20 @@ class CNOAC
        redef fun name do return "cnoac"
        redef fun desc do return "number of class_kind ancestor"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).greaters do
-                       if parent == mclass then continue
-                       if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).greaters do
+                               if parent == mclass then continue
+                               if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -307,15 +351,20 @@ class CNOPC
        redef fun name do return "cnopc"
        redef fun desc do return "number of class_kind parent"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
-                       if parent == mclass then continue
-                       if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
+                               if parent == mclass then continue
+                               if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -328,15 +377,20 @@ class CNOCC
        redef fun name do return "cnocc"
        redef fun desc do return "number of class_kind children"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
-                       if parent == mclass then continue
-                       if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
+                               if parent == mclass then continue
+                               if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -349,15 +403,20 @@ class CNODC
        redef fun name do return "cnodc"
        redef fun desc do return "number of class_kind descendants"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).smallers do
-                       if parent == mclass then continue
-                       if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).smallers do
+                               if parent == mclass then continue
+                               if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -370,15 +429,20 @@ class CNOAI
        redef fun name do return "cnoai"
        redef fun desc do return "number of interface_kind ancestor"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).greaters do
-                       if parent == mclass then continue
-                       if parent.kind == interface_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).greaters do
+                               if parent == mclass then continue
+                               if parent.kind == interface_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -391,15 +455,20 @@ class CNOPI
        redef fun name do return "cnopi"
        redef fun desc do return "number of interface_kind parent"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
-                       if parent == mclass then continue
-                       if parent.kind == interface_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
+                               if parent == mclass then continue
+                               if parent.kind == interface_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -412,15 +481,20 @@ class CNOCI
        redef fun name do return "cnoci"
        redef fun desc do return "number of interface_kind children"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
-                       if parent == mclass then continue
-                       if parent.kind == interface_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
+                               if parent == mclass then continue
+                               if parent.kind == interface_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -433,15 +507,20 @@ class CNODI
        redef fun name do return "cnodi"
        redef fun desc do return "number of interface_kind descendants"
 
-       redef fun collect(mclass, mainmodule) do
-               var count = 0
-               for parent in mclass.in_hierarchy(mainmodule).smallers do
-                       if parent == mclass then continue
-                       if parent.kind == interface_kind then
-                               count += 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       var count = 0
+                       for parent in mclass.in_hierarchy(mainmodule).smallers do
+                               if parent == mclass then continue
+                               if parent.kind == interface_kind then
+                                       count += 1
+                               end
                        end
+                       values[mclass] = count
                end
-               values[mclass] = count
        end
 end
 
@@ -454,8 +533,13 @@ class CDITC
        redef fun name do return "cditc"
        redef fun desc do return "depth in class tree following only class, abstract, extern kind"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.ditc(mainmodule)
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.ditc(mainmodule)
+               end
        end
 end
 
@@ -468,8 +552,13 @@ class CDITI
        redef fun name do return "cditi"
        redef fun desc do return "depth in class tree following only interface_kind"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.diti(mainmodule)
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.diti(mainmodule)
+               end
        end
 end
 

diff --git a/src/metrics/mclasses_metrics.nit b/src/metrics/mclasses_metrics.nit
index 69a1063..9b7ddb1 100644 (file)
--- a/src/metrics/mclasses_metrics.nit
+++ b/src/metrics/mclasses_metrics.nit
@@ -37,8 +37,14 @@ private class MClassesMetricsPhase
 
                var metrics = new MClassMetricSet
                var min_vis = private_visibility
-               metrics.register(new CNOA, new CNOP, new CNOC, new CNOD, new CDIT)
-               metrics.register(new CNBIP(min_vis), new CNBRP(min_vis), new CNBHP(min_vis))
+               metrics.register(new CNOA(mainmodule))
+               metrics.register(new CNOP(mainmodule))
+               metrics.register(new CNOC(mainmodule))
+               metrics.register(new CNOD(mainmodule))
+               metrics.register(new CDIT(mainmodule))
+               metrics.register(new CNBIP(mainmodule, min_vis))
+               metrics.register(new CNBRP(mainmodule, min_vis))
+               metrics.register(new CNBHP(mainmodule, min_vis))
                #TODO metrics.register(new CNBI) # nb init
                #TODO metrics.register(new CNBA) # nb attrs
                #TODO metrics.register(new CNBM) # nb methods
@@ -101,9 +107,7 @@ class MClassMetricSet
        fun collect(mclasses: Set[MClass], mainmodule: MModule) do
                clear
                for metric in metrics.values do
-                       for mclass in mclasses do
-                               metric.collect(mclass, mainmodule)
-                       end
+                       metric.collect(mclasses)
                end
        end
 end
@@ -112,9 +116,6 @@ end
 interface MClassMetric
        super Metric
        redef type ELM: MClass
-
-       # Collect the metric value for this mclass
-       fun collect(mclass: MClass, mainmodule: MModule) is abstract
 end
 
 # Class Metric: Number of Ancestors
@@ -124,8 +125,13 @@ class CNOA
        redef fun name do return "cnoa"
        redef fun desc do return "number of ancestor classes"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.in_hierarchy(mainmodule).greaters.length - 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.in_hierarchy(mainmodule).greaters.length - 1
+               end
        end
 end
 
@@ -136,8 +142,13 @@ class CNOP
        redef fun name do return "cnop"
        redef fun desc do return "number of parent classes"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.in_hierarchy(mainmodule).direct_greaters.length
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.in_hierarchy(mainmodule).direct_greaters.length
+               end
        end
 end
 
@@ -148,8 +159,13 @@ class CNOC
        redef fun name do return "cnoc"
        redef fun desc do return "number of child classes"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.in_hierarchy(mainmodule).direct_smallers.length
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.in_hierarchy(mainmodule).direct_smallers.length
+               end
        end
 end
 
@@ -160,8 +176,13 @@ class CNOD
        redef fun name do return "cnod"
        redef fun desc do return "number of descendant classes"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.in_hierarchy(mainmodule).smallers.length - 1
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.in_hierarchy(mainmodule).smallers.length - 1
+               end
        end
 end
 
@@ -172,8 +193,13 @@ class CDIT
        redef fun name do return "cdit"
        redef fun desc do return "depth in class tree"
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.in_hierarchy(mainmodule).depth
+       var mainmodule: MModule
+       init(mainmodule: MModule) do self.mainmodule = mainmodule
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.in_hierarchy(mainmodule).depth
+               end
        end
 end
 
@@ -184,11 +210,18 @@ class CNBIP
        redef fun name do return "cnbip"
        redef fun desc do return "number of introduced properties"
 
+       var mainmodule: MModule
        var min_visibility: MVisibility
-       init(min_visibility: MVisibility) do self.min_visibility = min_visibility
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.intro_mproperties(min_visibility).length
+       init(mainmodule: MModule, min_visibility: MVisibility) do
+               self.mainmodule = mainmodule
+               self.min_visibility = min_visibility
+       end
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.intro_mproperties(min_visibility).length
+               end
        end
 end
 
@@ -199,11 +232,18 @@ class CNBRP
        redef fun name do return "cnbrp"
        redef fun desc do return "number of redefined properties"
 
+       var mainmodule: MModule
        var min_visibility: MVisibility
-       init(min_visibility: MVisibility) do self.min_visibility = min_visibility
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.redef_mproperties(min_visibility).length
+       init(mainmodule: MModule, min_visibility: MVisibility) do
+               self.mainmodule = mainmodule
+               self.min_visibility = min_visibility
+       end
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.redef_mproperties(min_visibility).length
+               end
        end
 end
 
@@ -214,11 +254,18 @@ class CNBHP
        redef fun name do return "cnbhp"
        redef fun desc do return "number of inherited properties"
 
+       var mainmodule: MModule
        var min_visibility: MVisibility
-       init(min_visibility: MVisibility) do self.min_visibility = min_visibility
 
-       redef fun collect(mclass, mainmodule) do
-               values[mclass] = mclass.inherited_mproperties(mainmodule, min_visibility).length
+       init(mainmodule: MModule, min_visibility: MVisibility) do
+               self.mainmodule = mainmodule
+               self.min_visibility = min_visibility
+       end
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.inherited_mproperties(mainmodule, min_visibility).length
+               end
        end
 end
 

diff --git a/src/metrics/metrics_base.nit b/src/metrics/metrics_base.nit
index f5f9589..c1fcb51 100644 (file)
--- a/src/metrics/metrics_base.nit
+++ b/src/metrics/metrics_base.nit
@@ -154,6 +154,8 @@ interface Metric
        # Values for each element
        fun values: RES is abstract
 
+       # Collect metric values on elements
+       fun collect(elements: Set[ELM]) is abstract
 
        # The value calculated for the element
        fun [](element: ELM): VAL do return values[element]

diff --git a/src/metrics/mmodules_metrics.nit b/src/metrics/mmodules_metrics.nit
index 4075280..4af3424 100644 (file)
--- a/src/metrics/mmodules_metrics.nit
+++ b/src/metrics/mmodules_metrics.nit
@@ -93,9 +93,7 @@ class MModuleMetricSet
        fun collect(mmodules: Set[MModule], mainmodule: MModule) do
                clear
                for metric in metrics.values do
-                       for mmodule in mmodules do
-                               metric.collect(mmodule, mainmodule)
-                       end
+                       metric.collect(mmodules)
                end
        end
 end
@@ -104,10 +102,6 @@ end
 abstract class MModuleMetric
        super Metric
        redef type ELM: MModule
-       # Collect the metric on the MModule
-       #
-       # Results are stored in the property `values`
-       fun collect(mmodule: MModule, mainmodule: MModule) is abstract
 end
 
 # Module Metric: Number of Ancestors
@@ -117,8 +111,10 @@ class MNOA
        redef fun name do return "mnoa"
        redef fun desc do return "number of ancestor modules"
 
-       redef fun collect(mmodule, main) do
-               values[mmodule] = mmodule.in_importation.greaters.length - 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       values[mmodule] = mmodule.in_importation.greaters.length - 1
+               end
        end
 end
 
@@ -129,8 +125,10 @@ class MNOP
        redef fun name do return "mnop"
        redef fun desc do return "number of parent modules"
 
-       redef fun collect(mmodule, main) do
-               values[mmodule] = mmodule.in_importation.direct_greaters.length
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       values[mmodule] = mmodule.in_importation.direct_greaters.length
+               end
        end
 end
 
@@ -141,8 +139,10 @@ class MNOC
        redef fun name do return "mnoc"
        redef fun desc do return "number of child modules"
 
-       redef fun collect(mmodule, main) do
-               values[mmodule] = mmodule.in_importation.direct_smallers.length
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       values[mmodule] = mmodule.in_importation.direct_smallers.length
+               end
        end
 end
 
@@ -153,8 +153,10 @@ class MNOD
        redef fun name do return "mnod"
        redef fun desc do return "number of descendant modules"
 
-       redef fun collect(mmodule, main) do
-               values[mmodule] = mmodule.in_importation.smallers.length - 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       values[mmodule] = mmodule.in_importation.smallers.length - 1
+               end
        end
 end
 
@@ -165,8 +167,10 @@ class MDIT
        redef fun name do return "mdit"
        redef fun desc do return "depth in module tree"
 
-       redef fun collect(mmodule, main) do
-               values[mmodule] = mmodule.in_importation.depth
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       values[mmodule] = mmodule.in_importation.depth
+               end
        end
 end
 
@@ -179,8 +183,10 @@ class MNBI
        redef fun name do return "mnbi"
        redef fun desc do return "number of introduction in module"
 
-       redef fun collect(mmodule, main) do
-               values[mmodule] = mmodule.intro_mclasses.length
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       values[mmodule] = mmodule.intro_mclasses.length
+               end
        end
 end
 
@@ -193,12 +199,14 @@ class MNBR
        redef fun name do return "mnbr"
        redef fun desc do return "number of refinement in module"
 
-       redef fun collect(mmodule, main) do
-               var value = 0
-               for mclassdef in mmodule.mclassdefs do
-                       if not mclassdef.is_intro then value += 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var value = 0
+                       for mclassdef in mmodule.mclassdefs do
+                               if not mclassdef.is_intro then value += 1
+                       end
+                       values[mmodule] = value
                end
-               values[mmodule] = value
        end
 end
 
@@ -209,12 +217,14 @@ class MNBCC
        redef fun name do return "mnbcc"
        redef fun desc do return "number of concrete class in module (intro + redef)"
 
-       redef fun collect(mmodule, main) do
-               var value = 0
-               for mclassdef in mmodule.mclassdefs do
-                       if mclassdef.mclass.kind == concrete_kind then value += 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var value = 0
+                       for mclassdef in mmodule.mclassdefs do
+                               if mclassdef.mclass.kind == concrete_kind then value += 1
+                       end
+                       values[mmodule] = value
                end
-               values[mmodule] = value
        end
 end
 
@@ -225,12 +235,14 @@ class MNBAC
        redef fun name do return "mnbac"
        redef fun desc do return "number of abstract class in module (intro + redef)"
 
-       redef fun collect(mmodule, main) do
-               var value = 0
-               for mclassdef in mmodule.mclassdefs do
-                       if mclassdef.mclass.kind == abstract_kind then value += 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var value = 0
+                       for mclassdef in mmodule.mclassdefs do
+                               if mclassdef.mclass.kind == abstract_kind then value += 1
+                       end
+                       values[mmodule] = value
                end
-               values[mmodule] = value
        end
 end
 
@@ -241,12 +253,14 @@ class MNBIC
        redef fun name do return "mnbic"
        redef fun desc do return "number of interface in module (intro + redef)"
 
-       redef fun collect(mmodule, main) do
-               var value = 0
-               for mclassdef in mmodule.mclassdefs do
-                       if mclassdef.mclass.kind == interface_kind then value += 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var value = 0
+                       for mclassdef in mmodule.mclassdefs do
+                               if mclassdef.mclass.kind == interface_kind then value += 1
+                       end
+                       values[mmodule] = value
                end
-               values[mmodule] = value
        end
 end
 
@@ -257,12 +271,14 @@ class MNBEC
        redef fun name do return "mnbec"
        redef fun desc do return "number of enum in module (intro + redef)"
 
-       redef fun collect(mmodule, main) do
-               var value = 0
-               for mclassdef in mmodule.mclassdefs do
-                       if mclassdef.mclass.kind == enum_kind then value += 1
+       redef fun collect(mmodules) do
+               for mmodule in mmodules do
+                       var value = 0
+                       for mclassdef in mmodule.mclassdefs do
+                               if mclassdef.mclass.kind == enum_kind then value += 1
+                       end
+                       values[mmodule] = value
                end
-               values[mmodule] = value
        end
 end