metric_fu 1.5.1 → 2.0.0

data/HISTORY

@@ -1,3 +1,8 @@
+=== MetricFu 2.0.0 / 2010-11-10
+
+* Hotspots - Dan Mayer, Ben Brinckerhoff, Jake Scruggs
+* Rcov integration with Hotspots - Jake Scruggs, Tony Castiglione, Rob Meyer
+
 === MetricFu 1.5.1 / 2010-7-28 
 
 * Patch that allows graphers to skip dates that didn't generate metrics for that graph (GitHub Issue #20). - Chris Griego

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008,2009 Jake Scruggs
+Copyright (c) 2008,2009,2010 Jake Scruggs
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README

@@ -3,12 +3,13 @@ See http://metric-fu.rubyforge.org/ for documentation, or the HISTORY file for a
 How to contribute:
 
 1. Fork metric_fu on github.
-2. 'gem install metric_fu --development'  #to get development dependencies
-3. Run the tests ('rake')
-4. Run metric_fu on itself ('rake metrics:all')
-5. Make the changes you want and back them up with tests.
-6. Make sure two important rake tests still run ('rake' and 'rake metrics:all')
-7. Commit and send me a pull request with details as to what has been changed.
+2. 'gem install metric_fu'  #to get gem dependencies
+3. Install the gems RSpec 1.3.0, test-construct, and googlecharts
+4. Run the tests ('rake')
+5. Run metric_fu on itself ('rake metrics:all')
+6. Make the changes you want and back them up with tests.
+7. Make sure two important rake tests still run ('rake' and 'rake metrics:all')
+8. Commit and send me a pull request with details as to what has been changed.
 
 Extra Credit:  
 1. Make sure your changes work in 1.8.7, Ruby Enterprise Edition, and 1.9.1 (Hint use 'rvm' to help install multiple rubies)
@@ -24,4 +25,5 @@ Resources:
 Homepage: http://metric-fu.rubyforge.org/
 Github: http://github.com/jscruggs/metric_fu
 Google Group: http://groups.google.com/group/metric_fu
+Issue Tracker: http://github.com/jscruggs/metric_fu/issues
 My Blog: http://jakescruggs.blogspot.com/

data/Rakefile

@@ -8,9 +8,11 @@ desc "Run all specs in spec directory"
 Spec::Rake::SpecTask.new(:spec) do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
 end
- 
+
 MetricFu::Configuration.run do |config|
-  config.roodi = config.roodi.merge(:roodi_config => 'config/roodi_config.yml')
+  config.roodi    = config.roodi.merge(:roodi_config => 'config/roodi_config.yml')
+  config.churn    = { :start_date => "1 year ago", :minimum_churn_count => 10}
+  config.hotspots = { :start_date => "1 year ago", :minimum_churn_count => 10}
 end
- 
+
 task :default => :spec

data/TODO

@@ -1,9 +1,4 @@
 == TODO list
 
 * Color code flog results with scale from: http://jakescruggs.blogspot.com/2008/08/whats-good-flog-score.html
-* Integrate Flog, Saikuro, and Coverage into one report so you can see methods that have high complexity and low coverage (this is a big one)
-* Update flog specs so that they actually run flog
-* Add flay specs that run flay
-* Convert readme to markdown and rename to README.mkdn so github will render it
-* Saikuro.rb falls over if tries to parse an empty file.  Fair enough.  We shouldn't feed it empty files
 * Make running metric_fu on metric_fu less embarrassing 

data/lib/base/base_template.rb

@@ -117,6 +117,22 @@ module MetricFu
         name
       end
     end
+
+    def display_location(location, stat)
+      file_path, class_name, method_name = location.file_path, location.class_name, location.method_name
+      str = ""
+      str += link_to_filename(file_path)
+      str += " : " if method_name || class_name
+      if(method_name)
+        str += "#{method_name}"
+      else
+        #TODO HOTSPOTS BUG ONLY exists on move over to metric_fu
+        if class_name.is_a?(String)
+          str+= "#{class_name}"
+        end
+      end
+      str
+    end
     
     def file_url(name, line) # :nodoc:
       return '' unless name

data/lib/base/churn_analyzer.rb

@@ -0,0 +1,52 @@
+class ChurnAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{times_changed}
+
+  def columns
+    COLUMNS
+  end
+  
+  def name
+    :churn
+  end
+
+  def map(row)
+    ScoringStrategies.present(row)
+  end
+
+  def reduce(scores)
+    ScoringStrategies.sum(scores)
+  end
+
+  def score(metric_ranking, item)
+    flat_churn_score = 0.50
+    metric_ranking.scored?(item) ? flat_churn_score : 0
+  end
+  
+  def generate_records(data, table)
+   return if data==nil
+    Array(data[:changes]).each do |change|
+      table << {
+        "metric" => :churn,
+        "times_changed" => change[:times_changed],
+        "file_path" => change[:file_path]
+      }
+    end
+  end
+
+  private 
+
+  def self.update_changes(total, changed)
+    changed.each do |change|
+      #should work as has_key(change), but hash == doesn't work on 1.8.6 here for some reason it never matches
+      if total.has_key?(change.to_a.sort)
+        total[change.to_a.sort] += 1
+      else
+        total[change.to_a.sort] = 1
+      end
+    end
+    total
+  end
+
+end

data/lib/base/code_issue.rb

@@ -0,0 +1,97 @@
+require 'delegate'
+require MetricFu::LIB_ROOT + '/base/metric_analyzer'
+require MetricFu::LIB_ROOT + '/base/flog_analyzer'
+require MetricFu::LIB_ROOT + '/base/saikuro_analyzer'
+require MetricFu::LIB_ROOT + '/base/churn_analyzer'
+require MetricFu::LIB_ROOT + '/base/reek_analyzer'
+require MetricFu::LIB_ROOT + '/base/flay_analyzer'
+
+module CarefulArray
+
+  def carefully_remove(elements)
+    missing_elements = elements - self
+    raise "Cannot delete missing elements: #{missing_elements.inspect}" unless missing_elements.empty?
+    (self - elements).extend(CarefulArray)
+  end
+
+end
+
+class CodeIssue < DelegateClass(Record) #DelegateClass(Ruport::Data::Record)
+  include Comparable
+
+  # TODO: Yuck! 'stat_value' is a column for StatAnalyzer  
+  EXCLUDED_COLUMNS = FlogAnalyzer::COLUMNS + SaikuroAnalyzer::COLUMNS + ['stat_value'] + ChurnAnalyzer::COLUMNS + ReekAnalyzer.new.columns.extend(CarefulArray).carefully_remove(['reek__type_name', 'reek__comparable_message']) + FlayAnalyzer.new.columns.extend(CarefulArray).carefully_remove(['flay_matching_reason'])
+
+  def <=>(other)
+    spaceship_for_columns(self.attributes, other)
+  end
+  
+  def ===(other)
+    self.hash_for(included_columns_hash, included_columns) == other.hash_for(included_columns_hash, included_columns)
+  end
+  
+  def spaceship_for_columns(columns, other)
+    columns.each do |column|
+      equality = self[column].to_s <=> other[column].to_s
+      return equality if equality!=0
+    end
+    return 0
+  end
+
+  def hash_for(column_hash, columns)
+    @hashes ||= {}
+    # fetch would be cleaner, but slower
+    if @hashes.has_key?(column_hash) 
+      @hashes[column_hash]
+    else
+      values = columns.map {|column| self[column]}
+      hash_for_columns = values.join('').hash
+      @hashes[column_hash]=hash_for_columns
+      hash_for_columns
+    end
+  end
+
+  def included_columns_hash
+    @included_columns_hash ||= included_columns.hash
+  end
+  
+  def included_columns
+    @included_columns ||= self.attributes.extend(CarefulArray).carefully_remove(EXCLUDED_COLUMNS)
+  end
+
+  def find_counterpart_index_in(collection)
+    # each_with_index is cleaner, but it is slower and we
+    # spend a lot of time in this loop
+    index = 0
+    collection.each do |issue|
+      return index if self === issue
+      index += 1
+    end
+    return nil
+  end
+
+  def modifies?(other)
+    case self.metric
+    when :reek
+      #return false unless ["Large Class", "Long Method", "Long Parameter List"].include?(self.reek__type_name)
+      return false if self.reek__type_name != other.reek__type_name
+      self.reek__value != other.reek__value
+    when :flog
+      self.score != other.score
+    when :saikuro 
+      self.complexity != other.complexity
+    when :stats
+      self.stat_value != other.stat_value     
+    when :churn
+      self.times_changed != other.times_changed
+    when :flay
+      #self.flay_reason != other.flay_reason
+      # do nothing for now
+    when :roodi, :stats
+      # do nothing
+    else
+      raise ArgumentError, "Invalid metric type #{self.metric}"
+    end
+  end
+  
+end

data/lib/base/configuration.rb

@@ -6,7 +6,8 @@ module MetricFu
   # course, in order to use these metrics, their respective gems must
   # be installed on the system.
   AVAILABLE_METRICS = [:churn, :flog, :flay, :reek, 
-                       :roodi, :saikuro, :rcov]
+                       :roodi, :saikuro, :rcov,
+                      :hotspots]
 
   AVAILABLE_GRAPHS = [:flog, :flay, :reek, :roodi, :rcov, :rails_best_practices]
   AVAILABLE_GRAPH_ENGINES = [:gchart, :bluff]
@@ -139,6 +140,7 @@ module MetricFu
                     :external => nil
                   }
       @rails_best_practices = {}
+      @hotspots = {}
       @file_globs_to_ignore = []
                                    
       @graph_engine = :bluff # can be :bluff or :gchart
@@ -159,7 +161,7 @@ module MetricFu
         @metrics = MetricFu::AVAILABLE_METRICS + [:stats, :rails_best_practices]
       else
         @metrics = MetricFu::AVAILABLE_METRICS
-      end 
+      end
     end
     
     def set_graphs

data/lib/base/flay_analyzer.rb

@@ -0,0 +1,50 @@
+class FlayAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{flay_reason flay_matching_reason}
+
+  def columns
+    COLUMNS
+  end
+  
+  def name
+    :flay
+  end
+
+  def map(row)
+    ScoringStrategies.present(row)
+  end
+
+  def reduce(scores)
+    ScoringStrategies.sum(scores)
+  end
+
+  def score(metric_ranking, item)
+    ScoringStrategies.percentile(metric_ranking, item)
+  end
+  
+  def generate_records(data, table)
+    return if data==nil
+    Array(data[:matches]).each do |match|
+      problems  = match[:reason]
+      matching_reason = problems.gsub(/^[0-9]+\) /,'').gsub(/\:[0-9]+/,'')
+      files     = []
+      locations = []
+      match[:matches].each do |file_match|
+        file_path = file_match[:name].sub(%r{^/},'')
+        locations << "#{file_path}:#{file_match[:line]}"
+        files     << file_path
+      end
+      files = files.uniq
+      files.each do |file|
+        table << {
+          "metric" => self.name,
+          "file_path" => file,
+          "flay_reason" => problems+" files: #{locations.join(', ')}",
+          "flay_matching_reason" => matching_reason
+        }
+      end
+    end
+  end
+
+end

data/lib/base/flog_analyzer.rb

@@ -0,0 +1,43 @@
+class FlogAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{score}
+
+  def columns
+    COLUMNS
+  end
+  
+  def name
+    :flog
+  end
+  
+  def map(row)
+    row.score
+  end
+
+  def reduce(scores)
+    ScoringStrategies.average(scores)
+  end
+
+  def score(metric_ranking, item)
+    ScoringStrategies.identity(metric_ranking, item)
+  end
+  
+  def generate_records(data, table)
+    return if data==nil
+    Array(data[:method_containers]).each do |method_container|
+      Array(method_container[:methods]).each do |entry|
+        file_path = entry[1][:path].sub(%r{^/},'') if entry[1][:path]
+        location = Location.for(entry.first)
+        table << {
+          "metric" => name,
+          "score" => entry[1][:score],
+          "file_path" => file_path,
+          "class_name" => location.class_name,
+          "method_name" => location.method_name
+        }
+      end
+    end
+  end
+
+end

data/lib/base/line_numbers.rb

@@ -0,0 +1,65 @@
+require 'ruby_parser'
+
+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 in_method? line_number
+    !!@locations.detect do |method_name, line_number_range|
+      line_number_range.include?(line_number)
+    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)
+    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)
+    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)
+    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

@@ -0,0 +1,83 @@
+class Location
+  include Comparable
+
+  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
+    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
+
+  # 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
+  
+  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(/\:\:/,"#")
+      else
+        class_name = strip_modules(class_or_method_name)
+        method_name = nil
+      end
+    else
+      class_name = nil
+      method_name = nil
+    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
+
+  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
+  end
+
+end