danmayer-metric_fu 2.1.2

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,40 @@
+require 'rake'
+require 'yaml'
+begin
+  require 'active_support/core_ext/object/to_json'
+  require 'active_support/core_ext/object/blank'
+  require 'active_support/inflector'
+rescue LoadError
+  require 'activesupport'
+end
+
+# 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 things first because our other classes
+# depend on them.
+require File.join(base_dir, 'report')
+require File.join(base_dir, 'generator')
+require File.join(base_dir, 'graph')
+require 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.join(MetricFu::LIB_ROOT, '..', 'tasks', 'metric_fu.rake')
+end
+
+# Now load everything else that's in the directory
+Dir[File.join(base_dir, '*.rb')].each{|l| require l }
+Dir[File.join(generator_dir, '*.rb')].each {|l| require l }
+Dir[File.join(template_dir, 'standard/*.rb')].each {|l| require l}
+Dir[File.join(template_dir, 'awesome/*.rb')].each {|l| require l}
+require graph_dir + "/grapher"
+Dir[File.join(graph_dir, '*.rb')].each {|l| require l}
+Dir[File.join(graph_dir, 'engines', '*.rb')].each {|l| require l}

data/lib/templates/awesome/awesome_template.rb

@@ -0,0 +1,73 @@
+require 'fileutils'
+require 'syntax/convertors/html'
+
+class AwesomeTemplate < MetricFu::Template
+
+  def write
+    # Getting rid of the crap before and after the project name from integrity
+    @name = File.basename(Dir.pwd).gsub(/^\w+-|-\w+$/, "")
+
+    # Copy Bluff javascripts to output directory
+    Dir[File.join(this_directory, '..', 'javascripts', '*')].each do |f|
+      FileUtils.copy(f, File.join(MetricFu.output_directory, File.basename(f)))
+    end
+
+    report.each_pair do |section, contents|
+      if template_exists?(section)
+        create_instance_var(section, contents)
+        create_instance_var(:per_file_data, per_file_data)
+        @html = erbify(section)
+        html = erbify('layout')
+        fn = output_filename(section)
+        MetricFu.report.save_output(html, MetricFu.output_directory, fn)
+      end
+    end
+
+    # Instance variables we need should already be created from above
+    if template_exists?('index')
+      @html = erbify('index')
+      html = erbify('layout')
+      fn = output_filename('index')
+      MetricFu.report.save_output(html, MetricFu.output_directory, fn)
+    end
+
+    write_file_data
+  end
+
+  def write_file_data
+    convertor = Syntax::Convertors::HTML.for_syntax('ruby')
+
+    per_file_data.each_pair do |file, lines|
+      data = File.open(file, 'r').readlines
+      fn = "#{file.gsub(%r{/}, '_')}.html"
+
+      out = "<html><head><style>#{inline_css('css/syntax.css')}</style></head><body>"
+      out << "<table cellpadding='0' cellspacing='0' class='ruby'>"
+      data.each_with_index do |line, idx|
+        out << "<tr><td valign='top'><small>#{idx + 1}</small></td>"
+        out << "<td valign='top'>"
+        if lines.has_key?((idx + 1).to_s)
+          out << "<ul>"
+          lines[(idx + 1).to_s].each do |problem|
+            out << "<li>#{problem[:description]} &raquo; #{problem[:type]}</li>"
+          end
+          out << "</ul>"
+        else
+          out << "&nbsp;"
+        end
+        out << "</td>"
+        line_for_display = MetricFu.configuration.syntax_highlighting ? convertor.convert(line) : line
+        out << "<td valign='top'><a name='line#{idx + 1}'>#{line_for_display}</a></td>"
+        out << "</tr>"
+      end
+      out << "<table></body></html>"
+
+      MetricFu.report.save_output(out, MetricFu.output_directory, fn)
+    end
+  end
+
+  def this_directory
+    File.dirname(__FILE__)
+  end
+end
+