metric_fu 1.5.1 → 2.0.0

data/lib/base/reek_analyzer.rb

@@ -0,0 +1,114 @@
+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 = Location.for(smell[:method])
+        smell_type = smell[:type]
+        message = smell[:message]
+        table << {
+          "metric" => name,
+          "file_path" => file_path,
+          # 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,
+          "method_name" => location.method_name,
+        }
+      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

data/lib/base/roodi_analyzer.rb

@@ -0,0 +1,37 @@
+class RoodiAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{problems}
+
+  def columns
+    COLUMNS
+  end
+  
+  def name
+    :roodi
+  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[:problems]).each do |problem|
+      table << {
+        "metric" => name,
+        "problems" => problem[:problem],
+        "file_path" => problem[:file]
+      }
+    end
+  end
+
+end

data/lib/base/saikuro_analyzer.rb

@@ -0,0 +1,48 @@
+class SaikuroAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{lines complexity}
+
+  def columns
+    COLUMNS
+  end
+  
+  def name
+    :saikuro
+  end
+
+  def map(row)
+    row.complexity
+  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[:files].each do |file|
+      file_name = file[:filename]
+      file[:classes].each do |klass|
+        location = Location.for(klass[:class_name])
+        offending_class = location.class_name
+        klass[:methods].each do |match|
+          offending_method = Location.for(match[:name]).method_name
+          table << {
+            "metric" => name,
+            "lines" => match[:lines],
+            "complexity" => match[:complexity],
+            "class_name" => offending_class,
+            "method_name" => offending_method,
+            "file_path" => file_name,
+          }
+        end
+      end
+    end
+  end
+
+end

data/lib/base/scoring_strategies.rb

@@ -0,0 +1,29 @@
+module ScoringStrategies
+
+  def percentile(ranking, item)
+    ranking.percentile(item)
+  end
+  
+  def identity(ranking, item)
+    ranking[item]
+  end
+
+  def present(row)
+    1
+  end
+
+  def sum(scores)
+    scores.inject(0) {|s,x| s+x}
+  end
+
+  def average(scores)
+    # remove dependency on statarray
+    # scores.to_statarray.mean
+    score_length = scores.length
+    sum = 0
+    sum = scores.inject( nil ) { |sum,x| sum ? sum+x : x }
+    (sum.to_f / score_length.to_f)
+  end
+  
+  extend self
+end

data/lib/base/stats_analyzer.rb

@@ -0,0 +1,37 @@
+class StatsAnalyzer
+
+  COLUMNS = %w{stat_name stat_value}
+
+  def columns
+    COLUMNS
+  end
+  
+  def name
+    :stats
+  end
+
+  def map(row)
+    0
+  end
+  
+  def reduce(scores)
+    0
+  end
+
+  def score(metric_ranking, item)
+    0
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    data.each do |key, value|
+      next if value.kind_of?(Array)
+      table << {
+        "metric" => name,
+        "stat_name" => key,
+        "stat_value" => value
+      }
+    end
+  end
+
+end

data/lib/base/table.rb

@@ -0,0 +1,102 @@
+class Table
+  
+  def initialize(opts = {})
+    @rows = []
+    @columns = opts.fetch(:column_names)
+    
+    @make_index = opts.fetch(:make_index) {true}
+    @metric_index = {}
+  end
+
+  def <<(row)
+    record = nil
+    if row.is_a?(Record) || row.is_a?(CodeIssue)
+      record = row
+    else
+      record = Record.new(row, @columns)
+    end
+    @rows << record
+    updated_key_index(record) if @make_index
+  end
+
+  def each
+    @rows.each do |row|
+      yield row
+    end
+  end
+
+  def size
+    length
+  end
+
+  def length
+    @rows.length
+  end
+
+  def [](index)
+    @rows[index]
+  end
+
+  def column(column_name)
+    arr = []
+    @rows.each do |row|
+      arr << row[column_name]
+    end
+    arr
+  end
+  
+  def group_by_metric
+    @metric_index.to_a
+  end
+
+  def rows_with(conditions)
+    if optimized_conditions?(conditions)
+      optimized_select(conditions)
+    else
+      slow_select(conditions)
+    end
+  end
+
+  def delete_at(index)
+    @rows.delete_at(index)
+  end
+
+  def to_a
+    @rows
+  end
+  
+  def map
+    new_table = Table.new(:column_names => @columns)
+    @rows.map do |row|
+      new_table << (yield row)
+    end
+    new_table
+  end
+
+  private
+
+  def optimized_conditions?(conditions)
+    conditions.keys.length == 1 && conditions.keys.first.to_sym == :metric
+  end
+
+  def optimized_select(conditions)
+    metric = (conditions['metric'] || conditions[:metric]).to_s
+    @metric_index[metric].to_a.clone
+  end
+
+  def slow_select(conditions)
+    @rows.select do |row|
+      conditions.all? do |key, value|
+        row.has_key?(key.to_s) && row[key.to_s] == value
+      end
+    end
+  end
+
+  def updated_key_index(record)
+    if record.has_key?('metric')
+      @metric_index[record.metric] ||= Table.new(:column_names => @columns, :make_index => false)
+      @metric_index[record.metric] << record
+    end
+  end
+
+end

data/lib/generators/hotspots.rb

@@ -0,0 +1,52 @@
+module MetricFu
+
+  class Hotspots < Generator
+
+    def initialize(options={})
+      super
+    end
+
+    def self.verify_dependencies!
+      true
+    end
+
+    def emit
+      @analyzer = MetricAnalyzer.new(MetricFu.report.report_hash)
+    end
+
+    def analyze
+      num = nil
+      worst_items = {}
+      if @analyzer
+        worst_items[:files] = 
+          @analyzer.worst_files(num).inject([]) do |array, worst_file|
+          array << 
+            {:location => @analyzer.location(:file, worst_file),
+            :details => @analyzer.problems_with(:file, worst_file)}
+          array
+        end
+        worst_items[:classes] = @analyzer.worst_classes(num).inject([]) do |array, class_name|
+          location = @analyzer.location(:class, class_name)
+          array << 
+            {:location => location,
+            :details => @analyzer.problems_with(:class, class_name)}
+          array
+        end
+        worst_items[:methods] = @analyzer.worst_methods(num).inject([]) do |array, method_name|
+          location = @analyzer.location(:method, method_name)
+          array << 
+            {:location => location,
+            :details => @analyzer.problems_with(:method, method_name)}
+          array
+        end
+      end
+
+      @hotspots = worst_items
+    end
+
+    def to_h
+      {:hotspots => @hotspots}
+    end
+  end
+
+end

data/lib/generators/rcov.rb

@@ -48,11 +48,52 @@ module MetricFu
 
     def to_h
       global_percent_run = ((@global_total_lines_run.to_f / @global_total_lines.to_f) * 100)
+      add_method_data
       {:rcov => @rcov.merge({:global_percent_run => round_to_tenths(global_percent_run) })}   
     end
     
     private
     
+    def add_method_data
+      @rcov.each_pair do |file_path, info|
+        file_contents = ""
+        coverage = []
+        
+        info[:lines].each_with_index do |line, index|
+          file_contents << "#{line[:content]}\n"
+          coverage << line[:was_run]
+        end
+        
+        begin
+          line_numbers = LineNumbers.new(file_contents)
+        rescue StandardError => e
+          raise e unless e.message =~ /you shouldn't be able to get here/
+          puts "ruby_parser blew up while trying to parse #{file_path}. You won't have method level Rcov information for this file."
+          next
+        end
+        
+        method_coverage_map = {}
+        coverage.each_with_index do |covered, index|
+          line_number = index + 1
+          if line_numbers.in_method?(line_number)
+            method_name = line_numbers.method_at_line(line_number)
+            method_coverage_map[method_name] ||= {}
+            method_coverage_map[method_name][:total] ||= 0
+            method_coverage_map[method_name][:total] += 1
+            method_coverage_map[method_name][:uncovered] ||= 0
+            method_coverage_map[method_name][:uncovered] += 1 if !covered
+          end
+        end
+        
+        @rcov[file_path][:methods] = {}
+        
+        method_coverage_map.each do |method_name, coverage_data|
+          @rcov[file_path][:methods][method_name] = (coverage_data[:uncovered] / coverage_data[:total].to_f) * 100.0
+        end
+        
+      end
+    end
+    
     def assemble_files(output)
       files = {}
       output.each_slice(2) {|out| files[out.first.strip] = out.last}