metric_fu 4.4.1 → 4.4.2

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 5b6391c40e351ab9265635b6b35f32662bbe450c
-  data.tar.gz: eb534c71875d84de4e477332a365de843ec7dfb3
-SHA512:
-  metadata.gz: 7a9d4acd5a6b37a5ce18219ff9e8e363395e7f8c65f0fcaae138f0c6660172eefd49006371df55fd1cad2984e30cd91ccc64aaf6d7d1e170d1c37d2e6d3c9e12
-  data.tar.gz: c6dd298de619f6628ae7c5b46026bc7819ff38a9912f1bdd1e13da5e7b70fee82446397b3e6eb08fe602db6e3a7a78f395739874d95e357a6efda95e9eaa5acc
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTFmYmRkMmExNTg1MDBhMDI0MTQ1OTFiMGJkNDc1MTY2OTdlYTJiNQ==
+  data.tar.gz: !binary |-
+    ZDQ5OGMzN2QwNWE0M2JmMTM0ZTljYTA4OTFhYjBhNzgzZGVkYjYzMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZTFlNDhmNDE1NjM1ZmMxODlmYjQ1NDZjMDI4MWE4NzBiMDFjNDc5YTBkODc2
+    NzZkZTA1ZTA1OWRhYjYyZmZmZDcxOGVmMGE1ODcxY2E1ZWEzMTliNDUxOTgx
+    NDdkYTNkNGViYTBmZmFhYWFjYzFlNTk1ZTNkZGRlOTFhY2VmNTc=
+  data.tar.gz: !binary |-
+    OTY3Y2ZkMGVlZmJjNzM4MDQxZmMyNWIyNjU1OThmZTVmZDI4YTQyZjYxMDJi
+    MjYxMGQyYjM4YTcyNjliYTdlMjlkYzFmMjhlYjA0OTA2OTJiNDI1NzUwODM4
+    MzZkOTkyMzBmM2Q1N2IwYWNmMjc5MDQ2ZDJlYTFlNjhiNjkwZWI=

data/CONTRIBUTORS

@@ -0,0 +1 @@
+George Erickson

data/Gemfile

@@ -14,7 +14,7 @@ group :test do
     # https://github.com/kina/simplecov-rcov-text
     gem 'simplecov-rcov-text'
   end
-  gem "fakefs", :require => "fakefs/safe"
+  gem "fakefs", :require => "fakefs/safe", :platform => :ruby
   gem 'json'
 end
 gemspec :path => File.expand_path('..', __FILE__)

data/HISTORY.md

@@ -10,6 +10,19 @@ As such, a _Feature_ would map to either major or minor. A _bug fix_ to a patch.
 * Fixes
 * Misc
 
+### MetricFu [4.4.2 / 2013-09-25](https://github.com/metricfu/metric_fu/compare/v4.4.1...v4.4.2)
+
+* Features
+  * Add --debug-info command line switch to get debug info for Issues. (calveto, #118)
+* Fixes
+  * Return valid line locations for code with either no AST or nil nodes (Benjamin Fleischer, #137)
+  * Only use FakeFS on MRI.  Avoid intermittent failures on JRuby or Rubinius (Benjamin Fleischer, #135)
+  * Hotspots no longer serialize actual classes to YAML. (Benjamin Fleischer, #128)
+* Misc
+  * Extract SexpNode class from LineNumbers to handle Sexp Processing (Benjamin Fleischer, #137)
+  * Separate out Hotspot ranked problem location and misc code improvements (Benjamin Fleischer, #128)
+  * Identify directories with code to analyze by checking if they exist. (No longer use :rails? as a proxy for checking if we should run on 'app'). (George Erickson, #129)
+
 ### MetricFu [4.4.1 / 2013-08-29](https://github.com/metricfu/metric_fu/compare/v4.4.0...v4.4.1)
 
 * Features

data/checksum/metric_fu-4.4.1.gem.sha512

@@ -0,0 +1 @@
+bbcd106dba00bcf0c1bfe8562d012a82f0945d8388bcd768598b872c35655668bfc9d0c1e7b0d67369713902dd9f1dd6fba9b83b21d79fe8ee774a2f8fa2defe

data/lib/metric_fu/cli/parser.rb

@@ -65,6 +65,7 @@ module MetricFu
             p.on_tail("-h", "--help", "Show this message") {puts p ; exit}
             short = @used_short.include?("v") ? "-V" : "-v"
             p.on_tail(short, "--version", "Print version") {puts @version ; exit} unless @version.nil?
+            p.on_tail("--debug-info", "Print debug info") { debug_info; exit }
             @default_values = @result.clone # save default values to reset @result in subsequent calls
           end
 
@@ -78,6 +79,12 @@ module MetricFu
           @result
         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

data/lib/metric_fu/data_structures/line_numbers.rb

@@ -1,63 +1,39 @@
-# MetricFu::LineNumber
-# (see #initialize)
-require 'ruby_parser'
+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
-        rp = RubyParser.new
-        @locations = {}
-        file_sexp = rp.parse(contents)
-        case file_sexp[0]
-        when nil
-          mf_log "No ruby code found in #{file_path}"
-        when :class
-          process_class(file_sexp)
-        when :module
-          process_module(file_sexp)
-        else
-          mf_debug "SEXP: Parsing line numbers for classes in sexp type #{file_sexp[0].inspect}"
-          mf_debug "      in #{file_path}"
-          file_sexp.each_of_type(:module) { |sexp| process_class(sexp) }
-          file_sexp.each_of_type(:class)  { |sexp| process_class(sexp) }
-        end
+        parse_code(contents)
       end
-    rescue Exception => 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}"
-      @locations
     end
 
-    # @param line_number [String]
+    # @param line_number [Integer]
     # @return [Boolean] if the given line number is in a method
-    def in_method? line_number
-      !!@locations.detect do |method_name, line_number_range|
-        line_number_range.include?(line_number)
-      end
+    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 its first element
-    #   Else return nil
-    def method_at_line line_number
-      found_method_and_range = @locations.detect do |method_name, line_number_range|
+    # 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
-      if found_method_and_range
-        found_method_and_range.first
-      else
-        nil
-      end
+      end.first
     end
 
     # @param method [String] the method name being queried
@@ -69,33 +45,68 @@ module MetricFu
 
     private
 
-    def process_module(sexp)
-      module_name = sexp[1]
-      sexp.each_of_type(:class) do |exp|
-        process_class(exp, module_name)
-        hide_methods_from_next_round(exp)
+    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(sexp)
+      process_class(module_node)
     end
 
-    def process_class(sexp, module_name=nil)
-      class_name = sexp[1]
-      process_class_self_blocks(sexp, class_name)
-      module_name_string = module_name ? "#{module_name}::" : nil
-      sexp.each_of_type(:defn) { |s| @locations["#{module_name_string}#{class_name}##{s[1]}"] = (s.line)..(s.last.line) }
-      sexp.each_of_type(:defs) { |s| @locations["#{module_name_string}#{class_name}::#{s[2]}"] = (s.line)..(s.last.line) }
+    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_class_self_blocks(sexp, class_name)
-      sexp.each_of_type(:sclass) do |sexp_in_class_self_block|
-        sexp_in_class_self_block.each_of_type(:defn) { |s| @locations["#{class_name}::#{s[1]}"] = (s.line)..(s.last.line) }
-        hide_methods_from_next_round(sexp_in_class_self_block)
+    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 hide_methods_from_next_round(sexp)
-      sexp.find_and_replace_all(:defn, :ignore_me)
-      sexp.find_and_replace_all(:defs, :ignore_me)
+    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

data/lib/metric_fu/data_structures/location.rb

@@ -3,34 +3,58 @@ module MetricFu
     include Comparable
 
     attr_accessor :file_path, :file_name, :line_number,
-                  :class_name, :method_name, :simple_method_name, :hash
+                  :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.to_key) do
-        @@locations[location.to_key] = location
+      @@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_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               = to_key.hash
+      @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
 
-    # TODO - we need this method (and hash accessor above) as a temporary hack where we're using Location as a hash key
+    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)
-      # REMOVED per https://github.com/jscruggs/metric_fu/pull/67/files
-      # [self.file_path.to_s, self.class_name.to_s, self.method_name.to_s] == [other.file_path.to_s, other.class_name.to_s, other.method_name.to_s]
       @hash == other.hash
     end
-    # END we need these methods as a temporary hack where we're using Location as a hash key
+
+    def <=>(other)
+      self.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)
@@ -61,14 +85,6 @@ module MetricFu
       self.get(nil, class_name, method_name)
     end
 
-    def <=>(other)
-      [self.file_path.to_s, self.class_name.to_s, self.method_name.to_s] <=> [other.file_path.to_s, other.class_name.to_s, other.method_name.to_s]
-    end
-
-    def to_key
-      [@file_path, @class_name, @method_name]
-    end
-
     def finalize
       @file_path   &&= @file_path.clone
       @file_name   &&= @file_name.clone

data/lib/metric_fu/data_structures/sexp_node.rb

@@ -0,0 +1,89 @@
+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

data/lib/metric_fu/environment.rb

@@ -1,4 +1,5 @@
 require 'redcard'
+require 'rbconfig'
 MetricFu.logging_require { 'mf_debugger' }
 module MetricFu
   module Environment
@@ -66,10 +67,57 @@ module MetricFu
                              false
                            end
     end
+
     def platform #:nodoc:
       return RUBY_PLATFORM
     end
 
+    def version
+      MetricFu::VERSION
+    end
+
+    def environment_details
+      @environment_details ||= {
+        'VERBOSE' => $VERBOSE.inspect,
+        'External Encoding' => Encoding.default_external.to_s,
+        'Internal Encoding' => Encoding.default_internal.to_s,
+        'Host Architecture' => RbConfig::CONFIG['build'],
+        'Ruby Prefix'       => RbConfig::CONFIG['prefix'],
+        'Ruby Options'      => ENV.keys.grep(/RUBYOPT/).map{|key| "#{key}=#{ENV[key]}" }.join(', '),
+      }
+    end
+
+    # To consider
+    # $LOADED_FEATURES
+    # $LOAD_PATH
+    def ruby_details
+      @ruby_details ||= {
+        'Engine' => ruby_flavor,
+        'Version' => ruby_version,
+        'Patchlevel' => (defined?(RUBY_PATCHLEVEL) && RUBY_PATCHLEVEL),
+        'Ripper Support' => supports_ripper?,
+        'Rubygems Version' => Gem::VERSION,
+        'Long Description' => (defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : platform),
+      }
+    end
+
+    def library_details
+      @library_details ||= {
+        'Version' =>  version,
+        'Verbose Mode' => verbose,
+        'Enabled Metrics' => MetricFu::Metric.enabled_metrics.map(&:name),
+        # 'Dependencies' => `gem dependency metric_fu`, # TODO how should we handle this?
+      }
+    end
+
+    def debug_info
+      @debug_info ||= {
+        'Ruby' => ruby_details,
+        'Environment' => environment_details,
+        'MetricFu' => library_details,
+      }
+    end
+
     def osx?
       @osx ||= platform.include?('darwin')
     end