bf4-metric_fu 2.1.3.1

data/lib/graphs/engines/gchart.rb

@@ -0,0 +1,157 @@
+module MetricFu
+  module GchartGrapher
+    COLORS = %w{009999 FF7400 A60000 008500 E6399B 344AD7 00B860 D5CCB9}
+    GCHART_GRAPH_SIZE = "945x317" # maximum permitted image size is 300000 pixels
+
+    NUMBER_OF_TICKS = 6
+    def determine_y_axis_scale(values)
+      values.collect! {|val| val || 0.0 }
+      if values.empty?
+        @max_value = 10
+        @yaxis = [0, 2, 4, 6, 8, 10]
+      else
+        @max_value = values.max + Integer(0.1 * values.max)
+        portion_size = (@max_value / (NUMBER_OF_TICKS - 1).to_f).ceil
+        @yaxis = []
+        NUMBER_OF_TICKS.times {|n| @yaxis << Integer(portion_size * n) }
+        @max_value = @yaxis.last
+      end
+    end
+  end
+
+  class Grapher
+    include MetricFu::GchartGrapher
+
+    def self.require_graphing_gem
+      require 'gchart' if MetricFu.graph_engine == :gchart
+    rescue LoadError
+      puts "#"*99 + "\n" +
+           "If you want to use google charts for graphing, you'll need to install the googlecharts rubygem." +
+           "\n" + "#"*99
+    end
+  end
+
+  class FlayGchartGrapher < FlayGrapher
+    def graph!
+      determine_y_axis_scale(@flay_score)
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Flay: duplication"),
+        :data => @flay_score,
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'flay.png'))
+    end
+  end
+
+  class FlogGchartGrapher < FlogGrapher
+    def graph!
+      determine_y_axis_scale(@top_five_percent_average + @flog_average)
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Flog: code complexity"),
+        :data => [@flog_average, @top_five_percent_average],
+        :stacked => false,
+        :bar_colors => COLORS[0..1],
+        :legend => ['average', 'top 5% average'],
+        :custom => "chdlp=t",
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'flog.png'))
+    end
+  end
+
+  class RcovGchartGrapher < RcovGrapher
+    def graph!
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Rcov: code coverage"),
+        :data => self.rcov_percent,
+        :max_value => 101,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [self.labels.values, [0,20,40,60,80,100]],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'rcov.png')
+      )
+    end
+  end
+
+  class ReekGchartGrapher < ReekGrapher
+    def graph!
+      determine_y_axis_scale(@reek_count.values.flatten.uniq)
+      values = []
+      legend = @reek_count.keys.sort
+      legend.collect {|k| values << @reek_count[k]}
+
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Reek: code smells"),
+        :data => values,
+        :stacked => false,
+        :bar_colors => COLORS,
+        :legend => legend,
+        :custom => "chdlp=t",
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'reek.png'))
+    end
+  end
+
+  class RoodiGchartGrapher < RoodiGrapher
+    def graph!
+      determine_y_axis_scale(@roodi_count)
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Roodi: potential design problems"),
+        :data => @roodi_count,
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'roodi.png'))
+    end
+  end
+
+  class StatsGchartGrapher < StatsGrapher
+    def graph!
+      determine_y_axis_scale(@loc_counts + @lot_counts)
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Stats: LOC & LOT"),
+        :data => [@loc_counts, @lot_counts],
+        :bar_colors => COLORS[0..1],
+        :legend => ['Lines of code', 'Lines of test'],
+        :custom => "chdlp=t",
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'stats.png'))
+    end
+  end
+
+  class RailsBestPracticesGchartGrapher < RailsBestPracticesGrapher
+    def graph!
+      determine_y_axis_scale(@rails_best_practices_count)
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Rails Best Practices: design problems"),
+        :data => self.rails_best_practices_count,
+        :bar_colors => COLORS[0..1],
+        :legend => ['Problems'],
+        :custom => "chdlp=t",
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'rails_best_practices.png')
+      )
+    end
+  end
+end

data/lib/graphs/flay_grapher.rb

@@ -0,0 +1,18 @@
+module MetricFu
+  class FlayGrapher < Grapher
+    attr_accessor :flay_score, :labels
+
+    def initialize
+      super
+      @flay_score = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:flay]
+        @flay_score.push(metrics[:flay][:total_score].to_i)
+        @labels.update( { @labels.size => date })
+      end
+    end
+  end
+end

data/lib/graphs/flog_grapher.rb

@@ -0,0 +1,57 @@
+module MetricFu
+  class FlogGrapher < Grapher
+    attr_accessor :flog_average, :labels, :top_five_percent_average
+
+    def initialize
+      super
+      @flog_average = []
+      @labels = {}
+      @top_five_percent_average =[]
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:flog]
+        @top_five_percent_average.push(calc_top_five_percent_average(metrics))
+        @flog_average.push(metrics[:flog][:average])
+        @labels.update( { @labels.size => date })
+      end
+    end
+
+    private
+
+    def calc_top_five_percent_average(metrics)
+      return calc_top_five_percent_average_legacy(metrics) if metrics[:flog][:pages]
+
+      method_scores = metrics[:flog][:method_containers].inject([]) do |method_scores, container|
+        method_scores += container[:methods].values.map {|v| v[:score]}
+      end
+      method_scores.sort!.reverse!
+
+      number_of_methods_that_is_five_percent = (method_scores.size * 0.05).ceil
+
+      total_for_five_percent =
+        method_scores[0...number_of_methods_that_is_five_percent].inject(0) { |total, score| total += score }
+      if number_of_methods_that_is_five_percent == 0
+        0.0
+      else
+        total_for_five_percent / number_of_methods_that_is_five_percent.to_f
+      end
+    end
+
+    def calc_top_five_percent_average_legacy(metrics)
+      methods = metrics[:flog][:pages].inject([]) {|methods, page| methods << page[:scanned_methods]}
+      methods.flatten!
+      methods = methods.sort_by {|method| method[:score]}.reverse
+
+      number_of_methods_that_is_five_percent = (methods.size * 0.05).ceil
+
+      total_for_five_percent =
+        methods[0...number_of_methods_that_is_five_percent].inject(0) {|total, method| total += method[:score] }
+      if number_of_methods_that_is_five_percent == 0
+        0.0
+      else
+        total_for_five_percent / number_of_methods_that_is_five_percent.to_f
+      end
+    end
+  end
+end

data/lib/graphs/grapher.rb

@@ -0,0 +1,11 @@
+module MetricFu
+  class Grapher
+    def initialize
+      self.class.require_graphing_gem
+    end
+
+    def self.require_graphing_gem
+      # to be overridden by charting engines
+    end
+  end
+end

data/lib/graphs/rails_best_practices_grapher.rb

@@ -0,0 +1,19 @@
+module MetricFu
+  class RailsBestPracticesGrapher < Grapher
+    attr_accessor :rails_best_practices_count, :labels
+
+    def initialize
+      super
+      @rails_best_practices_count = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:rails_best_practices]
+        size = (metrics[:rails_best_practices][:problems] || []).size
+        @rails_best_practices_count.push(size)
+        @labels.update( { @labels.size => date })
+      end
+    end
+  end
+end

data/lib/graphs/rcov_grapher.rb

@@ -0,0 +1,18 @@
+module MetricFu
+  class RcovGrapher < Grapher
+    attr_accessor :rcov_percent, :labels
+
+    def initialize
+      super
+      self.rcov_percent = []
+      self.labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:rcov]
+        self.rcov_percent.push(metrics[:rcov][:global_percent_run])
+        self.labels.update( { self.labels.size => date })
+      end
+    end
+  end
+end

data/lib/graphs/reek_grapher.rb

@@ -0,0 +1,30 @@
+module MetricFu
+  class ReekGrapher < Grapher
+    attr_accessor :reek_count, :labels
+
+    def initialize
+      super
+      @reek_count = {}
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:reek]
+        counter = @labels.size
+        @labels.update( { @labels.size => date })
+
+        metrics[:reek][:matches].each do |reek_chunk|
+          reek_chunk[:code_smells].each do |code_smell|
+            # speaking of code smell...
+            @reek_count[code_smell[:type]] = [] if @reek_count[code_smell[:type]].nil?
+            if @reek_count[code_smell[:type]][counter].nil?
+              @reek_count[code_smell[:type]][counter] = 1
+            else
+              @reek_count[code_smell[:type]][counter] += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphs/roodi_grapher.rb

@@ -0,0 +1,18 @@
+module MetricFu
+  class RoodiGrapher < Grapher
+    attr_accessor :roodi_count, :labels
+
+    def initialize
+      super
+      @roodi_count = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:roodi]
+        @roodi_count.push(metrics[:roodi][:problems].size)
+        @labels.update( { @labels.size => date })
+      end
+    end
+  end
+end

data/lib/graphs/stats_grapher.rb

@@ -0,0 +1,20 @@
+module MetricFu
+  class StatsGrapher < Grapher
+    attr_accessor :loc_counts, :lot_counts, :labels
+
+    def initialize
+      super
+      self.loc_counts = []
+      self.lot_counts = []
+      self.labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:stats]
+        self.loc_counts.push(metrics[:stats][:codeLOC].to_i)
+        self.lot_counts.push(metrics[:stats][:testLOC].to_i)
+        self.labels.update( { self.labels.size => date })
+      end
+    end
+  end
+end

data/lib/metric_fu.rb

@@ -0,0 +1,80 @@
+require 'rake'
+require 'yaml'
+begin
+  require 'psych'
+  YAML::ENGINE.yamler = 'syck'
+rescue LoadError
+  #nothing to report
+end
+# def with_syck(&block)
+#   current_engine = YAML::ENGINE.yamler
+#   YAML::ENGINE.yamler = 'syck'
+#   block.call
+#   YAML::ENGINE.yamler = current_engine
+# end
+begin
+  require 'active_support'
+  require 'active_support/core_ext/object/to_json'
+  require 'active_support/core_ext/object/blank'
+  require 'active_support/inflector'
+rescue LoadError
+  require 'activesupport' unless defined?(ActiveSupport)
+end
+
+module MfDebugger
+  class Logger
+    class << self
+      attr_accessor :debug_on
+      @debug_on = false
+    end
+  end
+
+  def self.mf_debug(msg,&block)
+    if MfDebugger::Logger.debug_on
+      if block_given?
+        block.call
+      end
+      STDOUT.puts msg
+    end
+  end
+  def mf_debug(msg,&block)
+    if block_given?
+      MfDebugger.mf_debug(msg,&block)
+    else
+      MfDebugger.mf_debug(msg)
+    end
+  end
+end
+include MfDebugger
+MfDebugger::Logger.debug_on = !!(ENV['MF_DEBUG'] =~ /true/i)
+
+# Load a few things to make our lives easier elsewhere.
+module MetricFu
+  LIB_ROOT = File.dirname(__FILE__)
+end
+base_dir         = File.join(MetricFu::LIB_ROOT, 'base')
+generator_dir    = File.join(MetricFu::LIB_ROOT, 'generators')
+template_dir     = File.join(MetricFu::LIB_ROOT, 'templates')
+graph_dir        = File.join(MetricFu::LIB_ROOT, 'graphs')
+
+# We need to require these two (sic?) things first because our other classes
+# depend on them.
+require File.expand_path File.join(base_dir, 'report')
+require File.expand_path File.join(base_dir, 'generator')
+require File.expand_path File.join(base_dir, 'graph')
+require File.expand_path File.join(base_dir, 'scoring_strategies')
+
+# prevent the task from being run multiple times.
+unless Rake::Task.task_defined? "metrics:all"
+  # Load the rakefile so users of the gem get the default metric_fu task
+  load File.expand_path File.join(MetricFu::LIB_ROOT, 'tasks', 'metric_fu.rake')
+end
+
+# Now load everything else that's in the directory
+Dir[File.expand_path File.join(base_dir, '*.rb')].each{|l| require l }
+Dir[File.expand_path File.join(generator_dir, '*.rb')].each {|l| require l }
+Dir[File.expand_path File.join(template_dir, 'standard/*.rb')].each {|l| require l}
+Dir[File.expand_path File.join(template_dir, 'awesome/*.rb')].each {|l| require l}
+require graph_dir + "/grapher"
+Dir[File.expand_path File.join(graph_dir, '*.rb')].each {|l| require l}
+Dir[File.expand_path File.join(graph_dir, 'engines', '*.rb')].each {|l| require l}

data/lib/tasks/metric_fu.rake

@@ -0,0 +1,36 @@
+require 'rake'
+namespace :metrics do
+  desc "Generate all metrics reports"
+  task :all do
+    STDOUT.sync = true
+    MetricFu::Configuration.run {}
+    MetricFu.metrics.each {|metric| 
+      mf_debug "** STARTING METRIC #{metric}"
+      MetricFu.report.add(metric) 
+      mf_debug "** ENDING METRIC #{metric}"
+    }
+    mf_debug "** SAVING REPORT YAML OUTPUT TO #{MetricFu.base_directory}"
+    MetricFu.report.save_output(MetricFu.report.to_yaml,
+                                MetricFu.base_directory,
+                                "report.yml")
+    mf_debug "** SAVING REPORT DATA OUTPUT TO #{MetricFu.data_directory}"
+    MetricFu.report.save_output(MetricFu.report.to_yaml,
+                                MetricFu.data_directory,
+                                "#{Time.now.strftime("%Y%m%d")}.yml")
+    mf_debug "** SAVING TEMPLATIZED REPORT"
+    MetricFu.report.save_templatized_report
+
+    mf_debug "** PREPARING TO GRAPH"
+    MetricFu.graphs.each {|graph| 
+      mf_debug "** Graphing #{graph} with #{MetricFu.graph_engine}"
+      MetricFu.graph.add(graph, MetricFu.graph_engine) 
+    }
+    mf_debug "** GENERATING GRAPH"
+    MetricFu.graph.generate
+
+    if MetricFu.report.open_in_browser?
+      mf_debug "** OPENING IN BROWSER FROM #{MetricFu.output_directory}"
+      MetricFu.report.show_in_browser(MetricFu.output_directory)
+    end
+  end
+end