edouard-metric_fu 1.0.3.2 → 1.0.3.3

data/lib/generators/flay.rb

@@ -0,0 +1,29 @@
+require 'generator'
+module MetricFu
+  
+  class Flay < Generator
+
+    def emit
+      files_to_flay = MetricFu.flay[:dirs_to_flay].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      @output = `flay #{files_to_flay.join(" ")}`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n\n").map{|m| m.split("\n  ") }
+    end
+
+    def to_h
+      target = []
+      total_score = @matches.shift.first.split('=').last.strip
+      @matches.each do |problem|
+        reason = problem.shift.strip
+        lines_info = problem.map do |full_line|
+          name, line = full_line.split(":")
+          {:name => name.strip, :line => line.strip}
+        end
+        target << [:reason => reason, :matches => lines_info]
+      end
+      {:flay => {:total_score => total_score, :matches => target.flatten}}
+    end
+  end
+end

data/lib/generators/flog.rb

@@ -0,0 +1,127 @@
+module MetricFu
+
+  class Flog < Generator
+    attr_reader :pages
+
+    SCORE_FORMAT = "%0.2f"
+    METHOD_LINE_REGEX = /(\d+\.\d+):\s+([A-Za-z:]+#.*)/
+    OPERATOR_LINE_REGEX = /\s*(\d+\.\d+):\s(.*)$/
+
+    def emit
+      metric_dir = MetricFu::Flog.metric_directory
+      MetricFu.flog[:dirs_to_flog].each do |directory|
+        Dir.glob("#{directory}/**/*.rb").each do |filename|
+          output_dir = "#{metric_dir}/#{filename.split("/")[0..-2].join("/")}"
+          mkdir_p(output_dir, :verbose => false) unless File.directory?(output_dir)
+          if MetricFu::MD5Tracker.file_changed?(filename, metric_dir)
+            `flog -ad #{filename} > #{metric_dir}/#{filename.split('.')[0]}.txt`
+          end
+        end
+      end
+    rescue LoadError
+      if RUBY_PLATFORM =~ /java/
+        puts 'running in jruby - flog tasks not available'
+      else
+        puts 'sudo gem install flog # if you want the flog tasks'
+      end
+    end
+
+    def parse(text)
+      summary, methods_summary = text.split "\n\n"
+      score, average = summary.split("\n").map {|line| line[OPERATOR_LINE_REGEX, 1]}
+      return nil unless score && methods_summary
+      page = Flog::Page.new(score, average)
+      methods_summary.each_line do |method_line|
+        if match = method_line.match(METHOD_LINE_REGEX)
+         page.scanned_methods << ScannedMethod.new(match[2], match[1])
+        elsif match = method_line.match(OPERATOR_LINE_REGEX)
+          return if page.scanned_methods.empty?
+          page.scanned_methods.last.operators << Operator.new(match[1], match[2])
+        end
+      end
+      page
+    end
+
+    def analyze
+      @pages = []
+      flog_results.each do |path|
+        page = parse(open(path, "r") { |f| f.read })
+        if page
+          page.path = path.sub(metric_directory, "").sub(".txt", ".rb") 
+          @pages << page
+        end
+      end
+    end
+
+    def to_h
+      number_of_methods = @pages.inject(0) {|count, page| count += page.scanned_methods.size}
+      total_flog_score = @pages.inject(0) {|total, page| total += page.score}
+      sorted_pages = @pages.sort_by {|page| page.score }.reverse 
+      {:flog => { :total => total_flog_score,
+                  :average => round_to_tenths(total_flog_score/number_of_methods),
+                  :pages => sorted_pages.map {|page| page.to_h}}}
+    end
+    
+    def flog_results
+      Dir.glob("#{metric_directory}/**/*.txt")
+    end
+  
+    class Operator
+      attr_accessor :score, :operator
+
+      def initialize(score, operator)
+        @score = score.to_f
+        @operator = operator
+      end
+    
+      def to_h
+        {:score => @score, :operator => @operator}
+      end
+    end  
+
+    class ScannedMethod
+      attr_accessor :name, :score, :operators
+
+      def initialize(name, score, operators = [])
+        @name = name
+        @score = score.to_f
+        @operators = operators
+      end
+
+      def to_h
+        {:name => @name,
+         :score => @score,
+         :operators => @operators.map {|o| o.to_h}}
+      end
+    end  
+  
+  end
+
+  class Flog::Page < MetricFu::Generator
+    attr_accessor :path, :score, :scanned_methods, :average_score
+
+    def initialize(score, average_score, scanned_methods = [])
+      @score = score.to_f
+      @scanned_methods = scanned_methods
+      @average_score = average_score.to_f
+    end
+
+    def filename 
+      File.basename(path, ".txt") 
+    end
+
+    def to_h
+      {:score => @score, 
+       :scanned_methods => @scanned_methods.map {|sm| sm.to_h},
+       :highest_score => highest_score,
+       :average_score => average_score,
+       :path => path}
+    end
+
+    def highest_score
+      scanned_methods.inject(0) do |highest, m|
+        m.score > highest ? m.score : highest
+      end
+    end
+  end  
+end

data/lib/generators/rcov.rb

@@ -0,0 +1,77 @@
+require 'enumerator'
+
+module MetricFu
+
+  class Rcov < Generator
+    NEW_FILE_MARKER =  ("=" * 80) + "\n"
+
+
+    class Line
+      attr_accessor :content, :was_run
+
+      def initialize(content, was_run)
+        @content = content
+        @was_run = was_run
+      end
+
+      def to_h
+        {:content => @content, :was_run => @was_run}
+      end
+    end
+
+    def emit
+      begin
+        FileUtils.rm_rf(MetricFu::Rcov.metric_directory, :verbose => false)
+        Dir.mkdir(MetricFu::Rcov.metric_directory)
+        test_files = FileList[*MetricFu.rcov[:test_files]].join(' ')
+        rcov_opts = MetricFu.rcov[:rcov_opts].join(' ')
+        output = ">> #{MetricFu::Rcov.metric_directory}/rcov.txt"
+        `rcov --include-file #{test_files}  #{rcov_opts} #{output}`
+      rescue LoadError
+        if RUBY_PLATFORM =~ /java/
+          puts 'running in jruby - rcov tasks not available'
+        else
+          puts 'sudo gem install rcov # if you want the rcov tasks'
+        end
+      end
+    end
+
+
+    def analyze
+      output = File.open(MetricFu::Rcov.metric_directory + '/rcov.txt').read
+      output = output.split(NEW_FILE_MARKER)
+      # Throw away the first entry - it's the execution time etc.
+      output.shift
+      files = {}
+      output.each_slice(2) {|out| files[out.first.strip] = out.last}
+      files.each_pair {|fname, content| files[fname] = content.split("\n") }
+      files.each_pair do |fname, content|
+        content.map! do |raw_line|
+          if raw_line.match(/^!!/)
+            line = Line.new(raw_line.gsub('!!', '  '), false).to_h
+          else
+            line = Line.new(raw_line, true).to_h
+          end
+        end
+        files[fname] = {:lines => content}
+      end
+
+      # Calculate the percentage of lines run in each file
+      @global_total_lines = 0
+      @global_total_lines_run = 0
+      files.each_pair do |fname, content|
+        lines = content[:lines]
+        @global_total_lines_run += lines_run = lines.find_all {|line| line[:was_run] == true }.length
+        @global_total_lines += total_lines = lines.length
+        percent_run = ((lines_run.to_f / total_lines.to_f) * 100).round
+        files[fname][:percent_run] = percent_run 
+      end
+      @rcov = files
+    end
+
+    def to_h
+      global_percent_run = ((@global_total_lines_run.to_f / @global_total_lines.to_f) * 100)
+      {:rcov => @rcov.merge({:global_percent_run => round_to_tenths(global_percent_run) })}   
+    end
+  end
+end

data/lib/generators/reek.rb

@@ -0,0 +1,32 @@
+module MetricFu
+  
+  class Reek < Generator
+    REEK_REGEX = /^(\S+) (.*) \((.*)\)$/
+
+    def emit
+      files_to_reek = MetricFu.reek[:dirs_to_reek].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      @output = `reek #{files_to_reek.join(" ")}`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n\n").map{|m| m.split("\n") }
+      @matches = @matches.map do |match|
+        file_path = match.shift.split('--').first
+        file_path = file_path.gsub('"', ' ').strip
+        code_smells = match.map do |smell|
+          match_object = smell.match(REEK_REGEX)
+          next unless match_object
+          {:method => match_object[1].strip,
+           :message => match_object[2].strip,
+           :type => match_object[3].strip}
+        end.compact
+        {:file_path => file_path, :code_smells => code_smells}
+      end
+    end
+
+    def to_h
+      {:reek => {:matches => @matches}}
+    end
+
+  end
+end

data/lib/generators/roodi.rb

@@ -0,0 +1,24 @@
+module MetricFu
+  class Roodi < Generator
+    def emit
+      files_to_analyze = MetricFu.roodi[:dirs_to_roodi].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      @output = `roodi #{files_to_analyze.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,211 @@
+module MetricFu
+
+class Saikuro < Generator
+
+
+  def emit
+    relative_path = [File.dirname(__FILE__), '..', '..', 
+                     'vendor', 'saikuro', 'saikuro.rb']
+    saikuro = File.expand_path(File.join(relative_path))
+    
+    format_directories
+    
+    options_string = MetricFu.saikuro.inject("") do |options, option|
+      options + "--#{option.join(' ')} " 
+    end
+    
+    sh %{ruby "#{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 = "\"#{dirs}\""
+    MetricFu.saikuro[:input_directory] = dirs
+  end
+
+  def analyze
+    @files = []
+    saikuro_results.each do |path|
+      if Saikuro::SFile.is_valid_text_file?(path)
+        file = Saikuro::SFile.new(path) 
+        if file 
+          @files << file 
+        end
+      end
+    end
+    @files = @files.sort_by do |file|
+      file.elements.
+           max {|a,b| a.complexity.to_i <=> b.complexity.to_i}.
+           complexity.to_i
+    end
+    @files.reverse!
+    klasses = []
+    @files.each {|f| klasses << f.elements}
+    klasses.flatten!
+    @classes = klasses.sort_by {|k| k.complexity.to_i}
+    @classes.reverse!
+    meths = []
+    @files.each {|f| 
+      f.elements.each {|el|
+        el.defs.each {|defn|
+          defn.name = "#{el.name}##{defn.name}"
+          meths <<  defn}
+      }
+    }
+    meths = meths.sort_by {|meth| meth.complexity.to_i}
+    @meths = meths.reverse
+    
+  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
+
+  def saikuro_results
+    Dir.glob("#{metric_directory}/**/*.html")
+  end
+
+  private
+
+
+end
+
+class Saikuro::SFile
+
+  attr_reader :elements
+  
+  def initialize(path)
+    @path = path
+    @file_handle = File.open(@path, "r")
+    @elements = []
+    get_elements
+  end
+
+  def self.is_valid_text_file?(path)
+    File.open(path, "r") do |f|
+      unless 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
+        if line.match /START/
+          line = @file_handle.readline
+          element = Saikuro::ParsingElement.new(line)
+        elsif line.match /END/
+          @elements << element 
+          element = nil
+        else
+          element << line
+        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,43 @@
+module MetricFu
+
+  class Stats < Generator
+
+    def emit
+      `rake stats > #{metric_directory + '/stats.txt'}`
+    end
+
+    def analyze
+      output = File.open(metric_directory + '/stats.txt').read
+      output = output.split("\n")
+      output = output.find_all {|line| line[0].chr != "+" }
+      output = output.find_all {|line| line[0].chr != "(" }
+      output.shift
+      totals = output.pop
+      totals = totals.split("  ").find_all {|el| ! el.empty? }
+      @stats = {}
+      @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
+      
+      @stats[:lines] = output.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
+      @stats
+    end
+
+    def to_h
+      {:stats => @stats}
+    end
+
+  end
+end

data/lib/metric_fu.rb

@@ -0,0 +1,21 @@
+# 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')
+
+# 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')
+
+# Load the rakefile so users of the gem get the default metric_fu task
+load File.join(MetricFu::LIB_ROOT, '..', 'tasks', 'metric_fu.rake')
+
+# 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}

data/lib/templates/awesome/awesome_template.rb

@@ -0,0 +1,30 @@
+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+$/, "")
+
+    report.each_pair do |section, contents|
+      if template_exists?(section)
+        create_instance_var(section, contents)
+        @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
+  end
+
+  def this_directory
+    File.dirname(__FILE__)
+  end
+end
+

data/lib/templates/awesome/churn.html.erb

@@ -0,0 +1,19 @@
+<h3>Source Control Churn Results</h3>
+<p>Files that change a lot in your project may be bad a sign.
+  This task uses your source control log to identify those files.
+  </p>
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Times Changed</th>
+  </tr>
+  <% count = 0 %>
+  <% @churn[:changes].each do |change| %>
+    <tr>
+      <td><%= change[:file_path] %></td>
+      <td><%= change[:times_changed] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<p>Generated on <%= Time.now.localtime %></p>	

data/lib/templates/awesome/default.css

@@ -0,0 +1,62 @@
+table {
+  margin-top: 20px;
+  border-collapse: collapse;
+  border: 1px solid #666;
+  background: #fff;
+  margin-bottom: 20px;
+}
+
+table tr.light {
+   background: #fff;
+}
+
+table tr.dark {
+  background: #f9f9f9;
+}
+
+table td, table th {
+  padding: 4px;
+  font-size: 11px;
+}
+table th {
+  text-align: center;
+  color: #337022;
+  background: #DDFFCC;
+  font-weight: bold;
+  border: #99D688 1px solid;
+}
+
+table td {
+  border: #d0d0d0 1px solid;
+}
+
+table td.score {
+  text-align: right;
+}
+
+.warning {
+  background: yellow;
+}
+.rcov_code td {
+  border-bottom: 1px solid #ddd ;
+  padding: 0;
+  margin: 0;
+}
+.rcov_code tr {
+  border: 0px;
+  padding:0px;
+  margin: 0px;
+}
+.rcov_code pre {
+  border: 0px;
+  padding: 0px;
+  margin: 0px;
+}
+.rcov_run {}
+.rcov_not_run {
+  background-color: #d88;
+}
+.rcov_overflow {
+  overflow: auto;
+  font-size: 50%;
+}

data/lib/templates/awesome/flay.html.erb

@@ -0,0 +1,22 @@
+<h3>Flay Results</h3>
+<h4>Total Score (lower is better): <%= @flay[:total_score] %></h4>
+<p><a href='http://ruby.sadi.st/Flay.html'>Flay</a> analyzes ruby code for structural similarities.</p>  
+<table>
+  <tr>
+    <th>Files</th>
+    <th>Matches</th>		  
+  </tr>
+  <% count = 0 %>
+  <% @flay[:matches].each do |match| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td>
+        <% match[:matches].each do |file| %>
+          <%= file[:name] %>:<%= file[:line] %><br />
+        <% end %>
+      </td>
+      <td><%= match[:reason] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<p>Generated on <%= Time.now.localtime %></p>