metric_fu 4.4.1 → 4.4.2

data/lib/metric_fu/io.rb

@@ -48,13 +48,7 @@ module MetricFu
 
       # Add the 'app' directory if we're running within rails.
       def set_code_dirs(config)
-        # TODO: Rather than check if we're running against a rails app,
-        #   shouldn't we just check if the directories exist?
-        if config.rails?
-          @directories['code_dirs'] = %w(app lib)
-        else
-          @directories['code_dirs'] = %w(lib)
-        end
+        @directories['code_dirs'] = %w(app lib).select{|dir| Dir.exists?(dir) }
       end
 
     end

data/lib/metric_fu/metrics/base_template.rb

@@ -1,4 +1,3 @@
-require 'pathname'
 require 'erb'
 module MetricFu
 
@@ -7,7 +6,7 @@ module MetricFu
   # methods to make templating a bit easier.  However, classes do not
   # have to inherit from here in order to provide a template.  The only
   # requirement for a template class is that it provides a #write method
-  # to actually write out the template.  See StandardTemplate for an
+  # to actually write out the template.  See AwesomeTemplate for an
   # example.
   class Template
     attr_accessor :result, :per_file_data, :formatter, :output_directory
@@ -27,8 +26,21 @@ module MetricFu
     # @return String
     #   The erb evaluated string
     def erbify(section)
-      erb_doc = File.read(template(section))
-      ERB.new(erb_doc).result(binding)
+      template_file = template(section)
+      erb           = erb_template_source(template_file)
+      erb.result(binding)
+    rescue => e
+      message = "Error: #{e.class}; message #{e.message}. "
+      message << "Failed evaluating erb template "
+      message << "for section #{section} and template #{template_file}."
+      raise message
+    end
+
+    def erb_template_source(template_file)
+      erb_doc       = File.read(template_file)
+      erb           = ERB.new(erb_doc)
+      erb.filename  = template_file
+      erb
     end
 
     # Copies an instance variable mimicing the name of the section
@@ -64,9 +76,11 @@ module MetricFu
         File.join(template_directory,  section.to_s + ".html.erb")
       end
     end
+
     def template_dir(metric)
       File.join(MetricFu.metrics_dir, metric, metric_template_dir)
     end
+
     # e.g. template_awesome, template_standard
     def metric_template_dir
       template_name = self.class.name.sub('Template', '')[/^([A-Z][a-z]+)+/].downcase
@@ -106,7 +120,8 @@ module MetricFu
     # @return String
     #   The contents of the css file
     def inline_css(css)
-      open(File.join(template_directory, css)) { |f| f.read }
+      css_file = File.join(template_directory, css)
+      open(css_file) {|f| f.read }
     end
 
     # Provides a link to open a file through the textmate protocol
@@ -121,7 +136,9 @@ module MetricFu
     # @return String
     #   An anchor link to a textmate reference or a file reference
     def link_to_filename(name, line = nil, link_content = nil)
-      "<a href='#{file_url(name, line)}'>#{link_content(name, line, link_content)}</a>"
+      href = file_url(name, line)
+      link_text = link_content(name, line, link_content)
+      "<a href='#{href}'>#{link_text}</a>"
     end
 
     def round_to_tenths(decimal)
@@ -140,9 +157,9 @@ module MetricFu
     end
 
     def display_location(location)
-      class_name, method_name = location.class_name, location.method_name
+      class_name, method_name = location.fetch('class_name'), location.fetch('method_name')
       str = ""
-      str += link_to_filename(location.file_name, location.line_number)
+      str += link_to_filename(location.fetch('file_name'), location.fetch('line_number'))
       str += " : " if method_name || class_name
       if(method_name)
         str += "#{method_name}"
@@ -177,6 +194,7 @@ module MetricFu
     def remove_leading_slash(filename)
       filename.gsub(/^\//, '')
     end
+
     def render_as_txmt_protocol? # :nodoc:
       if MetricFu.configuration.osx?
         !MetricFu::Formatter::Templates.option('darwin_txmt_protocol_no_thanks')
@@ -184,6 +202,7 @@ module MetricFu
         false
       end
     end
+
     def render_as_mvim_protocol? # :nodoc:
       if MetricFu.configuration.osx?
         !MetricFu::Formatter::Templates.option('darwin_mvim_protocol_no_thanks')
@@ -227,7 +246,7 @@ module MetricFu
     end
 
     def snake_case_to_title_case(string)
-     string.split('_').collect{|word| word[0] = word[0..0].upcase; word}.join(" ")
+      string.split('_').collect{|word| word[0] = word[0..0].upcase; word}.join(" ")
     end
 
     # belive me, I tried to meta program this with an inherited hook

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

@@ -1,11 +1,12 @@
 module MetricFu
   class HotspotAnalyzedProblems
-
+    MetricFu.metrics_require   { "hotspots/analysis/ranked_problem_location" }
 
     def initialize(hotspot_rankings, analyzer_tables)
       @hotspot_rankings = hotspot_rankings
       @analyzer_tables = analyzer_tables
     end
+
     def worst_items
       worst_items = {}
       worst_items[:files]   = worst(@hotspot_rankings.worst_files,   :file)
@@ -18,53 +19,16 @@ module MetricFu
 
     # @param rankings [Array<MetricFu::HotspotRankings>]
     # @param granularity [Symbol] one of :class, :method, :file
-    def worst(rankings,granularity)
+    def worst(rankings, granularity)
       rankings.map do |ranked_item_name|
-        location = location(granularity, ranked_item_name)
-        details = problems_with(granularity, ranked_item_name)
-        {:location => location, :details =>  details}
-      end
-    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
-    def problems_with(item, value)
-      sub_table = get_sub_table(item, value)
-      #grouping = Ruport::Data::Grouping.new(sub_table, :by => 'metric')
-      grouping = get_grouping(sub_table, :by => 'metric')
-      MetricFu::HotspotProblems.new(grouping).problems
-    end
-
-    def location(item, value)
-      sub_table = get_sub_table(item, value)
-      assert_sub_table_has_data(item, sub_table, value)
-      first_row = sub_table[0]
-      case item
-      when :class
-        MetricFu::Location.get(first_row.file_path, first_row.class_name, nil)
-      when :method
-        MetricFu::Location.get(first_row.file_path, first_row.class_name, first_row.method_name)
-      when :file
-        MetricFu::Location.get(first_row.file_path, nil, nil)
-      else
-        raise ArgumentError, "Item must be :class, :method, or :file"
-      end
-    end
-
-    def assert_sub_table_has_data(item, sub_table, value)
-      if (sub_table.length==0)
-        raise MetricFu::AnalysisError, "The #{item.to_s} '#{value.to_s}' does not have any rows in the analysis table"
+        sub_table = get_sub_table(granularity, ranked_item_name)
+        MetricFu::HotspotRankedProblemLocation.new(sub_table, granularity)
       end
     end
 
-    def get_sub_table(item, value)
-      tables = @analyzer_tables.tables_for(item)
-      tables[value]
-    end
-
-    def get_grouping(table, opts)
-      MetricFu::HotspotGroupings.new(table, opts).get_grouping
+    def get_sub_table(granularity, ranked_item_name)
+      tables = @analyzer_tables.tables_for(granularity)
+      tables[ranked_item_name]
     end
 
   end

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

@@ -44,6 +44,7 @@ module MetricFu
       }
     end
 
+    # COLLECT AND PROCESS RAW HOTSPOT METRICS
     def build_lookups!
       @class_and_method_to_file ||= {}
       # Build a mapping from [class,method] => filename
@@ -58,6 +59,7 @@ module MetricFu
       end
     end
 
+    # COLLECT AND PROCESS RAW HOTSPOT METRICS
     def process_rows!
       # Correct incorrect rows in the table
       table.each do |row|
@@ -74,6 +76,7 @@ module MetricFu
     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

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

@@ -1,8 +1,8 @@
 module MetricFu
   class HotspotProblems
 
-    def initialize(grouping)
-      @grouping = grouping
+    def initialize(sub_table)
+      @grouping = group_by(sub_table, 'metric')
     end
 
     def problems
@@ -13,5 +13,9 @@ module MetricFu
       problems
     end
 
+    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

@@ -0,0 +1,71 @@
+module MetricFu
+  class HotspotRankedProblemLocation
+    MetricFu.data_structures_require { 'location' }
+    attr_reader :sub_table, :granularity
+    def initialize(sub_table, granularity)
+      @sub_table = sub_table
+      @granularity = granularity
+    end
+
+    def to_hash
+      {
+        'location' => location.to_hash,
+        'details' =>  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
+    def problems
+      @problems ||= MetricFu::HotspotProblems.new(sub_table).problems
+    end
+
+    def location
+      @location ||= case granularity
+                    when :class  then class_location
+                    when :method then method_location
+                    when :file   then file_location
+                    else              raise ArgumentError, "Item must be :class, :method, or :file"
+                    end
+    end
+
+    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"
+      end
+    end
+
+  end
+end

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

@@ -39,8 +39,15 @@ module MetricFu
 
     def calculate_score_for_granularity(analyzer, granularity)
       metric_ranking = calculate_metric_scores(granularity, analyzer)
-      add_to_master_ranking(ranking(granularity), metric_ranking, analyzer)
+
+      add_to_master_ranking(
+        ranking(granularity),
+        metric_ranking,
+        analyzer
+      )
     end
+
+    # CALCULATES METRIC HOTSPOT SCORES / RANKINGS PER map/reduce in HOTSPOT subclasses
     def calculate_metric_scores(granularity, analyzer)
       metric_ranking = MetricFu::Ranking.new
       metric_violations = @tool_tables[analyzer.name]

data/lib/metric_fu/metrics/hotspots/hotspot_analyzer.rb

@@ -1,5 +1,4 @@
 require File.expand_path('analysis_error', MetricFu.errors_dir)
-MetricFu.data_structures_require { 'location' }
 %w(table record grouping ranking problems).each do |path|
   MetricFu.metrics_require   { "hotspots/analysis/#{path}" }
 end

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

@@ -12,15 +12,20 @@ module MetricFu
     end
 
     def emit
-      @analyzer = MetricFu::HotspotAnalyzer.new(MetricFu.result.result_hash)
+      # no-op
     end
 
     def analyze
-      @hotspots = @analyzer && @analyzer.hotspots || {}
+      analyzer = MetricFu::HotspotAnalyzer.new(MetricFu.result.result_hash)
+      @hotspots = analyzer.hotspots
     end
 
     def to_h
-      {:hotspots => @hotspots}
+      result = {:hotspots => {}}
+      @hotspots.each do |granularity, hotspots|
+        result[:hotspots][granularity.to_s] = hotspots.map(&:to_hash)
+      end
+      result
     end
   end
 

data/lib/metric_fu/metrics/hotspots/template_awesome/hotspots.html.erb

@@ -2,11 +2,11 @@
 <p>Meta analysis of your metrics to find hotspots in your code.</p>
 <br/>
 
-<% if !@hotspots || @hotspots.size == 0 %>
+<% if @hotspots.nil? || @hotspots.size.zero? %>
   No Hotspots were found.
-<% elsif @hotspots && @hotspots.size > 0 %>
+<% else %>
 
-  <% granularities = [:files, :classes, :methods] %>
+  <% granularities = %w[files classes methods] %>
   <table>
     <tr valign="top">
     <% granularities.each do |granularity| %>
@@ -15,21 +15,21 @@
     <% end %>
     </tr>
 
-    <% items = [] %>
+    <% hotspots = [] %>
     <% granularities.each_index do |index| %>
       <% granularity = granularities[index] %>
-      <% items << @hotspots[granularity] %>
+      <% hotspots << @hotspots[granularity] %>
     <% end %>
 
-    <% items_length = 0 %>
+    <% hotspots_length = 0 %>
     <% columns = [0, 1, 2] %>
-    <% while (items_length < items[0].length || items_length < items[1].length || items_length < items[2].length) do %>
+    <% while (hotspots_length < hotspots[0].length || hotspots_length < hotspots[1].length || hotspots_length < hotspots[2].length) do %>
       <tr  valign="top">
         <% columns.each do |column| %>
-          <% item = items[column].length >= items_length ? items[column][items_length] : nil %>
+          <% item = hotspots[column].length >= hotspots_length ? hotspots[column][hotspots_length] : nil %>
           <% if item %>
-            <% location = item[:location] %>
-            <% file, line =  location.file_name, location.line_number %>
+            <% location = item.fetch('location') %>
+            <% file, line =  location.fetch('file_name'), location.fetch('line_number') %>
             <td>
             <b>
               <%= display_location(location) %>
@@ -43,7 +43,7 @@
             <% end %>
             <br/><br/>
             <!-- TODO HOTSPOTS for metric fu nice metric_link method -->
-            <% item[:details].each do |metric, info| %>
+            <% item.fetch('details').each do |metric, info| %>
               <%#= metric_link(@stat, metric, h(metric.to_s.capitalize)) + ": " + h(info)%><br/>
               <%= "#{metric.to_s.capitalize}: #{info}" %><br/>
             <% end %>
@@ -52,7 +52,7 @@
           <td> &nbsp; </td>
           <% end %>
         <% end %>
-        <% items_length += 1 %>
+        <% hotspots_length += 1 %>
       </tr>
     <% end %>
 

data/lib/metric_fu/metrics/saikuro/init.rb

@@ -23,5 +23,8 @@ module MetricFu
       super
     end
 
+    def activate
+      super
+    end
   end
 end

data/lib/metric_fu/metrics/saikuro/parsing_element.rb

@@ -0,0 +1,39 @@
+module MetricFu
+  class SaikuroParsingElement
+
+    TYPE_REGEX=/Type:(.*) Name/
+    NAME_REGEX=/Name:(.*) Complexity/
+    COMPLEXITY_REGEX=/Complexity:(.*) Lines/
+    LINES_REGEX=/Lines:(.*)/
+
+    attr_reader :complexity, :lines, :defs, :element_type
+    attr_accessor :name
+
+    def initialize(line)
+      @line = line
+      @element_type = line.match(TYPE_REGEX)[1].strip
+      @name = line.match(NAME_REGEX)[1].strip
+      @complexity = line.match(COMPLEXITY_REGEX)[1].strip
+      @lines = line.match(LINES_REGEX)[1].strip
+      @defs = []
+    end
+
+    def <<(line)
+      @defs << MetricFu::SaikuroParsingElement.new(line)
+    end
+
+    def to_h
+      base = {:name => @name, :complexity => @complexity.to_i, :lines => @lines.to_i}
+      unless @defs.empty?
+        defs = @defs.map do |my_def|
+          my_def = my_def.to_h
+          my_def.delete(:defs)
+          my_def
+        end
+        base[:defs] = defs
+      end
+      return base
+    end
+
+  end
+end