metric_fu 4.10.0 → 4.11.0

data/lib/metric_fu/gem_run.rb

@@ -2,7 +2,7 @@
 require 'open3'
 require 'shellwords'
 require 'metric_fu'
-MetricFu.lib_require { 'logging/mf_debugger' }
+MetricFu.lib_require { 'logger' }
 MetricFu.lib_require { 'gem_version' }
 module MetricFu
   class GemRun
@@ -34,7 +34,7 @@ module MetricFu
         captured_output << stdout.read.chomp
         captured_errors << stderr.read.chomp
       end
-      STDERR.puts MetricFu::AnalysisError.new(captured_errors) unless captured_errors.empty?
+      captured_output << "\nERRORS:\n#{captured_errors}"
     rescue StandardError => run_error
       handle_run_error(run_error)
     rescue SystemExit => system_exit

data/lib/metric_fu/loader.rb

@@ -38,7 +38,7 @@ module MetricFu
           define_method("#{dir}_dir") do
             File.join(lib_dir,dir)
           end
-          module_eval(%Q(def #{dir}_require(&block); lib_require('#{dir}', &block); end))
+          module_eval(%Q(def #{dir}_require(&block); lib_require('#{dir}', &block); end),  __FILE__, __LINE__)
         end
       end
     end
@@ -59,30 +59,11 @@ module MetricFu
       end
     end
 
-    # Load specified task task only once
-    #   if and only if rake is required and the task is not yet defined
-    #   to prevent the task from being loaded multiple times
-    # @param tasks_relative_path [String] 'metric_fu.rake' by default
-    # @param options [Hash] optional task_name to check if loaded
-    # @option options [String] :task_name The task_name to load, if not yet loaded
-    def load_tasks(tasks_relative_path, options={task_name: ''})
-      if defined?(Rake::Task) and not Rake::Task.task_defined?(options[:task_name])
-        load File.join(@lib_root, 'tasks', *Array(tasks_relative_path))
-      end
-    end
-
     def setup
-      MetricFu.logging_require { 'mf_debugger' }
-      Object.send :include, MfDebugger
-      MfDebugger::Logger.debug_on = !!(ENV['MF_DEBUG'] =~ /true/i)
-
-      MetricFu.lib_require { 'configuration' }
-      MetricFu.lib_require { 'metric' }
+      MetricFu.lib_require { 'logger' }
+      MetricFu.logger.debug_on = !!(ENV['MF_DEBUG'] =~ /true/i)
 
-      Dir.glob(File.join(MetricFu.metrics_dir, '**/init.rb')).each{|init_file|require(init_file)}
-
-      MetricFu.configuration.configure_metrics
-      load_user_configuration
+      load_metric_configuration
 
       MetricFu.lib_require       { 'reporter' }
       MetricFu.reporting_require { 'result' }
@@ -90,10 +71,36 @@ module MetricFu
       MetricFu.load_tasks('metric_fu.rake', task_name: 'metrics:all')
     end
 
+    def load_metric_configuration
+      MetricFu.lib_require { 'configuration' }
+      load_installed_metrics
+      MetricFu.configuration.configure_metrics
+      load_user_configuration
+    end
+
+    def load_installed_metrics
+      MetricFu.lib_require { 'metric' }
+      Dir.glob(File.join(MetricFu.metrics_dir, '**/metric.rb')).each do |metric_config|
+        require metric_config
+      end
+    end
+
     def load_user_configuration
       file = File.join(MetricFu.run_dir, '.metrics')
       load file if File.exist?(file)
     end
 
+    # Load specified task task only once
+    #   if and only if rake is required and the task is not yet defined
+    #   to prevent the task from being loaded multiple times
+    # @param tasks_relative_path [String] 'metric_fu.rake' by default
+    # @param options [Hash] optional task_name to check if loaded
+    # @option options [String] :task_name The task_name to load, if not yet loaded
+    def load_tasks(tasks_relative_path, options={task_name: ''})
+      if defined?(Rake::Task) and not Rake::Task.task_defined?(options[:task_name])
+        load File.join(@lib_root, 'tasks', *Array(tasks_relative_path))
+      end
+    end
+
   end
 end

data/lib/metric_fu/logger.rb

@@ -0,0 +1,65 @@
+require 'logger'
+require 'forwardable'
+module MetricFu
+
+  def self.logger
+    @logger ||= ::MetricFu::Logger.new($stdout)
+  end
+
+  class Logger
+    extend Forwardable
+    MfLogger = ::Logger
+
+    def initialize(stdout)
+      @logger = MfLogger.new(stdout)
+      self.debug_on = false
+      self.formatter = ->(severity, time, progname, msg){ "#{msg}\n" }
+      self.level = 'info'
+    end
+
+    def debug_on=(bool)
+      self.level = bool ? 'debug' : 'info'
+    end
+
+    def debug_on
+      @logger.level == MfLogger::DEBUG
+    end
+
+    def_delegators :@logger, :info, :warn, :error, :fatal, :unknown
+
+    LEVELS = {
+      'debug' => MfLogger::DEBUG,
+      'info'  => MfLogger::INFO,
+      'warn'  => MfLogger::WARN,
+      'error' => MfLogger::ERROR,
+      'fatal' => MfLogger::FATAL,
+      'unknown' => MfLogger::UNKNOWN,
+    }
+
+    def level=(level)
+      @logger.level = LEVELS.fetch(level.to_s.downcase) { level }
+    end
+
+    def formatter=(formatter)
+      @logger.formatter = formatter
+    end
+
+    def log(msg)
+      @logger.info '*'*5 + msg.to_s
+    end
+
+    def debug(msg)
+      @logger.debug '*'*5 + msg.to_s
+    end
+
+  end
+
+end
+# For backward compatibility
+def mf_debug(msg,&block)
+  MetricFu.logger.debug(msg, &block)
+end
+
+def mf_log(msg,&block)
+  MetricFu.logger.log(msg, &block)
+end

data/lib/metric_fu/logging/mf_debugger.rb

@@ -1,58 +1,23 @@
+warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+MetricFu.lib_require { 'logger' }
 module MfDebugger
   extend self
-
   class Logger
-    class << self
-      attr_accessor :debug_on
-      @debug_on = false
+    def self.debug_on
+      warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+      MetricFu.logger.debug_on
+    end
+    def self.debug_on=(bool)
+      warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+      MetricFu.logger.level = bool ? 'debug' : 'info'
     end
     def self.log(msg, &block)
-      if block_given?
-        block.call
-      end
-      STDOUT.puts '*'*5 + msg.to_s
+      warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+      MetricFu.logger.info msg
     end
     def self.debug(msg, &block)
-      if MfDebugger::Logger.debug_on
-        if block_given?
-          log(msg,&block)
-        else
-          log(msg)
-        end
-      end
-    end
-    # From episode 029 of Ruby Tapas by Avdi
-    # https://rubytapas.dpdcart.com/subscriber/post?id=88
-    def self.capture_output(stream=STDOUT, &block)
-      old_stdout = stream.clone
-      pipe_r, pipe_w = IO.pipe
-      pipe_r.sync    = true
-      output         = ""
-      reader = Thread.new do
-        begin
-          loop do
-            output << pipe_r.readpartial(1024)
-          end
-        rescue EOFError
-        end
-      end
-      stream.reopen(pipe_w)
-      yield
-    ensure
-      stream.reopen(old_stdout)
-      pipe_w.close
-      reader.join
-      pipe_r.close
-      return output
+      warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+      MetricFu.logger.debug msg
     end
   end
-
-  def mf_debug(msg,&block)
-    MfDebugger::Logger.debug(msg, &block)
-  end
-
-  def mf_log(msg,&block)
-    MfDebugger::Logger.log(msg, &block)
-  end
-
 end

data/lib/metric_fu/metric.rb

@@ -1,6 +1,6 @@
 require 'set'
 MetricFu.lib_require { 'gem_run' }
-MetricFu.metrics_require { 'generator' }
+MetricFu.lib_require { 'generator' }
 # Encapsulates the configuration options for each metric
 module MetricFu
   class Metric
@@ -124,9 +124,9 @@ module MetricFu
 
     def default_metric_library_paths
       paths = []
-      paths << generator_path = "#{name}/#{name}"
+      paths << generator_path = "#{name}/generator"
       if has_graph?
-          paths << grapher_path   = "#{name}/#{name}_grapher"
+          paths << grapher_path   = "#{name}/grapher"
       end
       paths
     end

data/lib/metric_fu/metrics/cane/{init.rb → metric.rb}

@@ -24,7 +24,7 @@ module MetricFu
       if MetricFu.configuration.supports_ripper? && !MetricFu.configuration.ruby18?
         super
       else
-        MetricFu.configuration.mf_debug("Cane is only available in MRI. It requires ripper and 1.9 hash syntax support")
+        MetricFu.logger.debug("Cane is only available in MRI. It requires ripper and 1.9 hash syntax support")
       end
     end
 

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

@@ -7,8 +7,7 @@ module MetricFu
     end
 
     def emit
-      minimum_score_parameter = options[:minimum_score] ? "--mass #{options[:minimum_score]} " : ""
-      args =  "#{minimum_score_parameter} #{options[:dirs_to_flay].join(" ")}"
+      args =  "#{minimum_duplication_mass} #{dirs_to_flay}"
       @output = run!(args)
     end
 
@@ -29,5 +28,20 @@ module MetricFu
       end
       {:flay => {:total_score => total_score, :matches => target.flatten}}
     end
+
+    private
+
+    def minimum_duplication_mass
+      flay_mass = options[:minimum_score]
+      return "" unless flay_mass
+
+
+      "--mass #{flay_mass} "
+    end
+
+    def dirs_to_flay
+      options[:dirs_to_flay].join(" ")
+    end
+
   end
 end

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

@@ -11,7 +11,7 @@ module MetricFu
       # a long time. This is a really big number, considering
       # the default is 16. Setting it to nil to use the Flay default.
       :minimum_score => nil,
-      :filetypes => ['rb'] }
+      }
     end
 
     def has_graph?

data/lib/metric_fu/metrics/flog/{init.rb → metric.rb}

@@ -17,7 +17,7 @@ module MetricFu
       if MetricFu.configuration.mri?
         super
       else
-        MetricFu.configuration.mf_debug("Flog is only available in MRI due to flog tasks")
+        MetricFu.logger.debug("Flog is only available in MRI due to flog tasks")
       end
     end
 

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

@@ -34,7 +34,7 @@ module MetricFu
     private
 
     def require_hotspot(metric_name)
-      require "metric_fu/metrics/#{metric_name}/#{metric_name}_hotspot"
+      require "metric_fu/metrics/#{metric_name}/hotspot"
     rescue LoadError
       mf_debug "*** No hotspot for #{metric_name}"
     end

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

@@ -17,7 +17,7 @@ module MetricFu
       if MetricFu.configuration.supports_ripper?
         super if MetricFu.configuration.rails?
       else
-        MetricFu.configuration.mf_debug("Rails Best Practices is only available in MRI 1.9. It requires ripper")
+        MetricFu.logger.debug("Rails Best Practices is only available in MRI 1.9. It requires ripper")
       end
     end
 

data/lib/metric_fu/metrics/rcov/rcov_format_coverage.rb

@@ -18,6 +18,28 @@ module MetricFu
       def to_h
         {:content => @content, :was_run => @was_run}
       end
+
+      def covered?
+        @was_run.one?
+      end
+      def missed?
+        @was_run.zero?
+      end
+      def ignored?
+        @was_run.nil?
+      end
+      def self.line_coverage(lines)
+        lines.map{|line| line[:was_run] }
+      end
+      def self.covered_lines(line_coverage)
+        line_coverage.count(1)
+      end
+      def self.missed_lines(line_coverage)
+        line_coverage.count(0)
+      end
+      def self.ignored_lines(line_coverage)
+        line_coverage.count(nil)
+      end
     end
 
     def to_h
@@ -39,7 +61,13 @@ module MetricFu
       files.each_pair {|fname, content| files[fname] = content.split("\n") }
       files.each_pair do |fname, content|
         content.map! do |raw_line|
-          covered_line = raw_line.match(/^!!/).nil?
+          covered_line = if raw_line.start_with?('--')
+                           nil # simplecov ignores some lines
+                         elsif raw_line.start_with?('!!')
+                           0
+                         else
+                           1
+                         end
           Line.new(raw_line[3..-1], covered_line).to_h
         end
         content.reject! {|line| line[:content].to_s == '' }
@@ -64,6 +92,26 @@ module MetricFu
         end
       end
 
+      def self.floating_percent(numerator, denominator)
+        (numerator * 100.0) / denominator.to_f
+      end
+
+      def self.integer_percent(numerator, denominator)
+        ::MetricFu::Calculate.integer_percent(numerator, denominator)
+      end
+
+      def self.percent_run(lines)
+        line_coverage = Line.line_coverage(lines)
+        covered_lines = Line.covered_lines(line_coverage)
+        ignored_lines = Line.ignored_lines(line_coverage)
+        relevant_lines = lines.count - ignored_lines
+        if block_given?
+          yield covered_lines, relevant_lines
+        else
+          floating_percent(covered_lines, relevant_lines)
+        end
+      end
+
       private
       # TODO: remove multiple side effects
       #   sets global ivars and
@@ -71,18 +119,18 @@ module MetricFu
       def add_coverage_percentage(files)
         files.each_pair do |fname, content|
           lines = content[:lines]
-          lines_run = lines.count {|line| line[:was_run] }
-          total_lines = lines.length
-          integer_percent = ::MetricFu::Calculate.integer_percent(lines_run, total_lines)
-
-          files[fname][:percent_run] = integer_percent
-          @global_total_lines_run += lines_run
-          @global_total_lines += total_lines
+          percent_run =
+            self.class.percent_run(lines) do |covered, relevant|
+              @global_total_lines_run += covered
+              @global_total_lines += relevant
+              self.class.integer_percent(covered, relevant)
+            end
+          files[fname][:percent_run] = percent_run
         end
       end
 
       def add_global_percent_run(test_coverage, total_lines, total_lines_run)
-        percentage = (total_lines_run.to_f / total_lines.to_f) * 100
+        percentage = self.class.floating_percent(total_lines_run, total_lines)
         test_coverage.update({
           :global_percent_run => round_to_tenths(percentage)
         })