bf4-metric_fu 2.1.3.1

data/lib/base/generator.rb

@@ -0,0 +1,166 @@
+module MetricFu
+
+  # = Generator
+  #
+  # The Generator class is an abstract class that provides the
+  # skeleton for producing different types of metrics.
+  #
+  # It drives the production of the metrics through a template
+  # method - #generate_report(options={}).  This method calls
+  # #emit, #analyze and #to_h in order to produce the metrics.
+  #
+  # To implement a concrete class to generate a metric, therefore,
+  # the class must implement those three methods.
+  #
+  # * #emit should take care of running the metric tool and
+  #   gathering its output.
+  # * #analyze should take care of manipulating the output from
+  #   #emit and making it possible to store it in a programmatic way.
+  # * #to_h should provide a hash representation of the output from
+  #   #analyze ready to be serialized into yaml at some point.
+  #
+  # == Pre-conditions
+  #
+  # Based on the class name of the concrete class implementing a
+  # Generator, the Generator class will create a 'metric_directory'
+  # named after the class under the MetricFu.scratch_directory, where
+  # any output from the #emit method should go.
+  #
+  # It will also create the MetricFu.output_directory if neccessary, and
+  # in general setup the directory structure that the MetricFu system
+  # expects.
+  class Generator
+    attr_reader :report, :template
+
+    def initialize(options={})
+      create_metric_dir_if_missing
+      create_output_dir_if_missing
+      create_data_dir_if_missing
+    end
+
+    # Creates a new generator and returns the output of the
+    # #generate_report method.  This is the typical way to
+    # generate a new MetricFu report. For more information see
+    # the #generate_report instance method.
+    #
+    # @params options Hash
+    #   A currently unused hash to configure the Generator
+    #
+    # @see generate_report
+    def self.generate_report(options={})
+      generator = self.new(options)
+      generator.generate_report
+    end
+
+    # Provides the unqualified class name of an implemented concrete
+    # class, as a string.  For example:
+    #
+    #   class Flay < Generator; end
+    #   klass = Flay.new
+    #   klass.class_name
+    #   > "flay"
+    #
+    # @return String
+    #   The unqualified class name of this concrete class, returned
+    #   as a string.
+    def self.class_name
+      self.to_s.split('::').last.downcase
+    end
+
+    # Returns the directory where the Generator will write any output
+    def self.metric_directory
+      File.join(MetricFu.scratch_directory, class_name)
+    end
+
+    def create_metric_dir_if_missing #:nodoc:
+      unless File.directory?(metric_directory)
+        FileUtils.mkdir_p(metric_directory, :verbose => false)
+      end
+    end
+
+    def create_output_dir_if_missing #:nodoc:
+      unless File.directory?(MetricFu.output_directory)
+        FileUtils.mkdir_p(MetricFu.output_directory, :verbose => false)
+      end
+    end
+
+    def create_data_dir_if_missing #:nodoc:
+      unless File.directory?(MetricFu.data_directory)
+        FileUtils.mkdir_p(MetricFu.data_directory, :verbose => false)
+      end
+    end
+
+    # @return String
+    #   The path of the metric directory this class is using.
+    def metric_directory
+      self.class.metric_directory
+    end
+
+    def remove_excluded_files(paths, globs_to_remove = MetricFu.file_globs_to_ignore)
+      files_to_remove = []
+      globs_to_remove.each do |glob|
+        files_to_remove.concat(Dir[glob])
+      end
+      paths - files_to_remove
+    end
+
+    # Defines some hook methods for the concrete classes to hook into.
+    %w[emit analyze].each do |meth|
+      define_method("before_#{meth}".to_sym) {}
+      define_method("after_#{meth}".to_sym) {}
+    end
+    define_method("before_to_h".to_sym) {}
+
+    # Provides a template method to drive the production of a metric
+    # from a concrete implementation of this class.  Each concrete
+    # class must implement the three methods that this template method
+    # calls: #emit, #analyze and #to_h.  For more details, see the
+    # class documentation.
+    #
+    # This template method also calls before_emit, after_emit... etc.
+    # 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
+
+      %w[emit analyze].each do |meth|
+        send("before_#{meth}".to_sym)
+        send("#{meth}".to_sym)
+        send("after_#{meth}".to_sym)
+      end
+      before_to_h()
+      to_h()
+    end
+
+    def round_to_tenths(decimal)
+      decimal = 0.0 if decimal.to_s.eql?('NaN')
+      (decimal * 10).round / 10.0
+    end
+
+    def emit #:nodoc:
+      raise <<-EOF
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more
+        information.
+      EOF
+    end
+
+    def analyze #:nodoc:
+      raise <<-EOF
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more
+        information.
+      EOF
+    end
+
+    def to_graph #:nodoc:
+      raise <<-EOF
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more
+        information.
+      EOF
+    end
+  end
+end

data/lib/base/graph.rb

@@ -0,0 +1,44 @@
+module MetricFu
+
+  def self.graph
+    @graph ||= Graph.new
+  end
+
+  class Graph
+
+    attr_accessor :clazz
+
+    def initialize
+      self.clazz = []
+    end
+
+    def add(graph_type, graph_engine)
+      grapher_name = graph_type.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } + graph_engine.to_s.capitalize + "Grapher"
+      self.clazz.push MetricFu.const_get(grapher_name).new
+    end
+
+
+    def generate
+      return if self.clazz.empty?
+      puts "Generating graphs"
+      Dir[File.join(MetricFu.data_directory, '*.yml')].sort.each do |metric_file|
+        puts "Generating graphs for #{metric_file}"
+        date_parts = year_month_day_from_filename(metric_file)
+        metrics = YAML::load(File.open(metric_file))
+
+        self.clazz.each do |grapher|
+          grapher.get_metrics(metrics, "#{date_parts[:m]}/#{date_parts[:d]}")
+        end
+      end
+      self.clazz.each do |grapher|
+        grapher.graph!
+      end
+    end
+
+    private
+    def year_month_day_from_filename(path_to_file_with_date)
+      date = path_to_file_with_date.match(/\/(\d+).yml$/)[1]
+      {:y => date[0..3].to_i, :m => date[4..5].to_i, :d => date[6..7].to_i}
+    end
+  end
+end

data/lib/base/grouping.rb

@@ -0,0 +1,42 @@
+[
+  '/base/table'
+  ].each do |path|
+  require File.expand_path(File.join(MetricFu::LIB_ROOT,path))
+end
+module MetricFu
+  class Grouping
+
+    def initialize(table, opts)
+      column_name = opts.fetch(:by)
+      order = opts.fetch(:order) { nil }
+      hash = {}
+      if column_name.to_sym == :metric # special optimized case
+        hash = table.group_by_metric
+      else
+        table.each do |row|
+          hash[row[column_name]] ||= Table.new(:column_names => row.attributes)
+          hash[row[column_name]] << row
+        end
+      end
+      if order
+        @arr = hash.sort_by &order
+      else
+        @arr = hash.to_a
+      end
+    end
+
+    def [](key)
+      @arr.each do |group_key, table|
+        return table if group_key == key
+      end
+      return nil
+    end
+
+    def each
+      @arr.each do |value, rows|
+        yield value, rows
+      end
+    end
+
+  end
+end

data/lib/base/line_numbers.rb

@@ -0,0 +1,79 @@
+require 'ruby_parser'
+module MetricFu
+  class LineNumbers
+
+    def initialize(contents)
+      rp = RubyParser.new
+      @locations = {}
+      file_sexp = rp.parse(contents)
+      case file_sexp[0]
+      when :class
+        process_class(file_sexp)
+      when :module
+        process_module(file_sexp)
+      when :block
+        file_sexp.each_of_type(:class) { |sexp| process_class(sexp) }
+      else
+        puts "Unexpected sexp_type #{file_sexp[0].inspect}"
+      end
+    rescue Exception => e
+      #catch errors for files ruby_parser fails on
+      puts "#{e.class}\t#{e.message}\t#{class_name.inspect}\t#{sexp.inspect}\t#{e.backtrace}"
+      @locations
+    end
+
+    def in_method? line_number
+      !!@locations.detect do |method_name, line_number_range|
+        line_number_range.include?(line_number)
+      end
+    end
+
+    def method_at_line line_number
+      found_method_and_range = @locations.detect 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
+
+    def start_line_for_method(method)
+      return nil unless @locations.has_key?(method)
+      @locations[method].first
+    end
+
+    private
+
+    def process_module(sexp)
+      module_name = sexp[1]
+      sexp.each_of_type(:class) do |sexp|
+        process_class(sexp, module_name)
+        hide_methods_from_next_round(sexp)
+      end
+      process_class(sexp)
+    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) }
+    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)
+      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)
+    end
+
+  end
+end

data/lib/base/location.rb

@@ -0,0 +1,87 @@
+module MetricFu
+  class Location
+    include Comparable
+
+    attr_accessor :class_name, :method_name, :file_path, :simple_method_name, :hash
+
+    def self.get(file_path, class_name, method_name)
+      # This could be more 'confident' using Maybe, but we want it to be as fast as possible
+      file_path_copy = file_path == nil ? nil : file_path.clone
+      class_name_copy = class_name == nil ? nil : class_name.clone
+      method_name_copy = method_name == nil ? nil : method_name.clone
+      key = [file_path_copy, class_name_copy, method_name_copy]
+      @@locations ||= {}
+      if @@locations.has_key?(key)
+        @@locations[key]
+      else
+        location = self.new(file_path_copy, class_name_copy, method_name_copy)
+        @@locations[key] = location
+        location.freeze  # we cache a lot of method call results, so we want location to be immutable
+        location
+      end
+    end
+
+    def initialize(file_path, class_name, method_name)
+      @file_path = file_path
+      @class_name = class_name
+      @method_name = method_name
+      @simple_method_name = @method_name.sub(@class_name,'') unless @method_name == nil
+      @hash = [@file_path, @class_name, @method_name].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 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 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.
+          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
+      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
+
+    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/base/md5_tracker.rb

@@ -0,0 +1,52 @@
+require 'digest/md5'
+require 'fileutils'
+
+module MetricFu
+  class MD5Tracker
+
+    @@unchanged_md5s = []
+
+    class << self
+      def md5_dir(path_to_file, base_dir)
+        File.join(base_dir,
+                  path_to_file.split('/')[0..-2].join('/'))
+      end
+
+      def md5_file(path_to_file, base_dir)
+        File.join(md5_dir(path_to_file, base_dir),
+                  path_to_file.split('/').last.sub(/\.[a-z]+/, '.md5'))
+      end
+
+      def track(path_to_file, base_dir)
+        md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        FileUtils.mkdir_p(md5_dir(path_to_file, base_dir), :verbose => false)
+        f = File.new(md5_file(path_to_file, base_dir), "w")
+        f.puts(md5)
+        f.close
+        md5
+      end
+
+      def file_changed?(path_to_file, base_dir)
+        orig_md5_file = md5_file(path_to_file, base_dir)
+        return !!track(path_to_file, base_dir) unless File.exist?(orig_md5_file)
+
+        current_md5 = ""
+        file = File.open(orig_md5_file, 'r')
+        file.each_line { |line| current_md5 << line }
+        file.close
+        current_md5.chomp!
+
+        new_md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        new_md5.chomp!
+
+        @@unchanged_md5s << path_to_file if new_md5 == current_md5
+
+        return new_md5 != current_md5
+      end
+
+      def file_already_counted?(path_to_file)
+        return @@unchanged_md5s.include?(path_to_file)
+      end
+    end
+  end
+end