code_metric_fu 4.14.0

data/lib/metric_fu/cli/parser.rb

@@ -0,0 +1,138 @@
+require "optparse"
+module MetricFu
+  module Cli
+    # see https://github.com/florianpilz/CLI-Option-Parser-Examples
+    # https://raw.github.com/florianpilz/micro-optparse/master/lib/micro-optparse/parser.rb
+    module MicroOptParse
+      class Parser
+        attr_accessor :banner, :version
+        def initialize
+          @options = []
+          @used_short = []
+          @default_values = nil
+          yield self if block_given?
+        end
+
+        def process!(arguments = ARGV)
+          parser = build_option_parser
+          process_options(parser, arguments)
+        end
+
+        def option(name, desc, settings = {})
+          @options << [name, desc, settings]
+        end
+
+        private
+
+        def build_option_parser
+          @result = (@default_values || {}).clone # reset or new
+
+          @optionparser ||= OptionParser.new do |p| # prepare only once
+            configure_options(p)
+          end
+        end
+
+        def process_options(parser, arguments)
+          begin
+            parser.parse!(arguments)
+          rescue OptionParser::ParseError => e
+            puts e.message
+            MetricFu::Cli.immediate_shutdown!
+          end
+
+          @result
+        end
+
+        def configure_options(p)
+          add_general_options(@options, p)
+
+          add_format_option(p)
+          add_output_option(p)
+
+          p.banner = @banner unless @banner.nil?
+          p.on_tail("-h", "--help", "Show this message") { puts p; success! }
+          short = @used_short.include?("v") ? "-V" : "-v"
+          p.on_tail(short, "--version", "Print version") { puts @version; success! } unless @version.nil?
+          p.on_tail("--debug-info", "Print debug info") { debug_info; success! }
+          @default_values = @result.clone # save default values to reset @result in subsequent calls
+        end
+
+        def add_general_options(options, p)
+          options.each do |o|
+            add_general_option(p, o)
+          end
+        end
+
+        def add_general_option(p, o)
+          @used_short << short = o[2][:short] || short_from(o[0])
+          @result[o[0]] = o[2][:default] || false # set default
+          klass = o[2][:default].class == Integer ? Integer : o[2][:default].class
+
+          if [TrueClass, FalseClass, NilClass].include?(klass) # boolean switch
+            p.on("-" << short, "--[no-]" << o[0].to_s.gsub("_", "-"), o[1]) { |x| @result[o[0]] = x }
+          else # argument with parameter
+            p.on("-" << short, "--" << o[0].to_s.gsub("_", "-") << " " << o[2][:default].to_s, klass, o[1]) { |x| @result[o[0]] = x }
+          end
+        end
+
+        def add_output_option(p)
+          p.on("--out FILE|DIR",
+               "Specify the file or directory to use for output",
+               "This option applies to the previously",
+               "specified --format, or the default format",
+               "if no format is specified. Paths are relative to",
+               "#{MetricFu.run_path.join(MetricFu::Io::FileSystem.directory('base_directory'))}",
+               "Check the specific formatter\'s docs to see",
+               "whether to pass a file or a dir.") do |o|
+            @result[:format] ||= MetricFu::Formatter::DEFAULT
+            @result[:format].last << o
+          end
+        end
+
+        def add_format_option(p)
+          p.on("--format FORMAT",
+               "Specify the formatter to use for output.",
+               "This option can be specified multiple times.",
+               "Specify a built-in formatter from the list below,",
+               "or the fully-qualified class name of your own custom formatter.",
+               *format_descriptions) do |f|
+            @result[:format] ||= []
+            @result[:format] << [f]
+          end
+        end
+
+        def short_from(name)
+          name.to_s.chars.each do |c|
+            next if @used_short.include?(c) || c == "_"
+            return c # returns from short_from method
+          end
+        end
+
+        def debug_info
+          extend(MetricFu::Environment)
+          require "pp"
+          pp debug_info
+        end
+
+        # Build a nicely formatted list of built-in
+        # formatter keys and their descriptions
+        # @see MetricFu::Formatter::BUILTIN_FORMATS
+        # @example
+        #    format_descriptions #=> ["  yaml :  Generates the raw output as yaml"]
+        # @return [Array<String>] in the form of
+        #    "   <key>  : <description>."
+        def format_descriptions
+          formats = MetricFu::Formatter::BUILTIN_FORMATS
+          max = formats.keys.map(&:length).max
+          formats.keys.sort.map do |key|
+            "  #{key}#{' ' * (max - key.length)} : #{formats[key][1]}"
+          end
+        end
+
+        def success!
+          MetricFu::Cli.complete!
+        end
+      end
+    end
+  end
+end

data/lib/metric_fu/configuration.rb

@@ -0,0 +1,150 @@
+MetricFu.lib_require { "logger" }
+module MetricFu
+  # Even though the below class methods are defined on the MetricFu module
+  # They are included here as they deal with configuration
+
+  # 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
+
+  def self.configure
+    configuration.tap(&:configure_metrics)
+  end
+
+  # = Configuration
+  #
+  # The Configuration class, as it sounds, provides methods for
+  # configuring the behaviour of MetricFu.
+  #
+  # == 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.configure_metric(:flog) do |flog|
+  #     flog.enable
+  #     flog.dirs_to_flog = %w(app lib spec)
+  #     ...
+  #   end
+  #
+  # or iterate over all metrics to configure by e.g.
+  #   config.configure_metrics.each do |metric|
+  #     ...
+  #   end
+  #
+  # == Formatter Configuration
+  #
+  # Formatters can be configured by e.g.
+  #   config.configure_formatter(:html)
+  #   config.configure_formatter(:yaml, "customreport.yml")
+  #   config.configure_formatter(MyCustomFormatter)
+  #
+  class Configuration
+    require_relative "environment"
+    require_relative "io"
+    require_relative "formatter"
+    require_relative "templates/configuration"
+
+    # TODO: Remove need to include the module
+    include MetricFu::Environment
+
+    def initialize #:nodoc:#
+      reset
+    end
+
+    # TODO review if these code is functionally duplicated in the
+    # base generator initialize
+    attr_reader :formatters
+    def reset
+      # TODO: Remove calls to self and/or allow querying the
+      #   template/filesystem/metric/graph/environment, etc settings
+      #   from the configuration instance
+      MetricFu::Io::FileSystem.set_directories
+      @templates_configuration = MetricFu::Templates::Configuration.new
+      MetricFu::Formatter::Templates.templates_configuration = @templates_configuration
+      @formatters = []
+      @graph_engine = :bluff
+    end
+
+    # This allows us to have a nice syntax like:
+    #
+    #   MetricFu.run do |config|
+    #     config.configure_metric(:churn) do
+    #       ...
+    #     end
+    #
+    #     config.configure_formatter(MyCustomFormatter)
+    #   end
+    #
+    # See the README for more information on configuration options.
+    # TODO: Consider breaking compatibility by removing this, now unused method
+    def self.run
+      yield MetricFu.configuration
+    end
+
+    def self.configure_metric(name)
+      yield MetricFu::Metric.get_metric(name)
+    end
+
+    def configure_metric(name, &block)
+      self.class.configure_metric(name, &block)
+    end
+
+    def configure_metrics
+      MetricFu::Io::FileSystem.set_directories
+      MetricFu::Metric.metrics.each do |metric|
+        if block_given?
+          yield metric
+        else
+          metric.enabled = false
+          metric.enable
+        end
+        metric.activate if metric.enabled unless metric.activated
+      end
+    end
+
+    # TODO: Reconsider method name/behavior, as it really adds a formatter
+    def configure_formatter(format, output = nil)
+      @formatters << MetricFu::Formatter.class_for(format).new(output: output)
+    end
+
+    # @return [Array<Symbol>] names of enabled metrics with graphs
+    def graphed_metrics
+      # TODO: This is a common enough need to be pushed into MetricFu::Metric as :enabled_metrics_with_graphs
+      MetricFu::Metric.enabled_metrics.select(&:has_graph?).map(&:name)
+    end
+
+    def configure_graph_engine(graph_engine)
+      @graph_engine = graph_engine
+    end
+
+    def graph_engine
+      @graph_engine
+    end
+
+    # This allows us to configure the templates with:
+    #
+    #   MetricFu.run do |config|
+    #     config.templates_configuration do |templates_config|
+    #       templates_config.link_prefix = 'http:/'
+    #     end
+    #   end
+    def templates_configuration
+      yield @templates_configuration
+    end
+
+    # @param option [String, Symbol] the requested template option
+    # @return [String] the configured template option
+    def templates_option(option)
+      @templates_configuration.option(option)
+    end
+  end
+end

data/lib/metric_fu/constantize.rb

@@ -0,0 +1,57 @@
+module MetricFu
+  module Constantize
+    # Copied from ActiveSupport and modified so as not to introduce a dependency.
+    # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L220
+    def constantize(camel_cased_word)
+      tries ||= 2
+      names = camel_cased_word.split("::")
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    rescue NameError
+      # May need to attempt to require the file and try again.
+      begin
+        require underscore(camel_cased_word)
+      rescue LoadError => e
+        mf_log e.message
+      end
+
+      if (tries -= 1).zero?
+        raise
+      else
+        retry
+      end
+    end
+
+    # Copied from active_support
+    # https://github.com/rails/rails/blob/51cd6bb829c418c5fbf75de1dfbb177233b1b154/activesupport/lib/active_support/inflector/methods.rb#L88
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, "/")
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+end

data/lib/metric_fu/data_structures/line_numbers.rb

@@ -0,0 +1,112 @@
+MetricFu.data_structures_require { "sexp_node" }
+module MetricFu
+  class LineNumbers
+    attr_reader :file_path
+
+    # Parses ruby code to collect line numbers for class, module, and method definitions.
+    # Used by metrics that don't provide line numbers for class, module, or methods problems
+    # @param contents [String] a string of ruby code
+    # @param file_path [String] the file path for the contents, defaults to empty string
+    def initialize(contents, file_path = "")
+      @file_path = file_path
+      @locations = {}
+      if contents.to_s.size.zero?
+        mf_log "NON PARSEABLE INPUT: File is empty at path #{file_path.inspect}\n\t#{caller.join("\n\t")}"
+      else
+        parse_code(contents)
+      end
+    end
+
+    # @param line_number [Integer]
+    # @return [Boolean] if the given line number is in a method
+    def in_method?(line_number)
+      not method_at_line(line_number) == :no_method_at_line
+    end
+
+    # @param line_number [Integer]
+    # @return [String, nil] the method which includes that line number, if any
+    # For all collected locations, find the first location
+    #   where the line_number_range includes the line_number.
+    #   If a location is found, return the method name (first element)
+    #   Else return :no_method_at_line
+    def method_at_line(line_number)
+      default_proc = -> { [:no_method_at_line] }
+      @locations.detect(default_proc) do |_method_name, line_number_range|
+        line_number_range.include?(line_number)
+      end.first
+    end
+
+    # @param method [String] the method name being queried
+    # @return [Integer, nil] the line number at which the given method is defined
+    def start_line_for_method(method)
+      return nil unless @locations.has_key?(method)
+      @locations[method].first
+    end
+
+    private
+
+    def parse_code(contents)
+      file_sexp = MetricFu::SexpNode.parse(contents)
+      file_sexp && process_ast(file_sexp)
+    rescue => e
+      # catch errors for files ruby_parser fails on
+      mf_log "RUBY PARSE FAILURE: #{e.class}\t#{e.message}\tFILE:#{file_path}\tSEXP:#{file_sexp.inspect}\n\tCONTENT:#{contents.inspect}\n\t#{e.backtrace}"
+    end
+
+    def process_ast(file_sexp)
+      node = MetricFu::SexpNode.new(file_sexp)
+      case node.node_type
+      when nil
+        mf_log "No ruby code found in #{file_path}"
+      when :class
+        process_class(node)
+      when :module
+        process_module(node)
+      else
+        mf_debug "SEXP: Parsing line numbers for classes in sexp type #{node.node_type.inspect}"
+        mf_debug "      in #{file_path}"
+        node.each_module { |child_node| process_class(child_node) }
+        node.each_class  { |child_node| process_class(child_node) }
+      end
+    end
+
+    def process_module(module_node)
+      module_name = module_node.name
+      module_node.each_class do |class_node|
+        process_class(class_node, module_name)
+        class_node.hide_methods_from_next_round
+      end
+      process_class(module_node)
+    end
+
+    def process_class(class_node, module_name = nil)
+      class_name = class_node.name
+      process_singleton_methods(class_node, class_name)
+      process_instance_methods(class_node, class_name, module_name)
+      process_class_methods(class_node, class_name, module_name)
+    end
+
+    def process_singleton_methods(class_node, class_name)
+      class_node.each_singleton_class do |singleton_node|
+        singleton_node.each_singleton_method do |singleton_method_node|
+          singleton_method_name = singleton_method_node.full_name(class_name)
+          @locations[singleton_method_name] = singleton_method_node.line_range
+        end
+      end
+    end
+
+    def process_instance_methods(class_node, class_name, module_name)
+      class_node.each_instance_method do |instance_method_node|
+        instance_method_name = instance_method_node.full_name(module_name, class_name)
+        @locations[instance_method_name] = instance_method_node.line_range
+      end
+    end
+
+    def process_class_methods(class_node, class_name, module_name)
+      class_node.each_class_method do |class_method_node|
+        class_method_name = class_method_node.full_name(module_name, class_name)
+        @locations[class_method_name] = class_method_node.line_range
+      end
+    end
+  end
+end

data/lib/metric_fu/data_structures/location.rb

@@ -0,0 +1,110 @@
+module MetricFu
+  class Location
+    include Comparable
+
+    attr_accessor :file_path, :file_name, :line_number,
+                  :class_name, :method_name, :simple_method_name, :hash, :hash_key
+
+    def self.get(file_path, class_name, method_name)
+      location = new(file_path, class_name, method_name)
+      @@locations ||= {}
+      @@locations.fetch(location.hash_key) do
+        @@locations[location.hash_key] = location
+        location.finalize
+        location
+      end
+    end
+
+    def initialize(file_path, class_name, method_name)
+      @file_path               = file_path
+      @file_name, @line_number = file_path.to_s.split(/:/)
+      @class_name              = class_name
+      @method_name             = method_name
+      @simple_method_name      = @method_name.to_s.sub(@class_name.to_s, "")
+      @hash_key                = to_key
+      @hash                    = @hash_key.hash
+    end
+
+    def to_hash
+      hash = {
+        "class_name"  => class_name,
+        "method_name" => method_name,
+        "file_path"   => file_path,
+        "file_name"   => file_name,
+        "line_number" => line_number,
+        "hash_key"    => hash_key,
+      }
+
+      if method_name.to_s.size > 0
+        hash = hash.merge("simple_method_name" => simple_method_name)
+      else
+        hash
+      end
+    end
+
+    # defining :eql? and :hash to use Location as a hash key
+    def eql?(other)
+      @hash == other.hash
+    end
+
+    def <=>(other)
+      hash <=> other.hash
+    end
+
+    # Generates the @hash key
+    def to_key
+      [@file_path, @class_name, @method_name].inspect
+    end
+
+    def self.for(class_or_method_name)
+      class_or_method_name = strip_modules(class_or_method_name)
+      if class_or_method_name
+        begin
+          match = class_or_method_name.match(/(.*)((\.|\#|\:\:[a-z])(.+))/)
+        rescue => error
+          # new error during port to metric_fu occasionally a unintialized
+          # MatchData object shows up here. Not expected.
+          mf_debug "ERROR on getting location for #{class_or_method_name} #{error.inspect}"
+          match = nil
+        end
+
+        # reek reports the method with :: not # on modules like
+        # module ApplicationHelper \n def signed_in?, convert it so it records correctly
+        # but classes have to start with a capital letter... HACK for REEK bug, reported underlying issue to REEK
+        if match
+          class_name = strip_modules(match[1])
+          method_name = class_or_method_name.gsub(/\:\:/, "#")
+        else
+          class_name = strip_modules(class_or_method_name)
+          method_name = nil
+        end
+      else
+        class_name = nil
+        method_name = nil
+      end
+      get(nil, class_name, method_name)
+    end
+
+    def finalize
+      @file_path   &&= @file_path.clone
+      @file_name   &&= @file_name.clone
+      @line_number &&= @line_number.clone
+      @class_name  &&= @class_name.clone
+      @method_name &&= @method_name.clone
+      freeze  # we cache a lot of method call results, so we want location to be immutable
+    end
+
+    private
+
+    def self.strip_modules(class_or_method_name)
+      # reek reports the method with :: not # on modules like
+      # module ApplicationHelper \n def signed_in?, convert it so it records correctly
+      # but classes have to start with a capital letter... HACK for REEK bug, reported underlying issue to REEK
+      if class_or_method_name =~ /\:\:[A-Z]/
+        class_or_method_name.split("::").last
+      else
+        class_or_method_name
+      end
+    end
+  end
+end

data/lib/metric_fu/data_structures/sexp_node.rb

@@ -0,0 +1,107 @@
+require "ruby_parser"
+module MetricFu
+  SexpNode = Struct.new(:sexp) do
+    # @return file_sexp
+    def self.parse(contents)
+      rp = RubyParser.new
+      rp.parse(contents)
+    end
+    def nil?
+      sexp.nil?
+    end
+
+    def node_type
+      sexp[0]
+    end
+
+    def name
+      sexp[1]
+    end
+
+    def each_of_type(type, node_class = SexpNode)
+      sexp.each_of_type(type) do |child_sexp|
+        yield node_class.new(child_sexp)
+      end
+    end
+
+    def each_module(&block)
+      each_of_type(:module, &block)
+    end
+
+    def each_class(&block)
+      each_of_type(:class, &block)
+    end
+
+    def each_singleton_class(&block)
+      each_of_type(:sclass, SingletonMethodNode, &block)
+    end
+
+    def each_instance_method(&block)
+      each_of_type(:defn, InstanceMethodNode, &block)
+    end
+
+    def each_class_method(&block)
+      each_of_type(:defs, ClassMethodNode, &block)
+    end
+
+    def first_line
+      sexp.line
+    end
+
+    def last_line
+      sexp.last.line
+    end
+
+    def line_range
+      (first_line..last_line)
+    end
+
+    def hide_methods_from_next_round
+      sexp.find_and_replace_all(:defn, :ignore_me)
+      sexp.find_and_replace_all(:defs, :ignore_me)
+    end
+
+    def full_method_name(method_separator, class_name, module_name = nil)
+      [module_namespace(module_name), class_name, method_separator, name].join
+    end
+
+    def module_namespace(module_name = nil)
+      if module_name.nil?
+        nil
+      else
+        [module_name, class_method_separator].join
+      end
+    end
+
+    def instance_method_separator
+      "#"
+    end
+
+    def class_method_separator
+      "::"
+    end
+  end
+  class ClassMethodNode < SexpNode
+    def name
+      sexp[2]
+    end
+
+    def full_name(module_name, class_name)
+      full_method_name(class_method_separator, class_name, module_name)
+    end
+  end
+  class InstanceMethodNode < SexpNode
+    def full_name(module_name, class_name)
+      full_method_name(instance_method_separator, class_name, module_name)
+    end
+  end
+  class SingletonMethodNode < SexpNode
+    def full_name(class_name)
+      full_method_name(class_method_separator, class_name)
+    end
+
+    def each_singleton_method(&block)
+      each_of_type(:defn, SingletonMethodNode, &block)
+    end
+  end
+end