mwilden-metric_fu 1.1.1

data/lib/base/generator.rb

@@ -0,0 +1,160 @@
+module MetricFu
+
+  # = Generator
+  #
+  # The Generator class is an abstract class that provides the 
+  # skeleton for producing different types of metrics.
+  #
+  # It drives the production of the metrics through a template 
+  # method - #generate_report(options={}).  This method calls
+  # #emit, #analyze and #to_h in order to produce the metrics.
+  #
+  # To implement a concrete class to generate a metric, therefore,
+  # the class must implement those three methods. 
+  #
+  # * #emit should take care of running the metric tool and 
+  #   gathering its output.  
+  # * #analyze should take care of manipulating the output from
+  #   #emit and making it possible to store it in a programmatic way.
+  # * #to_h should provide a hash representation of the output from
+  #   #analyze ready to be serialized into yaml at some point.
+  #
+  # == Pre-conditions
+  #
+  # Based on the class name of the concrete class implementing a
+  # Generator, the Generator class will create a 'metric_directory'
+  # named after the class under the MetricFu.scratch_directory, where
+  # any output from the #emit method should go.
+  #
+  # It will also create the MetricFu.output_directory if neccessary, and
+  # in general setup the directory structure that the MetricFu system
+  # expects.
+  class Generator
+    attr_reader :report, :template
+
+    def initialize(options={})
+      self.class.verify_dependencies!
+      create_metric_dir_if_missing
+      create_output_dir_if_missing
+      create_data_dir_if_missing
+    end
+    
+    # Creates a new generator and returns the output of the 
+    # #generate_report method.  This is the typical way to 
+    # generate a new MetricFu report. For more information see
+    # the #generate_report instance method.
+    #
+    # @params options Hash
+    #   A currently unused hash to configure the Generator
+    #
+    # @see generate_report
+    def self.generate_report(options={})
+      generator = self.new(options)
+      generator.generate_report
+    end
+
+    # Provides the unqualified class name of an implemented concrete
+    # class, as a string.  For example:
+    #
+    #   class Flay < Generator; end
+    #   klass = Flay.new
+    #   klass.class_name
+    #   > "flay"
+    #
+    # @return String
+    #   The unqualified class name of this concrete class, returned
+    #   as a string.
+    def self.class_name
+      self.to_s.split('::').last.downcase
+    end
+   
+    # Returns the directory where the Generator will write any output
+    def self.metric_directory
+      File.join(MetricFu.scratch_directory, class_name) 
+    end
+
+    def create_metric_dir_if_missing #:nodoc:
+      unless File.directory?(metric_directory)
+        FileUtils.mkdir_p(metric_directory, :verbose => false) 
+      end
+    end
+    
+    def create_output_dir_if_missing #:nodoc:
+      unless File.directory?(MetricFu.output_directory)
+        FileUtils.mkdir_p(MetricFu.output_directory, :verbose => false) 
+      end
+    end
+    
+    def create_data_dir_if_missing #:nodoc:
+      unless File.directory?(MetricFu.data_directory)
+        FileUtils.mkdir_p(MetricFu.data_directory, :verbose => false) 
+      end
+    end
+
+    # @return String
+    #   The path of the metric directory this class is using.
+    def metric_directory
+      self.class.metric_directory
+    end
+
+   
+    # Defines some hook methods for the concrete classes to hook into.
+    %w[emit analyze].each do |meth|
+      define_method("before_#{meth}".to_sym) {}
+      define_method("after_#{meth}".to_sym) {}
+    end
+    define_method("before_to_h".to_sym) {}
+
+    # Provides a template method to drive the production of a metric
+    # from a concrete implementation of this class.  Each concrete
+    # class must implement the three methods that this template method
+    # calls: #emit, #analyze and #to_h.  For more details, see the
+    # class documentation.
+    #
+    # This template method also calls before_emit, after_emit... etc.
+    # methods to allow extra hooks into the processing methods, and help
+    # to keep the logic of your Generators clean.
+    def generate_report
+      %w[emit analyze].each do |meth|
+        send("before_#{meth}".to_sym)
+        send("#{meth}".to_sym)
+        send("after_#{meth}".to_sym)
+      end
+      before_to_h()
+      to_h()
+    end
+
+    def round_to_tenths(decimal)
+      (decimal * 10).round / 10.0 
+    end
+    
+    # Allows subclasses to check for required gems
+    def self.verify_dependencies!
+      true
+    end
+
+    def emit #:nodoc:
+      raise <<-EOF
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more 
+        information.
+      EOF
+    end
+
+    def analyze #:nodoc:
+      raise <<-EOF
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more 
+        information.
+      EOF
+    end
+    
+    def to_graph #:nodoc:
+      raise <<-EOF
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more 
+        information.
+      EOF
+    end
+  end
+end

data/lib/base/graph.rb

@@ -0,0 +1,37 @@
+module MetricFu
+
+  def self.graph
+    @graph ||= Graph.new
+  end
+
+  class Graph
+    
+    attr_accessor :clazz
+    
+    def initialize
+      self.clazz = []
+    end
+    
+    def add(graph_type)
+      grapher_name = graph_type.to_s.capitalize + "Grapher"
+      self.clazz.push MetricFu.const_get(grapher_name).new
+    end
+    
+    
+    def generate
+      puts "Generating graphs"
+      Dir[File.join(MetricFu.data_directory, '*.yml')].sort.each do |metric_file|
+        puts "Generating graphs for #{metric_file}"
+        date = metric_file.split('/')[3].split('.')[0]
+        metrics = YAML::load(File.open(metric_file))
+        
+        self.clazz.each do |grapher|
+          grapher.get_metrics(metrics, date)
+        end
+      end
+      self.clazz.each do |grapher|
+        grapher.graph!
+      end
+    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,91 @@
+require 'chronic'
+require 'generator'
+module MetricFu
+  
+  class Churn < Generator
+
+    
+    def initialize(options={})
+      super
+      if self.class.git?
+        @source_control = Git.new(MetricFu.churn[:start_date])
+      elsif File.exist?(".svn")
+        @source_control = Svn.new(MetricFu.churn[:start_date])
+      else
+        raise "Churning requires a subversion or git repo"
+      end
+      @minimum_churn_count = MetricFu.churn[:minimum_churn_count] || 5
+    end
+
+    def self.git?
+      system("git branch")
+    end
+    
+    def emit
+      @changes = parse_log_for_changes.reject {|file, change_count| change_count < @minimum_churn_count}
+    end
+
+    def analyze
+      @changes = @changes.to_a.sort {|x,y| y[1] <=> x[1]}
+      @changes = @changes.map {|change| {:file_path => change[0], :times_changed => change[1] }}
+    end
+
+    def to_h
+      {:churn => {:changes => @changes}}
+    end
+
+    private
+
+    def parse_log_for_changes
+      changes = {}
+
+      logs = @source_control.get_logs
+      logs.each do |line|
+        changes[line] ? changes[line] += 1 : changes[line] = 1
+      end
+      changes
+    end
+
+
+    class SourceControl
+      def initialize(start_date=nil)
+        @start_date = start_date
+      end
+    end
+
+    class Git < SourceControl
+      def get_logs
+        `git log #{date_range} --name-only --pretty=format:`.split(/\n/).reject{|line| line == ""}
+      end
+
+      private
+      def date_range
+        if @start_date
+          date = Chronic.parse(@start_date)
+          "--after=#{date.strftime('%Y-%m-%d')}"
+        end
+      end
+
+    end
+
+    class Svn < SourceControl
+      def get_logs
+        `svn log #{date_range} --verbose`.split(/\n/).map { |line| clean_up_svn_line(line) }.compact
+      end
+
+      private
+      def date_range
+        if @start_date
+          date = Chronic.parse(@start_date)
+          "--revision {#{date.strftime('%Y-%m-%d')}}:{#{Time.now.strftime('%Y-%m-%d')}}"
+        end
+      end
+
+      def clean_up_svn_line(line)
+        m = line.match(/\W*[A,M]\W+(\/.*)\b/)
+        m ? m[1] : nil
+      end
+    end
+
+  end
+end

data/lib/generators/flay.rb

@@ -0,0 +1,34 @@
+require 'generator'
+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")] }
+      @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,140 @@
+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|
+        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"
+      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") 
+          @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 => average_score(total_flog_score, number_of_methods),
+                  :pages => sorted_pages.map {|page| page.to_h}}}
+    end
+    
+    private
+    
+    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
+
+      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,87 @@
+require 'enumerator'
+
+module MetricFu
+
+  class Rcov < Generator
+    NEW_FILE_MARKER =  ("=" * 80) + "\n"
+
+    def self.verify_dependencies!
+      `flay --help`
+      unless $?.success?
+        if RUBY_PLATFORM =~ /java/
+          raise 'running in jruby - rcov tasks not available'
+        else
+          raise 'sudo gem install rcov # if you want the rcov tasks'
+        end
+      end
+    end
+
+    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