fastruby-metric_fu 5.0.0

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

data/lib/metric_fu/environment.rb

@@ -0,0 +1,129 @@
+require "redcard"
+require "rbconfig"
+MetricFu.lib_require { "logger" }
+module MetricFu
+  module Environment
+    # TODO: Set log_level here, instead
+    def verbose
+      MetricFu.logger.debug_on
+    end
+
+    def verbose=(toggle)
+      MetricFu.logger.debug_on = toggle
+    end
+
+    # Perform a simple check to try and guess if we're running
+    # against a rails app.
+    #
+    # TODO This should probably be made a bit more robust.
+    def rails?
+      @rails ||= begin
+                   exists = File.exist?("config/environment.rb")
+                   def MetricFu.rails?
+                     exists
+                   end
+                   exists
+                 end
+    end
+
+    def is_cruise_control_rb?
+      !!ENV["CC_BUILD_ARTIFACTS"]
+    end
+
+    def jruby?
+      @jruby ||= !!RedCard.check(:jruby)
+    end
+
+    def mri?
+      @mri ||= !!RedCard.check(:ruby)
+    end
+
+    def ruby_flavor
+      @ruby_flavor ||= RedCard.engine
+    end
+
+    def ruby_version
+      @ruby_version ||= RedCard.engine_version
+    end
+
+    def ruby18?
+      @ruby18 ||= mri? && !!RedCard.check("1.8"..."1.9")
+    end
+
+    def ruby192?
+      @ruby192 ||= mri? && ruby_version == "1.9.2"
+    end
+
+    def rubinius?
+      @rubinius ||= !!RedCard.check(:rubinius)
+    end
+
+    def supports_ripper?
+      @supports_ripper ||= begin
+                             require "ripper"
+                             true
+                           rescue LoadError
+                             false
+                           end
+    end
+
+    def platform #:nodoc:
+      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" => MetricFu::GemVersion.dependencies_summary,
+      }
+    end
+
+    def debug_info
+      @debug_info ||= {
+        "Ruby" => ruby_details,
+        "Environment" => environment_details,
+        "MetricFu" => library_details,
+      }
+    end
+
+    def osx?
+      @osx ||= platform.include?("darwin")
+    end
+
+    def ruby_strangely_makes_accessors_private?
+      @private_accessors ||= ruby192? || jruby?
+    end
+    module_function :ruby_strangely_makes_accessors_private?
+  end
+end

data/lib/metric_fu/errors/analysis_error.rb

@@ -0,0 +1,4 @@
+module MetricFu
+  class AnalysisError < RuntimeError
+  end
+end

data/lib/metric_fu/formatter.rb

@@ -0,0 +1,40 @@
+require "metric_fu/constantize"
+module MetricFu
+  module Formatter
+    BUILTIN_FORMATS = {
+      "html" => ["MetricFu::Formatter::HTML", "Generates a templated HTML report using the configured template class and graph engine."],
+      "yaml" => ["MetricFu::Formatter::YAML", "Generates the raw output as yaml"]
+    }
+    DEFAULT = [[:html]]
+
+    class << self
+      include MetricFu::Constantize
+
+      def class_for(format)
+        if (builtin = BUILTIN_FORMATS[format.to_s])
+          constantize(builtin[0])
+        else
+          constantize(format.to_s)
+        end
+      end
+    end
+
+    module Templates
+      MetricFu.lib_require { "templates/metrics_template" }
+
+      module_function
+
+      def templates_configuration=(templates_configuration)
+        @templates_configuration = templates_configuration
+      end
+
+      def option(name)
+        templates_configuration.option(name)
+      end
+
+      def templates_configuration
+        @templates_configuration ||= MetricFu::Templates::Configuration.new
+      end
+    end
+  end
+end

data/lib/metric_fu/formatter/html.rb

@@ -0,0 +1,96 @@
+require "launchy"
+MetricFu.formatter_require { "yaml" }
+MetricFu.reporting_require { "graphs/graph" }
+module MetricFu
+  module Formatter
+    class HTML
+      include MetricFu::Io
+
+      def initialize(opts = {})
+        @options = opts
+      end
+
+      def finish
+        mf_log "** SAVING REPORTS"
+        mf_debug "** SAVING REPORT YAML OUTPUT TO #{MetricFu::Io::FileSystem.directory('base_directory')}"
+        MetricFu::Formatter::YAML.new.finish
+
+        mf_debug "** SAVING REPORT DATA OUTPUT TO #{MetricFu::Io::FileSystem.directory('data_directory')}"
+        # TODO: Allow customizing output filenames
+        MetricFu::Formatter::YAML.new(
+          output: MetricFu.run_path.join("#{MetricFu::Io::FileSystem.directory('data_directory')}/#{MetricFu.report_id}.yml")
+        ).finish
+
+        mf_debug "** SAVING TEMPLATIZED REPORT"
+        save_templatized_result
+        save_graphs
+      end
+
+      def write_template(output, file)
+        write_output(output, "#{output_directory}/#{file}")
+      end
+
+      def display_results
+        if self.open_in_browser?
+          mf_debug "** OPENING IN BROWSER FROM #{output_directory}"
+          show_in_browser(output_directory)
+        end
+      end
+
+      protected
+
+      def output_directory
+        @output ||= dir_for(@options[:output]) || MetricFu.run_path.join(MetricFu::Io::FileSystem.directory("output_directory"))
+      end
+
+      # Instantiates a new template class based on the configuration set
+      # in MetricFu::Configuration, or through the MetricFu.config block
+      # in your rake file (defaults to the included MetricFu::Templates::MetricsTemplate),
+      # assigns the result_hash to the result_hash in the template, and
+      # tells the template to to write itself out.
+      def save_templatized_result
+        @template = MetricFu::Formatter::Templates.option("template_class").new
+        @template.output_directory = output_directory
+        @template.result = MetricFu.result.result_hash
+        @template.per_file_data = MetricFu.result.per_file_data
+        @template.formatter = self
+        @template.write
+      end
+
+      def save_graphs
+        mf_log "** GENERATING GRAPHS"
+        mf_debug "** PREPARING TO GRAPH"
+        MetricFu.configuration.graphed_metrics.each {|graphed_metric|
+          mf_debug "** Graphing #{graphed_metric} with #{MetricFu.configuration.graph_engine}"
+          # TODO: This should probably be defined on configuration
+          #   rather than the module. See MetricFu::Graph
+          MetricFu.graph.add(graphed_metric, MetricFu.configuration.graph_engine, output_directory)
+        }
+        mf_debug "** GENERATING GRAPH"
+        MetricFu.graph.generate
+      end
+
+      # Checks to discover whether we should try and open the results
+      # of the report in the browser on this system.  We only try and open
+      # in the browser if we're not running in a CruiseControl.rb environment.
+      # See MetricFu.configuration for more details about how we make those guesses.
+      #
+      # @return Boolean
+      #   Should we open in the browser or not?
+      def open_in_browser?
+        !MetricFu.configuration.is_cruise_control_rb?
+      end
+
+      # Shows 'index.html' from the passed directory in the browser
+      # if we're able to open the browser on this platform.
+      #
+      # @param dir Pathname
+      #   The directory path where the 'index.html' we want to open is
+      #   stored
+      def show_in_browser(dir)
+        uri = URI.join(URI.escape("file://#{dir}/"), "index.html")
+        Launchy.open(uri) if open_in_browser?
+      end
+    end
+  end
+end