nielsm-metric_fu 0.9.1 → 1.1.1

data/lib/metric_fu/base.rb

@@ -1,160 +0,0 @@
-require 'erb'
-module MetricFu
-
-  TEMPLATE_DIR = File.join(File.dirname(__FILE__), '..', 'templates')
-  BASE_DIRECTORY = ENV['CC_BUILD_ARTIFACTS'] || 'tmp/metric_fu'
-  RAILS = File.exist?("config/environment.rb")
-
-  if RAILS
-    CODE_DIRS = ['app', 'lib']
-    DEFAULT_METRICS = [:coverage, :churn, :flog, :flay, :reek, :roodi, :stats, :saikuro ]
-  else
-    CODE_DIRS = ['lib']
-    DEFAULT_METRICS = [:coverage, :churn, :flog, :flay, :reek, :roodi, :saikuro ]
-  end 
-
-  module Base
-    
-    ######################################################################
-    # Base class for report Generators
-    #
-    class Generator
-
-      def initialize(options={})
-        @base_dir = self.class.metric_dir
-      end
-
-      def self.metric_dir
-        File.join(BASE_DIRECTORY, template_name)        
-      end
-      
-      def self.template_name
-        self.to_s.split('::').last.downcase
-      end      
-
-      def self.generate_report(options={})
-        FileUtils.mkdir_p(metric_dir, :verbose => false) unless File.directory?(metric_dir)
-        self.new(options).generate_report
-      end
-
-      def save_html(content, file='index.html')
-        open("#{@base_dir}/#{file}", "w") do |f|
-          f.puts content
-        end
-      end
-
-      def generate_report
-        save_html(generate_html)
-      end
-
-      def generate_html
-        analyze
-        html = ERB.new(File.read(template_file)).result(binding)
-      end
-      
-      def template_name
-        self.class.template_name
-      end
-
-      def template_file
-        File.join(MetricFu::TEMPLATE_DIR, "#{template_name}.html.erb")
-      end      
-      
-      ########################
-      # Template methods
-      
-      def inline_css(css)
-	      open(File.join(MetricFu::TEMPLATE_DIR, css)) { |f| f.read }      
-      end
-      
-      def link_to_filename(name, line = nil)
-        filename = File.expand_path(name)
-        if PLATFORM['darwin']
-          %{<a href="txmt://open/?url=file://#{filename}&line=#{line}">#{name}:#{line}</a>}
-        else
-          %{<a href="file://#{filename}">#{name}:#{line}</a>}
-        end
-      end
-      
-      def cycle(first_value, second_value, iteration)
-        return first_value if iteration % 2 == 0
-        return second_value
-      end      
-    end
-  end
-  
-  class << self
-    # The Configuration instance used to configure the Rails environment
-    def configuration
-      @@configuration ||= Configuration.new
-    end
-
-    def churn
-      configuration.churn
-    end
-
-    def coverage
-      configuration.coverage
-    end
-
-    def flay
-      configuration.flay
-    end
-
-    def flog
-      configuration.flog
-    end
-
-    def metrics
-      configuration.metrics
-    end
-
-    def open_in_browser?
-      PLATFORM['darwin'] && !ENV['CC_BUILD_ARTIFACTS']
-    end
-    
-    def saikuro
-      configuration.saikuro
-    end
-
-    def reek
-      configuration.reek
-    end    
-
-    def roodi
-      configuration.roodi
-    end
-
-  end
-  
-  class Configuration
-    attr_accessor :churn, :coverage, :flay, :flog, :metrics, :reek, :roodi, :saikuro
-    def initialize
-      raise "Use config.churn instead of MetricFu::CHURN_OPTIONS" if defined? ::MetricFu::CHURN_OPTIONS
-      raise "Use config.flog[:dirs_to_flog] instead of MetricFu::DIRECTORIES_TO_FLOG" if defined? ::MetricFu::DIRECTORIES_TO_FLOG
-      raise "Use config.saikuro instead of MetricFu::SAIKURO_OPTIONS" if defined? ::MetricFu::SAIKURO_OPTIONS      
-      reset      
-    end
-    
-    def self.run()  
-      yield MetricFu.configuration
-    end
-    
-    def reset
-      @churn    =  {}
-      @coverage = { :test_files => ['test/**/*_test.rb', 'spec/**/*_spec.rb'],
-                    :rcov_opts => ["--sort coverage", "--html", "--rails", "--exclude /gems/,/Library/,spec"] }
-      @flay     = { :dirs_to_flay => CODE_DIRS}
-      @flog     = { :dirs_to_flog => CODE_DIRS}
-      @reek     = { :dirs_to_reek => CODE_DIRS}
-      @roodi    = { :dirs_to_roodi => CODE_DIRS}
-      @metrics          = DEFAULT_METRICS
-      @saikuro  = {}
-    end
-    
-    def saikuro=(options)
-      raise "saikuro need to be a Hash" unless options.is_a?(Hash)
-      @saikuro = options
-    end
-  end
-end

data/lib/metric_fu/flay.rb

@@ -1,17 +0,0 @@
-module MetricFu
-  
-  def self.generate_flay_report
-    Flay.generate_report
-    system("open #{Flay.metric_dir}/index.html") if open_in_browser?    
-  end
-    
-  class Flay < Base::Generator
-
-    def analyze
-      files_to_flay = MetricFu.flay[:dirs_to_flay].map{|dir| Dir[File.join(dir, "**/*.rb")] }
-      output = `flay #{files_to_flay.join(" ")}`
-      @matches = output.chomp.split("\n\n").map{|m| m.split("\n  ") }
-    end
-
-  end
-end

data/lib/metric_fu/flog.rb

@@ -1,129 +0,0 @@
-module MetricFu
-  
-  def self.generate_flog_report
-    Flog::Generator.generate_report
-    system("open #{Flog::Generator.metric_dir}/index.html") if open_in_browser?  
-  end
-  
-  module Flog
-    class Generator < Base::Generator
-      def generate_report
-        @base_dir = self.class.metric_dir
-        pages = []
-        flog_results.each do |filename|
-          page = Base.parse(open(filename, "r") { |f| f.read })
-          if page
-            page.filename = filename
-            pages << page
-          end
-        end
-        generate_pages(pages)
-      end
-
-      def generate_pages(pages)
-        pages.each do |page|
-          unless MetricFu::MD5Tracker.file_already_counted?(page.filename)
-            generate_page(page)
-          end
-        end      
-        save_html(ERB.new(File.read(template_file)).result(binding))
-      end
-
-      def generate_page(page)
-        save_html(page.to_html, page.path)
-      end
-
-      def flog_results
-        Dir.glob("#{@base_dir}/**/*.txt")
-      end
-      
-      def self.template_name
-        "flog"
-      end
-    end
-
-    SCORE_FORMAT = "%0.2f"
-
-    class Base
-      METHOD_LINE_REGEX = /([A-Za-z]+#.*):\s\((\d+\.\d+)\)/
-      OPERATOR_LINE_REGEX = /\s+(\d+\.\d+):\s(.*)$/
-
-      class << self
-
-        def parse(text)
-          score = text[/\w+ = (\d+\.\d+)/, 1]
-          return nil unless score
-          page = Page.new(score)
-
-          text.each_line do |method_line|
-           if match = method_line.match(METHOD_LINE_REGEX)
-              page.scanned_methods << ScannedMethod.new(match[1], match[2])
-            end
-            
-            if 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
-        
-      end
-    end 
-  
-    class Page < MetricFu::Base::Generator
-      attr_accessor :filename, :score, :scanned_methods
-
-      def initialize(score, scanned_methods = [])
-        @score = score.to_f
-        @scanned_methods = scanned_methods
-      end
-
-      def path
-        @path ||= File.basename(filename, ".txt") + '.html'
-      end
-
-      def to_html
-        ERB.new(File.read(template_file)).result(binding)
-      end
-
-      def average_score
-        return 0 if scanned_methods.length == 0
-        sum = 0
-        scanned_methods.each do |m|
-          sum += m.score
-        end
-        sum / scanned_methods.length
-      end
-
-      def highest_score
-        scanned_methods.inject(0) do |highest, m|
-          m.score > highest ? m.score : highest
-        end
-      end
-
-      def template_name
-        'flog_page'
-      end
-    end  
-  
-    class Operator
-      attr_accessor :score, :operator
-
-      def initialize(score, operator)
-        @score = score.to_f
-        @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
-    end  
-  end
-end

data/lib/metric_fu/reek.rb

@@ -1,17 +0,0 @@
-module MetricFu
-  
-  def self.generate_reek_report
-    Reek.generate_report
-    system("open #{Reek.metric_dir}/index.html") if open_in_browser?    
-  end
-    
-  class Reek < Base::Generator
-
-    def analyze
-      files_to_reek = MetricFu.reek[:dirs_to_reek].map{|dir| Dir[File.join(dir, "**/*.rb")] }
-      output = `reek #{files_to_reek.join(" ")}`
-      @matches = output.chomp.split("\n\n").map{|m| m.split("\n") }
-    end
-
-  end
-end

data/lib/metric_fu/roodi.rb

@@ -1,17 +0,0 @@
-module MetricFu
-  
-  def self.generate_roodi_report
-    MetricFu::Roodi.generate_report
-    system("open #{Roodi.metric_dir}/index.html") if open_in_browser?    
-  end
-    
-  class Roodi < Base::Generator
-
-    def analyze
-      files_to_analyze = MetricFu.roodi[:dirs_to_roodi].map{|dir| Dir[File.join(dir, "**/*.rb")] }
-      output = `roodi #{files_to_analyze.join(" ")}`
-      @matches = output.chomp.split("\n").map{|m| m.split(" - ") }
-    end
-
-  end
-end

data/lib/tasks/churn.rake

@@ -1,9 +0,0 @@
-require File.join(File.dirname(__FILE__), '../metric_fu/churn')
-
-namespace :metrics do
-
-  desc "Which files change the most"
-  task :churn do
-    MetricFu.generate_churn_report
-  end
-end

data/lib/tasks/coverage.rake

@@ -1,54 +0,0 @@
-require 'fileutils'
- 
-begin
-  require 'rcov'
-  require 'rcov/rcovtask'
-  require 'spec/rake/spectask'
- 
-  namespace :metrics do
- 
-    COVERAGE_DIR = File.join(MetricFu::BASE_DIRECTORY, 'coverage')
-    COVERAGE_DATA_FILE = File.join(MetricFu::BASE_DIRECTORY, 'coverage.data')
-    SPEC_HTML_FILE = File.join(MetricFu::BASE_DIRECTORY, 'specs.html')
- 
-    namespace :coverage do
-      rcov_output = COVERAGE_DIR
- 
-      desc "Delete aggregate coverage data."
-      task(:clean) { rm_f("rcov_tmp", :verbose => false) }
- 
-      desc "RCov task to generate report"
-      Rcov::RcovTask.new(:do => :clean) do |t|
-        FileUtils.mkdir_p(MetricFu::BASE_DIRECTORY) unless File.directory?(MetricFu::BASE_DIRECTORY)
-        t.test_files = FileList[*MetricFu.coverage[:test_files]]
-        t.rcov_opts = MetricFu.coverage[:rcov_opts]
-        t.output_dir = COVERAGE_DIR
-        # this line is a fix for Rails 2.1 relative loading issues
-        t.libs << 'test'
-      end
-      # TODO not sure what this improves but it requires the diff-lcs gem
-      # http://github.com/indirect/metric_fu/commit/b9c1cf75f09d5b531b388cd01661eb16b5126968#diff-1
-      # Spec::Rake::SpecTask.new(:do => :clean) do |t|
-      # FileUtils.mkdir_p(MetricFu::BASE_DIRECTORY) unless File.directory?(MetricFu::BASE_DIRECTORY)
-      # t.ruby_opts = ['-rtest/unit']
-      # t.spec_files = FileList['test/**/*_test.rb', 'spec/**/*spec.rb']
-      # t.spec_opts = ["--format", "html:#{SPEC_HTML_FILE}", "--diff"]
-      # t.rcov = true
-      # t.rcov_opts = ["--sort coverage", "--html", "--rails", "--exclude /gems/,/Library/"]
-      # t.rcov_dir = COVERAGE_DIR
-      # end
-    end
- 
-    desc "Generate and open coverage report"
-    task :coverage => ['coverage:do'] do
-      system("open #{COVERAGE_DIR}/index.html") if MetricFu.open_in_browser?
-    end
-  end
-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

data/lib/tasks/flay.rake

@@ -1,6 +0,0 @@
-namespace :metrics do
-  desc "Generate code duplication report with flay"
-  task :flay do
-    MetricFu.generate_flay_report
-  end
-end

data/lib/tasks/flog.rake

@@ -1,69 +0,0 @@
-begin
-
-  def flog(output, directory)
-    metric_dir = MetricFu::Flog::Generator.metric_dir
-    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 #{filename} > #{metric_dir}/#{filename.split('.')[0]}.txt`
-      end
-    end
-  end
-
-  namespace :metrics do
-
-    task :flog => ['flog:all'] do
-    end
-
-    namespace :flog do
-      desc "Delete aggregate flog data."
-      task(:clean) { rm_rf(MetricFu::Flog.metric_dir, :verbose => false) }
-
-      desc "Flog code in app/models"
-      task :models do
-        flog "models", "app/models"
-      end
-
-      desc "Flog code in app/controllers"
-      task :controllers do
-        flog "controllers", "app/controllers"
-      end
-
-      desc "Flog code in app/helpers"
-      task :helpers do
-        flog "helpers", "app/helpers"
-      end
-
-      desc "Flog code in lib"
-      task :lib do
-        flog "lib", "lib"
-      end
-
-      desc "Generate a flog report from specified directories"
-      task :custom do
-        MetricFu::flog[:dirs_to_flog].each { |directory| flog(directory, directory) }
-        MetricFu.generate_flog_report
-      end
-
-      desc "Generate and open flog report"
-      if MetricFu::RAILS
-        task :all => [:models, :controllers, :helpers, :lib] do
-          MetricFu.generate_flog_report
-        end
-      else
-        task :all => [:custom] do
-          MetricFu.generate_flog_report
-        end
-      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