fastruby-metric_fu 5.0.0

data/lib/metric_fu/metrics/stats/metric.rb

@@ -0,0 +1,28 @@
+module MetricFu
+  class MetricStats < Metric
+    def name
+      :stats
+    end
+
+    def default_run_options
+      {
+        # returns a list of directories that contains the glob of files that have the file_pattern in the file names
+        additional_test_directories: [{ glob_pattern: File.join(".", "spec", "**", "*_spec.rb"), file_pattern: "spec" }],
+        additional_app_directories: [{ glob_pattern: File.join(".", "engines", "**", "*.rb"), file_pattern: "" }],
+      }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      activate_library "code_metrics"
+      super
+    end
+  end
+end

data/lib/metric_fu/metrics/stats/report.html.erb

@@ -0,0 +1,44 @@
+<h3>Lines of Code/Tests Metric Results</h3>
+
+<%= render_partial 'graph', {:graph_name => 'stats'} %>
+
+<p>Lines of Code/Tests Metrics Results</p>
+<table>
+  <tr>
+    <th>Lines of Code</th>
+    <th>Lines of Test</th>
+    <th>Code to test ratio</th>
+  </tr>
+  <tr>
+    <td><%= @stats[:codeLOC] %></td>
+    <td><%= @stats[:testLOC] %></td>
+    <td>1:<%= @stats[:code_to_test_ratio] %></td>
+  </tr>
+</table>
+
+<table>
+  <tr>
+    <th>Name</th>
+    <th>Lines</th>
+    <th>LOC</th>
+    <th>Classes</th>
+    <th>Methods</th>
+    <th>Methods per class</th>
+    <th>LOC per method</th>
+  </tr>
+  <% count = 0 %>
+  <% @stats[:lines].each do |line| %>
+    <tr>
+      <td><%= line[:name] %></td>
+      <td><%= line[:lines] %></td>
+      <td><%= line[:loc] %></td>
+      <td><%= line[:classes] %></td>
+      <td><%= line[:methods] %></td>
+      <td><%= line[:methods_per_class] %></td>
+      <td><%= line[:loc_per_method] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+
+<%= render_partial 'report_footer' %>

data/lib/metric_fu/reporter.rb

@@ -0,0 +1,37 @@
+module MetricFu
+  class Reporter
+    def initialize(formatters = nil)
+      @formatters = Array(formatters)
+    end
+
+    def start
+      notify :start
+    end
+
+    def finish
+      notify :finish
+    end
+
+    def start_metric(metric)
+      mf_log "** STARTING METRIC #{metric}"
+      notify :start_metric, metric
+    end
+
+    def finish_metric(metric)
+      mf_log "** ENDING METRIC #{metric}"
+      notify :finish_metric, metric
+    end
+
+    def display_results
+      notify :display_results
+    end
+
+    protected
+
+    def notify(event, *args)
+      @formatters.each do |formatter|
+        formatter.send(event, *args) if formatter.respond_to?(event)
+      end
+    end
+  end
+end

data/lib/metric_fu/reporting/graphs/graph.rb

@@ -0,0 +1,69 @@
+module MetricFu
+  def self.graph
+    @graph ||= Graph.new
+  end
+
+  class Graph
+    attr_accessor :graphers
+
+    def initialize
+      self.graphers = []
+    end
+
+    def add(metric_name, _graph_engine, output_directory = MetricFu::Io::FileSystem.directory("output_directory"))
+      grapher = MetricFu::Grapher.get_grapher(metric_name).
+                new.tap { |g| g.output_directory = output_directory }
+      graphers.push grapher
+    rescue NameError => e
+      mf_log "#{e.message} called in MetricFu::Graph.add with #{graph_type}"
+    end
+
+    def generate
+      return if graphers.empty?
+      mf_log "Generating graphs"
+      generate_graphs_for_files
+      graph!
+    rescue NameError => e
+      mf_log "#{e.message} called in MetricFu::Graph generate"
+    end
+
+    private
+
+    def metric_files
+      MetricFu::Utility.glob(
+        File.join(MetricFu::Io::FileSystem.directory("data_directory"), "*.yml")
+      ).sort
+    end
+
+    def generate_graphs_for_files
+      metric_files.each do |metric_file|
+        generate_graphs_for_file(metric_file)
+      end
+    end
+
+    def generate_graphs_for_file(metric_file)
+      mf_log "Generating graphs for #{metric_file}"
+      date_parts = year_month_day_from_filename(metric_file)
+      metrics = MetricFu::Utility.load_yaml(metric_file)
+
+      build_graph(metrics, "#{date_parts[:m]}/#{date_parts[:d]}")
+    rescue NameError => e
+      mf_log "#{e.message} called in MetricFu::Graph.generate with #{metric_file}"
+    end
+
+    def build_graph(metrics, sortable_prefix)
+      graphers.each do |grapher|
+        grapher.get_metrics(metrics, sortable_prefix)
+      end
+    end
+
+    def graph!
+      graphers.each(&:graph!)
+    end
+
+    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/metric_fu/reporting/graphs/grapher.rb

@@ -0,0 +1,66 @@
+require "multi_json"
+module MetricFu
+  class Grapher
+    @graphers = []
+    # @return all subclassed graphers [Array<MetricFu::Grapher>]
+    def self.graphers
+      @graphers
+    end
+
+    def self.inherited(subclass)
+      @graphers << subclass
+    end
+
+    def self.get_grapher(metric)
+      graphers.find { |grapher|grapher.metric.to_s == metric.to_s }
+    end
+
+    attr_accessor :output_directory
+
+    def initialize(opts = {})
+      self.output_directory = opts[:output_directory]
+    end
+
+    def output_directory
+      @output_directory || MetricFu::Io::FileSystem.directory("output_directory")
+    end
+
+    def get_metrics(_metrics, _sortable_prefix)
+      not_implemented
+    end
+
+    def graph!
+      labels = MultiJson.dump(@labels)
+      content = <<-EOS
+        var graph_title = '#{title}';
+        #{build_data(data)}
+        var graph_labels = #{labels};
+      EOS
+      File.open(File.join(output_directory, output_filename), "w") { |f| f << content }
+    end
+
+    def title
+      not_implemented
+    end
+
+    def date
+      not_implemented
+    end
+
+    def output_filename
+      not_implemented
+    end
+
+    private
+
+    def build_data(data)
+      "var graph_series = [" << Array(data).map do |label, datum|
+        "{name: '#{label}', data: [#{datum}]}"
+      end.join(",") << "];"
+    end
+
+    def not_implemented
+      raise "#{__LINE__} in #{__FILE__} from #{caller[0]}"
+    end
+  end
+end

data/lib/metric_fu/reporting/result.rb

@@ -0,0 +1,59 @@
+module MetricFu
+  # MetricFu.result memoizes access to a Result object, that will be
+  # used throughout the lifecycle of the MetricFu app.
+  def self.result
+    @result ||= Result.new
+  end
+
+  # = Result
+  #
+  # The Result class is responsible for one thing:
+  #
+  # It tracks the results generated by each metric used in this test run.
+  class Result
+    # Renders the result of the result_hash into a yaml serialization
+    # ready for writing out to a file.
+    #
+    # @return YAML
+    #   A YAML object containing the results of the result generation
+    #   process
+    def as_yaml
+      result_hash.to_yaml
+    end
+
+    def per_file_data
+      @per_file_data ||= Hash.new do |hash, filename|
+        hash[filename] = Hash.new do |h, line|
+          h[line] = Array.new
+        end
+      end
+    end
+
+    def result_hash #:nodoc:
+      @result_hash ||= {}
+    end
+
+    # Adds a hash from a passed result, produced by one of the Generator
+    # classes to the aggregate result_hash managed by this hash.
+    #
+    # @param result_type Hash
+    #   The hash to add to the aggregate result_hash
+    def add(result_type)
+      mf_debug "result requested #{result_type}"
+      metric_options = metric_options_for_result_type(result_type)
+      generator_class =  MetricFu::Generator.get_generator(result_type)
+      mf_debug "result class found #{generator_class}"
+      generator = generator_class.new(metric_options)
+
+      result_hash.merge!(generator.generate_result)
+
+      generator.per_file_info(per_file_data) if generator.respond_to?(:per_file_info)
+    end
+
+    private
+
+    def metric_options_for_result_type(result_type)
+      MetricFu::Metric.get_metric(result_type).run_options
+    end
+  end
+end

data/lib/metric_fu/run.rb

@@ -0,0 +1,82 @@
+module MetricFu
+  class Run
+    def initialize
+      STDOUT.sync = true
+    end
+
+    def run(options = {})
+      configure_run(options)
+      measure
+      display_results if options[:open]
+    end
+
+    def report_metrics(metrics = MetricFu::Metric.enabled_metrics)
+      metrics.map(&:name)
+    end
+
+    def measure
+      reporter.start
+      report_metrics.each {|metric|
+        reporter.start_metric(metric)
+        MetricFu.result.add(metric)
+        reporter.finish_metric(metric)
+      }
+      reporter.finish
+    end
+
+    def display_results
+      reporter.display_results
+    end
+
+    private
+
+    def configure_run(options)
+      disable_metrics(options)
+      configure_formatters(options)
+    end
+
+    def disable_metrics(options)
+      return if options.size == 0
+      report_metrics.each do |metric|
+        metric = metric.to_sym
+        if (metric_options = options[metric])
+          mf_debug "using metric #{metric}"
+          configure_metric(metric, metric_options) if metric_options.is_a?(Hash)
+        else
+          mf_debug "disabling metric #{metric}"
+          MetricFu::Metric.get_metric(metric).enabled = false
+          mf_debug "active metrics are #{MetricFu::Metric.enabled_metrics.inspect}"
+        end
+      end
+    end
+
+    def configure_metric(metric, metric_options)
+      MetricFu::Configuration.configure_metric(metric) do |metric|
+        metric_options.each do |option, value|
+          mf_log "Setting #{metric} option #{option} to #{value}"
+          metric.public_send("#{option}=", value)
+        end
+      end
+    end
+
+    def configure_formatters(options)
+      # Configure from command line if any.
+      if options[:format]
+        MetricFu.configuration.formatters.clear # Command-line format takes precedence.
+        Array(options[:format]).each do |format, o|
+          MetricFu.configuration.configure_formatter(format, o)
+        end
+      end
+      # If no formatters specified, use defaults.
+      if MetricFu.configuration.formatters.empty?
+        Array(MetricFu::Formatter::DEFAULT).each do |format, o|
+          MetricFu.configuration.configure_formatter(format, o)
+        end
+      end
+    end
+
+    def reporter
+      MetricFu::Reporter.new(MetricFu.configuration.formatters)
+    end
+  end
+end

data/lib/metric_fu/tasks/metric_fu.rake

@@ -0,0 +1,54 @@
+require "rake"
+require "metric_fu/run"
+namespace :metrics do
+  def options_tip(task_name)
+    "with options, for example:  rake metrics:#{task_name}['cane: {abc_max: 81}']"
+  end
+  desc "Generate all metrics reports, or #{options_tip('all')}"
+  task :all, [:options] do |_t, args|
+    MetricFu.run(process_options(args.options))
+  end
+
+  desc "Run only specified ;-separated metrics, for example, metrics:only[cane;flog] or #{options_tip('only')}"
+  task :only, [:metrics, :options] do |_t, args|
+    requested_metrics = args.metrics.to_s.split(";").map(&:strip)
+    enabled_metrics = MetricFu::Metric.enabled_metrics.map(&:name)
+    metrics_to_run = enabled_metrics.select { |metric| requested_metrics.include?(metric.to_s) }
+    MetricFu.run_only(metrics_to_run, process_options(args.options))
+  end
+
+  MetricFu::Metric.enabled_metrics.each do |metric|
+    name = metric.name
+    desc "Generate report for #{name}, or #{options_tip('cane')}"
+    task name, [:options] do |_t, args|
+      MetricFu.run_only(name, process_options(args.options))
+    end
+  end
+
+  private
+
+  # from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb
+  class Hash
+    # Destructively, recursively convert all keys to symbols, as long as they respond
+    # to +to_sym+.
+    def recursively_symbolize_keys!
+      keys.each do |key|
+        value = delete(key)
+        new_key = key.intern # rescue
+        self[new_key] = (value.is_a?(Hash) ? value.dup.recursively_symbolize_keys! : value)
+      end
+      self
+    end
+  end
+
+  def process_options(options)
+    return {} if options.nil? or options.empty?
+    options = YAML.load(options)
+    if options.is_a?(Hash)
+      p "Got options #{options.recursively_symbolize_keys!.inspect}"
+      options
+    else
+      raise "Invalid options #{options.inspect}, is a #{options.class}, should be a Hash"
+    end
+  end
+end