adlint 2.6.14 → 3.0.0

data/lib/adlint/metric.rb

@@ -1,7 +1,7 @@
 # Code quality metrics.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,13 +29,11 @@
 #
 #++
 
-require "adlint/util"
-
 module AdLint #:nodoc:
 
   class CodeMetric
-    def to_a
-      subclass_responsibility
+    def print_as_csv(io)
+      io.puts(to_csv)
     end
 
     def to_s
@@ -43,273 +41,185 @@ module AdLint #:nodoc:
       to_a.map { |obj| obj.to_s.to_default_external }.join(delim)
     end
 
+    private
+    def to_a
+      subclass_responsibility
+    end
+
     def to_csv
       to_a.map { |obj| obj ? obj.to_s.to_default_external : nil }.to_csv
     end
   end
 
-  class FL_STMT_Metric < CodeMetric
-    def initialize(fpath, statement_count)
+  class FileMetric < CodeMetric
+    def initialize(name, fpath, val)
+      @name  = name
       @fpath = fpath
-      @statement_count = statement_count
+      @val   = val
     end
 
+    private
     def to_a
-      ["MET", "FL_STMT", @fpath, @statement_count]
+      ["MET", @name, @fpath, @val]
     end
   end
 
-  class FL_FUNC_Metric < CodeMetric
-    def initialize(fpath, function_count)
-      @fpath = fpath
-      @function_count = function_count
-    end
-
-    def to_a
-      ["MET", "FL_FUNC", @fpath, @function_count]
+  class FL_STMT_Metric < FileMetric
+    def initialize(fpath, stmt_cnt)
+      super("FL_STMT", fpath, stmt_cnt)
     end
   end
 
-  class FN_STMT_Metric < CodeMetric
-    def initialize(function_identifier, location, statement_count)
-      @function_identifier = function_identifier
-      @location = location
-      @statement_count = statement_count
-    end
-
-    def to_a
-      ["MET", "FN_STMT",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @statement_count]
+  class FL_FUNC_Metric < FileMetric
+    def initialize(fpath, fun_cnt)
+      super("FL_FUNC", fpath, fun_cnt)
     end
   end
 
-  class FN_UNRC_Metric < CodeMetric
-    def initialize(function_identifier, location, unreached_statement_count)
-      @function_identifier = function_identifier
-      @location = location
-      @unreached_statement_count = unreached_statement_count
+  class FunctionMetric < CodeMetric
+    def initialize(name, fun_id, loc, val)
+      @name   = name
+      @fun_id = fun_id
+      @loc    = loc
+      @val    = val
     end
 
+    private
     def to_a
-      ["MET", "FN_UNRC",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @unreached_statement_count]
+      ["MET", @name, *@fun_id.to_a, *@loc.to_a, @val]
     end
   end
 
-  class FN_LINE_Metric < CodeMetric
-    def initialize(function_identifier, location, total_lines)
-      @function_identifier = function_identifier
-      @location = location
-      @total_lines = total_lines
-    end
-
-    def to_a
-      ["MET", "FN_LINE",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @total_lines]
+  class FN_STMT_Metric < FunctionMetric
+    def initialize(fun_id, loc, stmt_cnt)
+      super("FN_STMT", fun_id, loc, stmt_cnt)
     end
   end
 
-  class FN_PARA_Metric < CodeMetric
-    def initialize(function_identifier, location, parameter_count)
-      @function_identifier = function_identifier
-      @location = location
-      @parameter_count = parameter_count
-    end
-
-    def to_a
-      ["MET", "FN_PARA",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @parameter_count]
+  class FN_UNRC_Metric < FunctionMetric
+    def initialize(fun_id, loc, unreached_stmt_cnt)
+      super("FN_UNRC", fun_id, loc, unreached_stmt_cnt)
     end
   end
 
-  class FN_UNUV_Metric < CodeMetric
-    def initialize(function_identifier, location, useless_variable_count)
-      @function_identifier = function_identifier
-      @location = location
-      @useless_variable_count = useless_variable_count
-    end
-
-    def to_a
-      ["MET", "FN_UNUV",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @useless_variable_count]
+  class FN_LINE_Metric < FunctionMetric
+    def initialize(fun_id, loc, fun_lines)
+      super("FN_LINE", fun_id, loc, fun_lines)
     end
   end
 
-  class FN_CSUB_Metric < CodeMetric
-    def initialize(function_identifier, location, function_call_count)
-      @function_identifier = function_identifier
-      @location = location
-      @function_call_count = function_call_count
-    end
-
-    def to_a
-      ["MET", "FN_CSUB",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @function_call_count]
+  class FN_PARA_Metric < FunctionMetric
+    def initialize(fun_id, loc, param_cnt)
+      super("FN_PARA", fun_id, loc, param_cnt)
     end
   end
 
-  class FN_GOTO_Metric < CodeMetric
-    def initialize(function_identifier, location, goto_count)
-      @function_identifier = function_identifier
-      @location = location
-      @goto_count = goto_count
-    end
-
-    def to_a
-      ["MET", "FN_GOTO",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @goto_count]
+  class FN_UNUV_Metric < FunctionMetric
+    def initialize(fun_id, loc, useless_var_cnt)
+      super("FN_UNUV", fun_id, loc, useless_var_cnt)
     end
   end
 
-  class FN_RETN_Metric < CodeMetric
-    def initialize(function_identifier, location, return_count)
-      @function_identifier = function_identifier
-      @location = location
-      @return_count = return_count
-    end
-
-    def to_a
-      ["MET", "FN_RETN",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @return_count]
+  class FN_CSUB_Metric < FunctionMetric
+    def initialize(fun_id, loc, funcall_cnt)
+      super("FN_CSUB", fun_id, loc, funcall_cnt)
     end
   end
 
-  class FN_UELS_Metric < CodeMetric
-    def initialize(function_identifier, location, if_statement_count)
-      @function_identifier = function_identifier
-      @location = location
-      @if_statement_count = if_statement_count
-    end
-
-    def to_a
-      ["MET", "FN_UELS",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @if_statement_count]
+  class FN_GOTO_Metric < FunctionMetric
+    def initialize(fun_id, loc, goto_cnt)
+      super("FN_GOTO", fun_id, loc, goto_cnt)
     end
   end
 
-  class FN_NEST_Metric < CodeMetric
-    def initialize(function_identifier, location, max_nest_level)
-      @function_identifier = function_identifier
-      @location = location
-      @max_nest_level = max_nest_level
-    end
-
-    def to_a
-      ["MET", "FN_NEST",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @max_nest_level]
+  class FN_RETN_Metric < FunctionMetric
+    def initialize(fun_id, loc, retn_cnt)
+      super("FN_RETN", fun_id, loc, retn_cnt)
     end
   end
 
-  class FN_PATH_Metric < CodeMetric
-    def initialize(function_identifier, location, path_count)
-      @function_identifier = function_identifier
-      @location = location
-      @path_count = path_count
-    end
-
-    def to_a
-      ["MET", "FN_PATH",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @path_count]
+  class FN_UELS_Metric < FunctionMetric
+    def initialize(fun_id, loc, if_stmt_cnt)
+      super("FN_UELS", fun_id, loc, if_stmt_cnt)
     end
   end
 
-  class FN_CYCM_Metric < CodeMetric
-    def initialize(function_identifier, location, cyclomatic_complexity)
-      @function_identifier = function_identifier
-      @location = location
-      @cyclomatic_complexity = cyclomatic_complexity
+  class FN_NEST_Metric < FunctionMetric
+    def initialize(fun_id, loc, max_nest)
+      super("FN_NEST", fun_id, loc, max_nest)
     end
+  end
 
-    def to_a
-      ["MET", "FN_CYCM",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @cyclomatic_complexity]
+  class FN_PATH_Metric < FunctionMetric
+    def initialize(fun_id, loc, path_cnt)
+      super("FN_PATH", fun_id, loc, path_cnt)
     end
   end
 
-  class FN_CALL_Metric < CodeMetric
-    def initialize(function_identifier, location, caller_count)
-      @function_identifier = function_identifier
-      @location = location
-      @caller_count = caller_count
+  class FN_CYCM_Metric < FunctionMetric
+    def initialize(fun_id, loc, cycl_compl)
+      super("FN_CYCM", fun_id, loc, cycl_compl)
     end
+  end
 
-    def to_a
-      ["MET", "FN_CALL",
-        @function_identifier.name, @function_identifier.signature,
-        @location.fpath, @location.line_no, @location.column_no,
-        @caller_count]
+  class FN_CALL_Metric < FunctionMetric
+    def initialize(fun_id, loc, caller_cnt)
+      super("FN_CALL", fun_id, loc, caller_cnt)
     end
   end
 
   class MetricRecord < CsvRecord
-    def self.of(csv_row)
+    def self.of(csv_row, sma_wd)
       case csv_row[0]
       when "VER"
         create_version_record(csv_row)
       when "DCL"
-        create_declaration_record(csv_row)
+        create_declaration_record(csv_row, sma_wd)
       when "DEF"
-        create_definition_record(csv_row)
+        create_definition_record(csv_row, sma_wd)
       when "INI"
-        create_initialization_record(csv_row)
+        create_initialization_record(csv_row, sma_wd)
       when "ASN"
-        create_assignment_record(csv_row)
+        create_assignment_record(csv_row, sma_wd)
       when "DEP"
-        create_dependency_record(csv_row)
+        create_dependency_record(csv_row, sma_wd)
       when "LIT"
-        create_literal_record(csv_row)
+        create_literal_record(csv_row, sma_wd)
       when "PRE"
-        create_pp_directive_record(csv_row)
+        create_pp_directive_record(csv_row, sma_wd)
       when "MET"
-        create_metric_record(csv_row)
+        create_metric_record(csv_row, sma_wd)
       else
         raise "invalid metric record."
       end
     end
 
+    def initialize(csv_row, sma_wd)
+      super(csv_row)
+      @sma_wd = sma_wd
+    end
+
     def type
       field_at(0)
     end
 
     def fpath
-      Pathname.new(field_at(1))
+      sma_abs_fpath = Pathname.new(field_at(1)).expand_path(@sma_wd)
+      sma_abs_fpath.relative_path_from(Pathname.pwd)
     end
 
     def line_no
-      field_at(2)
+      field_at(2).to_i
     end
 
     def column_no
-      field_at(3)
+      field_at(3).to_i
     end
 
     def location
       Location.new(fpath, line_no, column_no)
     end
+    memoize :location
 
     def version?; false end
 
@@ -354,69 +264,69 @@ module AdLint #:nodoc:
     end
     private_class_method :create_version_record
 
-    def self.create_declaration_record(csv_row)
+    def self.create_declaration_record(csv_row, sma_wd)
       case csv_row[4]
       when "T"
         case csv_row[5]
         when "T"
-          TypedefDeclarationRecord.new(csv_row)
+          TypedefDeclarationRecord.new(csv_row, sma_wd)
         when "S"
-          StructDeclarationRecord.new(csv_row)
+          StructDeclarationRecord.new(csv_row, sma_wd)
         when "U"
-          UnionDeclarationRecord.new(csv_row)
+          UnionDeclarationRecord.new(csv_row, sma_wd)
         when "E"
-          EnumDeclarationRecord.new(csv_row)
+          EnumDeclarationRecord.new(csv_row, sma_wd)
         else
           raise "invalid DCL record."
         end
       when "V"
-        GlobalVariableDeclarationRecord.new(csv_row)
+        GlobalVariableDeclarationRecord.new(csv_row, sma_wd)
       when "F"
-        FunctionDeclarationRecord.new(csv_row)
+        FunctionDeclarationRecord.new(csv_row, sma_wd)
       else
         raise "invalid DCL record."
       end
     end
     private_class_method :create_declaration_record
 
-    def self.create_definition_record(csv_row)
+    def self.create_definition_record(csv_row, sma_wd)
       case csv_row[4]
       when "V"
-        VariableDefinitionRecord.new(csv_row)
+        VariableDefinitionRecord.new(csv_row, sma_wd)
       when "F"
-        FunctionDefinitionRecord.new(csv_row)
+        FunctionDefinitionRecord.new(csv_row, sma_wd)
       when "M"
-        MacroDefinitionRecord.new(csv_row)
+        MacroDefinitionRecord.new(csv_row, sma_wd)
       when "L"
-        LabelDefinitionRecord.new(csv_row)
+        LabelDefinitionRecord.new(csv_row, sma_wd)
       else
         raise "invalid DEF record."
       end
     end
     private_class_method :create_definition_record
 
-    def self.create_initialization_record(csv_row)
-      InitializationRecord.new(csv_row)
+    def self.create_initialization_record(csv_row, sma_wd)
+      InitializationRecord.new(csv_row, sma_wd)
     end
     private_class_method :create_initialization_record
 
-    def self.create_assignment_record(csv_row)
-      AssignmentRecord.new(csv_row)
+    def self.create_assignment_record(csv_row, sma_wd)
+      AssignmentRecord.new(csv_row, sma_wd)
     end
     private_class_method :create_assignment_record
 
-    def self.create_dependency_record(csv_row)
+    def self.create_dependency_record(csv_row, sma_wd)
       case csv_row[4]
       when "I"
-        IncludeRecord.new(csv_row)
+        IncludeRecord.new(csv_row, sma_wd)
       when "C"
-        FunctionCallRecord.new(csv_row)
+        FunctionCallRecord.new(csv_row, sma_wd)
       when "X"
         case csv_row[5]
         when "V"
-          VariableXRefRecord.new(csv_row)
+          VariableXRefRecord.new(csv_row, sma_wd)
         when "F"
-          FunctionXRefRecord.new(csv_row)
+          FunctionXRefRecord.new(csv_row, sma_wd)
         else
           raise "invalid DEP record."
         end
@@ -426,22 +336,26 @@ module AdLint #:nodoc:
     end
     private_class_method :create_dependency_record
 
-    def self.create_literal_record(csv_row)
-      LiteralRecord.new(csv_row)
+    def self.create_literal_record(csv_row, sma_wd)
+      LiteralRecord.new(csv_row, sma_wd)
     end
     private_class_method :create_literal_record
 
-    def self.create_pp_directive_record(csv_row)
-      PPDirectiveRecord.new(csv_row)
+    def self.create_pp_directive_record(csv_row, sma_wd)
+      PPDirectiveRecord.new(csv_row, sma_wd)
     end
     private_class_method :create_pp_directive_record
 
-    def self.create_metric_record(csv_row)
-      MetricRecord.new(csv_row)
+    def self.create_metric_record(csv_row, sma_wd)
+      new(csv_row, sma_wd)
     end
     private_class_method :create_metric_record
 
     class VersionRecord < MetricRecord
+      def initialize(csv_row)
+        super(csv_row, nil)
+      end
+
       def version?
         true
       end
@@ -453,6 +367,10 @@ module AdLint #:nodoc:
       def exec_timestamp
         field_at(2)
       end
+
+      def exec_working_directory
+        field_at(3)
+      end
     end
     private_constant :VersionRecord
 
@@ -560,8 +478,12 @@ module AdLint #:nodoc:
         field_at(6)
       end
 
-      def function_identifier
-        FunctionIdentifier.new(field_at(7), field_at(8))
+      def function_declaration_type
+        field_at(7)
+      end
+
+      def function_id
+        FunctionId.new(field_at(8), field_at(9))
       end
     end
     private_constant :FunctionDeclarationRecord
@@ -571,11 +493,11 @@ module AdLint #:nodoc:
         true
       end
 
-      def var_linkage_type
+      def variable_linkage_type
         field_at(5)
       end
 
-      def var_scope_type
+      def variable_scope_type
         field_at(6)
       end
 
@@ -606,8 +528,8 @@ module AdLint #:nodoc:
         field_at(6)
       end
 
-      def function_identifier
-        FunctionIdentifier.new(field_at(7), field_at(8))
+      def function_id
+        FunctionId.new(field_at(7), field_at(8))
       end
 
       def lines
@@ -689,11 +611,11 @@ module AdLint #:nodoc:
       end
 
       def caller_function
-        FunctionIdentifier.new(field_at(5), field_at(6))
+        FunctionId.new(field_at(5), field_at(6))
       end
 
       def callee_function
-        FunctionIdentifier.new(field_at(7), field_at(8))
+        FunctionId.new(field_at(7), field_at(8))
       end
     end
     private_constant :FunctionCallRecord
@@ -704,7 +626,7 @@ module AdLint #:nodoc:
       end
 
       def accessor_function
-        FunctionIdentifier.new(field_at(6), field_at(7))
+        FunctionId.new(field_at(6), field_at(7))
       end
 
       def access_type
@@ -723,7 +645,7 @@ module AdLint #:nodoc:
       end
 
       def accessor_function
-        FunctionIdentifier.new(field_at(6), field_at(7))
+        FunctionId.new(field_at(6), field_at(7))
       end
 
       def access_type
@@ -731,7 +653,7 @@ module AdLint #:nodoc:
       end
 
       def accessee_function
-        FunctionIdentifier.new(field_at(9), field_at(10))
+        FunctionId.new(field_at(9), field_at(10))
       end
     end
     private_constant :FunctionXRefRecord