rferraz-metric_fu 2.1.1

data/lib/base/md5_tracker.rb

@@ -0,0 +1,52 @@
+require 'digest/md5'
+require 'fileutils'
+
+module MetricFu
+  class MD5Tracker
+
+    @@unchanged_md5s = []
+
+    class << self
+      def md5_dir(path_to_file, base_dir)
+        File.join(base_dir,
+                  path_to_file.split('/')[0..-2].join('/'))
+      end
+
+      def md5_file(path_to_file, base_dir)
+        File.join(md5_dir(path_to_file, base_dir),
+                  path_to_file.split('/').last.sub(/\.[a-z]+/, '.md5'))
+      end
+
+      def track(path_to_file, base_dir)
+        md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        FileUtils.mkdir_p(md5_dir(path_to_file, base_dir), :verbose => false)
+        f = File.new(md5_file(path_to_file, base_dir), "w")
+        f.puts(md5)
+        f.close
+        md5
+      end
+
+      def file_changed?(path_to_file, base_dir)
+        orig_md5_file = md5_file(path_to_file, base_dir)
+        return !!track(path_to_file, base_dir) unless File.exist?(orig_md5_file)
+
+        current_md5 = ""
+        file = File.open(orig_md5_file, 'r')
+        file.each_line { |line| current_md5 << line }
+        file.close
+        current_md5.chomp!
+
+        new_md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        new_md5.chomp!
+
+        @@unchanged_md5s << path_to_file if new_md5 == current_md5
+
+        return new_md5 != current_md5
+      end
+
+      def file_already_counted?(path_to_file)
+        return @@unchanged_md5s.include?(path_to_file)
+      end
+    end
+  end
+end

data/lib/base/metric_analyzer.rb

@@ -0,0 +1,404 @@
+class AnalysisError < RuntimeError; end;
+
+class MetricAnalyzer
+
+  COMMON_COLUMNS = %w{metric}
+  GRANULARITIES =  %w{file_path class_name method_name}
+
+  attr_accessor :table
+
+  def initialize(yaml)
+    if(yaml.is_a?(String))
+       @yaml = YAML.load(yaml)
+     else
+       @yaml = yaml
+     end
+    @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,
+    FlogAnalyzer.new, ChurnAnalyzer.new, SaikuroAnalyzer.new,
+    FlayAnalyzer.new, StatsAnalyzer.new, RcovAnalyzer.new]
+    # TODO There is likely a clash that will happen between
+    # column names eventually. We should probably auto-prefix
+    # them (e.g. "roodi_problem")
+    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
+
+    build_lookups!(table)
+    process_rows!(table)
+
+    tool_analyzers.each do |analyzer|
+      GRANULARITIES.each do |granularity|
+        metric_ranking = calculate_metric_scores(granularity, analyzer)
+        add_to_master_ranking(ranking(granularity), metric_ranking, analyzer)
+      end
+    end
+
+    rankings.each do |ranking|
+      ranking.delete(nil)
+    end
+  end
+
+  def location(item, value)
+    sub_table = get_sub_table(item, value)
+    if(sub_table.length==0)
+      raise AnalysisError, "The #{item.to_s} '#{value.to_s}' does not have any rows in the analysis table"
+    else
+      first_row = sub_table[0]
+      case item
+      when :class
+        MetricFu::Location.get(first_row.file_path, first_row.class_name, nil)
+      when :method
+        MetricFu::Location.get(first_row.file_path, first_row.class_name, first_row.method_name)
+      when :file
+        MetricFu::Location.get(first_row.file_path, nil, nil)
+      else
+        raise ArgumentError, "Item must be :class, :method, or :file"
+      end
+    end
+  end
+
+  #todo redo as item,value, options = {}
+  # Note that the other option for 'details' is :detailed (this isn't
+  # at all clear from this method itself
+  def problems_with(item, value, details = :summary, exclude_details = [])
+    sub_table = get_sub_table(item, value)
+    #grouping = Ruport::Data::Grouping.new(sub_table, :by => 'metric')
+    grouping = get_grouping(sub_table, :by => 'metric')
+    problems = {}
+    grouping.each do |metric, table|
+      if details == :summary || exclude_details.include?(metric)
+        problems[metric] = present_group(metric,table)
+      else
+        problems[metric] = present_group_details(metric,table)
+      end
+    end
+    problems
+  end
+
+  def worst_methods(size = nil)
+    @method_ranking.top(size)
+  end
+
+  def worst_classes(size = nil)
+    @class_ranking.top(size)
+  end
+
+  def worst_files(size = nil)
+    @file_ranking.top(size)
+  end
+
+  private
+
+  def get_grouping(table, opts)
+    #Ruport::Data::Grouping.new(table, opts)
+    Grouping.new(table, opts)
+    #@grouping_cache ||= {}
+    #@grouping_cache.fetch(grouping_key(table,opts)) do
+    #  @grouping_cache[grouping_key(table,opts)] = Ruport::Data::Grouping.new(table, opts)
+    #end
+  end
+
+  def grouping_key(table, opts)
+    "table #{table.object_id} opts #{opts.inspect}"
+  end
+
+  def build_lookups!(table)
+    @class_and_method_to_file ||= {}
+    # Build a mapping from [class,method] => filename
+    # (and make sure the mapping is unique)
+    table.each do |row|
+      # We know that Saikuro provides the wrong data
+      next if row['metric'] == :saikuro
+      key = [row['class_name'], row['method_name']]
+      file_path = row['file_path']
+      @class_and_method_to_file[key] ||= file_path
+    end
+  end
+
+  def process_rows!(table)
+    # Correct incorrect rows in the table
+    table.each do |row|
+      row_metric = row['metric'] #perf optimization
+      if row_metric == :saikuro
+        fix_row_file_path!(row)
+      end
+      @tool_tables[row_metric] << row
+      @file_tables[row["file_path"]] << row
+      @class_tables[row["class_name"]] << row
+      @method_tables[row["method_name"]] << row
+    end
+  end
+
+  def fix_row_file_path!(row)
+    # We know that Saikuro rows are broken
+    # 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]
+    if(correct_file_path!=nil && correct_file_path.include?(current_file_path))
+      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|
+        file_path!=nil && file_path.include?(current_file_path)
+      }
+      if(matching_file_path)
+        row['file_path'] = matching_file_path
+      end
+    end
+  end
+
+  def file_paths
+    @file_paths ||= @table.column('file_path').uniq
+  end
+
+  def ranking(column_name)
+    case column_name
+    when "file_path"
+      @file_ranking
+    when "class_name"
+      @class_ranking
+    when "method_name"
+      @method_ranking
+    else
+      raise ArgumentError, "Invalid column name #{column_name}"
+    end
+  end
+
+  def calculate_metric_scores(granularity, analyzer)
+    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) # scaling? Do we just add in the raw score?
+    end
+  end
+
+  def most_common_column(column_name, size)
+    #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})
+    values = []
+    grouping.each do |value, _|
+      values << value if value!=nil
+      if(values.size==size)
+        break
+      end
+    end
+    return nil if values.empty?
+    if(values.size == 1)
+      return values.first
+    else
+      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
+  def present_group(metric, group)
+    occurences = group.size
+    case(metric)
+    when :reek
+      "found #{occurences} code smells"
+    when :roodi
+      "found #{occurences} design problems"
+    when :churn
+      "detected high level of churn (changed #{group[0].times_changed} times)"
+    when :flog
+      complexity = get_mean(group.column("score"))
+      "#{"average " if occurences > 1}complexity is %.1f" % complexity
+    when :saikuro
+      complexity = get_mean(group.column("complexity"))
+      "#{"average " if occurences > 1}complexity is %.1f" % complexity
+    when :flay
+      "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
+    else
+      raise AnalysisError, "Unknown metric #{metric}"
+    end
+  end
+
+  def present_group_details(metric, group)
+    occurences = group.size
+    case(metric)
+    when :reek
+      message = "found #{occurences} code smells<br/>"
+      group.each do |item|
+        type    = item.data["reek__type_name"]
+        reek_message = item.data["reek__message"]
+        message << "* #{type}: #{reek_message}<br/>"
+      end
+      message
+    when :roodi
+      message = "found #{occurences} design problems<br/>"
+      group.each do |item|
+        problem    = item.data["problems"]
+        message << "* #{problem}<br/>"
+      end
+      message
+    when :churn
+      "detected high level of churn (changed #{group[0].times_changed} times)"
+    when :flog
+      complexity = get_mean(group.column("score"))
+      "#{"average " if occurences > 1}complexity is %.1f" % complexity
+    when :saikuro
+      complexity = get_mean(group.column("complexity"))
+      "#{"average " if occurences > 1}complexity is %.1f" % complexity
+    when :flay
+      message = "found #{occurences} code duplications<br/>"
+      group.each do |item|
+        problem    = item.data["flay_reason"]
+        problem    = problem.gsub(/^[0-9]*\)/,'')
+        problem    = problem.gsub(/files\:/,' <br>&nbsp;&nbsp;&nbsp;files:')
+        message << "* #{problem}<br/>"
+      end
+      message
+    else
+      raise AnalysisError, "Unknown metric #{metric}"
+    end
+  end
+
+  def make_table_hash(columns)
+    Hash.new { |hash, key|
+      hash[key] = make_table(columns)
+    }
+  end
+
+  def make_table(columns)
+    Table.new(:column_names => columns)
+  end
+
+  def get_sub_table(item, value)
+    tables = {
+      :class  => @class_tables,
+      :method => @method_tables,
+      :file   => @file_tables,
+      :tool   => @tool_tables
+    }.fetch(item) do
+      raise ArgumentError, "Item must be :class, :method, or :file"
+    end
+    tables[value]
+  end
+
+  def get_mean(collection)
+    collection_length = collection.length
+    sum = 0
+    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
+  end
+
+  def method_missing(name, *args, &block)
+    key = name.to_s
+    if @data.has_key?(key)
+      @data[key]
+    elsif @columns.member?(key)
+      nil
+    else
+      super(name, *args, &block)
+    end
+  end
+
+  def []=(key, value)
+     @data[key]=value
+  end
+
+  def [](key)
+    @data[key]
+  end
+
+  def keys
+    @data.keys
+  end
+
+  def has_key?(key)
+    @data.has_key?(key)
+  end
+
+  def attributes
+    @columns
+  end
+
+end
+
+class Grouping
+
+  def initialize(table, opts)
+    column_name = opts.fetch(:by)
+    order = opts.fetch(:order) { nil }
+    hash = {}
+    if column_name.to_sym == :metric # special optimized case
+      hash = table.group_by_metric
+    else
+      table.each do |row|
+        hash[row[column_name]] ||= Table.new(:column_names => row.attributes)
+        hash[row[column_name]] << row
+      end
+    end
+    if order
+      @arr = hash.sort_by &order
+    else
+      @arr = hash.to_a
+    end
+  end
+
+  def [](key)
+    @arr.each do |group_key, table|
+      return table if group_key == key
+    end
+    return nil
+  end
+
+  def each
+    @arr.each do |value, rows|
+      yield value, rows
+    end
+  end
+
+end
+
+

data/lib/base/ranking.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+module MetricFu
+  class Ranking
+    extend Forwardable
+
+    def initialize
+      @items_to_score = {}
+    end
+
+    def top(num=nil)
+      if(num.is_a?(Numeric))
+        sorted_items[0,num]
+      else
+        sorted_items
+      end
+    end
+
+    def percentile(item)
+      index = sorted_items.index(item)
+      worse_item_count = (length - (index+1))
+      worse_item_count.to_f/length
+    end
+
+    def_delegator :@items_to_score, :has_key?, :scored?
+    def_delegators :@items_to_score, :[], :[]=, :length, :each, :delete
+
+    private
+
+    def sorted_items
+      @sorted_items ||= @items_to_score.sort_by {|item, score| -score}.map {|item, score| item}
+    end
+
+  end
+end

data/lib/base/rcov_analyzer.rb

@@ -0,0 +1,43 @@
+class RcovAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{percentage_uncovered}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :rcov
+  end
+
+  def map(row)
+    row.percentage_uncovered
+  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
+   data.each do |file_name, info|
+     next if (file_name == :global_percent_run) || (info[:methods].nil?)
+     info[:methods].each do |method_name, percentage_uncovered|
+       location = MetricFu::Location.for(method_name)
+       table << {
+         "metric" => :rcov,
+         'file_path' => file_name,
+         'class_name' => location.class_name,
+         "method_name" => location.method_name,
+         "percentage_uncovered" => percentage_uncovered
+       }
+     end
+   end
+ end
+
+end

data/lib/base/reek_analyzer.rb

@@ -0,0 +1,163 @@
+# coding: utf-8
+
+class ReekAnalyzer
+  include ScoringStrategies
+
+  REEK_ISSUE_INFO = {
+    'Uncommunicative Name' =>
+      {'link' => 'http://wiki.github.com/kevinrutherford/reek/uncommunicative-name',
+       'info' => 'An Uncommunicative Name is a name that doesn’t communicate its intent well enough.'},
+    'Class Variable' =>
+      {'link' => 'http://wiki.github.com/kevinrutherford/reek/class-variable',
+       'info' => 'Class variables form part of the global runtime state, and as such make it ' +
+                 'easy for one part of the system to accidentally or inadvertently depend on ' +
+                 'another part of the system.'},
+    'Duplication' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/duplication',
+       'info' => 'Duplication occurs when two fragments of code look nearly identical, or when ' +
+                 'two fragments of code have nearly identical effects at some conceptual level.'},
+    'Low Cohesion' =>
+      {'link' => 'http://en.wikipedia.org/wiki/Cohesion_(computer_science)',
+       'info' => 'Low cohesion is associated with undesirable traits such as being difficult to ' +
+                 'maintain, difficult to test, difficult to reuse, and even difficult to understand.'},
+    'Nested Iterators' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/nested-iterators',
+       'info' => 'Nested Iterator occurs when a block contains another block.'},
+    'Control Couple' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/control-couple',
+       'info' => 'Control coupling occurs when a method or block checks the value of a parameter in ' +
+                 'order to decide which execution path to take. The offending parameter is often called a “Control Couple”.'},
+    'Irresponsible Module' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/irresponsible-module',
+       'info' => 'Classes and modules are the units of reuse and release. It is therefore considered ' +
+                 'good practice to annotate every class and module with a brief comment outlining its responsibilities.'},
+    'Long Parameter List' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/long-parameter-list',
+       'info' => 'A Long Parameter List occurs when a method has more than one or two parameters, ' +
+                 'or when a method yields more than one or two objects to an associated block.'},
+    'Data Clump' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/data-clump',
+       'info' => 'In general, a Data Clump occurs when the same two or three items frequently appear ' +
+                 'together in classes and parameter lists, or when a group of instance variable names ' +
+                 'start or end with similar substrings.'},
+    'Simulated Polymorphism' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/simulated-polymorphism',
+       'info' => 'Simulated Polymorphism occurs when, code uses a case statement (especially on a ' +
+                 'type field) or code uses instance_of?, kind_of?, is_a?, or === to decide what code to execute'},
+    'Large Class' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/large-class',
+       'info' => 'A Large Class is a class or module that has a large number of instance variables, ' +
+                 'methods or lines of code in any one piece of its specification.'},
+    'Long Method' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/long-method',
+       'info' => 'Long methods can be hard to read and understand. They often are harder to test and ' +
+                 'maintain as well, which can lead to buggier code.'},
+    'Feature Envy' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/feature-envy',
+       'info' => 'Feature Envy occurs when a code fragment references another object more often than ' +
+                 'it references itself, or when several clients do the same series of manipulations ' +
+                 'on a particular type of object.'},
+    'Utility Function' =>
+      {'link' =>'http://wiki.github.com/kevinrutherford/reek/utility-function',
+       'info' => 'A Utility Function is any instance method that has no dependency on the state of the ' +
+                 'instance. It reduces the code’s ability to communicate intent. Code that “belongs” on ' +
+                 'one class but which is located in another can be hard to find.'},
+    'Attribute' =>
+      {'link' => 'http://wiki.github.com/kevinrutherford/reek/attribute',
+       'info' => 'A class that publishes a getter or setter for an instance variable invites client ' +
+                 'classes to become too intimate with its inner workings, and in particular with its ' +
+                 'representation of state.'}
+  }
+
+  # Note that in practice, the prefix reek__ is appended to each one
+  # This was a partially implemented idea to avoid column name collisions
+  # but it is only done in the ReekAnalyzer
+  COLUMNS = %w{type_name message value value_description comparable_message}
+
+  def self.issue_link(issue)
+    REEK_ISSUE_INFO[issue]
+  end
+
+  def columns
+    COLUMNS.map{|column| "#{name}__#{column}"}
+  end
+
+  def name
+    :reek
+  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
+    data[:matches].each do |match|
+      file_path = match[:file_path]
+      match[:code_smells].each do |smell|
+        location = MetricFu::Location.for(smell[:method])
+        smell_type = smell[:type]
+        message = smell[:message]
+        table << {
+          "metric" => name, # important
+          "file_path" => file_path, # important
+          # NOTE: ReekAnalyzer is currently different than other analyzers with regard
+          # to column name. Note the COLUMNS constant and #columns method
+          "reek__message" => message,
+          "reek__type_name" => smell_type,
+          "reek__value" => parse_value(message),
+          "reek__value_description" => build_value_description(smell_type, message),
+          "reek__comparable_message" => comparable_message(smell_type, message),
+          "class_name" => location.class_name, # important
+          "method_name" => location.method_name, # important
+        }
+      end
+    end
+  end
+
+  def self.numeric_smell?(type)
+    ["Large Class", "Long Method", "Long Parameter List"].include?(type)
+  end
+
+  private
+
+  def comparable_message(type_name, message)
+    if self.class.numeric_smell?(type_name)
+      match = message.match(/\d+/)
+      if(match)
+        match.pre_match + match.post_match
+      else
+        message
+      end
+    else
+      message
+    end
+  end
+
+  def build_value_description(type_name, message)
+    item_type = message.match(/\d+ (.*)$/)
+    if(item_type)
+      "number of #{item_type[1]} in #{type_name.downcase}"
+    else
+      nil
+    end
+  end
+
+  def parse_value(message)
+    match = message.match(/\d+/)
+    if(match)
+      match[0].to_i
+    else
+      nil
+    end
+  end
+
+end