bf4-metric_fu 2.1.3.1

data/lib/base/reek_analyzer.rb

@@ -0,0 +1,164 @@
+# 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)
+    # mf_debug "parsing #{message}"
+    match = message.match(/\d+/)
+    if(match)
+      match[0].to_i
+    else
+      nil
+    end
+  end
+
+end

data/lib/base/report.rb

@@ -0,0 +1,110 @@
+module MetricFu
+
+  # MetricFu.report memoizes access to a Report object, that will be
+  # used throughout the lifecycle of the MetricFu app.
+  def self.report
+    @report ||= Report.new
+  end
+
+  # = Report
+  #
+  # The Report class is responsible two things:
+  #
+  # It adds information to the yaml report, produced by the system
+  # as a whole, for each of the generators used in this test run.
+  #
+  # It also handles passing the information from each generator used
+  # in this test run out to the template class set in
+  # MetricFu::Configuration.
+  class Report
+
+    # Renders the result of the report_hash into a yaml serialization
+    # ready for writing out to a file.
+    #
+    # @return YAML
+    #   A YAML object containing the results of the report generation
+    #   process
+    def to_yaml
+      report_hash.to_yaml
+    end
+
+    def per_file_data
+      @per_file_data ||= {}
+    end
+
+    def report_hash #:nodoc:
+      @report_hash ||= {}
+    end
+
+    # Instantiates a new template class based on the configuration set
+    # in MetricFu::Configuration, or through the MetricFu.config block
+    # in your rake file (defaults to the included AwesomeTemplate),
+    # assigns the report_hash to the report_hash in the template, and
+    # tells the template to to write itself out.
+    def save_templatized_report
+      @template = MetricFu.template_class.new
+      @template.report = report_hash
+      @template.per_file_data = per_file_data
+      @template.write
+    end
+
+    # Adds a hash from a passed report, produced by one of the Generator
+    # classes to the aggregate report_hash managed by this hash.
+    #
+    # @param report_type Hash
+    #   The hash to add to the aggregate report_hash
+    def add(report_type)
+      mf_debug "report requested #{report_type}"
+      clazz = MetricFu.const_get(report_type.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase })
+      mf_debug "report class found #{clazz}"
+      inst = clazz.new
+
+      report_hash.merge!(inst.generate_report)
+
+      inst.per_file_info(per_file_data) if inst.respond_to?(:per_file_info)
+    end
+
+    # Saves the passed in content to the passed in directory.  If
+    # a filename is passed in it will be used as the name of the
+    # file, otherwise it will default to 'index.html'
+    #
+    # @param content String
+    #   A string containing the content (usually html) to be written
+    #   to the file.
+    #
+    # @param dir String
+    #   A dir containing the path to the directory to write the file in.
+    #
+    # @param file String
+    #   A filename to save the path as.  Defaults to 'index.html'.
+    #
+    def save_output(content, dir, file='index.html')
+      open("#{dir}/#{file}", "w") do |f|
+        f.puts content
+      end
+    end
+
+    # Checks to discover whether we should try and open the results
+    # of the report in the browser on this system.  We only try and open
+    # in the browser if we're on OS X and we're not running in a
+    # CruiseControl.rb environment.  See MetricFu.configuration for more
+    # details about how we make those guesses.
+    #
+    # @return Boolean
+    #   Should we open in the browser or not?
+    def open_in_browser?
+      MetricFu.configuration.platform.include?('darwin') &&
+      ! MetricFu.configuration.is_cruise_control_rb?
+    end
+
+    # Shows 'index.html' from the passed directory in the browser
+    # if we're able to open the browser on this platform.
+    #
+    # @param dir String
+    #   The directory path where the 'index.html' we want to open is
+    #   stored
+    def show_in_browser(dir)
+      system("open #{dir}/index.html") if open_in_browser?
+    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 = MetricFu::Location.for(klass[:class_name])
+        offending_class = location.class_name
+        klass[:methods].each do |match|
+          offending_method = MetricFu::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) # per project score percentile
+  end
+
+  def identity(ranking, item)
+    ranking[item] # Use the score you got (ex flog score of 20 is not bad even if it is the top one in project)
+  end
+
+  def present(row)
+    1 # If present it's a one, not present it's a zero - For things like Reek that don't have a number
+  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,108 @@
+[
+  '/base/record'
+  ].each do |path|
+  require File.expand_path(File.join(MetricFu::LIB_ROOT,path))
+end
+
+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?(MetricFu::Record) || row.is_a?(CodeIssue)
+      record = row
+    else
+      record = MetricFu::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