metric_fu 4.11.1 → 4.13.0

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

@@ -1,16 +1,15 @@
 module MetricFu
   class MetricFlay < Metric
-
     def name
       :flay
     end
 
     def default_run_options
-      { :dirs_to_flay => MetricFu::Io::FileSystem.directory('code_dirs'),
-      # MetricFu has been setting the minimum score as 100 for
-      # a long time. This is a really big number, considering
-      # the default is 16. Setting it to nil to use the Flay default.
-      :minimum_score => nil,
+      { dirs_to_flay: MetricFu::Io::FileSystem.directory("code_dirs"),
+        # MetricFu has been setting the minimum score as 100 for
+        # a long time. This is a really big number, considering
+        # the default is 16. Setting it to nil to use the Flay default.
+        minimum_score: nil,
       }
     end
 
@@ -25,6 +24,5 @@ module MetricFu
     def activate
       super
     end
-
   end
 end

data/lib/metric_fu/metrics/flog/generator.rb

@@ -1,9 +1,8 @@
-require 'pathname'
-require 'optparse'
+require "pathname"
+require "optparse"
 
 module MetricFu
   class FlogGenerator < Generator
-
     def self.metric
       :flog
     end
@@ -14,14 +13,14 @@ module MetricFu
         options[:continue] ? "--continue" : nil,
       ].compact
       @flogger = FlogCLI.new parse_options
-      @flogger.flog *options[:dirs_to_flog]
+      @flogger.flog *files_to_flog
     end
 
     def analyze
       @method_containers = {}
       @flogger.calculate
       @flogger.each_by_score do |full_method_name, score, operators|
-        container_name = full_method_name.split('#').first
+        container_name = full_method_name.split("#").first
         path = @flogger.method_locations[full_method_name]
         if @method_containers[container_name]
           @method_containers[container_name].add_method(full_method_name, operators, score, path)
@@ -35,23 +34,35 @@ module MetricFu
     end
 
     def to_h
-      sorted_containers = @method_containers.values.sort_by {|c| c.highest_score}.reverse
-      {:flog => { :total => @flogger.total_score,
-                  :average => @flogger.average,
-                  :method_containers => sorted_containers.map {|method_container| method_container.to_h}}}
+      sorted_containers = @method_containers.values.sort_by(&:highest_score).reverse
+      { flog: { total: @flogger.total_score,
+                average: @flogger.average,
+                method_containers: sorted_containers.map(&:to_h) } }
     end
 
     def per_file_info(out)
-      @method_containers.each_pair do |klass, container|
-        container.methods.each_pair do |method_name, data|
+      @method_containers.each_pair do |_klass, container|
+        container.methods.each_pair do |_method_name, data|
           next if data[:path].nil?
 
-          file, line = data[:path].split(':')
+          file, line = data[:path].split(":")
 
-          out[file][line] << {:type => :flog, :description => "Score of %.2f" % data[:score]}
+          out[file][line] << { type: :flog, description: "Score of %.2f" % data[:score] }
         end
       end
     end
+
+    private
+
+    def files_to_flog
+      options[:dirs_to_flog].flatten.map do |p|
+        if File.directory? p then
+          Dir[File.join(p, '**/*.{rb,rake}')]
+        else
+          p
+        end
+      end.flatten
+    end
   end
 
   class MethodContainer
@@ -63,22 +74,22 @@ module MetricFu
       @methods = {}
     end
 
-    def add_path path
+    def add_path(path)
       return unless path
-      @path ||= path.split(':').first
+      @path ||= path.split(":").first
     end
 
     def add_method(full_method_name, operators, score, path)
-      @methods[full_method_name] = {:operators => operators, :score => score, :path => path}
+      @methods[full_method_name] = { operators: operators, score: score, path: path }
     end
 
     def to_h
-      { :name => @name,
-        :path => @path || '',
-        :total_score => total_score,
-        :highest_score => highest_score,
-        :average_score => average_score,
-        :methods => @methods}
+      { name: @name,
+        path: @path || "",
+        total_score: total_score,
+        highest_score: highest_score,
+        average_score: average_score,
+        methods: @methods }
     end
 
     def highest_score
@@ -88,11 +99,11 @@ module MetricFu
     private
 
     def method_scores
-      @method_scores ||= @methods.values.map {|v| v[:score] }
+      @method_scores ||= @methods.values.map { |v| v[:score] }
     end
 
     def total_score
-      @total_score ||= method_scores.inject(0) {|sum, score| sum += score}
+      @total_score ||= method_scores.inject(0) { |sum, score| sum += score }
     end
 
     def average_score

data/lib/metric_fu/metrics/flog/grapher.rb

@@ -1,4 +1,4 @@
-MetricFu.reporting_require { 'graphs/grapher' }
+MetricFu.reporting_require { "graphs/grapher" }
 module MetricFu
   class FlogGrapher < Grapher
     attr_accessor :flog_average, :labels, :top_five_percent_average
@@ -11,30 +11,30 @@ module MetricFu
       super
       @flog_average = []
       @labels = {}
-      @top_five_percent_average =[]
+      @top_five_percent_average = []
     end
 
     def get_metrics(metrics, date)
       if metrics && metrics[:flog]
         @top_five_percent_average.push(calc_top_five_percent_average(metrics))
         @flog_average.push(metrics[:flog][:average])
-        @labels.update( { @labels.size => date })
+        @labels.update(@labels.size => date)
       end
     end
 
     def title
-      'Flog: code complexity'
+      "Flog: code complexity"
     end
 
     def data
       [
-        ['average', @flog_average.join(',')],
-        ['top 5% average', @top_five_percent_average.join(',')]
+        ["average", @flog_average.join(",")],
+        ["top 5% average", @top_five_percent_average.join(",")]
       ]
     end
 
     def output_filename
-      'flog.js'
+      "flog.js"
     end
 
     private
@@ -43,7 +43,7 @@ module MetricFu
       return calc_top_five_percent_average_legacy(metrics) if metrics[:flog][:pages]
 
       method_scores = metrics[:flog][:method_containers].inject([]) do |method_scores, container|
-        method_scores += container[:methods].values.map {|v| v[:score]}
+        method_scores += container[:methods].values.map { |v| v[:score] }
       end
       method_scores.sort!.reverse!
 
@@ -59,14 +59,14 @@ module MetricFu
     end
 
     def calc_top_five_percent_average_legacy(metrics)
-      methods = metrics[:flog][:pages].inject([]) {|methods, page| methods << page[:scanned_methods]}
+      methods = metrics[:flog][:pages].inject([]) { |methods, page| methods << page[:scanned_methods] }
       methods.flatten!
-      methods = methods.sort_by {|method| method[:score]}.reverse
+      methods = methods.sort_by { |method| method[:score] }.reverse
 
       number_of_methods_that_is_five_percent = (methods.size * 0.05).ceil
 
       total_for_five_percent =
-        methods[0...number_of_methods_that_is_five_percent].inject(0) {|total, method| total += method[:score] }
+        methods[0...number_of_methods_that_is_five_percent].inject(0) { |total, method| total += method[:score] }
       if number_of_methods_that_is_five_percent == 0
         0.0
       else

data/lib/metric_fu/metrics/flog/hotspot.rb

@@ -1,5 +1,4 @@
 class MetricFu::FlogHotspot < MetricFu::Hotspot
-
   COLUMNS = %w{score}
 
   def columns
@@ -23,10 +22,10 @@ class MetricFu::FlogHotspot < MetricFu::Hotspot
   end
 
   def generate_records(data, table)
-    return if data==nil
+    return if data == nil
     Array(data[:method_containers]).each do |method_container|
       Array(method_container[:methods]).each do |entry|
-        file_path = entry[1][:path].sub(%r{^/},'') if entry[1][:path]
+        file_path = entry[1][:path].sub(%r{^/}, "") if entry[1][:path]
         location = MetricFu::Location.for(entry.first)
         table << {
           "metric" => name,
@@ -42,7 +41,6 @@ class MetricFu::FlogHotspot < MetricFu::Hotspot
   def present_group(group)
     occurences = group.size
     complexity = get_mean(group.column("score"))
-    "#{"average " if occurences > 1}complexity is %.1f" % complexity
+    "#{'average ' if occurences > 1}complexity is %.1f" % complexity
   end
-
 end

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

@@ -1,12 +1,11 @@
 module MetricFu
   class MetricFlog < Metric
-
     def name
       :flog
     end
 
     def default_run_options
-      { :dirs_to_flog => MetricFu::Io::FileSystem.directory('code_dirs'), :continue => true, :all => true, :quiet => true  }
+      { dirs_to_flog: MetricFu::Io::FileSystem.directory("code_dirs"), continue: true, all: true, quiet: true  }
     end
 
     def has_graph?
@@ -22,10 +21,9 @@ module MetricFu
     end
 
     def activate
-      activate_library 'flog'
-      activate_library 'flog_cli'
+      activate_library "flog"
+      activate_library "flog_cli"
       super
     end
-
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/analyzed_problems.rb

@@ -30,6 +30,5 @@ module MetricFu
       tables = @analyzer_tables.tables_for(granularity)
       tables[ranked_item_name]
     end
-
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/analyzer_tables.rb

@@ -23,10 +23,10 @@ module MetricFu
 
     def tables_for(item)
       {
-        :class  => @class_tables,
-        :method => @method_tables,
-        :file   => @file_tables,
-        :tool   => @tool_tables
+        class: @class_tables,
+        method: @method_tables,
+        file: @file_tables,
+        tool: @tool_tables
       }.fetch(item) do
         raise ArgumentError, "Item must be :class, :method, or :file, but was #{item}"
       end
@@ -35,7 +35,7 @@ module MetricFu
     private
 
     def make_table(columns)
-      MetricFu::Table.new(:column_names => columns)
+      MetricFu::Table.new(column_names: columns)
     end
 
     def make_table_hash(columns)
@@ -52,9 +52,9 @@ module MetricFu
       table.each do |row|
         # We know that Saikuro provides the wrong data
         # TODO inject Saikuro reference
-        next if row['metric'] == :saikuro
-        key = [row['class_name'], row['method_name']]
-        file_path = row['file_path']
+        next if row["metric"] == :saikuro
+        key = [row["class_name"], row["method_name"]]
+        file_path = row["file_path"]
         @class_and_method_to_file[key] ||= file_path
       end
     end
@@ -63,7 +63,7 @@ module MetricFu
     def process_rows!
       # Correct incorrect rows in the table
       table.each do |row|
-        row_metric = row['metric'] #perf optimization
+        row_metric = row["metric"] # perf optimization
         # TODO inject Saikuro reference
         if row_metric == :saikuro
           fix_row_file_path!(row)
@@ -75,37 +75,38 @@ module MetricFu
       end
     end
 
-
     # COLLECT AND PROCESS RAW HOTSPOT METRICS
     def fix_row_file_path!(row)
       # We know that Saikuro rows are broken
       # next unless row['metric'] == :saikuro
-      key = [row['class_name'], row['method_name']]
-      current_file_path = row['file_path'].to_s
+      key = [row["class_name"], row["method_name"]]
+      current_file_path = row["file_path"].to_s
       correct_file_path = @class_and_method_to_file[key]
-      if(correct_file_path!=nil && correct_file_path.include?(current_file_path))
-        row['file_path'] = correct_file_path
+      if !correct_file_path.nil? && correct_file_path.include?(current_file_path)
+        row["file_path"] = correct_file_path
       else
         # There wasn't an exact match, so we can do a substring match
         matching_file_path = file_paths.detect {|file_path|
-          file_path!=nil && file_path.include?(current_file_path)
+          !file_path.nil? && file_path.include?(current_file_path)
         }
-        if(matching_file_path)
-          row['file_path'] = matching_file_path
+        if matching_file_path
+          row["file_path"] = matching_file_path
         end
       end
     end
 
     def file_paths
-      @file_paths ||= @table.column('file_path').uniq
+      @file_paths ||= @table.column("file_path").uniq
     end
 
     def file_tables
       @file_tables  ||= make_table_hash(@columns)
     end
+
     def class_tables
       @class_tables  ||= make_table_hash(@columns)
     end
+
     def method_tables
       @method_tables ||= make_table_hash(@columns)
     end

data/lib/metric_fu/metrics/hotspots/analysis/grouping.rb

@@ -3,7 +3,6 @@
 end
 module MetricFu
   class Grouping
-
     def initialize(table, opts)
       column_name = opts.fetch(:by)
       hash = {}
@@ -20,6 +19,5 @@ module MetricFu
         yield value, rows
       end
     end
-
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/groupings.rb

@@ -1,7 +1,6 @@
-MetricFu.metrics_require { 'hotspots/analysis/grouping' }
+MetricFu.metrics_require { "hotspots/analysis/grouping" }
 module MetricFu
   class HotspotGroupings
-
     def initialize(table, opts)
       @table, @opts = table, opts
     end
@@ -9,6 +8,5 @@ module MetricFu
     def get_grouping
       MetricFu::Grouping.new(@table, @opts)
     end
-
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/problems.rb

@@ -1,9 +1,8 @@
-MetricFu.metrics_require { 'hotspots/analysis/groupings' }
+MetricFu.metrics_require { "hotspots/analysis/groupings" }
 module MetricFu
   class HotspotProblems
-
     def initialize(sub_table)
-      @grouping = group_by(sub_table, 'metric')
+      @grouping = group_by(sub_table, "metric")
     end
 
     def problems
@@ -14,9 +13,8 @@ module MetricFu
       problems
     end
 
-    def group_by(sub_table, by = 'metric')
-      MetricFu::HotspotGroupings.new(sub_table, :by => by).get_grouping
+    def group_by(sub_table, by = "metric")
+      MetricFu::HotspotGroupings.new(sub_table, by: by).get_grouping
     end
-
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/ranked_problem_location.rb

@@ -1,8 +1,8 @@
-MetricFu.lib_require { 'errors/analysis_error' }
-MetricFu.metrics_require { 'hotspots/analysis/problems' }
+MetricFu.lib_require { "errors/analysis_error" }
+MetricFu.metrics_require { "hotspots/analysis/problems" }
 module MetricFu
   class HotspotRankedProblemLocation
-    MetricFu.data_structures_require { 'location' }
+    MetricFu.data_structures_require { "location" }
     attr_reader :sub_table, :granularity
     def initialize(sub_table, granularity)
       @sub_table = sub_table
@@ -11,20 +11,11 @@ module MetricFu
 
     def to_hash
       {
-        'location' => location.to_hash,
-        'details' =>  stringify_keys(problems),
+        "location" => location.to_hash,
+        "details" =>  MetricFu::Utility.stringify_keys(problems),
       }
     end
 
-    def stringify_keys(hash)
-      result = {}
-      hash.each do |key, value|
-        result[key.to_s] = value
-      end
-      result
-    end
-
-
     # @todo redo as item,value, options = {}
     # Note that the other option for 'details' is :detailed (this isn't
     # at all clear from this method itself
@@ -44,30 +35,36 @@ module MetricFu
     def file_path
       first_row.file_path
     end
+
     def class_name
       first_row.class_name
     end
+
     def method_name
       first_row.method_name
     end
+
     def file_location
       MetricFu::Location.get(file_path, nil, nil)
     end
+
     def method_location
       MetricFu::Location.get(file_path, class_name, method_name)
     end
+
     def class_location
       MetricFu::Location.get(file_path, class_name, nil)
     end
+
     def first_row
       assert_sub_table_has_data
       @first_row ||= sub_table[0]
     end
+
     def assert_sub_table_has_data
-      if (sub_table.length==0)
-        raise MetricFu::AnalysisError, "The #{item.to_s} '#{value.to_s}' does not have any rows in the analysis table"
+      if (sub_table.length == 0)
+        raise MetricFu::AnalysisError, "The #{item} '#{value}' does not have any rows in the analysis table"
       end
     end
-
   end
 end