metric_fu 4.4.4 → 4.5.1

data/lib/metric_fu/cli/parser.rb

@@ -13,72 +13,102 @@ module MetricFu
           yield self if block_given?
         end
 
+        def process!(arguments = ARGV)
+          parser = build_option_parser
+          process_options(parser, arguments)
+        end
+
         def option(name, desc, settings = {})
           @options << [name, desc, settings]
         end
 
-        def short_from(name)
-          name.to_s.chars.each do |c|
-            next if @used_short.include?(c) || c == "_"
-            return c # returns from short_from method
-          end
-        end
 
-        def process!(arguments = ARGV)
+        private
+
+        def build_option_parser
           @result = (@default_values || {}).clone # reset or new
+
           @optionparser ||= OptionParser.new do |p| # prepare only once
-            @options.each do |o|
-              @used_short << short = o[2][:short] || short_from(o[0])
-              @result[o[0]] = o[2][:default] || false # set default
-              klass = o[2][:default].class == Fixnum ? Integer : o[2][:default].class
-
-              if [TrueClass, FalseClass, NilClass].include?(klass) # boolean switch
-                p.on("-" << short, "--[no-]" << o[0].to_s.gsub("_", "-"), o[1]) {|x| @result[o[0]] = x}
-              else # argument with parameter
-                p.on("-" << short, "--" << o[0].to_s.gsub("_", "-") << " " << o[2][:default].to_s, klass, o[1]) {|x| @result[o[0]] = x}
-              end
-            end
-
-            p.on("--format FORMAT",
-                 "Specify the formatter to use for output.",
-                 "This option can be specified multiple times.",
-                 "Specify a built-in formatter from the list below,",
-                 "or the fully-qualified class name of your own custom formatter.",
-                 *format_descriptions) do |f|
-              @result[:format] ||= []
-              @result[:format] << [f]
-            end
-
-            p.on("--out FILE|DIR",
-                "Specify the file or directory to use for output",
-                "This option applies to the previously",
-                "specified --format, or the default format",
-                "if no format is specified. Paths are relative to",
-                "#{Pathname.pwd.join(MetricFu::Io::FileSystem.directory('base_directory'))}",
-                "Check the specific formatter\'s docs to see",
-                "whether to pass a file or a dir.") do |o|
-              @result[:format] ||= MetricFu::Formatter::DEFAULT
-              @result[:format].last << o
-            end
-
-            p.banner = @banner unless @banner.nil?
-            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
+            configure_options(p)
           end
+        end
 
+        def process_options(parser, arguments)
           begin
-            @optionparser.parse!(arguments)
+            parser.parse!(arguments)
           rescue OptionParser::ParseError => e
-            puts e.message ; exit(1)
+            puts e.message
+            MetricFu::Cli.immediate_shutdown!
           end
 
-          validate(@result) if self.respond_to?("validate")
           @result
         end
 
+        def configure_options(p)
+          add_general_options(@options, p)
+
+          add_format_option(p)
+          add_output_option(p)
+
+          p.banner = @banner unless @banner.nil?
+          p.on_tail("-h", "--help", "Show this message") {puts p ; success!}
+          short = @used_short.include?("v") ? "-V" : "-v"
+          p.on_tail(short, "--version", "Print version") {puts @version ; success!} unless @version.nil?
+          p.on_tail("--debug-info", "Print debug info") { debug_info; success! }
+          @default_values = @result.clone # save default values to reset @result in subsequent calls
+        end
+
+        def add_general_options(options, p)
+          options.each do |o|
+            add_general_option(p, o)
+          end
+        end
+
+        def add_general_option(p, o)
+          @used_short << short = o[2][:short] || short_from(o[0])
+          @result[o[0]] = o[2][:default] || false # set default
+          klass = o[2][:default].class == Fixnum ? Integer : o[2][:default].class
+
+          if [TrueClass, FalseClass, NilClass].include?(klass) # boolean switch
+            p.on("-" << short, "--[no-]" << o[0].to_s.gsub("_", "-"), o[1]) {|x| @result[o[0]] = x}
+          else # argument with parameter
+            p.on("-" << short, "--" << o[0].to_s.gsub("_", "-") << " " << o[2][:default].to_s, klass, o[1]) {|x| @result[o[0]] = x}
+          end
+        end
+
+        def add_output_option(p)
+          p.on("--out FILE|DIR",
+              "Specify the file or directory to use for output",
+              "This option applies to the previously",
+              "specified --format, or the default format",
+              "if no format is specified. Paths are relative to",
+              "#{MetricFu.run_path.join(MetricFu::Io::FileSystem.directory('base_directory'))}",
+              "Check the specific formatter\'s docs to see",
+              "whether to pass a file or a dir.") do |o|
+            @result[:format] ||= MetricFu::Formatter::DEFAULT
+            @result[:format].last << o
+          end
+        end
+
+        def add_format_option(p)
+          p.on("--format FORMAT",
+               "Specify the formatter to use for output.",
+               "This option can be specified multiple times.",
+               "Specify a built-in formatter from the list below,",
+               "or the fully-qualified class name of your own custom formatter.",
+               *format_descriptions) do |f|
+            @result[:format] ||= []
+            @result[:format] << [f]
+          end
+        end
+
+        def short_from(name)
+          name.to_s.chars.each do |c|
+            next if @used_short.include?(c) || c == "_"
+            return c # returns from short_from method
+          end
+        end
+
         def debug_info
           extend(MetricFu::Environment)
           require 'pp'
@@ -99,6 +129,12 @@ module MetricFu
             "  #{key}#{' ' * (max - key.length)} : #{formats[key][1]}"
           end
         end
+
+        def success!
+          MetricFu::Cli.complete!
+        end
+
+
       end
     end
 

data/lib/metric_fu/configuration.rb

@@ -52,12 +52,6 @@ module MetricFu
   #   config.configure_formatter(:yaml, "customreport.yml")
   #   config.configure_formatter(MyCustomFormatter)
   #
-  # == Graph Configuration
-  #
-  # Graphing engine can be configured by e.g.
-  #   config.configure_graph_engine(:bluff)
-  #
-  #
   class Configuration
     require_relative 'environment'
     require_relative 'io'
@@ -83,17 +77,16 @@ module MetricFu
       MetricFu::Io::FileSystem.set_directories
       MetricFu::Formatter::Templates.configure_template(self)
       @formatters = []
-      @graph_engine_config = MetricFu::GraphEngine.new
     end
 
     # This allows us to have a nice syntax like:
     #
     #   MetricFu.run do |config|
-    #     congif.configure_metric(:churn) do
+    #     config.configure_metric(:churn) do
     #       ...
     #     end
     #
-    #     config.configure_graph_engine(:bluff)
+    #     config.configure_formatter(MyCustomFormatter)
     #   end
     #
     # See the README for more information on configuration options.
@@ -133,33 +126,13 @@ module MetricFu
     end
 
     # @return [Array<Symbol>] names of enabled metrics with graphs
-    def graphs
+    def graphed_metrics
       # TODO: This is a common enough need to be pushed into MetricFu::Metric as :enabled_metrics_with_graphs
       MetricFu::Metric.enabled_metrics.select{|metric|metric.has_graph?}.map(&:name)
     end
 
-    # TODO: Consider if we need to delegate so much to graph_engine_config
-    #   if we should use forwardable or change the api
-
-    # @return [Array<Symbol>] names of available graph engines
-    # @example [:bluff, :gchart]
-    def graph_engines
-      @graph_engine_config.graph_engines
-    end
-
-    # @return [Symbol] the selected graph engine
     def graph_engine
-      @graph_engine_config.graph_engine
-    end
-
-    # @param graph_engine [Symbol] the name of an available graph engine
-    def add_graph_engine(graph_engine)
-      @graph_engine_config.add_graph_engine(graph_engine)
-    end
-
-    # @param graph_engine [Symbol] sets the selected graph engine to use
-    def configure_graph_engine(graph_engine)
-      @graph_engine_config.configure_graph_engine(graph_engine)
+      :bluff
     end
 
   end

data/lib/metric_fu/environment.rb

@@ -106,7 +106,7 @@ module MetricFu
         'Version' =>  version,
         'Verbose Mode' => verbose,
         'Enabled Metrics' => MetricFu::Metric.enabled_metrics.map(&:name),
-        # 'Dependencies' => `gem dependency metric_fu`, # TODO how should we handle this?
+        'Dependencies' => MetricFu::GemVersion.dependencies_summary,
       }
     end
 

data/lib/metric_fu/formatter/html.rb

@@ -15,7 +15,7 @@ module MetricFu
         mf_debug "** SAVING REPORT DATA OUTPUT TO #{MetricFu::Io::FileSystem.directory('data_directory')}"
         # TODO: Allow customizing output filenames
         MetricFu::Formatter::YAML.new(
-          output: Pathname.pwd.join("#{MetricFu::Io::FileSystem.directory('data_directory')}/#{Time.now.strftime("%Y%m%d")}.yml")
+          output: MetricFu.run_path.join("#{MetricFu::Io::FileSystem.directory('data_directory')}/#{Time.now.strftime("%Y%m%d")}.yml")
         ).finish
 
         mf_debug "** SAVING TEMPLATIZED REPORT"
@@ -37,7 +37,7 @@ module MetricFu
       protected
 
       def output_directory
-        @output ||= dir_for(@options[:output]) || Pathname.pwd.join(MetricFu::Io::FileSystem.directory('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
@@ -57,11 +57,11 @@ module MetricFu
       def save_graphs
         mf_log "** GENERATING GRAPHS"
         mf_debug "** PREPARING TO GRAPH"
-        MetricFu.configuration.graphs.each {|graph|
-          mf_debug "** Graphing #{graph} with #{MetricFu.configuration.graph_engine}"
+        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(graph, MetricFu.configuration.graph_engine, self.output_directory)
+          MetricFu.graph.add(graphed_metric, MetricFu.configuration.graph_engine, self.output_directory)
         }
         mf_debug "** GENERATING GRAPH"
         MetricFu.graph.generate

data/lib/metric_fu/gem_run.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+require 'open3'
+require 'shellwords'
+require 'metric_fu'
+MetricFu.lib_require { 'logging/mf_debugger' }
+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 = ''
+      Open3.popen3("#{library_name}", *arguments) do |stdin, stdout, stderr, wait_thr|
+        captured_output << stdout.read.chomp
+      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
+    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,57 @@
+require 'rubygems'
+module MetricFu
+  class GemVersion
+
+    def initialize
+      @gem_spec = Gem::Specification.load(gemspec)
+    end
+
+    def gemspec
+      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.dependencies.select{|gem| gem.type == :runtime}.each do |gem_dep|
+                                        gem_dep.name = gem_dep.name.downcase.sub('metric_fu-','')
+                                      end << 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.dependencies_summary
+      dependencies.map do |gem_dep|
+        {
+          'name' => gem_dep.name,
+          'version' => gem_dep.requirements_list,
+        }
+      end
+    end
+
+  end
+end

data/lib/metric_fu/io.rb

@@ -127,7 +127,7 @@ module MetricFu
     end
 
     def path_relative_to_base(path)
-      pathname = Pathname.pwd.join(MetricFu::Io::FileSystem.directory('base_directory')) # make full path relative to base directory
+      pathname = MetricFu.run_path.join(MetricFu::Io::FileSystem.directory('base_directory')) # make full path relative to base directory
       pathname.join(path)
     end
   end

data/lib/metric_fu/load_files.rb

@@ -11,11 +11,9 @@ Dir.glob(File.join(MetricFu.lib_dir, '*.rb')).
   each do |file|
     require file
 end
-# prevent the task from being run multiple times.
-unless Rake::Task.task_defined? "metrics:all"
-  # Load the rakefile so users of the gem get the default metric_fu task
-  MetricFu.tasks_load 'metric_fu.rake'
-end
+
+MetricFu.load_tasks('metric_fu.rake', task_name: 'metrics:all')
+
 Dir.glob(File.join(MetricFu.data_structures_dir, '**/*.rb')).each do |file|
   require file
 end

data/lib/metric_fu/loader.rb

@@ -24,6 +24,14 @@ module MetricFu
     end
 
     # TODO: Reduce duplication of directory logic
+    # Adds methods x_dir and _x_require for the directory x,
+    #   relative to the metric_fu lib, to the given klass
+    # @param klass [Class] the klass to add methods for the specified directories
+    # @yieldreturn [Array<String>] Takes a list of directories and adds readers for each
+    # @example For the directory 'metrics', which is relative to the metric_fu lib directory,
+    #   creates on the klass two methods:
+    #     ::metrics_dir which returns the full path
+    #     ::metrics_require which takes a block of files to require relative to the metrics_dir
     def create_dirs(klass)
       class << klass
         Array(yield).each do |dir|
@@ -35,6 +43,12 @@ module MetricFu
       end
     end
 
+    # Adds method x_dir relative to the metric_fu artifact directory to the given klass
+    #   And strips any leading non-alphanumerical character from the directory name
+    # @param klass [Class] the klass to add methods for the specified artifact sub-directories
+    # @yieldreturn [Array<String>] Takes a list of directories and adds readers for each
+    # @example For the artifact sub-directory '_scratch', creates on the klass one method:
+    #     ::scratch_dir (which notably has the leading underscore removed)
     def create_artifact_subdirs(klass)
       class << klass
         Array(yield).each do |dir|
@@ -45,8 +59,16 @@ module MetricFu
       end
     end
 
-    def load_tasks(tasks_relative_path)
-      load File.join(@lib_root, 'tasks', *Array(tasks_relative_path))
+    # Load specified task task only once
+    #   if and only if rake is required and the task is not yet defined
+    #   to prevent the task from being loaded multiple times
+    # @param tasks_relative_path [String] 'metric_fu.rake' by default
+    # @param options [Hash] optional task_name to check if loaded
+    # @option options [String] :task_name The task_name to load, if not yet loaded
+    def load_tasks(tasks_relative_path, options={task_name: ''})
+      if defined?(Rake::Task) and not Rake::Task.task_defined?(options[:task_name])
+        load File.join(@lib_root, 'tasks', *Array(tasks_relative_path))
+      end
     end
 
     def setup
@@ -56,7 +78,14 @@ module MetricFu
       MetricFu.lib_require { 'initial_requires' }
       # Load a few things to make our lives easier elsewhere.
       MetricFu.lib_require { 'load_files' }
+      load_user_configuration
+    end
+
+    def load_user_configuration
+      file = File.join(MetricFu.run_dir, '.metrics')
+      load file if File.exist?(file)
     end
+
   end
 end