cdd-metric_fu 1.3.1

data/lib/base/graph.rb

@@ -0,0 +1,47 @@
+module MetricFu
+
+  def self.graph
+    @graph ||= Graph.new
+  end
+
+  class Graph
+    
+    attr_accessor :clazz
+    
+    def initialize
+      self.clazz = []
+    end
+    
+    def add(graph_type, graph_engine)
+      grapher_name = graph_type.to_s.capitalize + graph_engine.to_s.capitalize + "Grapher"
+      self.clazz.push MetricFu.const_get(grapher_name).new
+    end
+    
+    
+    def generate
+      return if self.clazz.empty?
+      puts "Generating graphs"
+      graphed_reports.each { |report| process_report(report) }
+      self.clazz.each { |grapher| grapher.graph! }
+    end
+    
+    private
+    def process_report(report)
+      puts "Processing #{report}"
+      date = date_for(report)
+      metrics = YAML::load(File.open(report))
+      self.clazz.each { |grapher| grapher.get_metrics(metrics, date) }
+    end
+    
+    def date_for(report)
+      date = File.basename(report, ".yml") # yyyy/mm/dd
+      "#{date[4..5].to_i}/#{date[6..7].to_i}"
+    end
+    
+    def graphed_reports
+      reports = Dir[File.join(MetricFu.data_directory, '*.yml')].sort
+      from = reports.size-MetricFu.graph_period < 0 ? 0 : reports.size-MetricFu.graph_period
+      reports[from..-1]
+    end
+  end
+end

data/lib/base/md5_tracker.rb

@@ -0,0 +1,52 @@
+require 'digest/md5'
+require 'fileutils'
+
+module MetricFu
+  class MD5Tracker
+
+    @@unchanged_md5s = []
+
+    class << self
+      def md5_dir(path_to_file, base_dir)
+        File.join(base_dir,
+                  path_to_file.split('/')[0..-2].join('/'))
+      end
+
+      def md5_file(path_to_file, base_dir)
+        File.join(md5_dir(path_to_file, base_dir),
+                  path_to_file.split('/').last.sub(/\.[a-z]+/, '.md5'))
+      end
+
+      def track(path_to_file, base_dir)
+        md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        FileUtils.mkdir_p(md5_dir(path_to_file, base_dir), :verbose => false)
+        f = File.new(md5_file(path_to_file, base_dir), "w")
+        f.puts(md5)
+        f.close
+        md5
+      end
+
+      def file_changed?(path_to_file, base_dir)
+        orig_md5_file = md5_file(path_to_file, base_dir)
+        return !!track(path_to_file, base_dir) unless File.exist?(orig_md5_file)
+
+        current_md5 = ""
+        file = File.open(orig_md5_file, 'r')
+        file.each_line { |line| current_md5 << line }
+        file.close
+        current_md5.chomp!
+
+        new_md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        new_md5.chomp!
+
+        @@unchanged_md5s << path_to_file if new_md5 == current_md5
+
+        return new_md5 != current_md5
+      end
+
+      def file_already_counted?(path_to_file)
+        return @@unchanged_md5s.include?(path_to_file)
+      end
+    end
+  end
+end

data/lib/base/report.rb

@@ -0,0 +1,100 @@
+module MetricFu
+
+  # MetricFu.report memoizes access to a Report object, that will be
+  # used throughout the lifecycle of the MetricFu app.
+  def self.report
+    @report ||= Report.new
+  end
+
+  # = Report
+  #
+  # The Report class is responsible two things:
+  #
+  # It adds information to the yaml report, produced by the system 
+  # as a whole, for each of the generators used in this test run.
+  #
+  # It also handles passing the information from each generator used
+  # in this test run out to the template class set in 
+  # MetricFu::Configuration.
+  class Report
+    
+    # Renders the result of the report_hash into a yaml serialization
+    # ready for writing out to a file.
+    #
+    # @return YAML
+    #   A YAML object containing the results of the report generation 
+    #   process
+    def to_yaml
+      report_hash.to_yaml
+    end
+
+    
+    def report_hash #:nodoc:
+      @report_hash ||= {}
+    end
+
+    # Instantiates a new template class based on the configuration set
+    # in MetricFu::Configuration, or through the MetricFu.config block
+    # in your rake file (defaults to the included AwesomeTemplate),
+    # assigns the report_hash to the report_hash in the template, and
+    # tells the template to to write itself out.
+    def save_templatized_report
+      @template = MetricFu.template_class.new
+      @template.report = report_hash
+      @template.write
+    end
+   
+    # Adds a hash from a passed report, produced by one of the Generator
+    # classes to the aggregate report_hash managed by this hash.
+    #
+    # @param report_type Hash
+    #   The hash to add to the aggregate report_hash
+    def add(report_type)
+      clazz = MetricFu.const_get(report_type.to_s.capitalize)
+      report_hash.merge!(clazz.generate_report)
+    end
+
+    # Saves the passed in content to the passed in directory.  If
+    # a filename is passed in it will be used as the name of the 
+    # file, otherwise it will default to 'index.html'
+    #
+    # @param content String
+    #   A string containing the content (usually html) to be written
+    #   to the file.
+    #
+    # @param dir String
+    #   A dir containing the path to the directory to write the file in.
+    #
+    # @param file String
+    #   A filename to save the path as.  Defaults to 'index.html'.
+    #
+    def save_output(content, dir, file='index.html')
+      open("#{dir}/#{file}", "w") do |f|
+        f.puts content
+      end
+    end
+
+    # Checks to discover whether we should try and open the results
+    # of the report in the browser on this system.  We only try and open
+    # in the browser if we're on OS X and we're not running in a 
+    # CruiseControl.rb environment.  See MetricFu.configuration for more
+    # details about how we make those guesses.
+    #
+    # @return Boolean
+    #   Should we open in the browser or not?
+    def open_in_browser?
+      MetricFu.configuration.platform.include?('darwin') &&
+      ! MetricFu.configuration.is_cruise_control_rb?
+    end
+
+    # Shows 'index.html' from the passed directory in the browser
+    # if we're able to open the browser on this platform.
+    #
+    # @param dir String
+    #   The directory path where the 'index.html' we want to open is  
+    #   stored
+    def show_in_browser(dir)
+      system("open #{dir}/index.html") if open_in_browser?
+    end
+  end
+end

data/lib/generators/churn.rb

@@ -0,0 +1,34 @@
+module MetricFu
+
+  class Churn < Generator
+
+    def initialize(options={})
+      super
+    end
+
+    def self.verify_dependencies!
+      result = `churn --help`
+      raise 'sudo gem install churn # if you want the churn tasks' unless result.match(/churn/)
+    end
+
+    
+    def emit
+      @output = `churn --yaml`
+      yaml_start = @output.index("---")
+      @output = @output[yaml_start...@output.length] if yaml_start
+    end
+
+    def analyze
+      if @output.match(/fatal: Not a git repository/)
+        @churn = [:churn => {}]
+      else
+        @churn = YAML::load(@output)
+      end
+    end
+
+    def to_h
+      {:churn => @churn[:churn]}
+    end
+  end
+
+end

data/lib/generators/flay.rb

@@ -0,0 +1,35 @@
+module MetricFu
+  
+  class Flay < Generator
+
+    def self.verify_dependencies!
+      `flay --help`
+      raise 'sudo gem install flay # if you want the flay tasks' unless $?.success?
+    end
+
+    def emit
+      files_to_flay = MetricFu.flay[:dirs_to_flay].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      files = remove_excluded_files(files_to_flay.flatten)
+      mimimum_score_parameter = MetricFu.flay[:minimum_score] ? "--mass #{MetricFu.flay[:minimum_score]} " : ""
+      @output = `flay #{mimimum_score_parameter}#{files.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,172 @@
+require 'pathname'
+
+module MetricFu
+
+  class Flog < Generator
+    attr_reader :pages
+
+    def self.verify_dependencies!
+      `flog --help`
+      raise 'sudo gem install flog # if you want the flog tasks' unless $?.success?
+    end
+
+    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|
+        directory = "." if directory=='./'
+        files = Dir.glob("#{directory}/**/*.rb")
+        files = remove_excluded_files(files)
+        files.each do |filename|
+          output_dir = "#{metric_dir}/#{filename.split("/")[0..-2].join("/")}"
+          mkdir_p(output_dir, :verbose => false) unless File.directory?(output_dir)
+          pathname         = Pathname.new(filename)
+          if MetricFu::MD5Tracker.file_changed?(filename, metric_dir) 
+		base_name = pathname.basename.to_s.gsub(/\..*$/,'.txt')
+                editted_filename = File.join(pathname.dirname.to_s, base_name)
+         `flog -ad #{filename} > #{metric_dir}/#{editted_filename}`
+          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"
+      return unless summary
+      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") 
+          #don't include old cached flog results for files that no longer exist.
+	  if is_file_current?(page.path.to_s)
+            @pages << page
+          end
+        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.highest_score }.reverse 
+      {:flog => { :total => total_flog_score,
+                  :average => average_score(total_flog_score, number_of_methods),
+                  :pages => sorted_pages.map {|page| page.to_h}}}
+    end
+    
+    private
+
+    def is_file_current?(pathname)
+      pathname        = pathname.gsub(/^\//,'')
+      local_pathname  = "./#{pathname}"
+      exists = false
+
+      MetricFu.flog[:dirs_to_flog].each do |directory|
+      	directory = "." if directory=='./'
+        files = Dir.glob("#{directory}/**/*.rb")
+        if files.include?(pathname) || files.include?(local_pathname)
+          exists = true
+          break
+        end
+      end
+      exists
+    end
+
+    def average_score(total_flog_score, number_of_methods)
+      return 0 if total_flog_score == 0
+      round_to_tenths(total_flog_score/number_of_methods)
+    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, :line
+
+      def initialize(name, score, operators = [])
+        if name.match(/\.rb:\d*/)
+          @line = name.match(/\.rb:\d*/).to_s.sub('.rb:','')
+          name = name.match(/\S*/)
+        end
+        @name = name
+        @score = score.to_f
+        @operators = operators
+      end
+
+      def to_h
+        {:name => @name,
+          :score => @score,
+          :operators => @operators.map {|o| o.to_h},
+          :line => @line}
+      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,82 @@
+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
+      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"
+      puts "** Running the specs/tests in the [#{MetricFu.rcov[:environment]}] environment"
+      `RAILS_ENV=#{MetricFu.rcov[:environment]} rcov #{test_files} #{rcov_opts} #{output}`
+    end
+
+
+    def analyze
+      output = File.open(MetricFu::Rcov.metric_directory + '/rcov.txt').read
+      output = output.split(NEW_FILE_MARKER)
+      
+      output.shift # Throw away the first entry - it's the execution time etc.
+      
+      files = assemble_files(output)
+
+      @global_total_lines = 0
+      @global_total_lines_run = 0
+      
+      @rcov = add_coverage_percentage(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
+    
+    private
+    
+    def assemble_files(output)
+      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
+        content.reject! {|line| line[:content].blank? }
+        files[fname] = {:lines => content}
+      end
+      files
+    end
+    
+    def add_coverage_percentage(files)
+      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
+    end
+    
+  end
+end