metric_fu 2.0.0 → 2.0.1

data/lib/base/generator.rb

@@ -2,18 +2,18 @@ module MetricFu
 
   # = Generator
   #
-  # The Generator class is an abstract class that provides the 
+  # The Generator class is an abstract class that provides the
   # skeleton for producing different types of metrics.
   #
-  # It drives the production of the metrics through a template 
+  # It drives the production of the metrics through a template
   # method - #generate_report(options={}).  This method calls
   # #emit, #analyze and #to_h in order to produce the metrics.
   #
   # To implement a concrete class to generate a metric, therefore,
-  # the class must implement those three methods. 
+  # the class must implement those three methods.
   #
-  # * #emit should take care of running the metric tool and 
-  #   gathering its output.  
+  # * #emit should take care of running the metric tool and
+  #   gathering its output.
   # * #analyze should take care of manipulating the output from
   #   #emit and making it possible to store it in a programmatic way.
   # * #to_h should provide a hash representation of the output from
@@ -37,9 +37,9 @@ module MetricFu
       create_output_dir_if_missing
       create_data_dir_if_missing
     end
-    
-    # Creates a new generator and returns the output of the 
-    # #generate_report method.  This is the typical way to 
+
+    # Creates a new generator and returns the output of the
+    # #generate_report method.  This is the typical way to
     # generate a new MetricFu report. For more information see
     # the #generate_report instance method.
     #
@@ -66,27 +66,27 @@ module MetricFu
     def self.class_name
       self.to_s.split('::').last.downcase
     end
-   
+
     # Returns the directory where the Generator will write any output
     def self.metric_directory
-      File.join(MetricFu.scratch_directory, class_name) 
+      File.join(MetricFu.scratch_directory, class_name)
     end
 
     def create_metric_dir_if_missing #:nodoc:
       unless File.directory?(metric_directory)
-        FileUtils.mkdir_p(metric_directory, :verbose => false) 
+        FileUtils.mkdir_p(metric_directory, :verbose => false)
       end
     end
-    
+
     def create_output_dir_if_missing #:nodoc:
       unless File.directory?(MetricFu.output_directory)
-        FileUtils.mkdir_p(MetricFu.output_directory, :verbose => false) 
+        FileUtils.mkdir_p(MetricFu.output_directory, :verbose => false)
       end
     end
-    
+
     def create_data_dir_if_missing #:nodoc:
       unless File.directory?(MetricFu.data_directory)
-        FileUtils.mkdir_p(MetricFu.data_directory, :verbose => false) 
+        FileUtils.mkdir_p(MetricFu.data_directory, :verbose => false)
       end
     end
 
@@ -103,7 +103,7 @@ module MetricFu
       end
       paths - files_to_remove
     end
-   
+
     # Defines some hook methods for the concrete classes to hook into.
     %w[emit analyze].each do |meth|
       define_method("before_#{meth}".to_sym) {}
@@ -132,13 +132,13 @@ module MetricFu
 
     def round_to_tenths(decimal)
       decimal = 0.0 if decimal.to_s.eql?('NaN')
-      (decimal * 10).round / 10.0 
+      (decimal * 10).round / 10.0
     end
 
     def emit #:nodoc:
       raise <<-EOF
         This method must be implemented by a concrete class descending
-        from Generator.  See generator class documentation for more 
+        from Generator.  See generator class documentation for more
         information.
       EOF
     end
@@ -146,15 +146,15 @@ module MetricFu
     def analyze #:nodoc:
       raise <<-EOF
         This method must be implemented by a concrete class descending
-        from Generator.  See generator class documentation for more 
+        from Generator.  See generator class documentation for more
         information.
       EOF
     end
-    
+
     def to_graph #:nodoc:
       raise <<-EOF
         This method must be implemented by a concrete class descending
-        from Generator.  See generator class documentation for more 
+        from Generator.  See generator class documentation for more
         information.
       EOF
     end

data/lib/base/graph.rb

@@ -5,35 +5,40 @@ module MetricFu
   end
 
   class Graph
-    
+
     attr_accessor :clazz
-    
+
     def initialize
       self.clazz = []
     end
-    
+
     def add(graph_type, graph_engine)
       grapher_name = graph_type.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } + graph_engine.to_s.capitalize + "Grapher"
       self.clazz.push MetricFu.const_get(grapher_name).new
     end
-    
-    
+
+
     def generate
       return if self.clazz.empty?
       puts "Generating graphs"
       Dir[File.join(MetricFu.data_directory, '*.yml')].sort.each do |metric_file|
         puts "Generating graphs for #{metric_file}"
-        date = metric_file.split('/')[3].split('.')[0]
-        y, m, d = date[0..3].to_i, date[4..5].to_i, date[6..7].to_i
+        date_parts = year_month_day_from_filename(metric_file)
         metrics = YAML::load(File.open(metric_file))
-        
+
         self.clazz.each do |grapher|
-          grapher.get_metrics(metrics, "#{m}/#{d}")
+          grapher.get_metrics(metrics, "#{date_parts[:m]}/#{date_parts[:d]}")
         end
       end
       self.clazz.each do |grapher|
         grapher.graph!
       end
     end
+
+    private
+    def year_month_day_from_filename(path_to_file_with_date)
+      date = path_to_file_with_date.match(/\/(\d+).yml$/)[1]
+      {:y => date[0..3].to_i, :m => date[4..5].to_i, :d => date[6..7].to_i}
+    end
   end
-end
+end

data/lib/base/line_numbers.rb

@@ -1,65 +1,66 @@
 require 'ruby_parser'
+module MetricFu
+  class LineNumbers
 
-class LineNumbers
+    def initialize(contents)
+      rp = RubyParser.new
+      file_sexp = rp.parse(contents)
+      @locations = {}
+      case file_sexp[0]
+      when :class
+        process_class(file_sexp)
+      when :module
+        process_module(file_sexp)
+      when :block
+        file_sexp.each_of_type(:class) { |sexp| process_class(sexp) }
+      else
+      end
+    end
 
-  def initialize(contents)
-    rp = RubyParser.new
-    file_sexp = rp.parse(contents)
-    @locations = {}
-    case file_sexp[0]
-    when :class
-      process_class(file_sexp)
-    when :module
-      process_module(file_sexp)
-    when :block
-      file_sexp.each_of_type(:class) { |sexp| process_class(sexp) }
-    else
+    def in_method? line_number
+      !!@locations.detect do |method_name, line_number_range|
+        line_number_range.include?(line_number)
+      end
     end
-  end
-  
-  def in_method? line_number
-    !!@locations.detect do |method_name, line_number_range|
-      line_number_range.include?(line_number)
+
+    def method_at_line line_number
+      found_method_and_range = @locations.detect do |method_name, line_number_range|
+        line_number_range.include?(line_number)
+      end
+      return nil unless found_method_and_range
+      found_method_and_range.first
     end
-  end
-  
-  def method_at_line line_number
-    found_method_and_range = @locations.detect do |method_name, line_number_range|
-      line_number_range.include?(line_number)
+
+    private
+
+    def process_module(sexp)
+      module_name = sexp[1]
+      sexp.each_of_type(:class) do |sexp|
+        process_class(sexp, module_name)
+        hide_methods_from_next_round(sexp)
+      end
+      process_class(sexp)
     end
-    return nil unless found_method_and_range
-    found_method_and_range.first
-  end
-  
-  private
-  
-  def process_module(sexp)
-    module_name = sexp[1]
-    sexp.each_of_type(:class) do |sexp| 
-      process_class(sexp, module_name) 
-      hide_methods_from_next_round(sexp)
+
+    def process_class(sexp, module_name=nil)
+      class_name = sexp[1]
+      process_class_self_blocks(sexp, class_name)
+      module_name_string = module_name ? "#{module_name}::" : nil
+      sexp.each_of_type(:defn) { |s| @locations["#{module_name_string}#{class_name}##{s[1]}"] = (s.line)..(s.last.line) }
+      sexp.each_of_type(:defs) { |s| @locations["#{module_name_string}#{class_name}::#{s[2]}"] = (s.line)..(s.last.line) }
     end
-    process_class(sexp)
-  end
-  
-  def process_class(sexp, module_name=nil)
-    class_name = sexp[1]
-    process_class_self_blocks(sexp, class_name)
-    module_name_string = module_name ? "#{module_name}::" : nil
-    sexp.each_of_type(:defn) { |s| @locations["#{module_name_string}#{class_name}##{s[1]}"] = (s.line)..(s.last.line) }
-    sexp.each_of_type(:defs) { |s| @locations["#{module_name_string}#{class_name}::#{s[2]}"] = (s.line)..(s.last.line) }
-  end
-  
-  def process_class_self_blocks(sexp, class_name)
-    sexp.each_of_type(:sclass) do |sexp_in_class_self_block| 
-      sexp_in_class_self_block.each_of_type(:defn) { |s| @locations["#{class_name}::#{s[1]}"] = (s.line)..(s.last.line) }
-      hide_methods_from_next_round(sexp_in_class_self_block)
+
+    def process_class_self_blocks(sexp, class_name)
+      sexp.each_of_type(:sclass) do |sexp_in_class_self_block|
+        sexp_in_class_self_block.each_of_type(:defn) { |s| @locations["#{class_name}::#{s[1]}"] = (s.line)..(s.last.line) }
+        hide_methods_from_next_round(sexp_in_class_self_block)
+      end
     end
+
+    def hide_methods_from_next_round(sexp)
+      sexp.find_and_replace_all(:defn, :ignore_me)
+      sexp.find_and_replace_all(:defs, :ignore_me)
+    end
+
   end
-  
-  def hide_methods_from_next_round(sexp)
-    sexp.find_and_replace_all(:defn, :ignore_me)
-    sexp.find_and_replace_all(:defs, :ignore_me)
-  end
-  
 end

data/lib/base/location.rb

@@ -1,83 +1,85 @@
-class Location
-  include Comparable
+module MetricFu
+  class Location
+    include Comparable
 
-  attr_accessor :class_name, :method_name, :file_path, :simple_method_name, :hash
+    attr_accessor :class_name, :method_name, :file_path, :simple_method_name, :hash
 
-  def self.get(file_path, class_name, method_name)
-    # This could be more 'confident' using Maybe, but we want it to be as fast as possible
-    file_path_copy = file_path == nil ? nil : file_path.clone
-    class_name_copy = class_name == nil ? nil : class_name.clone
-    method_name_copy = method_name == nil ? nil : method_name.clone
-    key = [file_path_copy, class_name_copy, method_name_copy]
-    @@locations ||= {}
-    if @@locations.has_key?(key)
-      @@locations[key]
-    else
-      location = self.new(file_path_copy, class_name_copy, method_name_copy)
-      @@locations[key] = location
-      location.freeze  # we cache a lot of method call results, so we want location to be immutable
-      location
+    def self.get(file_path, class_name, method_name)
+      # This could be more 'confident' using Maybe, but we want it to be as fast as possible
+      file_path_copy = file_path == nil ? nil : file_path.clone
+      class_name_copy = class_name == nil ? nil : class_name.clone
+      method_name_copy = method_name == nil ? nil : method_name.clone
+      key = [file_path_copy, class_name_copy, method_name_copy]
+      @@locations ||= {}
+      if @@locations.has_key?(key)
+        @@locations[key]
+      else
+        location = self.new(file_path_copy, class_name_copy, method_name_copy)
+        @@locations[key] = location
+        location.freeze  # we cache a lot of method call results, so we want location to be immutable
+        location
+      end
     end
-  end
 
-  def initialize(file_path, class_name, method_name)
-    @file_path = file_path
-    @class_name = class_name
-    @method_name = method_name
-    @simple_method_name = @method_name.sub(@class_name,'') unless @method_name == nil
-    @hash = [@file_path, @class_name, @method_name].hash
-  end
+    def initialize(file_path, class_name, method_name)
+      @file_path = file_path
+      @class_name = class_name
+      @method_name = method_name
+      @simple_method_name = @method_name.sub(@class_name,'') unless @method_name == nil
+      @hash = [@file_path, @class_name, @method_name].hash
+    end
 
-  # TODO - we need this method (and hash accessor above) as a temporary hack where we're using Location as a hash key
-  def eql?(other)
-    [self.file_path.to_s, self.class_name.to_s, self.method_name.to_s] == [other.file_path.to_s, other.class_name.to_s, other.method_name.to_s]
-  end
+    # TODO - we need this method (and hash accessor above) as a temporary hack where we're using Location as a hash key
+    def eql?(other)
+      [self.file_path.to_s, self.class_name.to_s, self.method_name.to_s] == [other.file_path.to_s, other.class_name.to_s, other.method_name.to_s]
+    end
+    # END we need these methods as a temporary hack where we're using Location as a hash key
 
-  # END we need these methods as a temporary hack where we're using Location as a hash key
-  
-  def self.for(class_or_method_name)
-    class_or_method_name = strip_modules(class_or_method_name)
-    if(class_or_method_name)
-      begin
-        match = class_or_method_name.match(/(.*)((\.|\#|\:\:[a-z])(.+))/)
-      rescue => error
-        #new error during port to metric_fu occasionally a unintialized 
-        #MatchData object shows up here. Not expected.
-        match = nil
-      end
+    def self.for(class_or_method_name)
+      class_or_method_name = strip_modules(class_or_method_name)
+      if(class_or_method_name)
+        begin
+          match = class_or_method_name.match(/(.*)((\.|\#|\:\:[a-z])(.+))/)
+        rescue => error
+          #new error during port to metric_fu occasionally a unintialized
+          #MatchData object shows up here. Not expected.
+          match = nil
+        end
 
-      # reek reports the method with :: not # on modules like 
-      # module ApplicationHelper \n def signed_in?, convert it so it records correctly
-      # but classes have to start with a capital letter... HACK for REEK bug, reported underlying issue to REEK
-      if(match)
-        class_name = strip_modules(match[1])
-        method_name = class_or_method_name.gsub(/\:\:/,"#")
+        # reek reports the method with :: not # on modules like
+        # module ApplicationHelper \n def signed_in?, convert it so it records correctly
+        # but classes have to start with a capital letter... HACK for REEK bug, reported underlying issue to REEK
+        if(match)
+          class_name = strip_modules(match[1])
+          method_name = class_or_method_name.gsub(/\:\:/,"#")
+        else
+          class_name = strip_modules(class_or_method_name)
+          method_name = nil
+        end
       else
-        class_name = strip_modules(class_or_method_name)
+        class_name = nil
         method_name = nil
       end
-    else
-      class_name = nil
-      method_name = nil
+      self.get(nil, class_name, method_name)
     end
-    self.get(nil, class_name, method_name)
-  end
 
-  def <=>(other)
-    [self.file_path.to_s, self.class_name.to_s, self.method_name.to_s] <=> [other.file_path.to_s, other.class_name.to_s, other.method_name.to_s]
-  end
+    def <=>(other)
+      [self.file_path.to_s, self.class_name.to_s, self.method_name.to_s] <=> [other.file_path.to_s, other.class_name.to_s, other.method_name.to_s]
+    end
 
-  private
+    private
+
+    def self.strip_modules(class_or_method_name)
+      # reek reports the method with :: not # on modules like 
+      # module ApplicationHelper \n def signed_in?, convert it so it records correctly
+      # but classes have to start with a capital letter... HACK for REEK bug, reported underlying issue to REEK
+      if(class_or_method_name=~/\:\:[A-Z]/)
+        class_or_method_name.split("::").last
+      else
+        class_or_method_name
+      end
 
-  def self.strip_modules(class_or_method_name)
-    # reek reports the method with :: not # on modules like 
-    # module ApplicationHelper \n def signed_in?, convert it so it records correctly
-    # but classes have to start with a capital letter... HACK for REEK bug, reported underlying issue to REEK
-    if(class_or_method_name=~/\:\:[A-Z]/)
-      class_or_method_name.split("::").last
-    else
-      class_or_method_name
     end
-  end
 
+  end
 end

data/lib/base/metric_analyzer.rb

@@ -13,9 +13,9 @@ class MetricAnalyzer
      else
        @yaml = yaml
      end
-    @file_ranking = Ranking.new
-    @class_ranking = Ranking.new
-    @method_ranking = Ranking.new
+    @file_ranking = MetricFu::Ranking.new
+    @class_ranking = MetricFu::Ranking.new
+    @method_ranking = MetricFu::Ranking.new
     rankings = [@file_ranking, @class_ranking, @method_ranking]
 
     tool_analyzers = [ReekAnalyzer.new, RoodiAnalyzer.new,
@@ -27,14 +27,14 @@ class MetricAnalyzer
     columns = COMMON_COLUMNS + GRANULARITIES + tool_analyzers.map{|analyzer| analyzer.columns}.flatten
 
     @table = make_table(columns)
-                                     
+
     # These tables are an optimization. They contain subsets of the master table.
     # TODO - these should be pushed into the Table class now
     @tool_tables   = make_table_hash(columns)
     @file_tables   = make_table_hash(columns)
     @class_tables  = make_table_hash(columns)
     @method_tables = make_table_hash(columns)
-                                     
+
     tool_analyzers.each do |analyzer|
       analyzer.generate_records(@yaml[analyzer.name], @table)
     end
@@ -62,11 +62,11 @@ class MetricAnalyzer
       first_row = sub_table[0]
       case item
       when :class
-        Location.get(first_row.file_path, first_row.class_name, nil)
+        MetricFu::Location.get(first_row.file_path, first_row.class_name, nil)
       when :method
-        Location.get(first_row.file_path, first_row.class_name, first_row.method_name)
+        MetricFu::Location.get(first_row.file_path, first_row.class_name, first_row.method_name)
       when :file
-        Location.get(first_row.file_path, nil, nil)
+        MetricFu::Location.get(first_row.file_path, nil, nil)
       else
         raise ArgumentError, "Item must be :class, :method, or :file"
       end
@@ -147,7 +147,7 @@ class MetricAnalyzer
 
   def fix_row_file_path!(row)
     # We know that Saikuro rows are broken
-    next unless row['metric'] == :saikuro
+    # next unless row['metric'] == :saikuro
     key = [row['class_name'], row['method_name']]
     current_file_path = row['file_path'].to_s
     correct_file_path = @class_and_method_to_file[key]
@@ -155,7 +155,7 @@ class MetricAnalyzer
       row['file_path'] = correct_file_path
     else
       # There wasn't an exact match, so we can do a substring match
-      matching_file_path = file_paths.detect {|file_path| 
+      matching_file_path = file_paths.detect {|file_path|
         file_path!=nil && file_path.include?(current_file_path)
       }
       if(matching_file_path)
@@ -180,32 +180,32 @@ class MetricAnalyzer
       raise ArgumentError, "Invalid column name #{column_name}"
     end
   end
-  
+
   def calculate_metric_scores(granularity, analyzer)
-    metric_ranking = Ranking.new
+    metric_ranking = MetricFu::Ranking.new
     metric_violations = @tool_tables[analyzer.name]
     metric_violations.each do |row|
       location = row[granularity]
       metric_ranking[location] ||= []
       metric_ranking[location] << analyzer.map(row)
     end
-    
+
     metric_ranking.each do |item, scores|
       metric_ranking[item] = analyzer.reduce(scores)
     end
-    
+
     metric_ranking
   end
 
   def add_to_master_ranking(master_ranking, metric_ranking, analyzer)
     metric_ranking.each do |item, _|
       master_ranking[item] ||= 0
-      master_ranking[item] += analyzer.score(metric_ranking, item)
+      master_ranking[item] += analyzer.score(metric_ranking, item) # scaling? Do we just add in the raw score?
     end
   end
 
   def most_common_column(column_name, size)
-    #grouping = Ruport::Data::Grouping.new(@table, 
+    #grouping = Ruport::Data::Grouping.new(@table,
     #                                      :by => column_name,
     #                                      :order => lambda { |g| -g.size})
     get_grouping(@table, :by => column_name, :order => lambda {|g| -g.size})
@@ -223,7 +223,7 @@ class MetricAnalyzer
       return values
     end
   end
-  
+
   # TODO: As we get fancier, the presenter should
   # be its own class, not just a method with a long
   # case statement
@@ -246,7 +246,7 @@ class MetricAnalyzer
       "found #{occurences} code duplications"
     when :rcov
       average_code_uncoverage = get_mean(group.column("percentage_uncovered"))
-      "#{"average " if occurences > 1}uncovered code is %.1f%" % average_code_uncoverage      
+      "#{"average " if occurences > 1}uncovered code is %.1f%" % average_code_uncoverage
     else
       raise AnalysisError, "Unknown metric #{metric}"
     end
@@ -320,13 +320,13 @@ class MetricAnalyzer
     sum = collection.inject( nil ) { |sum,x| sum ? sum+x : x }
     (sum.to_f / collection_length.to_f)
   end
-  
+
 end
 
 class Record
 
   attr_reader :data
-  
+
   def initialize(data, columns)
     @data = data
     @columns = columns
@@ -380,7 +380,7 @@ class Grouping
       end
     end
     if order
-      @arr = hash.sort_by &order 
+      @arr = hash.sort_by &order
     else
       @arr = hash.to_a
     end