cuke_sniffer 0.0.2 → 0.0.3

data/bin/cuke_sniffer.rb

@@ -6,8 +6,9 @@ Calling CukeSniffer with no arguments will run it against the current directory.
 Other Options for Running include:
   <feature_file_path>, <step_def_file_path> : Runs CukeSniffer against the
                                               specified paths.
-  -o, --out html (name)                     : Runs CukeSniffer then outputs an
-                                              html file in the current
+  -o, --out <type> (name)                   : Where <type> is 'html' or 'xml'.
+                                              Runs CukeSniffer then outputs an
+                                              html/xml file in the current
                                               directory (with optional name).
   -h, --help                                : You get this lovely document."
 
@@ -41,6 +42,14 @@ if ARGV.include? "--out" or ARGV.include? "-o"
         file_name = file_name + ".html" unless file_name =~ /\.html$/
         cuke_sniffer.output_html(file_name)
       end
+    when "xml"
+      file_name = ARGV[index + 2]
+      if file_name.nil?
+        cuke_sniffer.output_xml
+      else
+        file_name = file_name + ".xml" unless file_name =~ /\.xml$/
+        cuke_sniffer.output_xml(file_name)
+      end
     else
       print_results(cuke_sniffer)
   end

data/lib/cuke_sniffer.rb

@@ -1,3 +1,5 @@
+require 'nokogiri'
+require 'roxml'
 
 require 'cuke_sniffer/constants'
 require 'cuke_sniffer/rule_config'

data/lib/cuke_sniffer/cli.rb

@@ -1,10 +1,30 @@
 require 'erb'
+require 'roxml'
 
 module CukeSniffer
   class CLI
     include CukeSniffer::Constants
+    include ROXML
 
-    attr_accessor :features_location,:step_definitions_location, :features, :scenarios, :step_definitions, :summary
+    class SummaryNode
+      include ROXML
+      xml_accessor :score
+      xml_accessor :count
+      xml_accessor :average
+      xml_accessor :good
+      xml_accessor :bad
+      xml_accessor :threshold
+    end
+
+    xml_name "cuke_sniffer"
+    xml_accessor :features_summary, :as => SummaryNode
+    xml_accessor :scenarios_summary, :as => SummaryNode
+    xml_accessor :step_definitions_summary, :as => SummaryNode
+    xml_accessor :improvement_list, :as => {:key => "rule", :value => "total"}, :in =>  "improvement_list", :from => "improvement"
+    xml_accessor :features, :as => [CukeSniffer::Feature], :in => "features"
+    xml_accessor :step_definitions, :as => [CukeSniffer::StepDefinition], :in => "step_definitions"
+
+    attr_accessor :summary, :features_location, :step_definitions_location, :scenarios
 
     def initialize(features_location = Dir.getwd, step_definitions_location = Dir.getwd)
       @features_location = features_location
@@ -50,6 +70,21 @@ module CukeSniffer
       catalog_step_calls
       puts "\nAssessing Score: "
       assess_score
+      @improvement_list = @summary[:improvement_list]
+      @features_summary = load_summary_data(@summary[:features])
+      @scenarios_summary = load_summary_data(@summary[:scenarios])
+      @step_definitions_summary = load_summary_data(@summary[:step_definitions])
+    end
+
+    def load_summary_data(summary_hash)
+      summary_node = SummaryNode.new
+      summary_node.count = summary_hash[:total]
+      summary_node.score = summary_hash[:total_score]
+      summary_node.average = summary_hash[:average]
+      summary_node.threshold = summary_hash[:threshold]
+      summary_node.good = summary_hash[:good]
+      summary_node.bad = summary_hash[:bad]
+      summary_node
     end
 
     def good?
@@ -183,16 +218,27 @@ module CukeSniffer
       output
     end
 
+    def extract_steps_hash(scenario)
+      steps_hash = {}
+      counter = 1
+      scenario.steps.each do |step|
+        location = scenario.location.gsub(/:\d*$/, ":#{scenario.start_line + counter}")
+        steps_hash[location] = step
+        counter += 1
+      end
+      steps_hash
+    end
+
     def get_all_steps
       steps = {}
       @features.each do |feature|
+        unless feature.background.nil?
+          background_steps = extract_steps_hash(feature.background)
+          background_steps.each_key { |key| steps[key] = background_steps[key] }
+        end
         feature.scenarios.each do |scenario|
-          counter = 1
-          scenario.steps.each do |step|
-            location = scenario.location.gsub(/:\d*$/, ":#{scenario.start_line + counter}")
-            steps[location] = step
-            counter += 1
-          end
+          scenario_steps = extract_steps_hash(scenario)
+          scenario_steps.each_key { |key| steps[key] = scenario_steps[key] }
         end
       end
       @step_definitions.each do |definition|
@@ -215,12 +261,25 @@ module CukeSniffer
     end
 
     def get_dead_steps
-      dead_steps = []
+      dead_steps_hash = {}
       @step_definitions.each do |step_definition|
-        dead_steps << step_definition if step_definition.calls.empty?
+        location_match = step_definition.location.match(/(?<file>.*).rb:(?<line>\d+)/)
+        file_name = location_match[:file]
+        regex = step_definition.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
+        dead_steps_hash[file_name] ||= []
+        dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/" if step_definition.calls.empty?
       end
-
-      dead_steps.sort_by{|step| step.location}
+      total = 0
+      dead_steps_hash.each_key do |key|
+        unless dead_steps_hash[key] == []
+          total += dead_steps_hash[key].size
+          dead_steps_hash[key].sort_by! {|row| row[/^\d+/].to_i}
+        else
+          dead_steps_hash.delete(key)
+        end
+      end
+      dead_steps_hash[:total] = total
+      dead_steps_hash
     end
 
     def extract_markup
@@ -242,5 +301,14 @@ module CukeSniffer
         f.write(output)
       end
     end
+
+    def output_xml(file_name = "cuke_sniffer.xml")
+      doc = Nokogiri::XML::Document.new
+      doc.root = self.to_xml
+      open(file_name, "w") do |file|
+        file << doc.serialize
+      end
+
+    end
   end
 end

data/lib/cuke_sniffer/feature.rb

@@ -2,28 +2,38 @@ module CukeSniffer
   class Feature < FeatureRulesEvaluator
     include CukeSniffer::Constants
     include CukeSniffer::RuleConfig
+    include ROXML
+
+    xml_accessor :scenarios, :as => [CukeSniffer::FeatureRulesEvaluator], :in => "scenarios"
 
     SCENARIO_TITLE_REGEX = /#{COMMENT_REGEX}#{SCENARIO_TITLE_STYLES}(?<name>.*)/
 
-    attr_accessor :background, :scenarios, :scenarios_score, :total_score
+    attr_accessor :background, :scenarios, :scenarios_score,:total_score
 
     def initialize(file_name)
       super(file_name)
       @scenarios = []
-      @feature_rules_hash = {}
+      @RULES_hash = {}
       @scenarios_score = 0
       @total_score = 0
-      split_feature(file_name)
-      evaluate_score
+      feature_lines = extract_feature_from_file(file_name)
+      if feature_lines == []
+        store_rule(RULES[:empty_feature])
+      else
+        split_feature(file_name, feature_lines)
+        evaluate_score
+      end
     end
 
-    def split_feature(file_name)
+    def extract_feature_from_file(file_name)
       feature_lines = []
-
       feature_file = File.open(file_name)
       feature_file.each_line { |line| feature_lines << line }
       feature_file.close
+      feature_lines
+    end
 
+    def split_feature(file_name, feature_lines)
       index = 0
       until feature_lines[index].match /Feature:\s*(?<name>.*)/
         update_tag_list(feature_lines[index])
@@ -87,20 +97,20 @@ module CukeSniffer
     end
 
     def rule_no_scenarios
-      store_rule(FEATURE_RULES[:no_scenarios]) if @scenarios.empty?
+      store_rule(RULES[:no_scenarios]) if @scenarios.empty?
     end
 
     def rule_too_many_scenarios
-      rule = FEATURE_RULES[:too_many_scenarios]
+      rule = RULES[:too_many_scenarios]
       store_rule(rule) if @scenarios.size >= rule[:max]
     end
 
     def rule_background_with_no_scenarios
-      store_rule( FEATURE_RULES[:background_with_no_scenarios]) if @scenarios.empty? and !@background.nil?
+      store_rule( RULES[:background_with_no_scenarios]) if @scenarios.empty? and !@background.nil?
     end
 
     def rule_background_with_one_scenario
-      store_rule(FEATURE_RULES[:background_with_one_scenario]) if @scenarios.size == 1 and !@background.nil?
+      store_rule(RULES[:background_with_one_scenario]) if @scenarios.size == 1 and !@background.nil?
     end
 
   end

data/lib/cuke_sniffer/feature_rules_evaluator.rb

@@ -1,69 +1,69 @@
-require 'cuke_sniffer/constants'
-require 'cuke_sniffer/rule_config'
-require 'cuke_sniffer/rules_evaluator'
-
-module CukeSniffer
-  class FeatureRulesEvaluator < RulesEvaluator
-    include CukeSniffer::Constants
-    include CukeSniffer::RuleConfig
-    
-    attr_accessor :tags, :name
-
-    def initialize(location)
-      @name = ""
-      @tags = []
-      super(location)
-    end
-
-    def create_name(line, filter)
-      line.gsub!(/#{COMMENT_REGEX}#{filter}/, "")
-      line.strip!
-      @name += " " unless @name.empty? or line.empty?
-      @name += line
-    end
-
-    def update_tag_list(line)
-      if TAG_REGEX.match(line) && !is_comment?(line)
-        line.scan(TAG_REGEX).each { |tag| @tags << tag[0] }
-      else
-        @tags << line.strip unless line.empty?
-      end
-    end
-
-    def evaluate_score
-      super
-      cls_name = self.class.to_s.gsub('CukeSniffer::', '')
-      rule_too_many_tags(cls_name)
-      rule_no_description(cls_name)
-      rule_numbers_in_name(cls_name)
-      rule_long_name(cls_name)
-    end
-
-    def rule_too_many_tags(type)
-      rule = SHARED_RULES[:too_many_tags]
-      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if tags.size >= rule[:max]
-    end
-
-    def rule_no_description(type)
-      rule = SHARED_RULES[:no_description]
-      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if name.empty?
-    end
-
-    def rule_numbers_in_name(type)
-      rule = SHARED_RULES[:numbers_in_description]
-      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if name =~ /\d/
-    end
-
-    def rule_long_name(type)
-      rule = SHARED_RULES[:long_name]
-      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type))  if name.size >= rule[:max]
-    end
-
-    def == (comparison_object)
-      super(comparison_object)
-      comparison_object.name == name
-      comparison_object.tags == tags
-    end
-
-  end
-end
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+require 'cuke_sniffer/rules_evaluator'
+
+module CukeSniffer
+  class FeatureRulesEvaluator < RulesEvaluator
+    include CukeSniffer::Constants
+    include CukeSniffer::RuleConfig
+    
+    attr_accessor :tags, :name
+
+    def initialize(location)
+      @name = ""
+      @tags = []
+      super(location)
+    end
+
+    def create_name(line, filter)
+      line.gsub!(/#{COMMENT_REGEX}#{filter}/, "")
+      line.strip!
+      @name += " " unless @name.empty? or line.empty?
+      @name += line
+    end
+
+    def update_tag_list(line)
+      if TAG_REGEX.match(line) && !is_comment?(line)
+        line.scan(TAG_REGEX).each { |tag| @tags << tag[0] }
+      else
+        @tags << line.strip unless line.empty?
+      end
+    end
+
+    def evaluate_score
+      super
+      cls_name = self.class.to_s.gsub('CukeSniffer::', '')
+      rule_too_many_tags(cls_name)
+      rule_no_description(cls_name)
+      rule_numbers_in_name(cls_name)
+      rule_long_name(cls_name)
+    end
+
+    def rule_too_many_tags(type)
+      rule = RULES[:too_many_tags]
+      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if tags.size >= rule[:max]
+    end
+
+    def rule_no_description(type)
+      rule = RULES[:no_description]
+      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if name.empty?
+    end
+
+    def rule_numbers_in_name(type)
+      rule = RULES[:numbers_in_description]
+      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if name =~ /\d/
+    end
+
+    def rule_long_name(type)
+      rule = RULES[:long_name]
+      store_updated_rule(rule, rule[:phrase].gsub(/{.*}/, type))  if name.size >= rule[:max]
+    end
+
+    def == (comparison_object)
+      super(comparison_object)
+      comparison_object.name == name
+      comparison_object.tags == tags
+    end
+
+  end
+end

data/lib/cuke_sniffer/report/markup.rhtml

@@ -209,13 +209,22 @@
 
 <div class="sections">
   <div name="dead_steps" class="shrink_section" id="dead_steps">
+    <% dead_steps = cuke_sniffer.get_dead_steps %>
+    <br>
     <div style="font:bold;padding-left:3%;font:bold;font-size:14pt;">Total Dead
-      Steps: <%= cuke_sniffer.get_dead_steps.count %></div>
-    <% cuke_sniffer.get_dead_steps.each do |dead_step| %>
-        <div style="font:14pt;padding-left:5%;padding-bottom: 1%;">
-          <div><%= "/" + dead_step.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex] + "/" %></div>
-          <div style="padding-left:1%"><%= dead_step.location %></div>
-        </div>
+      Steps: <%= dead_steps[:total] %></div>
+    <% dead_steps.delete :total%>
+    <% dead_steps.each_key do |step_file| %>
+        <div style="font:bold;padding-left:3%;font-size:14pt;">
+          <%= step_file %>
+          <br>
+          <div style="padding-left:3%;font-size:12pt;">
+            <%dead_steps[step_file].each  do |regex|%>
+                <%= regex %>
+                <br>
+            <% end %>
+          </div></div>
+        <br>
     <% end %>
   </div>
 </div>
@@ -320,7 +329,7 @@
     <% i=0 %>
     <% cuke_sniffer.step_definitions.each do |step_definition| %>
         <div style="cursor: hand;" onclick="toggle(this,4)" class="feature <%= i%2==0 ? "even" : "odd" %>">
-          <% next if step_definition.score <= 0 and !step_definition.calls.empty? %>
+          <% next if step_definition.score <= 0 or step_definition.calls.empty? %>
           <div style="float:left;padding:4px;font-weight:bold;color:red;"><%= step_definition.score %></div>
           <div style="width:55%;padding:4px; float:left;">
 

data/lib/cuke_sniffer/rule_config.rb

@@ -1,160 +1,191 @@
-
-
 module CukeSniffer
   module RuleConfig
 
-    FATAL = 100       #will prevent suite from executing properly
-    ERROR = 25        #will cause problem with debugging
-    WARNING = 10      #readibility/misuse of cucumber
-    INFO = 1          #Small improvements that can be made
-
-    SHARED_RULES = {
-      :too_many_tags => {
-        :enabled => true,
-        :phrase => "{class} has too many tags.",
-        :score => INFO,
-        :max => 8
-      },
-      :no_description => {
-        :enabled => true,
-        :phrase => "{class} has no description.",
-        :score => ERROR,
-      },
-      :numbers_in_description => {
-        :enabled => true,
-        :phrase => "{class} has numbers in the description.",
-        :score => WARNING,
-      },
-      :long_name => {
-        :enabled => true,
-        :phrase => "{class} has a long description.",
-        :score => INFO,
-        :max => 180
-      },
-      :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"]
-      }
-    }
-
-    FEATURE_RULES = {
-      :background_with_no_scenarios => {
-        :enabled => true,
-        :phrase => "Feature has a background with no scenarios.",
-        :score => WARNING,
-      },
-      :background_with_one_scenario => {
-        :enabled => true,
-        :phrase => "Feature has a background with one scenario.",
-        :score => WARNING,
-      },
-      :no_scenarios => {
-        :enabled => true,
-        :phrase => "Feature with no scenarios.",
-        :score => ERROR,
-      },
-      :too_many_scenarios => {
-        :enabled => true,
-        :phrase => "Feature with too many scenarios.",
-        :score => INFO,
-        :max => 10,
-      },
-    }
-
-    SCENARIO_RULES = {
-      :too_many_steps => {
-        :enabled => true,
-        :phrase => "Scenario with too many steps.",
-        :score => WARNING,
-        :max => 7,
-      },
-      :out_of_order_steps  => {
-        :enabled => true,
-        :phrase => "Scenario steps out of Given/When/Then order.",
-        :score => WARNING,
-      },
-      :invalid_first_step  => {
-        :enabled => true,
-        :phrase => "Invalid first step. Began with And/But.",
-        :score => WARNING,
-      },
-      :asterisk_step => {
-        :enabled => true,
-        :phrase => "Step includes a * instead of Given/When/Then/And/But.",
-        :score => WARNING,
-      },
-      :commented_step => {
-        :enabled => true,
-        :phrase => "Commented step.",
-        :score => ERROR,
-      },
-      :commented_example => {
-        :enabled => true,
-        :phrase => "Commented example.",
-        :score => ERROR,
-      },
-      :no_examples => {
-        :enabled => true,
-        :phrase => "Scenario Outline with no examples.",
-        :score => FATAL,
-      },
-      :one_example => {
-        :enabled => true,
-        :phrase => "Scenario Outline with only one example.",
-        :score => WARNING,
-      },
-      :no_examples_table => {
-        :enabled => true,
-        :phrase => "Scenario Outline with no examples table.",
-        :score => FATAL,
-      },
-      :too_many_examples => {
-        :enabled => true,
-        :phrase => "Scenario Outline with too many examples.",
-        :score => WARNING,
-        :max => 10
-      },
-      :date_used => {
-        :enabled => true,
-        :phrase => "Date used.",
-        :score => INFO,
-      },
-      :no_steps => {
-        :enabled => true,
-        :phrase => "No steps in Scenario.",
-        :score => ERROR,
-      },
-    }
+    FATAL =   100 #will prevent suite from executing properly
+    ERROR =   25  #will cause problem with debugging
+    WARNING = 10  #readibility/misuse of cucumber
+    INFO =    1   #Small improvements that can be made
 
-    STEP_DEFINITION_RULES = {
-      :no_code => {
-        :enabled => true,
-        :phrase => "No code in Step Definition.",
-        :score => ERROR,
-      },
-      :too_many_parameters => {
-        :enabled => true,
-        :phrase => "Too many parameters in Step Definition.",
-        :score => WARNING,
-        :max => 4
-      },
-      :nested_step => {
-        :enabled => true,
-        :phrase => "Nested step call.",
-        :score => INFO,
-      },
-      :recursive_nested_step => {
-        :enabled => true,
-        :phrase => "Recursive nested step call.",
-        :score => FATAL,
-      },
-      :commented_code => {
-        :enabled => true,
-        :phrase => "Commented code in Step Definition.",
+    RULES = {
+        :too_many_tags => {
+            :enabled => true,
+            :phrase => "{class} has too many tags.",
+            :score => INFO,
+            :max => 8
+        },
+        :no_description => {
+            :enabled => true,
+            :phrase => "{class} has no description.",
+            :score => ERROR,
+        },
+        :numbers_in_description => {
+            :enabled => true,
+            :phrase => "{class} has numbers in the description.",
+            :score => WARNING,
+        },
+        :long_name => {
+            :enabled => true,
+            :phrase => "{class} has a long description.",
+            :score => INFO,
+            :max => 180
+        },
+        :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"]
+        },
+        :empty_feature => {
+            :enabled => true,
+            :phrase => "Feature file has no content.",
+            :score => WARNING,
+        },
+        :background_with_no_scenarios => {
+            :enabled => true,
+            :phrase => "Feature has a background with no scenarios.",
+            :score => WARNING,
+        },
+        :background_with_one_scenario => {
+            :enabled => true,
+            :phrase => "Feature has a background with one scenario.",
+            :score => WARNING,
+        },
+        :no_scenarios => {
+            :enabled => true,
+            :phrase => "Feature with no scenarios.",
+            :score => ERROR,
+        },
+        :too_many_scenarios => {
+            :enabled => true,
+            :phrase => "Feature with too many scenarios.",
+            :score => INFO,
+            :max => 10,
+        },
+        :too_many_steps => {
+            :enabled => true,
+            :phrase => "Scenario with too many steps.",
+            :score => WARNING,
+            :max => 7,
+        },
+        :out_of_order_steps => {
+            :enabled => true,
+            :phrase => "Scenario steps out of Given/When/Then order.",
+            :score => WARNING,
+        },
+        :invalid_first_step => {
+            :enabled => true,
+            :phrase => "Invalid first step. Began with And/But.",
+            :score => WARNING,
+        },
+        :asterisk_step => {
+            :enabled => true,
+            :phrase => "Step includes a * instead of Given/When/Then/And/But.",
+            :score => WARNING,
+        },
+        :commented_step => {
+            :enabled => true,
+            :phrase => "Commented step.",
+            :score => ERROR,
+        },
+        :commented_example => {
+            :enabled => true,
+            :phrase => "Commented example.",
+            :score => ERROR,
+        },
+        :no_examples => {
+            :enabled => true,
+            :phrase => "Scenario Outline with no examples.",
+            :score => FATAL,
+        },
+        :one_example => {
+            :enabled => true,
+            :phrase => "Scenario Outline with only one example.",
+            :score => WARNING,
+        },
+        :no_examples_table => {
+            :enabled => true,
+            :phrase => "Scenario Outline with no examples table.",
+            :score => FATAL,
+        },
+        :too_many_examples => {
+            :enabled => true,
+            :phrase => "Scenario Outline with too many examples.",
+            :score => WARNING,
+            :max => 10
+        },
+        :date_used => {
+            :enabled => true,
+            :phrase => "Date used.",
+            :score => INFO,
+        },
+        :no_steps => {
+            :enabled => true,
+            :phrase => "No steps in Scenario.",
+            :score => ERROR,
+        },
+        :one_word_step => {
+            :enabled => true,
+            :phrase => "Step that is only one word long.",
+            :score => ERROR,
+        },
+        :multiple_given_when_then => {
+            :enabled => true,
+            :phrase => "Given/When/Then used multiple times in the same scenario.",
+            :score => WARNING,
+        },
+        :no_code => {
+            :enabled => true,
+            :phrase => "No code in Step Definition.",
+            :score => ERROR,
+        },
+        :too_many_parameters => {
+            :enabled => true,
+            :phrase => "Too many parameters in Step Definition.",
+            :score => WARNING,
+            :max => 4
+        },
+        :nested_step => {
+            :enabled => true,
+            :phrase => "Nested step call.",
+            :score => INFO,
+        },
+        :recursive_nested_step => {
+            :enabled => true,
+            :phrase => "Recursive nested step call.",
+            :score => FATAL,
+        },
+        :commented_code => {
+            :enabled => true,
+            :phrase => "Commented code in Step Definition.",
+            :score => INFO,
+        },
+        :lazy_debugging => {
+            :enabled => true,
+            :phrase => "Lazy Debugging through puts, p, or print",
+            :score => WARNING,
+        },
+        :pending => {
+            :enabled => true,
+            :phrase => "Pending step definition. Implement or remove.",
+            :score => WARNING,
+        },
+        :small_sleep => {
+            :enabled => true,
+            :phrase => "Small sleeps used. Use a wait_until like method.",
+            :score => INFO,
+            :max => 2
+        },
+        :large_sleep => {
+        :enabled => true,
+        :phrase => "Large sleeps used. Use a wait_until like method.",
         :score => INFO,
-      },
+        :min => 2
+        },
+        :todo => {
+            :enabled => true,
+            :phrase => "Todo found. Resolve it.",
+            :score => INFO,
+        },
     }
 
   end

data/lib/cuke_sniffer/rules_evaluator.rb

@@ -1,6 +1,9 @@
+require 'roxml'
 module CukeSniffer
   class RulesEvaluator
-    attr_accessor :location, :score, :rules_hash
+    include ROXML
+    xml_accessor :score, :location
+    xml_accessor :rules_hash, :as => {:key => "phrase", :value => "score"}, :in => "rules", :from => "rule"
 
     def initialize(location)
       @location = location

data/lib/cuke_sniffer/scenario.rb

@@ -1,12 +1,13 @@
-require 'cuke_sniffer/constants'
-require 'cuke_sniffer/rule_config'
-
 module CukeSniffer
   class Scenario < FeatureRulesEvaluator
     include CukeSniffer::Constants
     include CukeSniffer::RuleConfig
-    
-    attr_accessor :start_line, :type, :steps, :inline_tables, :examples_table
+
+    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)
@@ -81,9 +82,22 @@ module CukeSniffer
       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
@@ -93,37 +107,37 @@ module CukeSniffer
     end
 
     def rule_empty_scenario
-      store_rule(SCENARIO_RULES[:no_steps]) if @steps.empty?
+      store_rule(RULES[:no_steps]) if @steps.empty?
     end
 
     def rule_too_many_steps
-      rule = SCENARIO_RULES[: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(SCENARIO_RULES[:out_of_order_steps]) unless step_order == %w(Given When Then) or step_order == %w(When Then)
+      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(SCENARIO_RULES[:invalid_first_step]) if %w(And But).include?(first_step)
+      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(SCENARIO_RULES[:asterisk_step]) }
+      get_step_order.count('*').times { store_rule(RULES[:asterisk_step]) }
     end
 
     def rule_commented_step
       @steps.each do |step|
-        store_rule(SCENARIO_RULES[:commented_step]) if is_comment?(step)
+        store_rule(RULES[:commented_step]) if is_comment?(step)
       end
     end
 
     def rule_implementation_words
-      rule = SHARED_RULES[:implementation_word]
+      rule = RULES[:implementation_word]
       @steps.each do |step|
         next if is_comment?(step)
         rule[:words].each do |word|
@@ -134,29 +148,29 @@ module CukeSniffer
 
     def rule_date_used_in_step
       @steps.each do |step|
-        store_rule(SCENARIO_RULES[:date_used]) if step =~ DATE_REGEX
+        store_rule(RULES[:date_used]) if step =~ DATE_REGEX
       end
     end
 
     def rule_no_examples_table
-      store_rule(SCENARIO_RULES[:no_examples_table]) if @examples_table.empty?
+      store_rule(RULES[:no_examples_table]) if @examples_table.empty?
     end
 
     def rule_no_examples
-      store_rule(SCENARIO_RULES[:no_examples]) if @examples_table.size == 1
+      store_rule(RULES[:no_examples]) if @examples_table.size == 1
     end
 
     def rule_one_example
-      store_rule(SCENARIO_RULES[:one_example]) if @examples_table.size == 2 and !is_comment?(@examples_table[1])
+      store_rule(RULES[:one_example]) if @examples_table.size == 2 and !is_comment?(@examples_table[1])
     end
 
     def rule_too_many_examples
-      store_rule(SCENARIO_RULES[:too_many_examples]) if (@examples_table.size - 1) >= 8
+      store_rule(RULES[:too_many_examples]) if (@examples_table.size - 1) >= 8
     end
 
     def rule_commented_example
       @examples_table.each do |example|
-        store_rule(SCENARIO_RULES[:commented_example]) if is_comment?(example)
+        store_rule(RULES[:commented_example]) if is_comment?(example)
       end
     end
 

data/lib/cuke_sniffer/step_definition.rb

@@ -1,15 +1,22 @@
+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>.*)"$/
-    SAME_LINE_COMPLEX_STEP_REGEX = /^steps\s%Q?{#{STEP_STYLES}(?<step_string>.*)}$/
-    START_COMPLEX_STEP_REGEX = /^steps\s%Q?\{\s*/
+    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?\{#{STEP_STYLES}(?<step_string>.*)$/
+    START_COMPLEX_WITH_STEP_REGEX = /steps\s%(q|Q)?\{#{STEP_STYLES}(?<step_string>.*)$/
     END_COMPLEX_WITH_STEP_REGEX = /#{STEP_STYLES}(?<step_string>.*)}$/
-    attr_accessor :start_line, :regex, :code, :parameters, :calls, :nested_steps
 
     def initialize(location, raw_code)
       super(location)
@@ -17,7 +24,7 @@ module CukeSniffer
       @parameters = []
       @calls = {}
       @nested_steps = {}
-      @start_line = location.match(/:(?<line>\d*)/)[:line].to_i
+      @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]
@@ -46,13 +53,26 @@ module CukeSniffer
         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 START_COMPLEX_WITH_STEP_REGEX
-            multi_line_step_flag = true
-            regex = START_COMPLEX_WITH_STEP_REGEX
-          when START_COMPLEX_STEP_REGEX
-            multi_line_step_flag = true
           when END_COMPLEX_WITH_STEP_REGEX
             if line =~ /[#]{.*}$/ && multi_line_step_flag
               regex = STEP_REGEX
@@ -60,6 +80,8 @@ module CukeSniffer
               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
@@ -89,7 +111,7 @@ module CukeSniffer
 
     def condensed_call_list
       condensed_list = {}
-      @calls.each{|call, step_string|
+      @calls.each { |call, step_string|
         condensed_list[step_string] ||= []
         condensed_list[step_string] << call
       }
@@ -112,30 +134,67 @@ module CukeSniffer
       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(STEP_DEFINITION_RULES[:no_code]) if code.empty?
+      store_rule(RULES[:no_code]) if code.empty?
     end
 
     def rule_too_many_parameters
-      rule = STEP_DEFINITION_RULES[:too_many_parameters]
+      rule = RULES[:too_many_parameters]
       store_rule(rule) if parameters.size >= rule[:max]
     end
 
     def rule_nested_steps
-      store_rule(STEP_DEFINITION_RULES[:nested_step]) unless nested_steps.empty?
+      store_rule(RULES[:nested_step]) unless nested_steps.empty?
     end
 
     def rule_recursive_nested_step
       nested_steps.each_value do |nested_step|
-        store_rule(STEP_DEFINITION_RULES[:recursive_nested_step]) if nested_step =~ regex
+        store_rule(RULES[:recursive_nested_step]) if nested_step =~ regex
       end
     end
 
     def rule_commented_code
       code.each do |line|
-        store_rule(STEP_DEFINITION_RULES[:commented_code]) if is_comment?(line)
+        store_rule(RULES[:commented_code]) if is_comment?(line)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cuke_sniffer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -11,10 +11,26 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-15 00:00:00.000000000 Z
-dependencies: []
+date: 2013-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: roxml
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A ruby library used to root out smells in your cukes.
-email: ''
+email: 
 executables:
 - cuke_sniffer.rb
 extensions: []
@@ -43,18 +59,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -320967053
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -320967053
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24