fastruby-metric_fu 5.0.0

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

data/lib/metric_fu/io.rb

@@ -0,0 +1,132 @@
+MetricFu.lib_require { "utility" }
+module MetricFu
+  module Io
+    # TODO: Move this module / functionality elsewhere and make less verbose
+    module FileSystem
+      # TODO: Use a better environmental variable name for the output / artiface dir.  Set to a different default in tests.
+      @default_artifact_dir = "tmp/metric_fu"
+      def self.default_artifact_dir
+        @default_artifact_dir
+      end
+      def self.artifact_dir
+        (ENV["CC_BUILD_ARTIFACTS"] || @artifact_dir)
+      end
+      def self.artifact_dir=(artifact_dir)
+        @artifact_dir = artifact_dir
+      end
+      self.artifact_dir = default_artifact_dir
+
+      module_function
+
+      def directories
+        @directories ||= {}
+      end
+
+      def directory(name)
+        directories.fetch(name) { raise "No such directory configured: #{name}" }
+      end
+
+      def scratch_directory(name)
+        File.join(directory("scratch_directory"), name.to_s)
+      end
+
+      def file_globs_to_ignore
+        @file_globs_to_ignore ||= []
+      end
+
+      def set_directories
+        @directories = {}
+        @directories["base_directory"]    = MetricFu.artifact_dir
+        @directories["scratch_directory"] = MetricFu.scratch_dir
+        @directories["output_directory"]  = MetricFu.output_dir
+        @directories["data_directory"]    = MetricFu.data_dir
+        create_directories @directories.values
+
+        @directories["root_directory"]    = MetricFu.root_dir
+        # TODO Though this is true of the general AwesomeTemplate, it is not necessarily true of templates within each Metric.  Each metric should probably know how to use AwesomeTemplate (or whatever)
+        @directories["template_directory"] = File.join(@directories.fetch("root_directory"), "lib", "templates")
+        @file_globs_to_ignore = []
+        set_code_dirs
+      end
+
+      def create_directories(*dirs)
+        # due to behavior differences between ruby 1.8.7 and 1.9.3
+        # this is good enough for now
+        Array(*dirs).each do |dir|
+          MetricFu::Utility.mkdir_p dir
+        end
+      end
+
+      # Add the 'app' directory if we're running within rails.
+      def set_code_dirs
+        @directories["code_dirs"] = %w(app lib).select { |dir| Dir.exist?(dir) }
+      end
+    end
+
+    # Writes the output to a file or io stream.
+    # @param output [String, #to_s] the content to write.
+    # @param path_or_io [String, #to_s, IO, #write] a file path
+    #   or an io stream that responds to write.
+    # @return [nil]
+    def write_output(output, path_or_io)
+      io_for(path_or_io) do |io|
+        io.write(output)
+      end
+    end
+
+    # Yields an io object for writing output.
+    # @example
+    #   io_for('path/to/file') do |io|
+    #     io.write(output)
+    #   end
+    #
+    #   io_for(STDOUT) do |io|
+    #     io.write(output)
+    #   end
+    #
+    #   stream = StringIO.new
+    #   io_for(stream) do |io|
+    #     io.write(output)
+    #   end
+    #
+    # @param path_or_io [String, #to_s, IO, #write] a file path
+    #   or an io stream that responds to write.
+    #
+    # @yield [IO] an open stream for writing.
+    #
+    # @note Given a path to a file, an open file will
+    #   be yielded and closed after the block completes.
+    #   Given an existing io stream, the stream will not
+    #   be automatically closed. Cleanup, if necessary, is
+    #   the responsibility of the caller.
+    def io_for(path_or_io, &block)
+      raise ArgumentError, "No path or io provided." if path_or_io.nil?
+      raise ArgumentError, "No block given. Cannot yield io stream." unless block_given?
+
+      if path_or_io.respond_to?(:write)
+        # We have an existing open stream...
+        block.call(path_or_io)
+      else # Otherwise, we assume its a file path...
+        file_for(path_or_io, &block)
+      end
+    end
+
+    def file_for(path, &block)
+      File.open(path_relative_to_base(path), "w") do |file|
+        block.call(file)
+      end
+    end
+
+    def dir_for(path)
+      return nil if path.nil?
+      pathname = path_relative_to_base(path)
+      MetricFu::Utility.mkdir_p(pathname) unless File.directory?(pathname)
+      pathname
+    end
+
+    def path_relative_to_base(path)
+      pathname = MetricFu.run_path.join(MetricFu::Io::FileSystem.directory("base_directory")) # make full path relative to base directory
+      pathname.join(path)
+    end
+  end
+end