bf4-metric_fu 2.1.3.1

data/lib/base/churn_analyzer.rb

@@ -0,0 +1,38 @@
+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
+
+end

data/lib/base/code_issue.rb

@@ -0,0 +1,100 @@
+require 'delegate'
+
+[ '/base/metric_analyzer',
+  '/base/flog_analyzer',
+  '/base/saikuro_analyzer',
+  '/base/churn_analyzer',
+  '/base/reek_analyzer',
+  '/base/flay_analyzer'].each do |path|
+  require File.expand_path(File.join(MetricFu::LIB_ROOT,path))
+end
+
+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(MetricFu::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

@@ -0,0 +1,219 @@
+module MetricFu
+
+  # A list of metrics which are available in the MetricFu system.
+  #
+  # These are metrics which have been developed for the system.  Of
+  # course, in order to use these metrics, their respective gems must
+  # be installed on the system.
+  AVAILABLE_METRICS = [:churn,
+                      :flog,
+                      :flay,
+                      :reek,
+                      :roodi,
+                      :rcov,
+                      :hotspots,
+                      :saikuro
+  ]
+
+  AVAILABLE_GRAPHS = [
+    :flog,
+    :flay,
+    :reek,
+    :roodi,
+    :rcov,
+    :rails_best_practices
+  ]
+  AVAILABLE_GRAPH_ENGINES = [:gchart, :bluff]
+
+  # The @@configuration class variable holds a global type configuration
+  # object for any parts of the system to use.
+  def self.configuration
+    @@configuration ||= Configuration.new
+  end
+
+  # = Configuration
+  #
+  # The Configuration class, as it sounds, provides methods for
+  # configuring the behaviour of MetricFu.
+  #
+  # == Customization for Rails
+  #
+  # The Configuration class checks for the presence of a
+  # 'config/environment.rb' file.  If the file is present, it assumes
+  # it is running in a Rails project.  If it is, it will:
+  #
+  # * Add 'app' to the @code_dirs directory to include the
+  #   code in the app directory in the processing
+  # * Add :stats to the list of metrics to run to get the Rails stats
+  #   task
+  #
+  # == Customization for CruiseControl.rb
+  #
+  # The Configuration class checks for the presence of a
+  # 'CC_BUILD_ARTIFACTS' environment variable.  If it's found
+  # it will change the default output directory from the default
+  # "tmp/metric_fu to the directory represented by 'CC_BUILD_ARTIFACTS'
+  #
+  # == Deprications
+  #
+  # The Configuration class checks for several deprecated constants
+  # that were previously used to configure MetricFu.  These include
+  # CHURN_OPTIONS, DIRECTORIES_TO_FLOG, SAIKURO_OPTIONS,
+  # and MetricFu::SAIKURO_OPTIONS.
+  #
+  # These have been replaced by config.churn, config.flog and
+  # config.saikuro respectively.
+  class Configuration
+
+    def initialize #:nodoc:#
+      reset
+      add_attr_accessors_to_self
+      add_class_methods_to_metric_fu
+    end
+
+    # Searches through the instance variables of the class and
+    # creates a class method on the MetricFu module to read the value
+    # of the instance variable from the Configuration class.
+    def add_class_methods_to_metric_fu
+      instance_variables.each do |name|
+        method_name = name[1..-1].to_sym
+        method = <<-EOF
+                  def self.#{method_name}
+                    configuration.send(:#{method_name})
+                  end
+        EOF
+        MetricFu.module_eval(method)
+      end
+    end
+
+    # Searches through the instance variables of the class and creates
+    # an attribute accessor on this instance of the Configuration
+    # class for each instance variable.
+    def add_attr_accessors_to_self
+      instance_variables.each do |name|
+        method_name = name[1..-1].to_sym
+        MetricFu::Configuration.send(:attr_accessor, method_name)
+      end
+    end
+
+    # This allows us to have a nice syntax like:
+    #
+    #   MetricFu.run do |config|
+    #     config.base_directory = 'tmp/metric_fu'
+    #   end
+    #
+    # See the README for more information on configuration options.
+    def self.run
+      yield MetricFu.configuration
+    end
+
+    # This does the real work of the Configuration class, by setting
+    # up a bunch of instance variables to represent the configuration
+    # of the MetricFu app.
+    def reset
+      @base_directory = ENV['CC_BUILD_ARTIFACTS'] || 'tmp/metric_fu'
+      @scratch_directory = File.join(@base_directory, 'scratch')
+      @output_directory = File.join(@base_directory, 'output')
+      @data_directory = File.join(@base_directory,'_data')
+      @metric_fu_root_directory = File.join(File.dirname(__FILE__),
+                                                        '..', '..')
+      @template_directory =  File.join(@metric_fu_root_directory,
+                                       'lib', 'templates')
+      @template_class = AwesomeTemplate
+      set_metrics
+      set_graphs
+      set_code_dirs
+      @flay     = { :dirs_to_flay => @code_dirs,
+                    :minimum_score => 100,
+                    :filetypes => ['rb'] }
+      @flog     = { :dirs_to_flog => @code_dirs  }
+      @reek     = { :dirs_to_reek => @code_dirs,
+                    :config_file_pattern => nil}
+      @roodi    = { :dirs_to_roodi => @code_dirs,
+                    :roodi_config => nil}
+      @saikuro  = { :output_directory => @scratch_directory + '/saikuro',
+                    :input_directory => @code_dirs,
+                    :cyclo => "",
+                    :filter_cyclo => "0",
+                    :warn_cyclo => "5",
+                    :error_cyclo => "7",
+                    :formater => "text"}
+      @churn    = {}
+      @stats    = {}
+      @rcov     = { :environment => 'test',
+                    :test_files => ['test/**/*_test.rb',
+                                    'spec/spec_helper.rb', # NOTE: ensure it is loaded before the specs
+                                    'spec/**/*_spec.rb'],
+                    :rcov_opts => ["--sort coverage",
+                                   "--no-html",
+                                   "--text-coverage",
+                                   "--no-color",
+                                   "--profile",
+                                   "--rails",
+                                   "--exclude /gems/,/Library/,/usr/,spec"],
+                    :external => nil
+                  }
+      @rails_best_practices = {}
+      @hotspots = {}
+      @file_globs_to_ignore = []
+      @link_prefix = nil
+
+
+      @verbose = false
+
+      @graph_engine = :bluff # can be :bluff or :gchart
+
+      @darwin_txmt_protocol_no_thanks = true
+      # uses the CodeRay gem (was syntax gem)
+      @syntax_highlighting = true #Can be set to false to avoid UTF-8 issues with Ruby 1.9.2 and Syntax 1.0
+    end
+
+    # Perform a simple check to try and guess if we're running
+    # against a rails app.
+    #
+    # @todo  This should probably be made a bit more robust.
+    def rails?
+      @rails = File.exist?("config/environment.rb")
+    end
+
+    # Add the :stats task to the AVAILABLE_METRICS constant if we're
+    # running within rails.
+    def set_metrics
+      if rails?
+        @metrics = MetricFu::AVAILABLE_METRICS + [
+          :stats,
+          :rails_best_practices
+        ]
+      else
+        @metrics = MetricFu::AVAILABLE_METRICS
+      end
+    end
+
+    def set_graphs
+      if rails?
+        @graphs = MetricFu::AVAILABLE_GRAPHS + [
+          :stats
+        ]
+      else
+        @graphs = MetricFu::AVAILABLE_GRAPHS
+      end
+    end
+
+    # Add the 'app' directory if we're running within rails.
+    def set_code_dirs
+      if rails?
+        @code_dirs = ['app', 'lib']
+      else
+        @code_dirs = ['lib']
+      end
+    end
+
+    def platform #:nodoc:
+      return RUBY_PLATFORM
+    end
+
+    def is_cruise_control_rb?
+      !!ENV['CC_BUILD_ARTIFACTS']
+    end
+  end
+end

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 = MetricFu::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