edouard-metric_fu 1.0.2 → 1.0.3

data/lib/base/report.rb

@@ -1,100 +0,0 @@
-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 StandardTemplate) and
-    # assigns the report_hash to the report_hash to the template and
-    # asks itself 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

@@ -1,91 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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 => 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

@@ -1,87 +0,0 @@
-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