code_metric_fu 4.14.0

data/lib/metric_fu/io.rb

@@ -0,0 +1,132 @@
+MetricFu.lib_require { "utility" }
+module MetricFu
+  module Io
+    # TODO: Move this module / functionality elsewhere and make less verbose
+    module FileSystem
+      # TODO: Use a better environmental variable name for the output / artiface dir.  Set to a different default in tests.
+      @default_artifact_dir = "tmp/metric_fu"
+      def self.default_artifact_dir
+        @default_artifact_dir
+      end
+      def self.artifact_dir
+        (ENV["CC_BUILD_ARTIFACTS"] || @artifact_dir)
+      end
+      def self.artifact_dir=(artifact_dir)
+        @artifact_dir = artifact_dir
+      end
+      self.artifact_dir = default_artifact_dir
+
+      module_function
+
+      def directories
+        @directories ||= {}
+      end
+
+      def directory(name)
+        directories.fetch(name) { raise "No such directory configured: #{name}" }
+      end
+
+      def scratch_directory(name)
+        File.join(directory("scratch_directory"), name.to_s)
+      end
+
+      def file_globs_to_ignore
+        @file_globs_to_ignore ||= []
+      end
+
+      def set_directories
+        @directories = {}
+        @directories["base_directory"]    = MetricFu.artifact_dir
+        @directories["scratch_directory"] = MetricFu.scratch_dir
+        @directories["output_directory"]  = MetricFu.output_dir
+        @directories["data_directory"]    = MetricFu.data_dir
+        create_directories @directories.values
+
+        @directories["root_directory"]    = MetricFu.root_dir
+        # TODO Though this is true of the general AwesomeTemplate, it is not necessarily true of templates within each Metric.  Each metric should probably know how to use AwesomeTemplate (or whatever)
+        @directories["template_directory"] = File.join(@directories.fetch("root_directory"), "lib", "templates")
+        @file_globs_to_ignore = []
+        set_code_dirs
+      end
+
+      def create_directories(*dirs)
+        # due to behavior differences between ruby 1.8.7 and 1.9.3
+        # this is good enough for now
+        Array(*dirs).each do |dir|
+          MetricFu::Utility.mkdir_p dir
+        end
+      end
+
+      # Add the 'app' directory if we're running within rails.
+      def set_code_dirs
+        @directories["code_dirs"] = %w(app lib).select { |dir| Dir.exist?(dir) }
+      end
+    end
+
+    # Writes the output to a file or io stream.
+    # @param output [String, #to_s] the content to write.
+    # @param path_or_io [String, #to_s, IO, #write] a file path
+    #   or an io stream that responds to write.
+    # @return [nil]
+    def write_output(output, path_or_io)
+      io_for(path_or_io) do |io|
+        io.write(output)
+      end
+    end
+
+    # Yields an io object for writing output.
+    # @example
+    #   io_for('path/to/file') do |io|
+    #     io.write(output)
+    #   end
+    #
+    #   io_for(STDOUT) do |io|
+    #     io.write(output)
+    #   end
+    #
+    #   stream = StringIO.new
+    #   io_for(stream) do |io|
+    #     io.write(output)
+    #   end
+    #
+    # @param path_or_io [String, #to_s, IO, #write] a file path
+    #   or an io stream that responds to write.
+    #
+    # @yield [IO] an open stream for writing.
+    #
+    # @note Given a path to a file, an open file will
+    #   be yielded and closed after the block completes.
+    #   Given an existing io stream, the stream will not
+    #   be automatically closed. Cleanup, if necessary, is
+    #   the responsibility of the caller.
+    def io_for(path_or_io, &block)
+      raise ArgumentError, "No path or io provided." if path_or_io.nil?
+      raise ArgumentError, "No block given. Cannot yield io stream." unless block_given?
+
+      if path_or_io.respond_to?(:write)
+        # We have an existing open stream...
+        block.call(path_or_io)
+      else # Otherwise, we assume its a file path...
+        file_for(path_or_io, &block)
+      end
+    end
+
+    def file_for(path, &block)
+      File.open(path_relative_to_base(path), "w") do |file|
+        block.call(file)
+      end
+    end
+
+    def dir_for(path)
+      return nil if path.nil?
+      pathname = path_relative_to_base(path)
+      MetricFu::Utility.mkdir_p(pathname) unless File.directory?(pathname)
+      pathname
+    end
+
+    def path_relative_to_base(path)
+      pathname = MetricFu.run_path.join(MetricFu::Io::FileSystem.directory("base_directory")) # make full path relative to base directory
+      pathname.join(path)
+    end
+  end
+end

data/lib/metric_fu/loader.rb

@@ -0,0 +1,105 @@
+module MetricFu
+  class Loader
+    # TODO: This class mostly serves to clean up the base MetricFu module,
+    #   but needs further work
+
+    attr_reader :loaded_files
+    def initialize(lib_root)
+      @lib_root = lib_root
+      @loaded_files = []
+    end
+
+    def lib_require(base = "", &_block)
+      paths = []
+      base_path = File.join(@lib_root, base)
+      Array((yield paths, base_path)).each do |path|
+        file = File.join(base_path, *Array(path))
+        require file
+        if @loaded_files.include?(file)
+          puts "!!!\tAlready loaded #{file}" if !!(ENV["MF_DEBUG"] =~ /true/i)
+        else
+          @loaded_files << file
+        end
+      end
+    end
+
+    # TODO: Reduce duplication of directory logic
+    # Adds methods x_dir and _x_require for the directory x,
+    #   relative to the metric_fu lib, to the given klass
+    # @param klass [Class] the klass to add methods for the specified directories
+    # @yieldreturn [Array<String>] Takes a list of directories and adds readers for each
+    # @example For the directory 'metrics', which is relative to the metric_fu lib directory,
+    #   creates on the klass two methods:
+    #     ::metrics_dir which returns the full path
+    #     ::metrics_require which takes a block of files to require relative to the metrics_dir
+    def create_dirs(klass)
+      class << klass
+        Array(yield).each do |dir|
+          define_method("#{dir}_dir") do
+            File.join(lib_dir, dir)
+          end
+          module_eval(%(def #{dir}_require(&block); lib_require('#{dir}', &block); end),  __FILE__, __LINE__)
+        end
+      end
+    end
+
+    # Adds method x_dir relative to the metric_fu artifact directory to the given klass
+    #   And strips any leading non-alphanumerical character from the directory name
+    # @param klass [Class] the klass to add methods for the specified artifact sub-directories
+    # @yieldreturn [Array<String>] Takes a list of directories and adds readers for each
+    # @example For the artifact sub-directory '_scratch', creates on the klass one method:
+    #     ::scratch_dir (which notably has the leading underscore removed)
+    def create_artifact_subdirs(klass)
+      class << klass
+        Array(yield).each do |dir|
+          define_method("#{dir.gsub(/[^A-Za-z0-9]/, '')}_dir") do
+            File.join(artifact_dir, dir)
+          end
+        end
+      end
+    end
+
+    def setup
+      MetricFu.lib_require { "logger" }
+      MetricFu.logger.debug_on = !!(ENV["MF_DEBUG"] =~ /true/i)
+
+      load_metric_configuration
+
+      MetricFu.lib_require       { "reporter" }
+      MetricFu.reporting_require { "result" }
+
+      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,62 @@
+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

@@ -0,0 +1,23 @@
+warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+MetricFu.lib_require { "logger" }
+module MfDebugger
+  extend self
+  class Logger
+    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)
+      warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+      MetricFu.logger.info msg
+    end
+    def self.debug(msg, &_block)
+      warn "MfDebugger if deprecated.  Please use MetricFu.logger"
+      MetricFu.logger.debug msg
+    end
+  end
+end

data/lib/metric_fu/metric.rb

@@ -0,0 +1,143 @@
+require "set"
+MetricFu.lib_require { "gem_run" }
+MetricFu.lib_require { "generator" }
+# Encapsulates the configuration options for each metric
+module MetricFu
+  class Metric
+    attr_accessor :enabled, :activated
+
+    def initialize
+      self.enabled = false
+      @libraries = Set.new
+      @configured_run_options = {}
+    end
+
+    def enable
+      self.enabled = true
+    end
+
+    # TODO: Confirm this catches load errors from requires in subclasses, such as for flog
+    def activate
+      MetricFu.metrics_require { default_metric_library_paths }
+      @libraries.each { |library| require(library) }
+      self.activated = true
+    rescue LoadError => e
+      mf_log "#{name} metric not activated, #{e.message}"
+    end
+
+    # @return metric name [Symbol]
+    def name
+      not_implemented
+    end
+
+    def gem_name
+      name
+    end
+
+    # @return metric run options [Hash]
+    def run_options
+      default_run_options.merge(configured_run_options)
+    end
+
+    def default_run_args
+      run_options.map { |k, v| "--#{k} #{v}" }.join(" ")
+    end
+
+    def run
+      not_implemented
+    end
+
+    def run_external(args = default_run_args)
+      runner = GemRun.new(
+        gem_name: gem_name.to_s,
+        metric_name: name.to_s,
+        # version: ,
+        args: args,
+      )
+      stdout, stderr, status = runner.run
+      # TODO: do something with the stderr
+      # for now, just acknowledge we got it
+      unless stderr.empty?
+        STDERR.puts "STDERR from #{gem_name}:\n#{stderr}"
+      end
+      # TODO: status.success? is not reliable for distinguishing
+      # between a successful run of the metric and problems
+      # found by the metric. Talk to other metrics about this.
+      MetricFu.logger.debug "#{gem_name} ran with #{status.success? ? 'success' : 'failure'} code #{status.exitstatus}"
+      stdout
+    end
+
+    def configured_run_options
+      @configured_run_options
+    end
+
+    # @return [Hash] default metric run options
+    def default_run_options
+      not_implemented
+    end
+
+    # @return [Hash] metric_options
+    def has_graph?
+      not_implemented
+    end
+
+    @metrics = []
+    # @return all subclassed metrics [Array<MetricFu::Metric>]
+    # ensure :hotspots runs last
+    def self.metrics
+      @metrics
+    end
+
+    def self.enabled_metrics
+      metrics.select { |metric| metric.enabled && metric.activated }.sort_by { |metric| metric.name  == :hotspots ? 1 : 0 }
+    end
+
+    def self.get_metric(name)
+      metrics.find { |metric|metric.name.to_s == name.to_s }
+    end
+
+    def self.inherited(subclass)
+      @metrics << subclass.new
+    end
+
+    protected
+
+    # Enable using a syntax such as metric.foo = 'foo'
+    #   by catching the missing method here,
+    #   checking if :foo is a key in the default_run_options, and
+    #   setting the key/value in the @configured_run_options hash
+    # TODO: See if we can do this without a method_missing
+    def method_missing(method, *args)
+      key = method_to_attr(method)
+      if default_run_options.has_key?(key)
+        configured_run_options[key] = args.first
+      else
+        raise "#{key} is not a valid configuration option"
+      end
+    end
+
+    # Used above to identify the stem of a setter method
+    def method_to_attr(method)
+      method.to_s.sub(/=$/, "").to_sym
+    end
+
+    private
+
+    def not_implemented
+      raise "Required method #{caller[0]} not implemented in #{__FILE__}"
+    end
+
+    def activate_library(file)
+      @libraries << file.strip
+    end
+
+    def default_metric_library_paths
+      paths = []
+      paths << generator_path = "#{name}/generator"
+      if has_graph?
+        paths << grapher_path   = "#{name}/grapher"
+      end
+      paths
+    end
+  end
+end

data/lib/metric_fu/metrics/cane/generator.rb

@@ -0,0 +1,95 @@
+MetricFu.metrics_require { "cane/violations" }
+module MetricFu
+  class CaneGenerator < Generator
+    attr_reader :violations, :total_violations
+
+    def self.metric
+      :cane
+    end
+
+    def emit
+      args =  [
+        abc_max_param,
+        style_measure_param,
+        no_doc_param,
+        no_readme_param
+      ].join
+      @output = run!(args)
+    end
+
+    def analyze
+      @violations = violations_by_category
+      extract_total_violations
+    end
+
+    def to_h
+      { cane: { total_violations: @total_violations, violations: @violations } }
+    end
+
+    private
+
+    def abc_max_param
+      options[:abc_max] ? " --abc-max #{options[:abc_max]}" : ""
+    end
+
+    def style_measure_param
+      options[:line_length] ? " --style-measure #{options[:line_length]}" : ""
+    end
+
+    def no_doc_param
+      options[:no_doc] == "y" ? " --no-doc" : ""
+    end
+
+    def no_readme_param
+      options[:no_readme] == "y" ? " --no-readme" : ""
+    end
+
+    def violations_by_category
+      violations_output = @output.scan(/(.*?)\n\n(.*?)\n\n/m)
+      violations_output.each_with_object({}) do |(category_desc, violation_list), violations|
+        category = category_from(category_desc) || :others
+        violations[category] ||= []
+        violations[category] += violations_for(category, violation_list)
+      end
+    end
+
+    def category_from(description)
+      category_descriptions = {
+        abc_complexity: /ABC complexity/,
+        line_style: /style requirements/,
+        comment: /comment/,
+        documentation: /documentation/
+      }
+      category, desc_matcher = category_descriptions.find { |_k, v| description =~ v }
+      mf_debug desc_matcher.inspect
+      category
+    end
+
+    def violations_for(category, violation_list)
+      violation_type_for(category).parse(violation_list)
+    end
+
+    def violation_type_for(category)
+      case category
+      when :abc_complexity
+        CaneViolations::AbcComplexity
+      when :line_style
+        CaneViolations::LineStyle
+      when :comment
+        CaneViolations::Comment
+      when :documentation
+        CaneViolations::Documentation
+      else
+        CaneViolations::Others
+      end
+    end
+
+    def extract_total_violations
+      if @output =~ /Total Violations: (\d+)/
+        @total_violations = $1.to_i
+      else
+        @total_violations = 0
+      end
+    end
+  end
+end

data/lib/metric_fu/metrics/cane/grapher.rb

@@ -0,0 +1,37 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class CaneGrapher < Grapher
+    attr_accessor :cane_violations, :labels
+
+    def self.metric
+      :cane
+    end
+
+    def initialize
+      super
+      @cane_violations = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:cane]
+        @cane_violations.push(metrics[:cane][:total_violations].to_i)
+        @labels.update(@labels.size => date)
+      end
+    end
+
+    def title
+      "Cane: code quality threshold violations"
+    end
+
+    def data
+      [
+        ["cane", @cane_violations.join(",")]
+      ]
+    end
+
+    def output_filename
+      "cane.js"
+    end
+  end
+end

data/lib/metric_fu/metrics/cane/metric.rb

@@ -0,0 +1,34 @@
+module MetricFu
+  class MetricCane < Metric
+    def name
+      :cane
+    end
+
+    def default_run_options
+      {
+        dirs_to_cane: MetricFu::Io::FileSystem.directory("code_dirs"),
+        abc_max: 15,
+        line_length: 80,
+        no_doc: "n",
+        no_readme: "n",
+        filetypes: ["rb"]
+      }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      if MetricFu.configuration.supports_ripper? && !MetricFu.configuration.ruby18?
+        super
+      else
+        MetricFu.logger.debug("Cane is only available in MRI. It requires ripper and 1.9 hash syntax support")
+      end
+    end
+
+    def activate
+      super
+    end
+  end
+end