cuke_sniffer 0.0.7 → 0.0.8

data/lib/cuke_sniffer/formatter.rb

@@ -2,7 +2,7 @@ require 'erb'
 
 module CukeSniffer
   # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # Copyright:: Copyright (C) 2014 Robert Cochran
   # License::   Distributes under the MIT License
   # Mixins: CukeSniffer::Constants
   # Static class used to generate output for the CukeSniffer::CLI object.

data/lib/cuke_sniffer/hook.rb

@@ -1,77 +1,103 @@
-require 'roxml'
-module CukeSniffer
-
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2013 Robert Cochran
-  # License::   Distributes under the MIT License
-  # Cucumber Hook class used for evaluating rules
-  # Extends CukeSniffer::RulesEvaluator
-  class Hook < RuleTarget
-
-    xml_accessor :start_line
-    xml_accessor :type
-    xml_accessor :tags, :as => [], :in => "tags"
-    xml_accessor :parameters, :as => [], :in => "parameters"
-    xml_accessor :code, :as => [], :in => "code"
-
-    # The type of the hook: AfterConfiguration, After, AfterStep, Around, Before, at_exit
-    attr_accessor :type
-
-    # The list of tags used as a filter for the hook
-    attr_accessor :tags
-
-    # The parameters that are declared on the hook
-    attr_accessor :parameters
-
-    # Integer of the line in which the hook was found
-    attr_accessor :start_line
-
-    # Array of strings that contain the code kept in the hook
-    attr_accessor :code
-
-
-    # location must be in the format of "file_path\file_name.rb:line_number"
-    # raw_code is an array of strings that represents the step definition
-    # must contain the hook declaration line and the pairing end
-    def initialize(location, hook_block)
-      super(location)
-      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
-      end_match_index = (hook_block.size - 1) - hook_block.reverse.index("end")
-      @code = hook_block[1...end_match_index]
-      initialize_hook_signature(hook_block)
-    end
-
-    def ==(comparison_object) # :nodoc:
-      super(comparison_object) &&
-          comparison_object.type == type &&
-          comparison_object.tags == tags &&
-          comparison_object.parameters == parameters &&
-          comparison_object.code == code
-    end
-
-    private
-
-    def initialize_hook_signature(hook_block)
-      @type = nil
-      @tags = []
-      @parameters = []
-
-      hook_signature = extract_hook_signature(hook_block)
-      matches = HOOK_REGEX.match(hook_signature)
-      @type = matches[:type]
-      initialize_tags(matches[:tags]) if matches[:tags]
-      @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
-    end
-
-    def extract_hook_signature(hook_block)
-      hook_block.each do |line|
-        return line if line =~ HOOK_REGEX
-      end
-    end
-
-    def initialize_tags(tag_list)
-      hook_tag_regexp = /["']([^"']*)["']/
-      tag_list.scan(hook_tag_regexp).each { |tag| @tags << tag[0] }
-    end
-  end
-end
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2014 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Cucumber Hook class used for evaluating rules
+  # Extends CukeSniffer::RulesEvaluator
+  class Hook < RuleTarget
+
+    xml_accessor :start_line
+    xml_accessor :tags, :as => [], :in => "tags"
+    xml_accessor :parameters, :as => [], :in => "parameters"
+    xml_accessor :code, :as => [], :in => "code"
+
+    # The type of the hook: AfterConfiguration, After, AfterStep, Around, Before, at_exit
+    attr_accessor :type
+
+    # The list of tags used as a filter for the hook
+    attr_accessor :tags
+
+    # The parameters that are declared on the hook
+    attr_accessor :parameters
+
+    # Integer of the line in which the hook was found
+    attr_accessor :start_line
+
+    # Array of strings that contain the code kept in the hook
+    attr_accessor :code
+
+
+    # location must be in the format of "file_path\file_name.rb:line_number"
+    # raw_code is an array of strings that represents the step definition
+    # must contain the hook declaration line and the pairing end
+    def initialize(location, hook_block)
+      super(location)
+      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
+      end_match_index = (hook_block.size - 1) - hook_block.reverse.index("end")
+      @code = hook_block[1...end_match_index]
+      initialize_hook_signature(hook_block)
+    end
+
+    def ==(comparison_object) # :nodoc:
+      super(comparison_object) &&
+          comparison_object.type == type &&
+          comparison_object.tags == tags &&
+          comparison_object.parameters == parameters &&
+          comparison_object.code == code
+    end
+
+    def around?
+      type == 'Around'
+    end
+
+    def calls_block?
+      @code.join.to_s.include?("#{@parameters[1]}.call")
+    end
+
+    def conflicting_tags?
+      all_tags = get_indepentent_tags
+      all_tags.each do |single_tag|
+        tag = single_tag.gsub("~", "")
+        return true if all_tags.include?(tag) and all_tags.include?("~#{tag}")
+      end
+      false
+    end
+
+    def rescues?
+      @code.empty? or @code.join.to_s =~ /.*begin.*rescue.*/
+    end
+
+    private
+
+    def get_indepentent_tags
+      all_tags = []
+      @tags.each { |single_tag| all_tags << single_tag.split(',') }
+      all_tags.flatten!
+      all_tags
+    end
+
+    def initialize_hook_signature(hook_block)
+      @type = nil
+      @tags = []
+      @parameters = []
+
+      hook_signature = extract_hook_signature(hook_block)
+      matches = HOOK_REGEX.match(hook_signature)
+      @type = matches[:type]
+      initialize_tags(matches[:tags]) if matches[:tags]
+      @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
+    end
+
+    def extract_hook_signature(hook_block)
+      hook_block.each do |line|
+        return line if line =~ HOOK_REGEX
+      end
+    end
+
+    def initialize_tags(tag_list)
+      hook_tag_regexp = /["']([^"']*)["']/
+      tag_list.scan(hook_tag_regexp).each { |tag| @tags << tag[0] }
+    end
+  end
+end

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

@@ -60,11 +60,6 @@
                   </td>
                 </tr>
             <% end %>
-            <tr>
-              <td>
-                <b>Reason: </b><%= rule.reason %>
-              </td>
-            </tr>
           </table>
         </td>
         </tr>

data/lib/cuke_sniffer/rule.rb

@@ -1,28 +1,27 @@
-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
-
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2014 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

@@ -21,54 +21,54 @@ module CukeSniffer
             :phrase => "Scenario Outline with no examples.",
             :score => FATAL,
             :targets => ["Scenario"],
-            :reason => "object.type == \"Scenario Outline\" and object.examples_table.size == 1"
+            :reason => lambda { |scenario, rule| scenario.outline? and scenario.examples_table.size == 1}
         },
         :no_examples_table => {
             :enabled => true,
             :phrase => "Scenario Outline with no examples table.",
             :score => FATAL,
             :targets => ["Scenario"],
-            :reason => "object.type == \"Scenario Outline\" and object.examples_table.empty?"
+            :reason => lambda { |scenario, rule| scenario.outline? and scenario.examples_table.empty?}
         },
         :recursive_nested_step => {
             :enabled => true,
             :phrase => "Recursive nested step call.",
             :score => FATAL,
             :targets => ["StepDefinition"],
-            :reason => "object.nested_steps.each_value {|nested_step| store_rule(object, rule) if nested_step =~ object.regex}"
+            :reason => lambda { |step_definition, rule| step_definition.store_rule_many_times(rule, step_definition.recursive_nested_steps.size)}
         },
         :background_with_tag => {
             :enabled => true,
             :phrase => "There is a background with a tag. This feature file cannot run!",
             :score => FATAL,
             :targets => ["Background"],
-            :reason =>  "object.tags.size > 0"
+            :reason =>  lambda { |background, rule| background.tags.size > 0}
         },
         :comment_after_tag => {
             :enabled => true,
             :phrase => "Comment comes between tag and properly executing line. This feature file cannot run!",
             :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"
+            :reason =>
+                lambda { |feature_rule_target, rule|
+                  tokens = feature_rule_target.tags.collect { |line| line.split }.flatten
+
+                  tokens.each_with_index do |token, index|
+                    if feature_rule_target.is_comment?(token) && tokens[0...index].any? { |x| x =~ /\A@/ }
+                      return feature_rule_target.store_rule(rule)
+                    end
+                  end
+                }
         },
         :universal_nested_step => {
             :enabled => true,
             :phrase => "A nested step should not universally match all step definitions.  Dead steps cannot be correctly cataloged.",
             :score => FATAL,
             :targets => ["StepDefinition"],
-            :reason => "object.nested_steps.each_value do | step_value |
-                          modified_step = step_value.gsub(/\\\#{[^}]*}/, '.*')
-                          store_rule(object, rule) if modified_step == '.*'
-                        end"
+            :reason => lambda { |step_definition, rule| step_definition.nested_steps.each_value do | step_value |
+                          modified_step = step_value.gsub(/\#{[^}]*}/, '.*')
+                          step_definition.store_rule(rule) if modified_step == '.*'
+                        end}
         }
     }
 
@@ -78,83 +78,72 @@ module CukeSniffer
             :phrase => "{class} has no description.",
             :score => ERROR,
             :targets => ["Feature", "Scenario"],
-            :reason => "object.name.empty?"
+            :reason => lambda { |feature_rule_target, rule| feature_rule_target.name.empty?}
         },
         :no_scenarios => {
             :enabled => true,
             :phrase => "Feature with no scenarios.",
             :score => ERROR,
             :targets => ["Feature"],
-            :reason => "object.scenarios.empty?"
+            :reason => lambda { |feature, rule| feature.scenarios.empty?}
         },
         :commented_step => {
             :enabled => true,
             :phrase => "Commented step.",
             :score => ERROR,
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.each do |step|
-                          store_rule(object, rule) if is_comment?(step)
-                        end"
+            :reason =>  lambda { |scenario, rule| scenario.steps.each do |step|
+                          scenario.store_rule(rule) if scenario.is_comment?(step)
+                        end}
         },
         :commented_example => {
             :enabled => true,
             :phrase => "Commented example.",
             :score => ERROR,
             :targets => ["Scenario"],
-            :reason => "if object.type == 'Scenario Outline'
-                          object.examples_table.each {|example| store_rule(object, rule) if is_comment?(example)}
-                        end"
+            :reason =>  lambda { |scenario, rule| scenario.store_rule_many_times(rule, scenario.commented_examples.size) }
         },
         :no_steps => {
             :enabled => true,
             :phrase => "No steps in Scenario.",
             :score => ERROR,
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.empty?"
+            :reason => lambda { |scenario, rule| scenario.steps.empty?}
         },
         :one_word_step => {
             :enabled => true,
             :phrase => "Step that is only one word long.",
             :score => ERROR,
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.each {|step| store_rule(object, rule) if step.split.count == 2}"
+            :reason => lambda { |scenario, rule| scenario.steps.each {|step| scenario.store_rule(rule) if step.split.count == 2}}
         },
         :no_code => {
             :enabled => true,
             :phrase => "No code in Step Definition.",
             :score => ERROR,
             :targets => ["StepDefinition"],
-            :reason => "object.code.empty?"
+            :reason => lambda { |step_definition, rule| step_definition.code.empty?}
         },
         :around_hook_without_2_parameters => {
             :enabled => true,
             :phrase => "Around hook without 2 parameters for Scenario and Block.",
             :score => ERROR,
             :targets => ["Hook"],
-            :reason => "object.type == \"Around\" and object.parameters.count != 2"
+            :reason => lambda { |hook, rule| hook.around? and hook.parameters.count != 2}
         },
         :around_hook_no_block_call => {
             :enabled => true,
             :phrase => "Around hook does not call its block.",
             :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"
+            :reason => lambda { |hook, rule| hook.around? and !hook.calls_block?}
         },
         :hook_no_debugging => {
             :enabled => true,
             :phrase => "Hook without a begin/rescue. Reduced visibility when debugging.",
             :score => ERROR,
             :targets => ["Hook"],
-            :reason => "(object.code.empty? != true and object.code.join.match(/.*begin.*rescue.*/).nil?)"
+            :reason => lambda { |hook, rule| !hook.rescues?}
 
         },
         :hook_conflicting_tags => {
@@ -162,19 +151,7 @@ module CukeSniffer
             :phrase => "Hook that both expects and ignores the same tag. This hook will not function as expected.",
             :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
-                        "
+            :reason => lambda { |hook, rule| hook.conflicting_tags? }
         },
     }
 
@@ -184,28 +161,28 @@ module CukeSniffer
             :phrase => "{class} has numbers in the description.",
             :score => WARNING,
             :targets => ["Feature", "Scenario", "Background"],
-            :reason => "!(object.name =~ /\\d+/).nil?"
+            :reason => lambda { |feature_rule_target, rule| !(feature_rule_target.name =~ /\d+/).nil?}
         },
         :empty_feature => {
             :enabled => true,
             :phrase => "Feature file has no content.",
             :score => WARNING,
             :targets => ["Feature"],
-            :reason => "object.feature_lines == []"
+            :reason => lambda { |feature, rule| feature.feature_lines == []}
         },
         :background_with_no_scenarios => {
             :enabled => true,
             :phrase => "Feature has a background with no scenarios.",
             :score => WARNING,
             :targets => ["Feature"],
-            :reason => "object.scenarios.empty? and !object.background.nil?"
+            :reason => lambda { |feature, rule| feature.scenarios.empty? and !feature.background.nil?}
         },
         :background_with_one_scenario => {
             :enabled => true,
             :phrase => "Feature has a background with one scenario.",
             :score => WARNING,
             :targets => ["Feature"],
-            :reason => "object.scenarios.size == 1 and !object.background.nil?"
+            :reason => lambda { |feature, rule| feature.scenarios.size == 1 and !feature.background.nil?}
         },
         :too_many_steps => {
             :enabled => true,
@@ -213,18 +190,18 @@ module CukeSniffer
             :score => WARNING,
             :max => 7,
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.count > rule.conditions[:max]"
+            :reason => lambda { |scenario, rule| scenario.steps.count > rule.conditions[:max]}
         },
         :out_of_order_steps => {
             :enabled => true,
             :phrase => "Scenario steps out of Given/When/Then order.",
             :score => WARNING,
             :targets => ["Scenario"],
-            :reason => 'step_order = object.get_step_order
+            :reason => lambda { |scenario, rule| step_order = scenario.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'
+                          scenario.store_rule(rule)
+                        end}
 
         },
         :invalid_first_step => {
@@ -232,24 +209,22 @@ module CukeSniffer
             :phrase => "Invalid first step. Began with And/But.",
             :score => WARNING,
             :targets => ["Scenario", "Background"],
-            :reason => "!(object.steps.first =~ /^\\s*(And|But).*$/).nil?"
+            :reason => lambda { |scenario, rule| !(scenario.steps.first =~ /^\s*(And|But).*$/).nil?}
         },
         :asterisk_step => {
             :enabled => true,
             :phrase => "Step includes a * instead of Given/When/Then/And/But.",
             :score => WARNING,
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.each do | step |
-                          store_rule(object, rule) if( step =~ /^\\s*[*].*$/)
-                       end
-                       "
+            :reason => lambda { |scenario, rule| scenario.store_rule_many_times(rule, scenario.get_steps("*").size)
+            }
         },
         :one_example => {
             :enabled => true,
             :phrase => "Scenario Outline with only one example.",
             :score => WARNING,
             :targets => ["Scenario"],
-            :reason => "object.type == 'Scenario Outline' and object.examples_table.size == 2 and !is_comment?(object.examples_table[1])"
+            :reason => lambda { |scenario, rule| scenario.outline? and scenario.examples_table.size == 2}
         },
         :too_many_examples => {
             :enabled => true,
@@ -257,17 +232,18 @@ module CukeSniffer
             :score => WARNING,
             :max => 10,
             :targets => ["Scenario"],
-            :reason => "object.type == 'Scenario Outline' and (object.examples_table.size - 1) >= rule.conditions[:max]"
+            :reason => lambda { |scenario, rule| scenario.outline? and (scenario.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,
             :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}"
+            :reason => lambda { |scenario, rule|
+              phrase = rule.phrase.gsub('{class}', scenario.type)
+              ['Given', 'When', 'Then'].each do |step_start|
+                scenario.store_rule(rule, phrase) if scenario.get_steps(step_start).size > 1
+              end}
         },
         :too_many_parameters => {
             :enabled => true,
@@ -275,7 +251,7 @@ module CukeSniffer
             :score => WARNING,
             :max => 4,
             :targets => ["StepDefinition"],
-            :reason => "object.parameters.size > rule.conditions[:max]"
+            :reason => lambda { |step_definition, rule| step_definition.parameters.size > rule.conditions[:max]}
 
         },
         :lazy_debugging => {
@@ -283,32 +259,32 @@ module CukeSniffer
             :phrase => "Lazy Debugging through puts, p, or print",
             :score => WARNING,
             :targets => ["StepDefinition"],
-            :reason => "object.code.each {|line| store_rule(object, rule) if line.strip =~ /^(p|puts)( |\\()('|\\\"|%(q|Q)?\\{)/}"
+            :reason => lambda { |step_definition, rule| step_definition.code.each {|line| step_definition.store_rule(rule) if line.strip =~ /^(p|puts)( |\()('|"|%(q|Q)?\{)/}}
         },
         :pending => {
             :enabled => true,
             :phrase => "Pending step definition. Implement or remove.",
             :score => WARNING,
             :targets => ["StepDefinition"],
-            :reason => "object.code.each {|line|
-                          if line =~ /^\\s*pending(\\(.*\\))?(\\s*[#].*)?$/
-                            store_rule(object, rule)
+            :reason => lambda { |step_definition, rule| step_definition.code.each {|line|
+                          if line =~ /^\s*pending(\(.*\))?(\s*[#].*)?$/
+                            step_definition.store_rule(rule)
                             break
                           end
-                        }"
+                        }}
         },
         :feature_same_tag => {
             :enabled => true,
             :phrase => "Same tag appears on Feature.",
             :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)
+            :reason => lambda { |feature, rule| if(feature.scenarios.count >= 2)
+                          feature.scenarios[1..-1].each do |scenario|
+                            feature.scenarios.first.tags.each do |tag|
+                              feature.store_rule(rule) if scenario.tags.include?(tag)
                             end
                           end
-                        end'
+                        end}
         },
         :scenario_same_tag => {
             :enabled => true,
@@ -316,60 +292,61 @@ module CukeSniffer
             :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|
+            :reason => lambda { |feature, rule| unless feature.scenarios.empty?
+                          base_tag_list = feature.scenarios.first.tags.clone
+                          feature.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"
+                          base_tag_list.count.times { feature.store_rule(rule) }
+                        end}
         },
         :commas_in_description => {
             :enabled => true,
             :phrase => "There are commas in the description, creating possible multirunning scenarios or features.",
             :score => WARNING,
             :targets => ["Feature", "Scenario"],
-            :reason => 'object.name.include?(",")'
+            :reason => lambda { |rule_target, rule| rule_target.name.include?(",")}
         },
         :commented_tag => {
             :enabled => true,
             :phrase => "{class} has a commented out tag",
             :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'
+            :reason => lambda { |feature_rule_target, rule| feature_rule_target.tags.each do | tag |
+                          feature_rule_target.store_rule(rule, rule.phrase.gsub("{class}", feature_rule_target.type)) if feature_rule_target.is_comment?(tag)
+                        end}
         },
         :empty_hook => {
             :enabled => true,
             :phrase => "Hook with no content.",
             :score => WARNING,
             :targets => ["Hook"],
-            :reason => "object.code == []"
+            :reason => lambda { |hook, rule| hook.code == []}
         },
         :hook_all_comments => {
             :enabled => true,
             :phrase => "Hook is only comments.",
             :score => WARNING,
             :targets => ["Hook"],
-            :reason => "flag = true
-                        object.code.each do |line|
-                          flag = false if line.match(/^\\s*\\#.*$/).nil?
+            :reason => lambda { |hook, rule| flag = true
+                        hook.code.each do |line|
+                          flag = false if line.match(/^\s*#.*$/).nil?
                         end
-                        flag"
+                        flag}
         },
         :hook_duplicate_tags => {
             :enabled => true,
             :phrase => "Hook has duplicate tags.",
             :score => WARNING,
             :targets => ["Hook"],
-            :reason => "all_tags = []
-                        object.tags.each { |single_tag| all_tags << single_tag.split(',') }
+            :reason => lambda { |hook, rule|
+                        all_tags = []
+                        hook.tags.each { |single_tag| all_tags << single_tag.split(',') }
                         all_tags.flatten!
                         unique_tags = all_tags.uniq
-                        true unless all_tags == unique_tags"
+                        true unless all_tags == unique_tags}
         }
     }
 
@@ -380,7 +357,7 @@ module CukeSniffer
             :score => INFO,
             :max => 8,
             :targets => ["Feature", "Scenario"],
-            :reason => "object.tags.size >= rule.conditions[:max]"
+            :reason => lambda { |feature_rule_target, rule| feature_rule_target.tags.size >= rule.conditions[:max]}
         },
         :long_name => {
             :enabled => true,
@@ -388,21 +365,21 @@ module CukeSniffer
             :score => INFO,
             :max => 180,
             :targets => ["Feature", "Scenario", "Background"],
-            :reason => "object.name.length >= rule.conditions[:max]"
+            :reason => lambda { |feature_rule_target, rule| feature_rule_target.name.length >= rule.conditions[:max]}
         },
         :implementation_word => {
             :enabled => true,
             :phrase => "Implementation word used: {word}.",
             :score => INFO,
-            :words => ["page", "site", "url", "drop down", "dropdown", "select list", "click", "text box", "radio button", "check box", "xml", "window", "pop up", "pop-up", "screen", "tab", "database", "DB"],
+            :words => ["page", "site", "url", "drop down", "dropdown", "select list", "click", "text box", "radio button", "check box", "xml", "window", "pop up", "pop-up", "screen", "database", "DB"],
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.each do |step|
-                          next if is_comment?(step)
+            :reason => lambda { |scenario, rule| scenario.steps.each do |step|
+                          next if scenario.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)
+                            scenario.store_rule(rule, new_phrase) if step.include?(word)
                           end
-                        end"
+                        end}
 
         },
         :implementation_word_button => {
@@ -410,41 +387,51 @@ module CukeSniffer
             :phrase => "Implementation word used: button.",
             :score => INFO,
             :targets => ["Scenario"],
-            :reason => "object.steps.each do |step|
-                          matches = step.match(/(?<prefix>\\w+)\\sbutton/i)
+            :reason => lambda { |scenario, rule| scenario.steps.each do |step|
+                          matches = step.match(/(?<prefix>\w+)\sbutton/i)
                           if(!matches.nil? and matches[:prefix].downcase != 'radio')
-                            store_rule(object, rule)
+                            scenario.store_rule(rule)
                           end
-                        end"
+                        end}
 
-        },:too_many_scenarios => {
+        },
+        :implementation_word_tab => {
+            :enabled => true,
+            :phrase => "Implementation word used: tab.",
+            :score => INFO,
+            :targets => ["Scenario"],
+            :reason => lambda { |scenario, rule| scenario.steps.each do |step|
+              scenario.store_rule(rule) if (step.split.include?("tab"))
+            end}
+        },
+        :too_many_scenarios => {
             :enabled => true,
             :phrase => "Feature with too many scenarios.",
             :score => INFO,
             :max => 10,
             :targets => ["Feature"],
-            :reason => "object.scenarios.size >= rule.conditions[:max]"
+            :reason => lambda { |feature, rule| feature.scenarios.size >= rule.conditions[:max]}
         },
         :date_used => {
             :enabled => true,
             :phrase => "Date used.",
             :score => INFO,
             :targets => ["Scenario", "Background"],
-            :reason => "object.steps.each {|step| store_rule(object, rule) if step =~ DATE_REGEX}"
+            :reason => lambda { |scenario, rule| scenario.steps.each {|step| scenario.store_rule(rule) if step =~ CukeSniffer::Constants::DATE_REGEX}}
         },
         :nested_step => {
             :enabled => true,
             :phrase => "Nested step call.",
             :score => INFO,
             :targets => ["StepDefinition"],
-            :reason => "!object.nested_steps.empty?"
+            :reason => lambda { |step_definition, rule| !step_definition.nested_steps.empty?}
         },
         :commented_code => {
             :enabled => true,
             :phrase => "Commented code in Step Definition.",
             :score => INFO,
             :targets => ["StepDefinition"],
-            :reason => "object.code.each {|line| store_rule(object, rule) if is_comment?(line)}"
+            :reason => lambda { |step_definition, rule| step_definition.code.each {|line| step_definition.store_rule(rule) if step_definition.is_comment?(line)}}
         },
         :small_sleep => {
             :enabled => true,
@@ -452,13 +439,13 @@ module CukeSniffer
             :score => INFO,
             :max => 2,
             :targets => ["StepDefinition"],
-            :reason => "object.code.each do |line|
-                          match_data = line.match /^\\s*sleep(\\s|\\()(?<sleep_time>.*)\\)?/
+            :reason => lambda { |step_definition, rule| step_definition.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]
+                            step_definition.store_rule(rule) if sleep_value < rule.conditions[:max]
                           end
-                        end"
+                        end}
         },
         :large_sleep => {
             :enabled => true,
@@ -466,21 +453,20 @@ module CukeSniffer
             :score => INFO,
             :min => 2,
             :targets => ["StepDefinition"],
-            :reason => "object.code.each do |line|
-                          match_data = line.match /^\\s*sleep(\\s|\\()(?<sleep_time>.*)\\)?/
+            :reason => lambda { |step_definition, rule| step_definition.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]
+                            step_definition.store_rule(rule) if sleep_value > rule.conditions[:min]
                           end
-                        end"
+                        end}
         },
         :todo => {
             :enabled => true,
             :phrase => "Todo found. Resolve it.",
             :score => INFO,
             :targets => ["StepDefinition"],
-            :reason => "object.code.each {|line| store_rule(object, rule) if line =~ /\\#(TODO|todo)/}
-                        false"
+            :reason => lambda { |step_definition, rule| step_definition.store_rule_many_times(rule, step_definition.todo.size)}
         },
         :hook_not_in_hooks_file => {
             :enabled => true,
@@ -488,7 +474,7 @@ module CukeSniffer
             :score => INFO,
             :file => "hooks.rb",
             :targets => ["Hook"],
-            :reason => "object.location.include?(rule.conditions[:file]) != true"
+            :reason => lambda { |hook, rule| hook.location.include?(rule.conditions[:file]) != true}
         },
     }