code_metric_fu 4.14.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, "results", 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

data/lib/metric_fu/templates/_gem_info.html.erb

@@ -0,0 +1,8 @@
+<%
+gem_spec        = MetricFu::GemVersion.activated_gems.find { |g| g.name =~ /metric_fu/ }
+gem_name        = gem_spec.name
+gem_version     = gem_spec.version.to_s
+gem_description = gem_spec.description
+gem_homepage    = gem_spec.homepage
+%>
+<p>Generated by <a href="<%= gem_homepage %>" title="<%= gem_description %>"><%= gem_name %></a> (v<%= gem_version %>)</p>

data/lib/metric_fu/templates/_graph.html.erb

@@ -0,0 +1,2 @@
+<div id="graph_container"></div>
+<script language="javascript" src="<%= @graph_name %>.js?<%= MetricFu.report_fingerprint %>" type="text/javascript"></script>

data/lib/metric_fu/templates/_report_footer.html.erb

@@ -0,0 +1 @@
+<p>Generated on <%= MetricFu.current_time %></p>

data/lib/metric_fu/templates/configuration.rb

@@ -0,0 +1,25 @@
+MetricFu.lib_require { "templates/metrics_template" }
+module MetricFu::Templates
+  class Configuration
+    FILE_PREFIX = "file:/"
+
+    def initialize
+      @options = {}
+      @options[:template_class] = MetricFu::Templates::MetricsTemplate
+      @options[:darwin_txmt_protocol_no_thanks] = true
+      # turning off syntax_highlighting may avoid some UTF-8 issues
+      @options[:syntax_highlighting] = true
+      @options[:link_prefix] = FILE_PREFIX
+    end
+
+    [:template_class, :link_prefix, :syntax_highlighting, :darwin_txmt_protocol_no_thanks].each do |option|
+      define_method("#{option}=") do |arg|
+        @options[option] = arg
+      end
+    end
+
+    def option(name)
+      @options.fetch(name.to_sym) { raise "No such template option: #{name}" }
+    end
+  end
+end

data/lib/metric_fu/templates/css/bluff.css

@@ -0,0 +1,15 @@
+.bluff-tooltip {
+  background: #fff;
+  border: 1px solid #d1edf5;
+  padding: 8px 8px 6px;
+}
+.bluff-tooltip .color {
+  display: block;
+  height: 4px;
+  width: 30px;
+  margin: 0 0 4px;
+  overflow: hidden;
+}
+.bluff-tooltip .data {
+  font-weight: bold;
+}

data/lib/metric_fu/templates/css/buttons.css

@@ -0,0 +1,82 @@
+/* --------------------------------------------------------------
+
+   buttons.css
+   * Gives you some great CSS-only buttons.
+
+   Created by Kevin Hale [particletree.com]
+   * particletree.com/features/rediscovering-the-button-element
+
+   See Readme.txt in this folder for instructions.
+
+-------------------------------------------------------------- */
+
+button {
+  display:block;
+  float:left;
+  margin:0 0.583em 0.667em 0;
+  padding:5px 10px 5px 7px;   /* Links */
+
+  border:1px solid #dedede;
+  border-top:1px solid #eee;
+  border-left:1px solid #eee;
+
+  background-color:#f5f5f5;
+  font-family:"Lucida Grande", Tahoma, Arial, Verdana, sans-serif;
+  font-size:100%;
+  line-height:130%;
+  text-decoration:none;
+  font-weight:bold;
+  color:#565656;
+  cursor:pointer;
+}
+button {
+  width:auto;
+  overflow:visible;
+  padding:4px 10px 3px 7px;   /* IE6 */
+}
+button[type] {
+  padding:4px 10px 4px 7px;   /* Firefox */
+  line-height:17px;           /* Safari */
+}
+*:first-child+html button[type] {
+  padding:4px 10px 3px 7px;   /* IE7 */
+}
+button img {
+  margin:0 3px -3px 0 !important;
+  padding:0;
+  border:none;
+  width:16px;
+  height:16px;
+  float:none;
+}
+
+
+/* Button colors
+-------------------------------------------------------------- */
+
+/* Standard */
+button:hover {
+  background-color:#dff4ff;
+  border:1px solid #c2e1ef;
+  color:#336699;
+}
+
+/* Positive */
+body .positive {
+  color:#529214;
+}
+button.positive:hover {
+  background-color:#E6EFC2;
+  border:1px solid #C6D880;
+  color:#529214;
+}
+
+/* Negative */
+body .negative {
+  color:#d12f19;
+}
+button.negative:hover {
+  background:#fbe3e4;
+  border:1px solid #fbc2c4;
+  color:#d12f19;
+}

data/lib/metric_fu/templates/css/default.css

@@ -0,0 +1,43 @@
+table {
+  margin-top: 20px;
+  border-collapse: collapse;
+  border: 1px solid #666;
+  background: #fff;
+  margin-bottom: 20px;
+}
+
+table tr.light {
+   background: #fff;
+}
+
+table tr.dark {
+  background: #f9f9f9;
+}
+
+table tr:hover {
+  background: #FFFFC0;
+}
+
+table td, table th {
+  padding: 4px;
+  font-size: 11px;
+}
+table th {
+  text-align: center;
+  color: #337022;
+  background: #DDFFCC;
+  font-weight: bold;
+  border: #99D688 1px solid;
+}
+
+table td {
+  border: #d0d0d0 1px solid;
+}
+
+table td.score {
+  text-align: right;
+}
+
+.warning {
+  background: yellow;
+}