metric_fu 2.1.3.7.19 → 2.1.4.pre

data/lib/metric_fu/configuration.rb

@@ -0,0 +1,192 @@
+require 'fileutils'
+MetricFu.reporting_require { 'templates/awesome/awesome_template' }
+module MetricFu
+
+
+  # The @configuration class variable holds a global type configuration
+  # object for any parts of the system to use.
+  # TODO Configuration should probably be a singleton class
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # = Configuration
+  #
+  # The Configuration class, as it sounds, provides methods for
+  # configuring the behaviour of MetricFu.
+  #
+  # == Customization for Rails
+  #
+  # The Configuration class checks for the presence of a
+  # 'config/environment.rb' file.  If the file is present, it assumes
+  # it is running in a Rails project.  If it is, it will:
+  #
+  # * Add 'app' to the @code_dirs directory to include the
+  #   code in the app directory in the processing
+  # * Add :stats  and :rails_best_practices to the list of metrics to run
+  #
+  # == Customization for CruiseControl.rb
+  #
+  # The Configuration class checks for the presence of a
+  # 'CC_BUILD_ARTIFACTS' environment variable.  If it's found
+  # it will change the default output directory from the default
+  # "tmp/metric_fu to the directory represented by 'CC_BUILD_ARTIFACTS'
+  #
+  # == Metric Configuration
+  #
+  # Each metric can be configured by e.g. config.churn, config.flog, config.saikuro
+  class Configuration
+
+    def initialize #:nodoc:#
+      reset
+    end
+
+    def verbose
+      MfDebugger::Logger.debug_on
+    end
+
+    def verbose=(toggle)
+      MfDebugger::Logger.debug_on = toggle
+    end
+
+    # TODO review if these code is functionally duplicated in the
+    # base generator initialize
+    def reset
+      set_directories
+      configure_template
+      add_promiscuous_instance_variable(:metrics, [])
+      add_promiscuous_instance_variable(:graphs, [])
+      add_promiscuous_instance_variable(:graph_engines, [])
+      add_promiscuous_method(:graph_engine)
+    end
+
+    # This allows us to have a nice syntax like:
+    #
+    #   MetricFu.run do |config|
+    #     config.base_directory = 'tmp/metric_fu'
+    #   end
+    #
+    # See the README for more information on configuration options.
+    def self.run
+      yield MetricFu.configuration
+    end
+
+    attr_accessor :metrics
+    # e.g. :churn
+    def add_metric(metric)
+      add_promiscuous_method(metric)
+      self.metrics = (metrics << metric).uniq
+    end
+
+    # e.g. :reek
+    def add_graph(metric)
+      add_promiscuous_method(metric)
+      self.graphs = (graphs << metric).uniq
+    end
+
+    # e.g. :reek, {}
+    def configure_metric(metric, metric_configuration)
+      add_promiscuous_instance_variable(metric, metric_configuration)
+    end
+
+    # e.g. :bluff
+    def add_graph_engine(graph_engine)
+      add_promiscuous_method(graph_engine)
+      self.graph_engines = (graph_engines << graph_engine).uniq
+    end
+
+    # e.g. :bluff
+    def configure_graph_engine(graph_engine)
+      add_promiscuous_instance_variable(:graph_engine, graph_engine)
+    end
+
+    # Perform a simple check to try and guess if we're running
+    # against a rails app.
+    #
+    # TODO This should probably be made a bit more robust.
+    def rails?
+      add_promiscuous_instance_variable(:rails, File.exist?("config/environment.rb"))
+    end
+
+    def is_cruise_control_rb?
+      !!ENV['CC_BUILD_ARTIFACTS']
+    end
+
+    def platform #:nodoc:
+      return RUBY_PLATFORM
+    end
+
+    def self.ruby_strangely_makes_accessors_private?
+      !!(RUBY_VERSION =~ /1.9.2/)
+    end
+    protected unless ruby_strangely_makes_accessors_private?
+
+    def add_promiscuous_instance_variable(name,value)
+      instance_variable_set("@#{name}", value)
+      add_promiscuous_method(name)
+      value
+    end
+
+    def add_promiscuous_method(method_name)
+        add_promiscuous_class_method_to_metric_fu(method_name)
+        add_accessor_to_config(method_name)
+    end
+
+    def add_promiscuous_class_method_to_metric_fu(method_name)
+        metric_fu_method = <<-EOF
+                  def self.#{method_name}
+                    configuration.send(:#{method_name})
+                  end
+        EOF
+      MetricFu.module_eval(metric_fu_method)
+    end
+
+
+    def add_accessor_to_config(method_name)
+      self.class.send(:attr_accessor, method_name)
+    end
+
+    private
+
+    def configure_template
+      add_promiscuous_instance_variable(:template_class, AwesomeTemplate)
+      add_promiscuous_instance_variable(:link_prefix, nil)
+      add_promiscuous_instance_variable(:darwin_txmt_protocol_no_thanks, true)
+      # turning off syntax_highlighting may avoid some UTF-8 issues
+      add_promiscuous_instance_variable(:syntax_highlighting, true)
+    end
+
+    def set_directories
+      add_promiscuous_instance_variable(:base_directory,MetricFu.artifact_dir)
+      add_promiscuous_instance_variable(:scratch_directory,MetricFu.scratch_dir)
+      add_promiscuous_instance_variable(:output_directory,MetricFu.output_dir)
+      add_promiscuous_instance_variable(:data_directory,MetricFu.data_dir)
+      # due to behavior differences between ruby 1.8.7 and 1.9.3
+      # this is good enough for now
+      create_directories [base_directory, scratch_directory, output_directory]
+
+      add_promiscuous_instance_variable(:metric_fu_root_directory,MetricFu.root_dir)
+      add_promiscuous_instance_variable(:template_directory,
+                                        File.join(metric_fu_root_directory,
+                                         'lib', 'templates'))
+      add_promiscuous_instance_variable(:file_globs_to_ignore,[])
+      set_code_dirs
+    end
+
+    def create_directories(*dirs)
+      Array(*dirs).each do |dir|
+        FileUtils.mkdir_p dir
+      end
+    end
+
+    # Add the 'app' directory if we're running within rails.
+    def set_code_dirs
+      if rails?
+        add_promiscuous_instance_variable(:code_dirs,['app', 'lib'])
+      else
+        add_promiscuous_instance_variable(:code_dirs,['lib'])
+      end
+    end
+
+  end
+end

data/lib/{initial_requires.rb → metric_fu/initial_requires.rb}

@@ -20,6 +20,7 @@ begin
 rescue LoadError
   require 'activesupport' unless defined?(ActiveSupport)
 end
+MetricFu.configure
 MetricFu.logging_require { 'mf_debugger' }
 include MfDebugger
 MfDebugger::Logger.debug_on = !!(ENV['MF_DEBUG'] =~ /true/i)

data/lib/{load_files.rb → metric_fu/load_files.rb}

@@ -5,7 +5,6 @@ MetricFu.metrics_require   { 'graph' }
 MetricFu.reporting_require { 'graphs/grapher' }
 MetricFu.metrics_require   { 'hotspots/analysis/scoring_strategies' }
 
-# Now load everything else that's in the directory
 Dir.glob(File.join(MetricFu.lib_dir, '*.rb')).each do |file|
   require file
 end
@@ -29,10 +28,3 @@ end
 Dir.glob(File.join(MetricFu.reporting_dir, '**/*.rb')).each do |file|
   require file
 end
-# Dir[File.expand_path File.join(base_dir, '*.rb')].each{|l| require l }
-# Dir[File.expand_path File.join(generator_dir, '*.rb')].each {|l| require l }
-# Dir[File.expand_path File.join(template_dir, 'standard/*.rb')].each {|l| require l}
-# Dir[File.expand_path File.join(template_dir, 'awesome/*.rb')].each {|l| require l}
-# require graph_dir + "/grapher"
-# Dir[File.expand_path File.join(graph_dir, '*.rb')].each {|l| require l}
-# Dir[File.expand_path File.join(graph_dir, 'engines', '*.rb')].each {|l| require l}

data/lib/metric_fu/metrics/churn/churn.rb

@@ -0,0 +1,64 @@
+module MetricFu
+
+  class Churn < Generator
+
+    def emit
+      @output = generate_churn_metrics
+    end
+
+    def analyze
+      if @output.match(/Churning requires a subversion or git repo/)
+        @churn = [:churn => {}]
+      else
+        @churn = YAML::load(@output)
+      end
+    end
+
+    # ensure hash only has the :churn key
+    def to_h
+      {:churn => @churn[:churn]}
+    end
+
+    private
+
+    def generate_churn_metrics
+      ensure_output_is_valid_yaml(churn_code)
+    end
+
+    def ensure_output_is_valid_yaml(output)
+      yaml_start = output.index("---")
+      if yaml_start
+        output[yaml_start...output.length]
+      else
+        nil
+      end
+    end
+
+    def churn_code
+      command = "churn #{build_churn_options}"
+      mf_debug "** #{command}"
+      `#{command}`
+    end
+
+    def build_churn_options
+      opts = ["--yaml"]
+      churn_options.each do |churn_option, command_flag|
+        if has_option?(churn_option)
+          opts << "#{command_flag}=#{options[churn_option]}"
+        end
+      end
+      opts.join(" ")
+    end
+
+    def has_option?(churn_option)
+      options.include?(churn_option)
+    end
+    def churn_options
+      {
+        :minimum_churn_count => '--minimum_churn_count'
+      }
+    end
+
+  end
+
+end

data/lib/metric_fu/metrics/churn/init.rb

@@ -0,0 +1,5 @@
+MetricFu::Configuration.run do |config|
+  config.add_metric(:churn)
+  config.configure_metric(:churn,
+        { :start_date => "1 year ago", :minimum_churn_count => 10})
+end

data/lib/{metrics → metric_fu/metrics}/flay/flay.rb

@@ -7,7 +7,9 @@ module MetricFu
     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(" ")}`
+      command = %Q(flay #{mimimum_score_parameter} #{MetricFu.flay[:dirs_to_flay].join(" ")})
+      mf_debug "** #{command}"
+      @output = `#{command}`
     end
 
     def analyze

data/lib/metric_fu/metrics/flay/init.rb

@@ -0,0 +1,9 @@
+MetricFu::Configuration.run do |config|
+  config.add_metric(:flay)
+  config.add_graph(:flay)
+  config.configure_metric(:flay,
+                    { :dirs_to_flay => MetricFu.code_dirs, # was @code_dirs
+                    :minimum_score => 100,
+                    :filetypes => ['rb'] }
+                          )
+end

data/lib/metric_fu/metrics/flog/init.rb

@@ -0,0 +1,7 @@
+MetricFu::Configuration.run do |config|
+  config.add_metric(:flog)
+  config.add_graph(:flog)
+  config.configure_metric(:flog,
+                          { :dirs_to_flog => MetricFu.code_dirs  }
+                          )
+end

data/lib/{metrics → metric_fu/metrics}/generator.rb

@@ -30,9 +30,10 @@ module MetricFu
   # in general setup the directory structure that the MetricFu system
   # expects.
   class Generator
-    attr_reader :report, :template
+    attr_reader :report, :template, :options
 
     def initialize(options={})
+      @options = options
       create_metric_dir_if_missing
       create_output_dir_if_missing
       create_data_dir_if_missing
@@ -121,9 +122,7 @@ module MetricFu
     # methods to allow extra hooks into the processing methods, and help
     # to keep the logic of your Generators clean.
     def generate_report
-      if MetricFu.configuration.verbose
-        puts "Executing #{self.class.to_s.gsub(/.*::/, '')}"
-      end
+      mf_debug "Executing #{self.class.to_s.gsub(/.*::/, '')}"
 
       %w[emit analyze].each do |meth|
         send("before_#{meth}".to_sym)

data/lib/metric_fu/metrics/hotspots/init.rb

@@ -0,0 +1,5 @@
+MetricFu::Configuration.run do |config|
+  config.add_metric(:hotspots)
+  config.configure_metric(:hotspots,
+      { :start_date => "1 year ago", :minimum_churn_count => 10})
+end

data/lib/metric_fu/metrics/rails_best_practices/init.rb

@@ -0,0 +1,7 @@
+MetricFu::Configuration.run do |config|
+  if config.rails?
+    config.add_metric(:rails_best_practices)
+    config.add_graph(:rails_best_practices)
+    config.configure_metric(:rails_best_practices, {})
+  end
+end

data/lib/{metrics → metric_fu/metrics}/rails_best_practices/rails_best_practices.rb

@@ -1,8 +1,10 @@
 module MetricFu
   class RailsBestPractices < Generator
-    VERSION = '0.10.1'
+    VERSION = '1.13.2'
     def emit
-      @output = `rails_best_practices _#{VERSION}_ --without-color .`
+      command = %Q(rails_best_practices _#{VERSION}_ --without-color .)
+      mf_debug "** #{command}"
+      @output = `#{command}`
     end
 
     def analyze