Merge: doc: fixed some typos and other misc. corrections

[nit.git] / src / metrics / mclasses_metrics.nit

diff --git a/src/metrics/mclasses_metrics.nit b/src/metrics/mclasses_metrics.nit
index fabd573..2404a38 100644 (file)
--- a/src/metrics/mclasses_metrics.nit
+++ b/src/metrics/mclasses_metrics.nit
@@ -18,8 +18,11 @@
 module mclasses_metrics
 
 import metrics_base
 module mclasses_metrics
 
 import metrics_base

+import model::model_collect

 
 redef class ToolContext
 
 redef class ToolContext

+
+       # MClass related metrics phase

        var mclasses_metrics_phase: Phase = new MClassesMetricsPhase(self, null)
 end
 
        var mclasses_metrics_phase: Phase = new MClassesMetricsPhase(self, null)
 end
 

@@ -33,32 +36,32 @@ private class MClassesMetricsPhase
                var out = "{toolcontext.opt_dir.value or else "metrics"}/mclasses"
                out.mkdir
 
                var out = "{toolcontext.opt_dir.value or else "metrics"}/mclasses"
                out.mkdir
 

+               var model = toolcontext.modelbuilder.model
+               var filter = new ModelFilter(private_visibility)

 
                print toolcontext.format_h1("\n# MClasses metrics")
 
                var metrics = new MetricSet
 
                print toolcontext.format_h1("\n# MClasses metrics")
 
                var metrics = new MetricSet

-               var min_vis = private_visibility
-               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 CNBP(mainmodule, min_vis))
-               metrics.register(new CNBA(mainmodule, min_vis))
-               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 CNBM) # nb methods
-               #TODO metrics.register(new CNBV) # nb vtypes
+               metrics.register(new CNOA(model, mainmodule, filter))
+               metrics.register(new CNOP(model, mainmodule, filter))
+               metrics.register(new CNOC(model, mainmodule, filter))
+               metrics.register(new CNOD(model, mainmodule, filter))
+               metrics.register(new CDIT(model, mainmodule, filter))
+               metrics.register(new CNBP(model, mainmodule, filter))
+               metrics.register(new CNBA(model, mainmodule, filter))
+               metrics.register(new CNBI(model, mainmodule, filter))
+               metrics.register(new CNBM(model, mainmodule, filter))
+               metrics.register(new CNBV(model, mainmodule, filter))
+               metrics.register(new CNBIP(model, mainmodule, filter))
+               metrics.register(new CNBRP(model, mainmodule, filter))
+               metrics.register(new CNBHP(model, mainmodule, filter))

 
 

-               var model = toolcontext.modelbuilder.model

                var mclasses = new HashSet[MClass]
                var mclasses = new HashSet[MClass]

-               for mproject in model.mprojects do
+               for mpackage in model.mpackages do

 
 

-                       print toolcontext.format_h2("\n ## project {mproject}")
+                       print toolcontext.format_h2("\n ## package {mpackage}")

 
 

-                       for mgroup in mproject.mgroups do
+                       for mgroup in mpackage.mgroups do

                                if mgroup.mmodules.is_empty then continue
                                metrics.clear
 
                                if mgroup.mmodules.is_empty then continue
                                metrics.clear
 

@@ -70,7 +73,7 @@ private class MClassesMetricsPhase
                                mclasses.add_all(mod_mclasses)
                                metrics.collect(new HashSet[MClass].from(mod_mclasses))
                                metrics.to_console(1, not toolcontext.opt_nocolors.value)
                                mclasses.add_all(mod_mclasses)
                                metrics.collect(new HashSet[MClass].from(mod_mclasses))
                                metrics.to_console(1, not toolcontext.opt_nocolors.value)

-                               if csv then metrics.to_csv.save("{out}/{mgroup}.csv")
+                               if csv then metrics.to_csv.write_to_file("{out}/{mgroup}.csv")

                        end
                end
                if not mclasses.is_empty then
                        end
                end
                if not mclasses.is_empty then

@@ -79,15 +82,24 @@ private class MClassesMetricsPhase
                        print toolcontext.format_h2("\n ## global metrics")
                        metrics.collect(mclasses)
                        metrics.to_console(1, not toolcontext.opt_nocolors.value)
                        print toolcontext.format_h2("\n ## global metrics")
                        metrics.collect(mclasses)
                        metrics.to_console(1, not toolcontext.opt_nocolors.value)

-                       if csv then metrics.to_csv.save("{out}/summary.csv")
+                       if csv then metrics.to_csv.write_to_file("{out}/summary.csv")

                end
        end
 end
 
 # A metric about MClass
                end
        end
 end
 
 # A metric about MClass

-interface MClassMetric
+abstract class MClassMetric

        super Metric
        redef type ELM: MClass
        super Metric
        redef type ELM: MClass

+
+       # Model used to collect and filter entities
+       var model: Model
+
+       # Mainmodule for class linearization
+       var mainmodule: MModule
+
+       # Filter to apply
+       var filter: nullable ModelFilter

 end
 
 # Class Metric: Number of Ancestors
 end
 
 # Class Metric: Number of Ancestors

@@ -97,9 +109,6 @@ class CNOA
        redef fun name do return "cnoa"
        redef fun desc do return "number of ancestor classes"
 
        redef fun name do return "cnoa"
        redef fun desc do return "number of ancestor classes"
 

-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do
                        values[mclass] = mclass.in_hierarchy(mainmodule).greaters.length - 1

@@ -114,9 +123,6 @@ class CNOP
        redef fun name do return "cnop"
        redef fun desc do return "number of parent classes"
 
        redef fun name do return "cnop"
        redef fun desc do return "number of parent classes"
 

-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do
                        values[mclass] = mclass.in_hierarchy(mainmodule).direct_greaters.length

@@ -131,9 +137,6 @@ class CNOC
        redef fun name do return "cnoc"
        redef fun desc do return "number of child classes"
 
        redef fun name do return "cnoc"
        redef fun desc do return "number of child classes"
 

-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do
                        values[mclass] = mclass.in_hierarchy(mainmodule).direct_smallers.length

@@ -148,9 +151,6 @@ class CNOD
        redef fun name do return "cnod"
        redef fun desc do return "number of descendant classes"
 
        redef fun name do return "cnod"
        redef fun desc do return "number of descendant classes"
 

-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do
                        values[mclass] = mclass.in_hierarchy(mainmodule).smallers.length - 1

@@ -165,9 +165,6 @@ class CDIT
        redef fun name do return "cdit"
        redef fun desc do return "depth in class tree"
 
        redef fun name do return "cdit"
        redef fun desc do return "depth in class tree"
 

-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do
                        values[mclass] = mclass.in_hierarchy(mainmodule).depth

@@ -182,17 +179,9 @@ class CNBP
        redef fun name do return "cnbp"
        redef fun desc do return "number of accessible properties (inherited + local)"
 
        redef fun name do return "cnbp"
        redef fun desc do return "number of accessible properties (inherited + local)"
 

-       var mainmodule: MModule
-       var min_visibility: MVisibility
-
-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do

-                       values[mclass] = mclass.all_mproperties(mainmodule, min_visibility).length
+                       values[mclass] = mclass.collect_accessible_mproperties(mainmodule, filter).length

                end
        end
 end
                end
        end
 end

@@ -204,17 +193,51 @@ class CNBA
        redef fun name do return "cnba"
        redef fun desc do return "number of accessible attributes (inherited + local)"
 
        redef fun name do return "cnba"
        redef fun desc do return "number of accessible attributes (inherited + local)"
 

-       var mainmodule: MModule
-       var min_visibility: MVisibility
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.collect_accessible_mattributes(mainmodule, filter).length
+               end
+       end
+end
+
+# Class Metric: Number of MMethods
+class CNBM
+       super MClassMetric
+       super IntMetric
+       redef fun name do return "cnbm"
+       redef fun desc do return "number of accessible methods (inherited + local)"
+
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.collect_accessible_mmethods(mainmodule, filter).length
+               end
+       end
+end
+
+# Class Metric: Number of Constructors
+class CNBI
+       super MClassMetric
+       super IntMetric
+       redef fun name do return "cnbi"
+       redef fun desc do return "number of accessible constructors (inherited + local)"

 
 

-       init(mainmodule: MModule, min_visibility: MVisibility) do
-               self.mainmodule = mainmodule
-               self.min_visibility = min_visibility
+       redef fun collect(mclasses) do
+               for mclass in mclasses do
+                       values[mclass] = mclass.collect_accessible_inits(mainmodule, filter).length
+               end

        end
        end

+end
+
+# Class Metric: Number of Virtual Types
+class CNBV
+       super MClassMetric
+       super IntMetric
+       redef fun name do return "cnbv"
+       redef fun desc do return "number of accessible virtual types (inherited + local)"

 
        redef fun collect(mclasses) do
                for mclass in mclasses do
 
        redef fun collect(mclasses) do
                for mclass in mclasses do

-                       values[mclass] = mclass.all_mattributes(mainmodule, min_visibility).length
+                       values[mclass] = mclass.collect_accessible_vts(mainmodule, filter).length

                end
        end
 end
                end
        end
 end

@@ -226,17 +249,9 @@ class CNBIP
        redef fun name do return "cnbip"
        redef fun desc do return "number of introduced properties"
 
        redef fun name do return "cnbip"
        redef fun desc do return "number of introduced properties"
 

-       var mainmodule: MModule
-       var min_visibility: MVisibility
-
-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do

-                       values[mclass] = mclass.intro_mproperties(min_visibility).length
+                       values[mclass] = mclass.collect_intro_mproperties(filter).length

                end
        end
 end
                end
        end
 end

@@ -248,17 +263,9 @@ class CNBRP
        redef fun name do return "cnbrp"
        redef fun desc do return "number of redefined properties"
 
        redef fun name do return "cnbrp"
        redef fun desc do return "number of redefined properties"
 

-       var mainmodule: MModule
-       var min_visibility: MVisibility
-
-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do

-                       values[mclass] = mclass.redef_mproperties(min_visibility).length
+                       values[mclass] = mclass.collect_redef_mproperties(filter).length

                end
        end
 end
                end
        end
 end

@@ -270,17 +277,9 @@ class CNBHP
        redef fun name do return "cnbhp"
        redef fun desc do return "number of inherited properties"
 
        redef fun name do return "cnbhp"
        redef fun desc do return "number of inherited properties"
 

-       var mainmodule: MModule
-       var min_visibility: MVisibility
-
-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do

-                       values[mclass] = mclass.inherited_mproperties(mainmodule, min_visibility).length
+                       values[mclass] = mclass.collect_inherited_mproperties(mainmodule, filter).length

                end
        end
 end
                end
        end
 end

@@ -292,17 +291,9 @@ class CNBLP
        redef fun name do return "cnblp"
        redef fun desc do return "number of local properties (intro + redef)"
 
        redef fun name do return "cnblp"
        redef fun desc do return "number of local properties (intro + redef)"
 

-       var mainmodule: MModule
-       var min_visibility: MVisibility
-
-       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
        redef fun collect(mclasses) do
                for mclass in mclasses do

-                       values[mclass] = mclass.local_mproperties(min_visibility).length
+                       values[mclass] = mclass.collect_local_mproperties(filter).length

                end
        end
 end
                end
        end
 end