code_metric_fu 4.14.0

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/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

data/lib/metric_fu/formatter/syntax.rb

@@ -0,0 +1,45 @@
+require "coderay"
+MetricFu.lib_require { "utility" }
+# CodeRay options
+# used to analyze source code, because object Tokens is a list of tokens with specified types.
+# :tab_width – tabulation width in spaces. Default: 8
+# :css – how to include the styles (:class и :style). Default: :class)
+#
+# :wrap – wrap result in html tag :page, :div, :span or not to wrap (nil)
+#
+# :line_numbers – how render line numbers (:table, :inline, :list or nil)
+#
+# :line_number_start – first line number
+#
+# :bold_every – make every n-th line number bold. Default: 10
+module MetricFu
+  module Formatter
+    class Syntax
+      def initialize
+        @options = { css: :class, style: :alpha }
+        @line_number_options = { line_numbers: :inline, line_number_start: 0 }
+      end
+
+      def highlight(ruby_text, line_number)
+        tokens = tokenize(ruby_text)
+        tokens.div(highlight_options(line_number))
+      end
+
+      def highlight_options(line_number)
+        line_number = line_number.to_i
+        if line_number > 0
+          @options.merge(@line_number_options.merge(line_number_start: line_number))
+        else
+          @options
+        end
+      end
+
+      private
+
+      def tokenize(ruby_text)
+        ascii_text = MetricFu::Utility.clean_ascii_text(ruby_text)
+        tokens = CodeRay.scan(ascii_text, :ruby)
+      end
+    end
+  end
+end

data/lib/metric_fu/formatter/yaml.rb

@@ -0,0 +1,18 @@
+module MetricFu
+  module Formatter
+    class YAML
+      include MetricFu::Io
+
+      DEFAULT_PATH = "report.yml"
+
+      def initialize(opts = {})
+        @options = opts
+        @path_or_io = @options[:output] || DEFAULT_PATH
+      end
+
+      def finish
+        write_output(MetricFu.result.as_yaml, @path_or_io)
+      end
+    end
+  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/gem_run.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+require "open3"
+require "shellwords"
+require "metric_fu"
+MetricFu.lib_require { "logger" }
+MetricFu.lib_require { "gem_version" }
+module MetricFu
+  class GemRun
+    attr_reader :output, :gem_name, :library_name, :version, :arguments
+    def initialize(arguments = {})
+      @gem_name    = arguments.fetch(:gem_name)
+      @library_name = arguments.fetch(:metric_name)
+      @version = arguments.fetch(:version) { MetricFu::GemVersion.for(library_name) }
+      args = arguments.fetch(:args)
+      @arguments = args.respond_to?(:scan) ? Shellwords.shellwords(args) : args
+      @output = ""
+      @errors = []
+    end
+
+    def summary
+      "RubyGem #{gem_name}, library #{library_name}, version #{version}, arguments #{arguments}"
+    end
+
+    def run
+      @output = execute
+    end
+
+    def execute
+      mf_debug "Running #{summary}"
+      captured_output = ""
+      captured_errors = ""
+      thread = ""
+      Open3.popen3("#{library_name}", *arguments) do |_stdin, stdout, stderr, wait_thr|
+        captured_output << stdout.read.chomp
+        captured_errors << stderr.read.chomp
+        thread = wait_thr
+      end
+    rescue StandardError => run_error
+      handle_run_error(run_error)
+    rescue SystemExit => system_exit
+      handle_system_exit(system_exit)
+    ensure
+      print_errors
+      return captured_output, captured_errors, thread.value
+    end
+
+    def handle_run_error(run_error)
+      @errors << "ERROR: #{run_error.inspect}"
+    end
+
+    def handle_system_exit(system_exit)
+      status =  system_exit.success? ? "SUCCESS" : "FAILURE"
+      message = "#{status} with code #{system_exit.status}: " <<
+                "#{system_exit.message}: #{system_exit.backtrace.inspect}"
+      if status == "SUCCESS"
+        mf_debug message
+      else
+        @errors << message
+      end
+    end
+
+    def print_errors
+      return if @errors.empty?
+      STDERR.puts "ERRORS running #{summary}"
+      @errors.each do |error|
+        STDERR.puts "\t" << error
+      end
+    end
+  end
+end

data/lib/metric_fu/gem_version.rb

@@ -0,0 +1,92 @@
+# coding: utf-8
+require "rubygems"
+module MetricFu
+  class GemVersion
+    # regexp from https://github.com/gemnasium/gemnasium-parser/blob/807d7ccc/lib/gemnasium/parser/patterns.rb#L11
+    #   under MIT License
+    GEM_NAME = /[a-zA-Z0-9\-_\.]+/
+    QUOTED_GEM_NAME = /(?:(?<gq>["'])(?<name>#{GEM_NAME})\k<gq>|%q<(?<name>#{GEM_NAME})>)/
+    MATCHER = /(?:=|!=|>|<|>=|<=|~>)/
+    VERSION = /[0-9]+(?:\.[a-zA-Z0-9]+)*/
+    REQUIREMENT = /[ \t]*(?:#{MATCHER}[ \t]*)?#{VERSION}[ \t]*/
+    REQUIREMENT_LIST = /(?<qr1>["'])(?<req1>#{REQUIREMENT})\k<qr1>(?:[ \t]*,[ \t]*(?<qr2>["'])(?<req2>#{REQUIREMENT})\k<qr2>)?/
+    REQUIREMENTS = /(?:#{REQUIREMENT_LIST}|\[[ \t]*#{REQUIREMENT_LIST}[ \t]*\])/
+    COMMENT = /(#[^\n]*)?/
+    ADD_DEPENDENCY_CALL = /^[ \t]*\w+\.add(?<type>_runtime|_development)?_dependency\(?[ \t]*#{QUOTED_GEM_NAME}(.freeze)?(?:[ \t]*,[ \t]*#{REQUIREMENTS})?[ \t]*\)?[ \t]*#{COMMENT}$/
+
+    def initialize
+      @gem_spec = File.open(gemspec, "rb") { |f| f.readlines }
+    end
+
+    def gemspec
+      File.join(MetricFu.root_dir, "metric_fu.gemspec")
+    end
+
+    def new_dependency(name, version)
+      Gem::Dependency.new(name, version, :runtime)
+    end
+
+    def gem_runtime_dependencies
+      @gem_runtime_dependencies ||=
+        begin
+          @gem_spec.grep(/add_dependency|add_runtime/).map do |line|
+            match = line.match(ADD_DEPENDENCY_CALL)
+            name = match["name"].downcase.sub("metric_fu-", "")
+            version = [match["req1"], match["req2"]].compact
+            new_dependency(name, version)
+          end.compact << new_dependency("rcov", ["~> 0.8"])
+        end
+    end
+
+    def for(name)
+      name.downcase!
+      dep = gem_runtime_dependencies.find(unknown_dependency(name)) do |gem_dep|
+        gem_dep.name == name
+      end
+
+      dep.requirements_list
+    end
+
+    def unknown_dependency(name)
+      -> { new_dependency(name, [">= 0"]) }
+    end
+
+    RESOLVER = new
+    def self.for(name)
+      RESOLVER.for(name).dup
+    end
+
+    def self.dependencies
+      RESOLVER.gem_runtime_dependencies.dup
+    end
+
+    def self.activated_gems
+      if Gem::Specification.respond_to?(:stubs)
+        Gem::Specification.stubs
+      else
+        Gem.loaded_specs.values
+      end.select(&:activated?)
+    end
+
+    def self.activated_version(name)
+      activated_gems.find do |gem|
+        return gem.version.version if gem.name == name
+      end
+    end
+
+    def self.dependency_summary(gem_dep)
+      name = gem_dep.name
+      version = activated_version(gem_dep.name) || gem_dep.requirements_list
+      {
+        "name" => name,
+        "version" => version,
+      }
+    end
+
+    def self.dependencies_summary
+      dependencies.map do |gem_dep|
+        dependency_summary(gem_dep)
+      end
+    end
+  end
+end

data/lib/metric_fu/generator.rb

@@ -0,0 +1,135 @@
+MetricFu.lib_require { "utility" }
+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_result(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 metric under the scratch_directory, where
+  # any output from the #emit method should go.
+  #
+  # It will also create the output_directory if neccessary, and
+  # in general setup the directory structure that the MetricFu system
+  # expects.
+  class Generator
+    attr_reader :result, :template, :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def self.metric
+      not_implemented
+    end
+
+    def metric
+      self.class.metric
+    end
+
+    @generators = []
+    # @return all subclassed generators [Array<MetricFu::Generator>]
+    def self.generators
+      @generators
+    end
+
+    def self.get_generator(metric)
+      generators.find { |generator|generator.metric.to_s == metric.to_s.downcase }
+    end
+
+    def self.inherited(subclass)
+      @generators << subclass
+    end
+
+    # Returns the directory where the Generator will write any output
+    def self.metric_directory
+      @metric_directory ||=
+        MetricFu::Metric.get_metric(metric).run_options[:output_directory] ||
+        begin
+          metric_directory = MetricFu::Io::FileSystem.scratch_directory(metric)
+          MetricFu::Utility.mkdir_p(metric_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::Io::FileSystem.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
+
+    def metric_config
+      MetricFu::Metric.get_metric(metric)
+    end
+
+    def run!(args)
+      metric_config.run_external(args)
+    end
+
+    # 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_result
+      mf_debug "Executing #{metric}"
+      emit
+      analyze
+      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:
+      self.class.not_implemented
+    end
+
+    def analyze #:nodoc:
+      self.class.not_implemented
+    end
+
+    def to_h #:nodoc:
+      self.class.not_implemented
+    end
+
+    def self.not_implemented
+      raise NotImplementedError.new <<-EOF
+        Required method #{caller[0]} not implemented in #{__FILE__}.
+        This method must be implemented by a concrete class descending
+        from Generator.  See generator class documentation for more
+        information.
+      EOF
+    end
+  end
+end