cuke_sniffer 0.0.3 → 0.0.5

data/lib/cuke_sniffer/scenario.rb

@@ -1,178 +1,238 @@
-module CukeSniffer
-  class Scenario < FeatureRulesEvaluator
-    include CukeSniffer::Constants
-    include CukeSniffer::RuleConfig
-
-    xml_accessor :start_line
-    xml_accessor :steps, :as => [], :in => "steps"
-    xml_accessor :examples_table, :as => [], :in => "examples"
-
-    attr_accessor :type, :inline_tables
-
-    def initialize(location, scenario)
-      super(location)
-      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
-      @steps = []
-      @inline_tables = {}
-      @examples_table = []
-      split_scenario(scenario)
-      evaluate_score
-    end
-
-    def split_scenario(scenario)
-      index = 0
-      until index >= scenario.length or scenario[index] =~ SCENARIO_TITLE_STYLES
-        update_tag_list(scenario[index])
-        index += 1
-      end
-
-      until index >= scenario.length or scenario[index].match STEP_REGEX or scenario[index].include?("Examples:")
-        match = scenario[index].match(SCENARIO_TITLE_STYLES)
-        @type = match[:type] unless match.nil?
-        create_name(scenario[index], SCENARIO_TITLE_STYLES)
-        index += 1
-      end
-
-      until index >= scenario.length or scenario[index].include?("Examples:")
-        if scenario[index] =~ /^\|.*\|/
-          step = scenario[index - 1]
-          @inline_tables[step] = []
-          until index >= scenario.length or scenario[index] =~ STEP_REGEX
-            @inline_tables[step] << scenario[index]
-            index += 1
-          end
-        else
-          @steps << scenario[index] if scenario[index] =~ STEP_REGEX
-          index += 1
-        end
-      end
-
-      if index < scenario.length and scenario[index].include?("Examples:")
-        index += 1
-        until index >= scenario.length
-          @examples_table << scenario[index] unless scenario[index].empty?
-          index += 1
-        end
-      end
-    end
-
-    def ==(comparison_object)
-      super(comparison_object)
-      comparison_object.steps == steps
-      comparison_object.examples_table == examples_table
-    end
-
-    def get_step_order
-      order = []
-      @steps.each { |line|
-        next if is_comment?(line)
-        match = line.match(STEP_REGEX)
-        order << match[:style] unless match.nil?
-      }
-      order
-    end
-
-    def evaluate_score
-      super
-      rule_empty_scenario
-      rule_too_many_steps
-      rule_step_order
-      rule_invalid_first_step
-      rule_asterisk_step
-      rule_commented_step
-      rule_implementation_words
-      rule_date_used_in_step
-      rule_one_word_step
-      rule_multiple_given_when_then
-      evaluate_outline_scores if type == "Scenario Outline"
-    end
-
-    def rule_multiple_given_when_then
-      step_order = get_step_order
-      %w(Given When Then).each { |type| store_rule(RULES[:multiple_given_when_then]) if step_order.count(type) > 1 }
-    end
-
-    def rule_one_word_step
-      @steps.each do |step|
-        store_rule(RULES[:one_word_step]) if step.split.count == 2
-      end
-    end
-
-    def evaluate_outline_scores
-      rule_no_examples_table
-      rule_no_examples
-      rule_one_example
-      rule_too_many_examples
-      rule_commented_example
-    end
-
-    def rule_empty_scenario
-      store_rule(RULES[:no_steps]) if @steps.empty?
-    end
-
-    def rule_too_many_steps
-      rule = RULES[:too_many_steps]
-      store_rule(rule) if @steps.size >= rule[:max]
-    end
-
-    def rule_step_order
-      step_order = get_step_order.uniq
-      %w(But * And).each { |type| step_order.delete(type) }
-      store_rule(RULES[:out_of_order_steps]) unless step_order == %w(Given When Then) or step_order == %w(When Then)
-    end
-
-    def rule_invalid_first_step
-      first_step = get_step_order.first
-      store_rule(RULES[:invalid_first_step]) if %w(And But).include?(first_step)
-    end
-
-    def rule_asterisk_step
-      get_step_order.count('*').times { store_rule(RULES[:asterisk_step]) }
-    end
-
-    def rule_commented_step
-      @steps.each do |step|
-        store_rule(RULES[:commented_step]) if is_comment?(step)
-      end
-    end
-
-    def rule_implementation_words
-      rule = RULES[:implementation_word]
-      @steps.each do |step|
-        next if is_comment?(step)
-        rule[:words].each do |word|
-          store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, word)) if step.include?(word)
-        end
-      end
-    end
-
-    def rule_date_used_in_step
-      @steps.each do |step|
-        store_rule(RULES[:date_used]) if step =~ DATE_REGEX
-      end
-    end
-
-    def rule_no_examples_table
-      store_rule(RULES[:no_examples_table]) if @examples_table.empty?
-    end
-
-    def rule_no_examples
-      store_rule(RULES[:no_examples]) if @examples_table.size == 1
-    end
-
-    def rule_one_example
-      store_rule(RULES[:one_example]) if @examples_table.size == 2 and !is_comment?(@examples_table[1])
-    end
-
-    def rule_too_many_examples
-      store_rule(RULES[:too_many_examples]) if (@examples_table.size - 1) >= 8
-    end
-
-    def rule_commented_example
-      @examples_table.each do |example|
-        store_rule(RULES[:commented_example]) if is_comment?(example)
-      end
-    end
-
-  end
-end
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # This class is a representation of the cucumber objects
+  # Background, Scenario, Scenario Outline
+  #
+  # Extends CukeSniffer::FeatureRulesEvaluator
+  class Scenario < FeatureRulesEvaluator
+
+    xml_accessor :start_line
+    xml_accessor :steps, :as => [], :in => "steps"
+    xml_accessor :examples_table, :as => [], :in => "examples"
+
+    # int: Line on which the scenario begins
+    attr_accessor :start_line
+
+    # string: The type of scenario
+    # Background, Scenario, Scenario Outline
+    attr_accessor :type
+
+    # string array: List of each step call in a scenario
+    attr_accessor :steps
+
+    # hash: Keeps each location and content of an inline table
+    # * Key: Step string the inline table is attached to
+    # * Value: Array of all of the lines in the table
+    attr_accessor :inline_tables
+
+    # string array: List of each example row in a scenario outline
+    attr_accessor :examples_table
+
+    # Location must be in the format of "file_path\file_name.rb:line_number"
+    # Scenario must be a string array containing everything from the first tag to the last example table
+    # where applicable.
+    def initialize(location, scenario)
+      super(location)
+      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
+      @steps = []
+      @inline_tables = {}
+      @examples_table = []
+      split_scenario(scenario)
+      evaluate_score
+    end
+
+    def ==(comparison_object) # :nodoc:
+      super(comparison_object) &&
+      comparison_object.steps == steps &&
+      comparison_object.examples_table == examples_table
+    end
+
+    private
+
+    def split_scenario(scenario)
+      index = 0
+      until index >= scenario.length or scenario[index] =~ SCENARIO_TITLE_STYLES
+        update_tag_list(scenario[index])
+        index += 1
+      end
+
+      until index >= scenario.length or scenario[index].match STEP_REGEX or scenario[index].include?("Examples:")
+        match = scenario[index].match(SCENARIO_TITLE_STYLES)
+        @type = match[:type] unless match.nil?
+        create_name(scenario[index], SCENARIO_TITLE_STYLES)
+        index += 1
+      end
+
+      until index >= scenario.length or scenario[index].include?("Examples:")
+        if scenario[index] =~ /^\|.*\|/
+          step = scenario[index - 1]
+          @inline_tables[step] = []
+          until index >= scenario.length or scenario[index] =~ /(#{STEP_REGEX}|^\s*Examples:)/
+            @inline_tables[step] << scenario[index]
+            index += 1
+          end
+        else
+          @steps << scenario[index] if scenario[index] =~ STEP_REGEX
+          index += 1
+        end
+      end
+
+      if index < scenario.length and scenario[index].include?("Examples:")
+        index += 1
+        until index >= scenario.length
+          index += 2 if scenario[index].include?("Examples:")
+          @examples_table << scenario[index] if scenario[index] =~ /#{COMMENT_REGEX}\|.*\|/
+          index += 1
+        end
+      end
+    end
+
+    def get_step_order
+      order = []
+      @steps.each do |line|
+        next if is_comment?(line)
+        match = line.match(STEP_REGEX)
+        order << match[:style] unless match.nil?
+      end
+      order
+    end
+
+    def evaluate_score
+      if type == "Background"
+        rule_numbers_in_name(type)
+        rule_long_name(type)
+        rule_tagged_background(type)
+      else
+        super
+        rule_step_order
+      end
+
+      rule_empty_scenario
+      rule_too_many_steps
+      rule_invalid_first_step
+      rule_asterisk_step
+      rule_commented_step
+      rule_implementation_words
+      rule_date_used_in_step
+      rule_one_word_step
+      rule_multiple_given_when_then
+      evaluate_outline_scores if type == "Scenario Outline"
+    end
+
+    def evaluate_outline_scores
+      rule_no_examples_table
+      rule_no_examples
+      rule_one_example
+      rule_too_many_examples
+      rule_commented_example
+    end
+
+    def rule_multiple_given_when_then
+      step_order = get_step_order
+      rule = RULES[:multiple_given_when_then]
+      phrase = rule[:phrase].gsub(/{.*}/, type)
+      ["Given", "When", "Then"].each { |step| store_rule(rule, phrase) if step_order.count(step) > 1 }
+    end
+
+    def rule_one_word_step
+      @steps.each do |step|
+        rule = RULES[:one_word_step]
+        store_rule(rule) if step.split.count == 2
+      end
+    end
+
+    def rule_step_order
+      step_order = get_step_order.uniq
+      ["But", "*", "And"].each { |type| step_order.delete(type) }
+      rule = RULES[:out_of_order_steps]
+      store_rule(rule) unless step_order == %w(Given When Then) or step_order == %w(When Then)
+    end
+
+    def rule_asterisk_step
+      get_step_order.count('*').times do
+        rule = RULES[:asterisk_step]
+        store_rule(rule)
+      end
+    end
+
+    def rule_commented_step
+      @steps.each do |step|
+        rule = RULES[:commented_step]
+        store_rule(rule) if is_comment?(step)
+      end
+    end
+
+    def rule_date_used_in_step
+      @steps.each do |step|
+        rule = RULES[:date_used]
+        store_rule(rule) if step =~ DATE_REGEX
+      end
+    end
+
+    def rule_no_examples_table
+      rule = RULES[:no_examples_table]
+      store_rule(rule) if @examples_table.empty?
+    end
+
+    def rule_no_examples
+      rule = RULES[:no_examples]
+      store_rule(rule) if @examples_table.size == 1
+    end
+
+    def rule_one_example
+      rule = RULES[:one_example]
+      store_rule(rule) if @examples_table.size == 2 and !is_comment?(@examples_table[1])
+    end
+
+    def rule_too_many_examples
+      rule = RULES[:too_many_examples]
+      store_rule(rule) if (@examples_table.size - 1) >= 8
+    end
+
+    def rule_commented_example
+      @examples_table.each do |example|
+        rule = RULES[:commented_example]
+        store_rule(rule) if is_comment?(example)
+      end
+    end
+
+    def rule_implementation_words
+      rule = RULES[:implementation_word]
+      @steps.each do |step|
+        next if is_comment?(step)
+        rule[:words].each do |word|
+          rule_phrase = rule[:phrase].gsub(/{.*}/, word)
+          store_rule(rule, rule_phrase) if step.include?(word)
+        end
+      end
+    end
+
+    def rule_tagged_background(type)
+      rule = RULES[:background_with_tag]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if tags.size > 0
+    end
+
+    def rule_invalid_first_step
+      first_step = get_step_order.first
+      rule = RULES[:invalid_first_step]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if %w(And But).include?(first_step)
+    end
+
+    def rule_empty_scenario
+      rule = RULES[:no_steps]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if @steps.empty?
+    end
+
+    def rule_too_many_steps
+      rule = RULES[:too_many_steps]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if @steps.size >= rule[:max]
+    end
+  end
+end

data/lib/cuke_sniffer/step_definition.rb

@@ -1,202 +1,239 @@
-require 'roxml'
-module CukeSniffer
-  class StepDefinition < RulesEvaluator
-    include CukeSniffer::Constants
-    include CukeSniffer::RuleConfig
-
-    xml_accessor :start_line
-    xml_accessor :regex
-    xml_accessor :parameters, :as => [], :in => "parameters"
-    xml_accessor :nested_steps, :as => {:key => 'location', :value => 'call'}, :in => "nested_steps"
-    xml_accessor :calls, :as => {:key => 'location', :value => 'call'}, :in => "calls"
-    xml_accessor :code, :as => [], :in => "code"
-
-    SIMPLE_NESTED_STEP_REGEX = /steps\s"#{STEP_STYLES}(?<step_string>.*)"$/
-    START_COMPLEX_STEP_REGEX = /^steps\s%(q|Q)?\{\s*/
-    SAME_LINE_COMPLEX_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)}$/
-    END_COMPLEX_STEP_REGEX = /}$/
-    START_COMPLEX_WITH_STEP_REGEX = /steps\s%(q|Q)?\{#{STEP_STYLES}(?<step_string>.*)$/
-    END_COMPLEX_WITH_STEP_REGEX = /#{STEP_STYLES}(?<step_string>.*)}$/
-
-    def initialize(location, raw_code)
-      super(location)
-
-      @parameters = []
-      @calls = {}
-      @nested_steps = {}
-      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
-
-      end_match_index = (raw_code.size - 1) - raw_code.reverse.index("end")
-      @code = raw_code[1...end_match_index]
-
-      raw_code.each do |line|
-        if line =~ STEP_DEFINITION_REGEX
-          matches = STEP_DEFINITION_REGEX.match(line)
-          @regex = Regexp.new(matches[:step])
-          @parameters = matches[:parameters].split(",") unless matches[:parameters].nil?
-        end
-      end
-
-      detect_nested_steps
-      evaluate_score
-    end
-
-    def add_call(location, step_string)
-      @calls[location] = step_string
-    end
-
-    def detect_nested_steps
-      multi_line_step_flag = false
-      counter = 1
-      @code.each do |line|
-        regex = nil
-        case line
-          when SIMPLE_NESTED_STEP_REGEX
-            regex = SIMPLE_NESTED_STEP_REGEX
-          when START_COMPLEX_WITH_STEP_REGEX
-            if line =~ /\}$/
-              if line.include?('#{')
-                reversed_line = line.reverse
-                last_capture = reversed_line[0..reversed_line.index('#')].reverse
-                if last_capture =~ /{.*}$/
-                  multi_line_step_flag = true
-                  regex = START_COMPLEX_WITH_STEP_REGEX
-                else
-                  regex = SAME_LINE_COMPLEX_STEP_REGEX
-                end
-              else
-                regex = SAME_LINE_COMPLEX_STEP_REGEX
-              end
-            else
-              multi_line_step_flag = true
-              regex = START_COMPLEX_WITH_STEP_REGEX
-            end
-          when SAME_LINE_COMPLEX_STEP_REGEX
-            regex = SAME_LINE_COMPLEX_STEP_REGEX
-          when END_COMPLEX_WITH_STEP_REGEX
-            if line =~ /[#]{.*}$/ && multi_line_step_flag
-              regex = STEP_REGEX
-            else
-              regex = END_COMPLEX_WITH_STEP_REGEX
-              multi_line_step_flag = false
-            end
-          when START_COMPLEX_STEP_REGEX
-            multi_line_step_flag = true
-          when STEP_REGEX
-            regex = STEP_REGEX if multi_line_step_flag
-          when END_COMPLEX_STEP_REGEX
-            multi_line_step_flag = false
-          else
-        end
-
-        if regex
-          index = 0
-          while line.include?('#{') and index <= line.length
-            index = line.index('#{')
-            replace_string = ""
-            while index <= line.length and line[index - 1] != "}"
-              replace_string << line[index]
-              index += 1
-            end
-            line.gsub!(replace_string, "variable")
-          end
-
-          match = regex.match(line)
-          nested_step_line = (@start_line + counter)
-          @nested_steps[location.gsub(/:\d*/, ":" + nested_step_line.to_s)] = match[:step_string]
-        end
-        counter += 1
-      end
-    end
-
-    def condensed_call_list
-      condensed_list = {}
-      @calls.each { |call, step_string|
-        condensed_list[step_string] ||= []
-        condensed_list[step_string] << call
-      }
-      condensed_list
-    end
-
-    def ==(comparison_object)
-      super(comparison_object)
-      comparison_object.regex == regex
-      comparison_object.code == code
-      comparison_object.parameters == parameters
-      comparison_object.calls == calls
-      comparison_object.nested_steps == nested_steps
-    end
-
-    def evaluate_score
-      super
-      rule_no_code
-      rule_too_many_parameters
-      rule_nested_steps
-      rule_recursive_nested_step
-      rule_commented_code
-      rule_lazy_debugging
-      rule_pending
-      rule_todo
-      sleep_rules
-    end
-
-    def rule_todo
-      code.each do |line|
-        store_rule(RULES[:todo]) if line =~ /\#(TODO|todo)/
-      end
-    end
-
-    def sleep_rules
-      code.each do |line|
-        match_data = line.match /^\s*sleep(\s|\()(?<sleep_time>.*)\)?/
-        unless match_data.nil?
-          sleep_value = match_data[:sleep_time].to_f
-          store_rule(RULES[:small_sleep]) if sleep_value <= RULES[:small_sleep][:max]
-          store_rule(RULES[:large_sleep]) if sleep_value > RULES[:large_sleep][:min]
-        end
-      end
-    end
-
-    def rule_pending
-      code.each do |line|
-        if line =~ /^\s*pending\s*$/
-          store_rule(RULES[:pending])
-          return
-        end
-      end
-    end
-
-    def rule_lazy_debugging
-      code.each do |line|
-        next if is_comment?(line)
-        store_rule(RULES[:lazy_debugging]) if line.strip =~ /^(p|puts)( |\()('|"|%(q|Q)?\{)/
-      end
-    end
-
-    def rule_no_code
-      store_rule(RULES[:no_code]) if code.empty?
-    end
-
-    def rule_too_many_parameters
-      rule = RULES[:too_many_parameters]
-      store_rule(rule) if parameters.size >= rule[:max]
-    end
-
-    def rule_nested_steps
-      store_rule(RULES[:nested_step]) unless nested_steps.empty?
-    end
-
-    def rule_recursive_nested_step
-      nested_steps.each_value do |nested_step|
-        store_rule(RULES[:recursive_nested_step]) if nested_step =~ regex
-      end
-    end
-
-    def rule_commented_code
-      code.each do |line|
-        store_rule(RULES[:commented_code]) if is_comment?(line)
-      end
-    end
-
-  end
-end
+require 'roxml'
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Translates and evaluates Cucumber step definitions
+  # Extends CukeSniffer::RulesEvaluator
+  class StepDefinition < RulesEvaluator
+
+    xml_accessor :start_line
+    xml_accessor :regex
+    xml_accessor :parameters, :as => [], :in => "parameters"
+    xml_accessor :nested_steps, :as => {:key => 'location', :value => 'call'}, :in => "nested_steps"
+    xml_accessor :calls, :as => {:key => 'location', :value => 'call'}, :in => "calls"
+    xml_accessor :code, :as => [], :in => "code"
+
+    # int: Line on which a step definition starts
+    attr_accessor :start_line
+
+    # Regex: Regex that cucumber uses to match step calls
+    attr_accessor :regex
+
+    # string array: List of the parameters a step definition has
+    attr_accessor :parameters
+
+    # hash: Contains each nested step call a step definition has
+    # * Key: location:line of the nested step
+    # * Value: The step call that appears on the line
+    attr_accessor :nested_steps
+
+    # hash: Contains each call that is made to a step definition
+    # * Key: Location in which the step definition is called from
+    # * Value: The step string that matched the regex
+    # In the case of a fuzzy match it will be a regex of the
+    # step call that was the inverse match of the regex translated
+    # into a string.
+    attr_accessor :calls
+
+    # string array: List of all of the content between the regex and the end of the step definition.
+    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 regex line and its pairing end
+    def initialize(location, raw_code)
+      super(location)
+
+      @parameters = []
+      @calls = {}
+      @nested_steps = {}
+      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
+
+      end_match_index = (raw_code.size - 1) - raw_code.reverse.index("end")
+      @code = raw_code[1...end_match_index]
+
+      raw_code.each do |line|
+        if line =~ STEP_DEFINITION_REGEX
+          matches = STEP_DEFINITION_REGEX.match(line)
+          @regex = Regexp.new(matches[:step])
+          @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
+        end
+      end
+
+      detect_nested_steps
+      evaluate_score
+    end
+
+    # Adds new location => step_string pairs to the calls hash
+    def add_call(location, step_string)
+      @calls[location] = step_string
+    end
+
+    def ==(comparison_object) # :nodoc:
+      super(comparison_object) &&
+      comparison_object.regex == regex &&
+      comparison_object.code == code &&
+      comparison_object.parameters == parameters &&
+      comparison_object.calls == calls &&
+      comparison_object.nested_steps == nested_steps
+    end
+
+    def condensed_call_list
+      condensed_list = {}
+      @calls.each do |call, step_string|
+        condensed_list[step_string] ||= []
+        condensed_list[step_string] << call
+      end
+      condensed_list
+    end
+
+    private
+
+    SIMPLE_NESTED_STEP_REGEX = /steps?\s"#{STEP_STYLES}(?<step_string>.*)"$/ # :nodoc:
+    START_COMPLEX_STEP_REGEX = /^steps?\s%(q|Q)?\{\s*/ # :nodoc:
+    SAME_LINE_COMPLEX_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)}$/ # :nodoc:
+    END_COMPLEX_STEP_REGEX = /}$/ # :nodoc:
+    START_COMPLEX_WITH_STEP_REGEX = /#{START_COMPLEX_STEP_REGEX}#{STEP_STYLES}(?<step_string>.*)$/ # :nodoc:
+    END_COMPLEX_WITH_STEP_REGEX = /#{STEP_STYLES}(?<step_string>.*)}$/ # :nodoc:
+
+    def detect_nested_steps
+      multi_line_step_flag = false
+      counter = 1
+      @code.each do |line|
+        regex = nil
+        case line
+          when SIMPLE_NESTED_STEP_REGEX
+            regex = SIMPLE_NESTED_STEP_REGEX
+          when SAME_LINE_COMPLEX_STEP_REGEX
+            regex = SAME_LINE_COMPLEX_STEP_REGEX
+          when START_COMPLEX_WITH_STEP_REGEX
+            if line =~ /\}$/
+              if line.include?('#{')
+                reversed_line = line.reverse
+                last_capture = reversed_line[0..reversed_line.index('#')].reverse
+                if last_capture =~ /{.*}$/
+                  multi_line_step_flag = true
+                  regex = START_COMPLEX_WITH_STEP_REGEX
+                else
+                  regex = SAME_LINE_COMPLEX_STEP_REGEX
+                end
+              else
+                regex = SAME_LINE_COMPLEX_STEP_REGEX
+              end
+            else
+              multi_line_step_flag = true
+              regex = START_COMPLEX_WITH_STEP_REGEX
+            end
+          when END_COMPLEX_WITH_STEP_REGEX
+            if line =~ /[#]{.*}$/ && multi_line_step_flag
+              regex = STEP_REGEX
+            else
+              regex = END_COMPLEX_WITH_STEP_REGEX
+              multi_line_step_flag = false
+            end
+          when START_COMPLEX_STEP_REGEX
+            multi_line_step_flag = true
+          when STEP_REGEX
+            regex = STEP_REGEX if multi_line_step_flag
+          when END_COMPLEX_STEP_REGEX
+            multi_line_step_flag = false
+          else
+        end
+
+        if regex and !is_comment?(line)
+          match = regex.match(line)
+          nested_step_line = (@start_line + counter)
+          @nested_steps[location.gsub(/:\d*$/, ":" + nested_step_line.to_s)] = match[:step_string].gsub("\\", "")
+        end
+        counter += 1
+      end
+    end
+
+    def evaluate_score
+      rule_no_code
+      rule_too_many_parameters
+      rule_nested_steps
+      rule_recursive_nested_step
+      rule_commented_code
+      rule_lazy_debugging
+      rule_pending
+      rule_todo
+      sleep_rules
+    end
+
+    def rule_todo
+      code.each do |line|
+        rule = RULES[:todo]
+        store_rule(rule) if line =~ /\#(TODO|todo)/
+      end
+    end
+
+    def sleep_rules
+      code.each do |line|
+        match_data = line.match /^\s*sleep(\s|\()(?<sleep_time>.*)\)?/
+        if match_data
+          sleep_value = match_data[:sleep_time].to_f
+          rule_small_sleep(sleep_value)
+          rule_large_sleep(sleep_value)
+        end
+      end
+    end
+
+    def rule_large_sleep(sleep_value)
+      rule = RULES[:large_sleep]
+      store_rule(rule) if sleep_value > rule[:min]
+    end
+
+    def rule_small_sleep(sleep_value)
+      rule = RULES[:small_sleep]
+      store_rule(rule) if sleep_value <= rule[:max]
+    end
+
+    def rule_pending
+      rule = RULES[:pending]
+      code.each do |line|
+        store_rule(rule) if line =~ /^\s*pending\s*$/
+        return
+      end
+    end
+
+    def rule_lazy_debugging
+      rule = RULES[:lazy_debugging]
+      code.each do |line|
+        next if is_comment?(line)
+        store_rule(rule) if line.strip =~ /^(p|puts)( |\()('|"|%(q|Q)?\{)/
+      end
+    end
+
+    def rule_no_code
+      rule = RULES[:no_code]
+      store_rule(rule) if code.empty?
+    end
+
+    def rule_too_many_parameters
+      rule = RULES[:too_many_parameters]
+      store_rule(rule) if parameters.size >= rule[:max]
+    end
+
+    def rule_nested_steps
+      rule = RULES[:nested_step]
+      store_rule(rule) unless nested_steps.empty?
+    end
+
+    def rule_recursive_nested_step
+      rule = RULES[:recursive_nested_step]
+      nested_steps.each_value do |nested_step|
+        store_rule(rule) if nested_step =~ regex
+      end
+    end
+
+    def rule_commented_code
+      rule = RULES[:commented_code]
+      code.each do |line|
+        store_rule(rule) if is_comment?(line)
+      end
+    end
+  end
+end