cuke_sniffer 0.0.5 → 0.0.6

data/lib/cuke_sniffer/report/step_definitions.html.erb

@@ -0,0 +1,49 @@
+<div class="title" onclick="toggleById('step_definitions_data', this)">
+  Step Definitions +
+</div>
+<div class="shrink_section" id="step_definitions_data">
+  <% if cuke_sniffer.step_definitions.count == 0 %>
+      <div class="empty_set_message">There were no Step Definitions to sniff in '<%= cuke_sniffer.step_definitions_location %>'!</div>
+  <% elsif cuke_sniffer.step_definitions.count >= 1 && cuke_sniffer.summary[:step_definitions][:total_score] ==0 %>
+      <div class="empty_set_message">Excellent! No smells found for Step Definitions!</div>
+  <% end %>
+  <% index = 0 %>
+  <% cuke_sniffer.step_definitions.each do |step_definition| %>
+      <% next if step_definition.score <= 0 %>
+      <div style="cursor: pointer; padding-top: 3px" onclick="updateDisplayStatus(document.getElementById('step_definition_<%=index%>'))">
+        <div class="red_number" style="float:left"><%= step_definition.score %></div>
+        <% parameters = "" %>
+        <% step_definition.parameters.each do |param| %>
+            <% if param == step_definition.parameters.first %>
+                <% parameters << "| " %>
+            <% end %>
+            <% parameters << param %>
+
+            <% if param == step_definition.parameters.last %>
+                <% parameters << " |" %>
+            <% else %>
+                <% parameters << ", " %>
+            <% end %>
+        <% end %>
+        <div style="float: left" class="notes"><%= "/" + step_definition.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex] + "/ do " + parameters %></div>
+        <div style="float: right; padding-right:1%" class="notes"><%= step_definition.calls.keys.count %> Call(s)</div>
+      </div>
+      <div id="step_definition_<%= index %>" style="display:none;">
+        <br style="clear:both">
+
+        <div class="sub_section" style="display:block">
+          <div style="text-indent: 4%; float: left; width: 45%; border-right: 2px solid #add8e6;">
+            <% step_definition.rules_hash.each_key do |rule| %>
+                <pre style="margin: 0;"><%= rule %></pre>
+            <% end %>
+          </div>
+          <div style="text-indent: 1%">
+            <p style="margin:0"><%= step_definition.location.gsub(cuke_sniffer.step_definitions_location, "") %></p>
+          </div>
+        </div>
+      </div>
+      <br style="clear:both">
+      <% index += 1 %>
+  <% end %>
+</div>
+<br style="clear:both">

data/lib/cuke_sniffer/report/sub_rules.html.erb

@@ -0,0 +1,24 @@
+<ol class="rule_style">
+  <p class="rule_heading"><%= heading %></p>
+  <% cuke_sniffer.rules.select { |rule| rule.enabled == state }.each do |rule| %>
+      <li class="rule_notes">
+        <div class="rule_details">Phrase: <%= rule.phrase %></div>
+        <div class="rule_details">Score: <%= rule.score %></div>
+        <% rule.conditions.each do |key, value| %>
+            <% if value.kind_of?(Array) %>
+                <div class="rule_details"><%= key.capitalize %>:</div>
+
+                <% result = CukeSniffer::Formatter.convert_array_condition_into_list_of_strings(value) %>
+                <% result.first.prepend("[") %>
+                <% result.last << "]" %>
+                <% result.each do |words| %>
+                    <div><%= words %></div>
+                <% end %>
+
+            <% else %>
+                <div class="rule_details"><%= key.capitalize %>: <%= value %></div>
+            <% end %>
+            </li>
+        <% end %>
+  <% end %>
+</ol>

data/lib/cuke_sniffer/report/summary.html.erb

@@ -0,0 +1,71 @@
+<div class="title" onclick="toggleById('summary_data', this)">
+  Summary -
+</div>
+<div class="shrink_section" style="display: block;" id="summary_data">
+  <% data_symbols = [:features, :scenarios, :step_definitions, :hooks] %>
+  <table style="width: 100%;" class="notes">
+    <tr class="divide_row">
+      <td class="table_top"></td>
+      <td class="table_top">Features</td>
+      <td class="table_top">Scenarios</td>
+      <td class="table_top">Step Definitions</td>
+      <td class="table_top">Hooks</td>
+    </tr>
+    <tr>
+      <td>Total Score</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= cuke_sniffer.summary[symbol][:total_score] %></td>
+      <% end %>
+    </tr>
+    <tr>
+      <td>Count</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= cuke_sniffer.summary[symbol][:total].inspect %></td>
+      <% end %>
+    </tr>
+    <tr/>
+    <tr>
+      <td>Lowest Score</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= cuke_sniffer.summary[symbol][:min] %></td>
+      <% end %>
+    </tr>
+    <tr>
+      <td>Highest Score</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= cuke_sniffer.summary[symbol][:max] %></td>
+      <% end %>
+    </tr>
+    <tr>
+      <td>Average Score</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= cuke_sniffer.summary[symbol][:average] %></td>
+      <% end %>
+    </tr>
+    <tr/>
+
+    <tr>
+      <td>Threshold</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= cuke_sniffer.summary[symbol][:threshold] %></td>
+      <% end %>
+    </tr>
+    <tr>
+      <td>Good</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= ((cuke_sniffer.summary[symbol][:good].to_f/cuke_sniffer.summary[symbol][:total].to_f) * 100).round(2) %>
+            %
+          </td>
+      <% end %>
+    </tr>
+    <tr>
+      <td>Bad</td>
+      <% data_symbols.each do |symbol| %>
+          <td><%= ((cuke_sniffer.summary[symbol][:bad].to_f/cuke_sniffer.summary[symbol][:total].to_f) * 100).round(2) %>
+            %
+          </td>
+      <% end %>
+    </tr>
+  </table>
+</div>
+<br style="clear:both">

data/lib/cuke_sniffer/rule.rb

@@ -0,0 +1,28 @@
+require 'roxml'
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Single Rule object used for passing around rule data and serializing out to xml
+  # Mixins: ROXML
+  class Rule
+    include ROXML
+    xml_accessor :enabled
+    xml_accessor :phrase
+    xml_accessor :score
+    xml_accessor :conditions, :as => {:key => "name", :value => "value"}, :in => "conditions", :from => "condition"
+    xml_accessor :targets, :in => "targets"
+    xml_accessor :reason
+
+    def initialize
+      @enabled = false
+      @phrase = ""
+      @score = 0
+      @conditions = {}
+      @targets = []
+      @reason = ""
+    end
+  end
+
+end

data/lib/cuke_sniffer/rule_config.rb

@@ -19,27 +19,46 @@ module CukeSniffer
         :no_examples => {
             :enabled => true,
             :phrase => "Scenario Outline with no examples.",
-            :score => FATAL
+            :score => FATAL,
+            :targets => ["Scenario"],
+            :reason => "object.type == \"Scenario Outline\" and object.examples_table.size == 1"
         },
         :no_examples_table => {
             :enabled => true,
             :phrase => "Scenario Outline with no examples table.",
-            :score => FATAL
+            :score => FATAL,
+            :targets => ["Scenario"],
+            :reason => "object.type == \"Scenario Outline\" and object.examples_table.empty?"
         },
         :recursive_nested_step => {
             :enabled => true,
             :phrase => "Recursive nested step call.",
-            :score => FATAL
+            :score => FATAL,
+            :targets => ["StepDefinition"],
+            :reason => "object.nested_steps.each_value {|nested_step| store_rule(object, rule) if nested_step =~ object.regex}"
         },
         :background_with_tag => {
             :enabled => true,
             :phrase => "There is a background with a tag. This feature file cannot run!",
-            :score => FATAL
+            :score => FATAL,
+            :targets => ["Background"],
+            :reason =>  "object.tags.size > 0"
         },
         :comment_after_tag => {
             :enabled => true,
             :phrase => "Comment comes between tag and properly executing line. This feature file cannot run!",
-            :score => FATAL
+            :score => FATAL,
+            :targets => ["Feature", "Scenario"],
+            :reason => "flag = false
+                        unless object.tags.empty?
+                          object.tags[1..-1].each do | tags |
+                            if tags =~ /^\\s*\\#.*$/
+                              flag = true
+                              break
+                            end
+                          end
+                        end
+                        flag"
         }
     }
 
@@ -47,57 +66,105 @@ module CukeSniffer
         :no_description => {
             :enabled => true,
             :phrase => "{class} has no description.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Feature", "Scenario"],
+            :reason => "object.name.empty?"
         },
         :no_scenarios => {
             :enabled => true,
             :phrase => "Feature with no scenarios.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Feature"],
+            :reason => "object.scenarios.empty?"
         },
         :commented_step => {
             :enabled => true,
             :phrase => "Commented step.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.each do |step|
+                          store_rule(object, rule) if is_comment?(step)
+                        end"
         },
         :commented_example => {
             :enabled => true,
             :phrase => "Commented example.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Scenario"],
+            :reason => "if object.type == 'Scenario Outline'
+                          object.examples_table.each {|example| store_rule(object, rule) if is_comment?(example)}
+                        end"
         },
         :no_steps => {
             :enabled => true,
             :phrase => "No steps in Scenario.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.empty?"
         },
         :one_word_step => {
             :enabled => true,
             :phrase => "Step that is only one word long.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.each {|step| store_rule(object, rule) if step.split.count == 2}"
         },
         :no_code => {
             :enabled => true,
             :phrase => "No code in Step Definition.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.empty?"
         },
         :around_hook_without_2_parameters => {
             :enabled => true,
             :phrase => "Around hook without 2 parameters for Scenario and Block.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Hook"],
+            :reason => "object.type == \"Around\" and object.parameters.count != 2"
         },
         :around_hook_no_block_call => {
             :enabled => true,
             :phrase => "Around hook does not call its block.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Hook"],
+            :reason => "flag = true
+                        flag = false if object.type != 'Around'
+                        block_call = \"\#{object.parameters[1]}.call\"
+                          object.code.each do |line|
+                            if line.include?(block_call)
+                              flag = false
+                              break
+                            end
+                          end
+                        flag"
         },
         :hook_no_debugging => {
             :enabled => true,
             :phrase => "Hook without a begin/rescue. Reduced visibility when debugging.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Hook"],
+            :reason => "(object.code.empty? != true and object.code.join.match(/.*begin.*rescue.*/).nil?)"
+
         },
         :hook_conflicting_tags => {
             :enabled => true,
             :phrase => "Hook that both expects and ignores the same tag. This hook will not function as expected.",
-            :score => ERROR
+            :score => ERROR,
+            :targets => ["Hook"],
+            :reason => "all_tags = []
+                        object.tags.each { |single_tag| all_tags << single_tag.split(',') }
+                        all_tags.flatten!
+                        flag = false
+                        all_tags.each do |single_tag|
+                          tag = single_tag.gsub(\"~\", \"\")
+                          if all_tags.include?(tag) and all_tags.include?(\"~\#{tag}\")
+                            flag =  true
+                            break
+                          end
+                        end
+                        flag
+                        "
         },
     }
 
@@ -105,110 +172,194 @@ module CukeSniffer
         :numbers_in_description => {
             :enabled => true,
             :phrase => "{class} has numbers in the description.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature", "Scenario", "Background"],
+            :reason => "!(object.name =~ /\\d+/).nil?"
         },
         :empty_feature => {
             :enabled => true,
             :phrase => "Feature file has no content.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature"],
+            :reason => "object.feature_lines == []"
         },
         :background_with_no_scenarios => {
             :enabled => true,
             :phrase => "Feature has a background with no scenarios.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature"],
+            :reason => "object.scenarios.empty? and !object.background.nil?"
         },
         :background_with_one_scenario => {
             :enabled => true,
             :phrase => "Feature has a background with one scenario.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature"],
+            :reason => "object.scenarios.size == 1 and !object.background.nil?"
         },
         :too_many_steps => {
             :enabled => true,
             :phrase => "{class} with too many steps.",
             :score => WARNING,
-            :max => 7
+            :max => 7,
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.count > rule.conditions[:max]"
         },
         :out_of_order_steps => {
             :enabled => true,
             :phrase => "Scenario steps out of Given/When/Then order.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Scenario"],
+            :reason => 'step_order = object.get_step_order
+                        ["But", "*", "And"].each { |type| step_order.delete(type) }
+                        if(step_order != %w(Given When Then) and step_order != %w(When Then))
+                          store_rule(object, rule)
+                        end'
+
         },
         :invalid_first_step => {
             :enabled => true,
             :phrase => "Invalid first step. Began with And/But.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Scenario", "Background"],
+            :reason => "!(object.steps.first =~ /^\\s*(And|But).*$/).nil?"
         },
         :asterisk_step => {
             :enabled => true,
             :phrase => "Step includes a * instead of Given/When/Then/And/But.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.each do | step |
+                          store_rule(object, rule) if( step =~ /^\\s*[*].*$/)
+                       end
+                       "
         },
         :one_example => {
             :enabled => true,
             :phrase => "Scenario Outline with only one example.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Scenario"],
+            :reason => "object.type == 'Scenario Outline' and object.examples_table.size == 2 and !is_comment?(object.examples_table[1])"
         },
         :too_many_examples => {
             :enabled => true,
             :phrase => "Scenario Outline with too many examples.",
             :score => WARNING,
-            :max => 10
+            :max => 10,
+            :targets => ["Scenario"],
+            :reason => "object.type == 'Scenario Outline' and (object.examples_table.size - 1) >= rule.conditions[:max]"
         },
         :multiple_given_when_then => {
             :enabled => true,
             :phrase => "Given/When/Then used multiple times in the same {class}.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Scenario", "Background"],
+            :reason => "
+                        step_order = object.get_step_order
+                        phrase = rule.phrase.gsub('{class}', type)
+                        ['Given', 'When', 'Then'].each {|step_start| store_rule(object, rule, phrase) if step_order.count(step_start) > 1}"
         },
         :too_many_parameters => {
             :enabled => true,
             :phrase => "Too many parameters in Step Definition.",
             :score => WARNING,
-            :max => 4
+            :max => 4,
+            :targets => ["StepDefinition"],
+            :reason => "object.parameters.size > rule.conditions[:max]"
+
         },
         :lazy_debugging => {
             :enabled => true,
             :phrase => "Lazy Debugging through puts, p, or print",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.each {|line| store_rule(object, rule) if line.strip =~ /^(p|puts)( |\\()('|\\\"|%(q|Q)?\\{)/}"
         },
         :pending => {
             :enabled => true,
             :phrase => "Pending step definition. Implement or remove.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.each {|line|
+                          if line =~ /^\\s*pending(\\(.*\\))?(\\s*[#].*)?$/
+                            store_rule(object, rule)
+                            break
+                          end
+                        }"
         },
         :feature_same_tag => {
             :enabled => true,
             :phrase => "Same tag appears on Feature.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature"],
+            :reason => 'if(object.scenarios.count >= 2)
+                          object.scenarios[1..-1].each do |scenario|
+                            object.scenarios.first.tags.each do |tag|
+                              store_rule(object, rule) if scenario.tags.include?(tag)
+                            end
+                          end
+                        end'
         },
         :scenario_same_tag => {
             :enabled => true,
             :phrase => "Tag appears on all scenarios.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature"],
+            #TODO really hacky
+            :reason => "unless object.scenarios.empty?
+                          base_tag_list = object.scenarios.first.tags.clone
+                          object.scenarios.each do |scenario|
+                            base_tag_list.each do |tag|
+                              base_tag_list.delete(tag) unless scenario.tags.include?(tag)
+                            end
+                          end
+                          base_tag_list.count.times { store_rule(object, rule) }
+                        end"
         },
         :commas_in_description => {
             :enabled => true,
             :phrase => "There are commas in the description, creating possible multirunning scenarios or features.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature", "Scenario"],
+            :reason => 'object.name.include?(",")'
         },
         :commented_tag => {
             :enabled => true,
             :phrase => "{class} has a commented out tag",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Feature", "Scenario"],
+            :reason => 'object.tags.each do | tag |
+                          store_rule(object, rule, rule.phrase.gsub("{class}", type)) if is_comment?(tag)
+                        end'
         },
         :empty_hook => {
             :enabled => true,
             :phrase => "Hook with no content.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Hook"],
+            :reason => "object.code == []"
         },
         :hook_all_comments => {
             :enabled => true,
             :phrase => "Hook is only comments.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Hook"],
+            :reason => "flag = true
+                        object.code.each do |line|
+                          flag = false if line.match(/^\\s*\\#.*$/).nil?
+                        end
+                        flag"
         },
         :hook_duplicate_tags => {
             :enabled => true,
             :phrase => "Hook has duplicate tags.",
-            :score => WARNING
+            :score => WARNING,
+            :targets => ["Hook"],
+            :reason => "all_tags = []
+                        object.tags.each { |single_tag| all_tags << single_tag.split(',') }
+                        all_tags.flatten!
+                        unique_tags = all_tags.uniq
+                        true unless all_tags == unique_tags"
         }
     }
 
@@ -217,63 +368,105 @@ module CukeSniffer
             :enabled => true,
             :phrase => "{class} has too many tags.",
             :score => INFO,
-            :max => 8
+            :max => 8,
+            :targets => ["Feature", "Scenario"],
+            :reason => "object.tags.size >= rule.conditions[:max]"
         },
         :long_name => {
             :enabled => true,
             :phrase => "{class} has a long description.",
             :score => INFO,
-            :max => 180
+            :max => 180,
+            :targets => ["Feature", "Scenario", "Background"],
+            :reason => "object.name.length >= rule.conditions[:max]"
         },
         :implementation_word => {
             :enabled => true,
             :phrase => "Implementation word used: {word}.",
             :score => INFO,
-            :words => ["page", "site", "url", "button", "drop down", "dropdown", "select list", "click", "text box", "radio button", "check box", "xml", "window", "pop up", "pop-up", "screen"]
+            :words => ["page", "site", "url", "button", "drop down", "dropdown", "select list", "click", "text box", "radio button", "check box", "xml", "window", "pop up", "pop-up", "screen"],
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.each do |step|
+                          next if is_comment?(step)
+                          rule.conditions[:words].each do |word|
+                            new_phrase = rule.phrase.gsub(/{.*}/, word)
+                            store_rule(object, rule, new_phrase) if step.include?(word)
+                          end
+                        end"
+
         },
         :too_many_scenarios => {
             :enabled => true,
             :phrase => "Feature with too many scenarios.",
             :score => INFO,
-            :max => 10
+            :max => 10,
+            :targets => ["Feature"],
+            :reason => "object.scenarios.size >= rule.conditions[:max]"
         },
         :date_used => {
             :enabled => true,
             :phrase => "Date used.",
-            :score => INFO
+            :score => INFO,
+            :targets => ["Scenario", "Background"],
+            :reason => "object.steps.each {|step| store_rule(object, rule) if step =~ DATE_REGEX}"
         },
         :nested_step => {
             :enabled => true,
             :phrase => "Nested step call.",
-            :score => INFO
+            :score => INFO,
+            :targets => ["StepDefinition"],
+            :reason => "!object.nested_steps.empty?"
         },
         :commented_code => {
             :enabled => true,
             :phrase => "Commented code in Step Definition.",
-            :score => INFO
+            :score => INFO,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.each {|line| store_rule(object, rule) if is_comment?(line)}"
         },
         :small_sleep => {
             :enabled => true,
             :phrase => "Small sleeps used. Use a wait_until like method.",
             :score => INFO,
-            :max => 2
+            :max => 2,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.each do |line|
+                          match_data = line.match /^\\s*sleep(\\s|\\()(?<sleep_time>.*)\\)?/
+                          if match_data
+                            sleep_value = match_data[:sleep_time].to_f
+                            store_rule(object, rule) if sleep_value < rule.conditions[:max]
+                          end
+                        end"
         },
         :large_sleep => {
             :enabled => true,
             :phrase => "Large sleeps used. Use a wait_until like method.",
             :score => INFO,
-            :min => 2
+            :min => 2,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.each do |line|
+                          match_data = line.match /^\\s*sleep(\\s|\\()(?<sleep_time>.*)\\)?/
+                          if match_data
+                            sleep_value = match_data[:sleep_time].to_f
+                            store_rule(object, rule) if sleep_value > rule.conditions[:min]
+                          end
+                        end"
         },
         :todo => {
             :enabled => true,
             :phrase => "Todo found. Resolve it.",
-            :score => INFO
+            :score => INFO,
+            :targets => ["StepDefinition"],
+            :reason => "object.code.each {|line| store_rule(object, rule) if line =~ /\\#(TODO|todo)/}
+                        false"
         },
         :hook_not_in_hooks_file => {
             :enabled => true,
             :phrase => "Hook found outside of the designated hooks file",
             :score => INFO,
-            :file => "hooks.rb"
+            :file => "hooks.rb",
+            :targets => ["Hook"],
+            :reason => "object.location.include?(rule.conditions[:file]) != true"
         },
     }