goldstar-metric_fu 1.5.1.1

data/lib/generators/roodi.rb

@@ -0,0 +1,27 @@
+module MetricFu
+  class Roodi < Generator
+
+    def emit
+      files_to_analyze = MetricFu.roodi[:dirs_to_roodi].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      files = remove_excluded_files(files_to_analyze.flatten)
+      config = MetricFu.roodi[:roodi_config] ? "-config=#{MetricFu.roodi[:roodi_config]}" : ""
+      @output = `roodi #{config} #{files.join(" ")}`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n").map{|m| m.split(" - ") }
+      total = @matches.pop
+      @matches.reject! {|array| array.empty? }
+      @matches.map! do |match|
+        file, line = match[0].split(':')
+        problem = match[1]
+        {:file => file, :line => line, :problem => problem}
+      end
+      @roodi_results = {:total => total, :problems => @matches}
+    end
+
+    def to_h
+      {:roodi => @roodi_results}
+    end
+  end
+end

data/lib/generators/saikuro.rb

@@ -0,0 +1,224 @@
+module MetricFu
+ 
+  class Saikuro < Generator
+
+    def emit 
+      options_string = MetricFu.saikuro.inject("") do |options, option| 
+        options + "--#{option.join(' ')} " unless option == :input_directory 
+      end 
+      
+      MetricFu.saikuro[:input_directory].each do |input_dir| 
+        options_string += "--input_directory #{input_dir} " 
+      end 
+      sh %{saikuro #{options_string}} do |ok, response| 
+        unless ok 
+          puts "Saikuro failed with exit status: #{response.exitstatus}" 
+          exit 1 
+        end 
+      end 
+    end 
+
+    def format_directories
+      dirs = MetricFu.saikuro[:input_directory].join(" | ")
+      "\"#{dirs}\""
+    end
+ 
+    def analyze
+      @files = sort_files(assemble_files)
+      @classes = sort_classes(assemble_classes(@files))
+      @meths = sort_methods(assemble_methods(@files))
+    end
+ 
+    def to_h
+      files = @files.map do |file|
+        my_file = file.to_h
+        my_file[:filename] = file.filename
+        my_file
+      end
+      {:saikuro => {:files => files,
+                    :classes => @classes.map {|c| c.to_h},
+                    :methods => @meths.map {|m| m.to_h}
+                   }
+      }
+    end
+    
+    private
+    def sort_methods(methods)
+      methods.sort_by {|method| method.complexity.to_i}.reverse
+    end
+    
+    def assemble_methods(files)
+      methods = []
+      files.each do |file|
+        file.elements.each do |element|
+          element.defs.each do |defn|
+            defn.name = "#{element.name}##{defn.name}"
+            methods << defn
+          end
+        end
+      end
+      methods
+    end
+    
+    def sort_classes(classes)
+      classes.sort_by {|k| k.complexity.to_i}.reverse
+    end
+    
+    def assemble_classes(files)
+      files.map {|f| f.elements}.flatten
+    end
+    
+    def sort_files(files)
+      files.sort_by do |file|
+        file.elements.
+             max {|a,b| a.complexity.to_i <=> b.complexity.to_i}.
+             complexity.to_i
+      end.reverse
+    end
+    
+    def assemble_files
+      files = []
+      Dir.glob("#{metric_directory}/**/*.html").each do |path|
+        if Saikuro::SFile.is_valid_text_file?(path)
+          file = Saikuro::SFile.new(path)
+          if file
+            files << file
+          end
+        end
+      end
+      files
+    end
+    
+  end
+ 
+  class Saikuro::SFile
+ 
+    attr_reader :elements
+
+    def initialize(path)
+      @path = path
+      @file_handle = File.open(@path, "r")
+      @elements = []
+      get_elements
+    ensure
+      @file_handle.close if @file_handle
+    end
+ 
+    def self.is_valid_text_file?(path)
+      File.open(path, "r") do |f|
+        if f.eof? || !f.readline.match(/--/)
+          return false
+        else
+          return true
+        end
+      end
+    end
+ 
+    def filename
+      File.basename(@path, '_cyclo.html')
+    end
+ 
+    def to_h
+      merge_classes
+      {:classes => @elements}
+    end
+ 
+    def get_elements
+      begin
+        while (line = @file_handle.readline) do
+          return [] if line.nil? || line !~ /\S/
+          element ||= nil
+          if line.match /START/
+            unless element.nil?
+              @elements << element
+              element = nil
+            end
+            line = @file_handle.readline
+            element = Saikuro::ParsingElement.new(line)
+          elsif line.match /END/
+            @elements << element if element
+            element = nil
+          else
+            element << line if element
+          end
+        end
+      rescue EOFError
+        nil
+      end
+    end
+ 
+ 
+    def merge_classes
+      new_elements = []
+      get_class_names.each do |target_class|
+        elements = @elements.find_all {|el| el.name == target_class }
+        complexity = 0
+        lines = 0
+        defns = []
+        elements.each do |el|
+          complexity += el.complexity.to_i
+          lines += el.lines.to_i
+          defns << el.defs
+        end
+ 
+        new_element = {:class_name => target_class,
+                       :complexity => complexity,
+                       :lines => lines,
+                       :methods => defns.flatten.map {|d| d.to_h}}
+        new_element[:methods] = new_element[:methods].
+                                sort_by {|x| x[:complexity] }.
+                                reverse
+ 
+        new_elements << new_element
+      end
+      @elements = new_elements if new_elements
+    end
+ 
+    def get_class_names
+      class_names = []
+      @elements.each do |element|
+        unless class_names.include?(element.name)
+          class_names << element.name
+        end
+      end
+      class_names
+    end
+ 
+  end
+ 
+  class Saikuro::ParsingElement
+    TYPE_REGEX=/Type:(.*) Name/
+    NAME_REGEX=/Name:(.*) Complexity/
+    COMPLEXITY_REGEX=/Complexity:(.*) Lines/
+    LINES_REGEX=/Lines:(.*)/
+ 
+    attr_reader :complexity, :lines, :defs, :element_type
+    attr_accessor :name
+ 
+    def initialize(line)
+      @line = line
+      @element_type = line.match(TYPE_REGEX)[1].strip
+      @name = line.match(NAME_REGEX)[1].strip
+      @complexity = line.match(COMPLEXITY_REGEX)[1].strip
+      @lines = line.match(LINES_REGEX)[1].strip
+      @defs = []
+    end
+ 
+    def <<(line)
+      @defs << Saikuro::ParsingElement.new(line)
+    end
+ 
+    def to_h
+      base = {:name => @name, :complexity => @complexity.to_i, :lines => @lines.to_i}
+      unless @defs.empty?
+        defs = @defs.map do |my_def|
+          my_def = my_def.to_h
+          my_def.delete(:defs)
+          my_def
+        end
+        base[:defs] = defs
+      end
+      return base
+    end
+  end
+end

data/lib/generators/stats.rb

@@ -0,0 +1,59 @@
+module MetricFu
+
+  class Stats < Generator
+
+    def emit
+      `rake stats > #{metric_directory + '/stats.txt'}`
+    end
+
+    def analyze
+      output = File.open(metric_directory + '/stats.txt').read
+      lines = remove_noise(output)
+
+      @stats = {}
+      
+      set_global_stats(lines.pop)
+      set_granular_stats(lines)
+
+      @stats
+    end
+
+    def to_h
+      {:stats => @stats}
+    end
+    
+    private
+    
+    def remove_noise(output)
+      lines = output.split("\n")
+      lines = lines.find_all {|line| line[0].chr != "+" }
+      lines = lines.find_all {|line| line[0].chr != "(" }
+      lines.shift
+      lines
+    end
+    
+    def set_global_stats(totals)
+      totals = totals.split("  ").find_all {|el| ! el.empty? }
+      @stats[:codeLOC] = totals[0].match(/\d.*/)[0].to_i
+      @stats[:testLOC] = totals[1].match(/\d.*/)[0].to_i
+      @stats[:code_to_test_ratio] = totals[2].match(/1\:(\d.*)/)[1].to_f
+    end
+    
+    def set_granular_stats(lines)
+      @stats[:lines] = lines.map do |line|
+        elements = line.split("|")
+        elements.map! {|el| el.strip }
+        elements = elements.find_all {|el| ! el.empty? }
+        info_line = {}
+        info_line[:name] = elements.shift
+        elements.map! {|el| el.to_i }
+        [:lines, :loc, :classes, :methods, 
+         :methods_per_class, :loc_per_method].each do |sym|
+          info_line[sym] = elements.shift
+        end
+        info_line
+      end
+    end
+
+  end
+end

data/lib/graphs/engines/bluff.rb

@@ -0,0 +1,113 @@
+require 'active_support'
+
+module MetricFu
+  class Grapher
+    BLUFF_GRAPH_SIZE = "1000x600"
+    BLUFF_DEFAULT_OPTIONS = <<-EOS
+      var g = new Bluff.Line('graph', "#{BLUFF_GRAPH_SIZE}");
+      g.theme_37signals();
+      g.tooltips = true;
+      g.title_font_size = "24px"
+      g.legend_font_size = "12px"
+      g.marker_font_size = "10px"
+    EOS
+  end
+  
+  class FlayBluffGrapher < FlayGrapher
+    def graph!
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Flay: duplication';
+        g.data('flay', [#{@flay_score.join(',')}]);
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'flay.js'), 'w') {|f| f << content }
+    end
+  end
+
+  class FlogBluffGrapher < FlogGrapher
+    def graph!
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Flog: code complexity';
+        g.data('average', [#{@flog_average.join(',')}]);
+        g.data('top 5% average', [#{@top_five_percent_average.join(',')}])
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'flog.js'), 'w') {|f| f << content }
+    end
+  end
+
+  class RcovBluffGrapher < RcovGrapher
+    def graph!
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Rcov: code coverage';
+        g.data('rcov', [#{@rcov_percent.join(',')}]);
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'rcov.js'), 'w') {|f| f << content }
+    end
+  end
+
+  class ReekBluffGrapher < ReekGrapher
+    def graph!
+      legend = @reek_count.keys.sort
+      data = ""
+      legend.each do |name|
+        data += "g.data('#{name}', [#{@reek_count[name].join(',')}])\n"
+      end
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Reek: code smells';
+        #{data}
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'reek.js'), 'w') {|f| f << content }
+    end
+  end
+
+  class RoodiBluffGrapher < RoodiGrapher
+    def graph!
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Roodi: design problems';
+        g.data('roodi', [#{@roodi_count.join(',')}]);
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'roodi.js'), 'w') {|f| f << content }
+    end
+  end
+
+  class StatsBluffGrapher < StatsGrapher
+    def graph!
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Stats: LOC & LOT';
+        g.data('LOC', [#{@loc_counts.join(',')}]);
+        g.data('LOT', [#{@lot_counts.join(',')}])
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'stats.js'), 'w') {|f| f << content }
+    end
+  end
+
+  class RailsBestPracticesBluffGrapher < RailsBestPracticesGrapher
+    def graph!
+      content = <<-EOS
+        #{BLUFF_DEFAULT_OPTIONS}
+        g.title = 'Rails Best Practices: design problems';
+        g.data('rails_best_practices', [#{@rails_best_practices_count.join(',')}]);
+        g.labels = #{@labels.to_json};
+        g.draw();
+      EOS
+      File.open(File.join(MetricFu.output_directory, 'rails_best_practices.js'), 'w') {|f| f << content }
+    end
+  end
+end

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