goldstar-metric_fu 1.5.1.1

data/lib/base/generator.rb

@@ -0,0 +1,162 @@
+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={})
+      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
+
+    def remove_excluded_files(paths, globs_to_remove = MetricFu.file_globs_to_ignore)
+      files_to_remove = []
+      globs_to_remove.each do |glob|
+        files_to_remove.concat(Dir[glob])
+      end
+      paths - files_to_remove
+    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 = 0.0 if decimal.to_s.eql?('NaN')
+      (decimal * 10).round / 10.0 
+    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,39 @@
+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.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } + 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"
+      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]
+        y, m, d = date[0..3].to_i, date[4..5].to_i, date[6..7].to_i
+        metrics = YAML::load(File.open(metric_file))
+        
+        self.clazz.each do |grapher|
+          grapher.get_metrics(metrics, "#{m}/#{d}")
+        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.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase })
+      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,28 @@
+module MetricFu
+
+  class Churn < Generator
+
+    def initialize(options={})
+      super
+    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,31 @@
+require 'flay'
+
+module MetricFu
+  
+  class Flay < Generator
+
+    def emit
+      mimimum_score_parameter = MetricFu.flay[:minimum_score] ? "--mass #{MetricFu.flay[:minimum_score]} " : ""
+
+      @output = `flay #{mimimum_score_parameter} #{MetricFu.flay[:dirs_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,98 @@
+require 'pathname'
+require 'optparse'
+require 'flog'
+
+module MetricFu
+
+  class Flog < Generator
+
+    def emit
+      files = []
+      MetricFu.flog[:dirs_to_flog].each do |directory|
+        directory = "." if directory=='./'
+        dir_files = Dir.glob("#{directory}/**/*.rb")
+        dir_files = remove_excluded_files(dir_files)
+        files += dir_files
+      end
+      options = ::Flog.parse_options ["--all", "--details"]
+
+      @flogger = ::Flog.new options
+      @flogger.flog files
+
+    rescue LoadError
+      if RUBY_PLATFORM =~ /java/
+        puts 'running in jruby - flog tasks not available'
+      end
+    end
+
+    def analyze
+      @method_containers = {}
+      @flogger.calls.each do |full_method_name, operators|
+        container_name = full_method_name.split('#').first
+        path = @flogger.method_locations[full_method_name]
+        if @method_containers[container_name]
+          @method_containers[container_name].add_method(full_method_name, operators, @flogger.totals[full_method_name], path)
+          @method_containers[container_name].add_path(path)
+        else
+          mc = MethodContainer.new(container_name, path)
+          mc.add_method(full_method_name, operators, @flogger.totals[full_method_name], path)
+          @method_containers[container_name] = mc
+        end
+      end
+    end
+
+    def to_h
+      sorted_containers = @method_containers.values.sort_by {|c| c.highest_score}.reverse
+      {:flog => { :total => @flogger.total,
+                  :average => @flogger.average,
+                  :method_containers => sorted_containers.map {|method_container| method_container.to_h}}}
+    end
+
+  end
+
+  class MethodContainer
+    attr_reader :methods
+
+    def initialize(name, path)
+      @name = name
+      add_path path
+      @methods = {}
+    end
+
+    def add_path path
+      return unless path
+      @path ||= path.split(':').first
+    end
+
+    def add_method(full_method_name, operators, score, path)
+      @methods[full_method_name] = {:operators => operators, :score => score, :path => path}
+    end
+
+    def to_h
+      { :name => @name,
+        :path => @path || '',
+        :total_score => total_score,
+        :highest_score => highest_score,
+        :average_score => average_score,
+        :methods => @methods}
+    end
+
+    def highest_score
+      method_scores.max
+    end
+
+    private
+
+    def method_scores
+      @method_scores ||= @methods.values.map {|v| v[:score] }
+    end
+
+    def total_score
+      @total_score ||= method_scores.inject(0) {|sum, score| sum += score}
+    end
+
+    def average_score
+      total_score / method_scores.size.to_f
+    end
+  end
+end

data/lib/generators/rails_best_practices.rb

@@ -0,0 +1,25 @@
+module MetricFu
+  class RailsBestPractices < Generator
+    
+    def emit
+      @output = `rails_best_practices .`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n").map{|m| m.split(" - ") }
+      total = @matches.pop
+      2.times { @matches.pop } # ignore wiki link
+      @matches.reject! {|array| array.empty? }
+      @matches.map! do |match|
+        file, line = match[0].split(':')
+        problem = match[1]
+        {:file => file, :line => line, :problem => problem}
+      end
+      @rails_best_practices_results = {:total => total, :problems => @matches}
+    end
+
+    def to_h
+      {:rails_best_practices => @rails_best_practices_results}
+    end
+  end
+end

data/lib/generators/rcov.rb

@@ -0,0 +1,85 @@
+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
+      unless MetricFu.rcov[:external]
+        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
+    end
+
+
+    def analyze
+      output_file = MetricFu.rcov[:external] ? MetricFu.rcov[:external] : MetricFu::Rcov.metric_directory + '/rcov.txt'
+      output = File.open(output_file).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

data/lib/generators/reek.rb

@@ -0,0 +1,60 @@
+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")] }
+      files = remove_excluded_files(files_to_reek.flatten)
+      config_file_param = MetricFu.reek[:config_file_pattern] ? "--config #{MetricFu.reek[:config_file_pattern]}" : ''
+      @output = `reek #{config_file_param} #{files.join(" ")}`
+      @output = massage_for_reek_12 if reek_12?
+    end
+
+    def reek_12?
+      return false if @output.length == 0
+      (@output =~ /^"/) != 0
+    end
+
+    def massage_for_reek_12
+      section_break = ''
+      @output.split("\n").map do |line|
+        case line
+        when /^  /
+          "#{line.gsub(/^  /, '')}\n"
+        else
+          parts = line.split(" -- ")
+          if parts[1].nil?
+            "#{line}\n"
+          else
+            warnings = parts[1].gsub(/ \(.*\):/, ':')
+            result = "#{section_break}\"#{parts[0]}\" -- #{warnings}\n"
+            section_break = "\n"
+            result
+          end
+        end
+      end.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