cuke_sniffer 0.0.1

data/bin/cuke_sniffer.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require 'cuke_sniffer'
+
+if ARGV.include? "-h" or ARGV.include? "--help"
+  puts HELP_CMD_TEXT
+  exit
+end
+
+@cuke_sniffer = nil
+if (ARGV[0] != nil and File.directory?(ARGV[0])) and (ARGV[1] != nil and File.directory?(ARGV[1]))
+  @cuke_sniffer = CukeSniffer::CLI.new(ARGV[0], ARGV[1])
+else
+  @cuke_sniffer = CukeSniffer::CLI.new
+end
+
+def print_results
+  puts @cuke_sniffer.output_results
+end
+
+if ARGV.include? "--out" or ARGV.include? "-o"
+  index = ARGV.index("--out")
+  index ||= ARGV.index("-o")
+  out_type = ARGV[index + 1]
+  case out_type
+    when "html"
+      @cuke_sniffer.output_html
+    else
+      print_results
+  end
+else
+  print_results
+end
+
+puts "Completed Sniffing."

data/lib/cuke_sniffer.rb

@@ -0,0 +1,13 @@
+
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+require 'cuke_sniffer/rules_evaluator'
+require 'cuke_sniffer/feature_rules_evaluator'
+require 'cuke_sniffer/feature'
+require 'cuke_sniffer/scenario'
+require 'cuke_sniffer/step_definition'
+require 'cuke_sniffer/cli'
+
+module CukeSniffer
+
+end

data/lib/cuke_sniffer/cli.rb

@@ -0,0 +1,226 @@
+require 'erb'
+require 'cuke_sniffer/constants'
+
+module CukeSniffer
+  class CLI
+    include CukeSniffer::Constants
+    
+    attr_accessor :features, :step_definitions, :summary
+
+    def initialize(features_location = Dir.getwd, step_definitions_location = Dir.getwd)
+      @features_location = features_location
+      @step_definitions_location = step_definitions_location
+      @features = []
+      @step_definitions = []
+
+      puts "\nFeatures:"
+      unless features_location.nil?
+        if File.file?(features_location)
+          @features = [Feature.new(features_location)]
+        else
+          build_file_list_from_folder(features_location, ".feature").each { |location|
+            @features << Feature.new(location)
+            print '.'
+          }
+        end
+      end
+
+      puts("\nStep Definitions:")
+      unless step_definitions_location.nil?
+        if File.file?(step_definitions_location)
+          @step_definitions = [build_step_definitions(step_definitions_location)]
+        else
+          build_file_list_from_folder(step_definitions_location, "steps.rb").each { |location|
+            @step_definitions << build_step_definitions(location)
+            print '.'
+          }
+        end
+      end
+
+      @step_definitions.flatten!
+      @summary = {
+        :total_score => 0,
+        :features => {},
+        :step_definitions => {},
+        :improvement_list => {}
+      }
+      puts "\nCataloging Step Calls: "
+      catalog_step_calls
+      puts "\nAssessing Score: "
+      assess_score
+    end
+
+    def build_file_list_from_folder(folder_name, extension)
+      list = []
+      Dir.entries(folder_name).each_entry do |file_name|
+        unless FILE_IGNORE_LIST.include?(file_name)
+          file_name = "#{folder_name}/#{file_name}"
+          if File.directory?(file_name)
+            list << build_file_list_from_folder(file_name, extension)
+          elsif file_name.include?(extension)
+            list << file_name
+          end
+        end
+      end
+      list.flatten
+    end
+
+    def build_step_definitions(file_name)
+      step_file_lines = []
+      step_file = File.open(file_name)
+      step_file.each_line { |line| step_file_lines << line }
+      step_file.close
+
+      counter = 0
+      step_code = []
+      step_definitions = []
+      found_first_step = false
+      until counter >= step_file_lines.length
+        if step_file_lines[counter] =~ STEP_DEFINITION_REGEX and !step_code.empty? and found_first_step
+          step_definitions << StepDefinition.new("#{file_name}:#{counter+1 - step_code.count}", step_code)
+          step_code = []
+        end
+        found_first_step = true if step_file_lines[counter] =~ STEP_DEFINITION_REGEX
+        step_code << step_file_lines[counter].strip
+        counter+=1
+      end
+      step_definitions << StepDefinition.new("#{file_name}:#{counter+1}", step_code) unless step_code.empty?
+      step_definitions
+    end
+
+    def assess_array(array)
+      min, max, min_file, max_file = nil
+      total = 0
+      array.each do |node|
+        score = node.score
+        @summary[:total_score] += score
+        node.rules_hash.each_key do |key|
+          @summary[:improvement_list][key] ||= 0
+          @summary[:improvement_list][key] += node.rules_hash[key]
+        end
+        min, min_file = score, node.location if (min.nil? or score < min)
+        max, max_file = score, node.location if (max.nil? or score > max)
+        total += score
+      end
+      {
+        :total => array.count,
+        :min => min,
+        :min_file => min_file,
+        :max => max,
+        :max_file => max_file,
+        :average => (total.to_f/array.count.to_f).round(2)
+      }
+    end
+
+    def assess_score
+      @summary[:features] = assess_array(@features)
+      @summary[:step_definitions] = assess_array(@step_definitions) unless @step_definitions.empty?
+      sort_improvement_list
+    end
+
+    def sort_improvement_list
+      sorted_array = @summary[:improvement_list].sort_by { |improvement, occurrence| occurrence }
+      @summary[:improvement_list] = {}
+      sorted_array.reverse.each { |node|
+        @summary[:improvement_list][node[0]] = node[1]
+      }
+    end
+
+    def output_results
+      feature_results = @summary[:features]
+      step_definition_results = @summary[:step_definitions]
+      #todo this string is completely dependent on the tabbing in the string
+      output = "Suite Summary
+  Total Score: #{@summary[:total_score]}
+    Features (#@features_location)
+      Min: #{feature_results[:min]} (#{feature_results[:min_file]})
+      Max: #{feature_results[:max]} (#{feature_results[:max_file]})
+      Average: #{feature_results[:average]}
+    Step Definitions (#@step_definitions_location)
+      Min: #{step_definition_results[:min]} (#{step_definition_results[:min_file]})
+      Max: #{step_definition_results[:max]} (#{step_definition_results[:max_file]})
+      Average: #{step_definition_results[:average]}
+  Improvements to make:"
+      create_improvement_list.each { |item| output << "\n    #{item}" }
+      output
+    end
+
+    def create_improvement_list
+      output = []
+      @summary[:improvement_list].each_key { |improvement| output << "(#{summary[:improvement_list][improvement]})#{improvement}" }
+      output
+    end
+
+    def get_all_steps
+      steps = {}
+      @features.each do |feature|
+        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
+        end
+      end
+      @step_definitions.each do |definition|
+        definition.nested_steps.each_key do |key|
+          steps[key] = definition.nested_steps[key]
+        end
+      end
+      steps
+    end
+
+    def catalog_step_calls
+      steps = get_all_steps
+      @step_definitions.each do |step_definition|
+        print '.'
+        calls = steps.find_all { |location, step| step.gsub(STEP_STYLES, "") =~ step_definition.regex }
+        calls.each { |call|
+          step_definition.add_call(call[0], call[1])
+        }
+      end
+    end
+
+    def update_step_definition(location, step)
+      @step_definitions.each do |step_definition|
+        if step.gsub(STEP_STYLES, "") =~ step_definition.regex
+          step_definition.add_call(location, step)
+          break
+        end
+      end
+    end
+
+    def get_dead_steps
+      dead_steps = []
+      @step_definitions.each do |step_definition|
+        dead_steps << step_definition if step_definition.calls.empty?
+      end
+      dead_steps
+    end
+
+    def sort_by_score(array)
+      array.sort_by { |item| item.score }.reverse
+    end
+
+    def extract_markup
+      markup_location = File.join(File.dirname(__FILE__), 'report', 'markup.rhtml')
+      markup = ""
+      File.open(markup_location).lines.each do |line|
+        markup << line
+      end
+      markup
+    end
+
+    def output_html(file_name = "cuke_sniffer_results.html", cuke_sniffer = self)
+      @features = sort_by_score(@features)
+      @step_definitions = sort_by_score(@step_definitions)
+
+      markup_erb = ERB.new extract_markup
+      output = markup_erb.result(binding)
+      File.open(file_name, 'w') do |f|
+        f.write(output)
+      end
+    end
+  end
+end

data/lib/cuke_sniffer/constants.rb

@@ -0,0 +1,35 @@
+module CukeSniffer
+  module Constants
+    FILE_IGNORE_LIST = %w(. .. .svn)
+    DATE_REGEX = /(?<date>\d{2}\/\d{2}\/\d{4})/
+    COMMENT_REGEX = /#?.*/
+
+    FEATURE_NAME_REGEX = /Feature:\s*(?<name>.*)/
+    TAG_REGEX = /(?<tag>@\S*)/
+    SCENARIO_TITLE_STYLES = /(?<type>Background|Scenario|Scenario Outline|Scenario Template):\s*/
+    SCENARIO_TITLE_REGEX = /#{COMMENT_REGEX}#{SCENARIO_TITLE_STYLES}(?<name>.*)/
+
+    STEP_STYLES = /(?<style>Given|When|Then|And|Or|But|Transform|\*)\s/
+    STEP_REGEX = /^#{COMMENT_REGEX}#{STEP_STYLES}(?<step_string>.*)/
+    STEP_DEFINITION_REGEX = /^#{STEP_STYLES}\/(?<step>.+)\/\sdo\s?(\|(?<parameters>.*)\|)?$/
+
+    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*/
+    END_COMPLEX_STEP_REGEX = /}/
+    START_COMPLEX_WITH_STEP_REGEX = /steps\s%Q?\{#{STEP_STYLES}(?<step_string>.*)/
+    END_COMPLEX_WITH_STEP_REGEX = /#{STEP_STYLES}(?<step_string>.*)}/
+
+    HELP_CMD_TEXT = "Welcome to CukeSniffer!
+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
+                                              directory (with optional name).
+  -h, --help                                : You get this lovely document."
+
+    
+  end
+end

data/lib/cuke_sniffer/feature.rb

@@ -0,0 +1,116 @@
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+require 'cuke_sniffer/feature_rules_evaluator'
+require 'cuke_sniffer/scenario'
+
+module CukeSniffer
+  class Feature < FeatureRulesEvaluator
+    include CukeSniffer::Constants
+    include CukeSniffer::RuleConfig
+
+    attr_accessor :background, :scenarios, :feature_rules_hash
+
+    def initialize(file_name)
+      super(file_name)
+      @scenarios = []
+      @feature_rules_hash = {}
+      split_feature(file_name)
+      evaluate_score
+    end
+
+    def split_feature(file_name)
+      feature_lines = []
+
+      feature_file = File.open(file_name)
+      feature_file.each_line { |line| feature_lines << line }
+      feature_file.close
+
+      index = 0
+      until feature_lines[index].match FEATURE_NAME_REGEX
+        update_tag_list(feature_lines[index])
+        index += 1
+      end
+
+      until index >= feature_lines.length or feature_lines[index].match TAG_REGEX or feature_lines[index].match SCENARIO_TITLE_REGEX
+        create_name(feature_lines[index], "Feature:")
+        index += 1
+      end
+
+      scenario_title_found = false
+      index_of_title = nil
+      code_block = []
+      until index >= feature_lines.length
+        if scenario_title_found and (feature_lines[index].match TAG_REGEX or feature_lines[index].match SCENARIO_TITLE_REGEX)
+          add_scenario_to_feature(code_block, index_of_title)
+          scenario_title_found = false
+          code_block = []
+        end
+        code_block << feature_lines[index].strip
+        if feature_lines[index].match SCENARIO_TITLE_REGEX
+          scenario_title_found = true
+          index_of_title = "#{file_name}:#{index + 1}"
+        end
+        index += 1
+      end
+      #TODO - Last scenario falling through above logic, needs a fix (code_block related)
+      add_scenario_to_feature(code_block, index_of_title) unless code_block==[]
+    end
+
+    def add_scenario_to_feature(code_block, index_of_title)
+      scenario = CukeSniffer::Scenario.new(index_of_title, code_block)
+      if scenario.type == "Background"
+        @background = scenario
+      else
+        @scenarios << scenario
+      end
+    end
+
+    def ==(comparison_object)
+      super(comparison_object)
+      comparison_object.scenarios == scenarios
+    end
+
+    def evaluate_score
+      super
+      rule_no_scenarios
+      rule_too_many_scenarios
+      rule_background_with_no_scenarios
+      rule_background_with_one_scenario
+      @feature_rules_hash = @rules_hash.clone
+      include_sub_scores(@background) unless @background.nil?
+      include_scenario_scores
+    end
+
+    def include_sub_scores(sub_class)
+      @score += sub_class.score
+      sub_class.rules_hash.each_key do |rule_descriptor|
+        rules_hash[rule_descriptor] ||= 0
+        rules_hash[rule_descriptor] += sub_class.rules_hash[rule_descriptor]
+      end
+    end
+
+    def include_scenario_scores
+      scenarios.each do |scenario|
+        include_sub_scores(scenario)
+      end
+    end
+
+    def rule_no_scenarios
+      store_rule(FEATURE_RULES[:no_scenarios]) if @scenarios.empty?
+    end
+
+    def rule_too_many_scenarios
+      rule = FEATURE_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?
+    end
+
+    def rule_background_with_one_scenario
+      store_rule(FEATURE_RULES[:background_with_one_scenario]) if @scenarios.size == 1 and !@background.nil?
+    end
+
+  end
+end

data/lib/cuke_sniffer/feature_rules_evaluator.rb

@@ -0,0 +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

data/lib/cuke_sniffer/report/markup.rhtml

@@ -0,0 +1,311 @@
+<script>
+    function toggle(item, off) {
+        updateDisplayStatus(item.getElementsByTagName("div")[off]);
+    }
+    function toggleById(item, link) {
+        updateDisplayStatus(document.getElementById(item));
+        toggleText(link)
+    }
+    function updateDisplayStatus(object) {
+        object.style.display = (object.style.display == "block") ? 'none' : "block";
+    }
+    function toggleText(link) {
+        var char_result = link.innerHTML.indexOf("+") > -1 ? "-" : "+";
+        link.innerHTML = link.innerHTML.replace(/(\+|\-)/, char_result)
+    }
+
+</script>
+<style>
+    body {
+        font-size: 12pt;
+        font-family: arial;
+    }
+
+    .padded {
+        padding-left: 3%;
+    }
+
+    .sections {
+        border: 2px solid #90ee90;
+    }
+
+    .shrink_section {
+        display: none;
+    }
+
+    .sub_title {
+        font-weight: bold;
+        font-size: 13pt;
+        padding: 1%;
+    }
+
+    .scenarios, .steps, {
+        border-top: 1px solid #bbb;
+        padding: 4px;
+        padding-left: 90px;
+    }
+
+    .scenarios, .steps {
+        border-top: 1px solid #bbb;
+        padding: 4px;
+        padding-left: 90px;
+    }
+
+    .title {
+        padding-left: 2%;
+        width: 25%;
+        background-color: green;
+        color: white;
+        border-top: 0;
+        border-bottom: 0;
+        padding-top: 4px;
+        font-weight: bold;
+        font-size: 15pt;
+        padding-bottom: 1%;
+    }
+
+    .rule {
+        background-color: #ffaaaa;
+        padding: 3px;
+        font-size: 13px;
+    }
+
+    span {
+        font-size: 20pt;
+        font-weight: bold;
+        width: 100%;
+        border-left: 2px solid #fff;
+        padding-bottom: 3px;
+        padding-left: 30px;
+        padding-top: 4px
+    }
+
+    .even {
+        background-color: #eeeeff;
+        border-bottom: 1px solid #ccc;
+    }
+
+    .odd {
+        border-bottom: 1px solid #ddd;
+    }
+</style>
+<div style="float:left; color: green; font-weight: bold; padding-left:10px;">
+  Cuke Sniffer
+</div>
+<br style="clear:both">
+<div style="border-top: 2px solid lightgreen;">
+  <div style="float:right;border-right: 2px solid lightgreen;">
+    <div style="background-color:green;border-right:2px solid #fff; color:white;padding:4px; padding-left:40px;font-size:11pt;font-weight:bold;padding-right:10px;">
+      <%= summary[:total_score] %> Total Score
+    </div>
+  </div>
+</div>
+<br style="clear:both">
+<div style="float:left;" class="title">
+  <a href=#summary style="color: white;font-style: normal;">
+    <span style="border-left-color:green;cursor: hand;" onclick="toggleById('summary',this)">- Summary</span>
+  </a>
+</div>
+<br style="clear:both">
+
+<div class="sections">
+  <div name="summary" class="shrink_section" id="summary" style="display:block">
+    <%
+       feature_results = cuke_sniffer.summary[:features]
+       step_definition_results = cuke_sniffer.summary[:step_definitions]
+    %>
+    <br>
+
+    <div><span class="sub_title">Features</span><br></div>
+    <div class="padded">Min: <%= feature_results[:min] %> (<%= feature_results[:min_file] %>)<br>
+      Max: <%= feature_results[:max] %> (<%= feature_results[:max_file] %>)<br>
+      Average: <%= feature_results[:average] %>
+    </div>
+    <br>
+
+    <div><span class="sub_title">Step Definitions</span><br></div>
+    <div class="padded">Min: <%= step_definition_results[:min] %> (<%= step_definition_results[:min_file] %>)<br>
+      Max: <%= step_definition_results[:max] %> (<%= step_definition_results[:max_file] %>)<br>
+      Average: <%= step_definition_results[:average] %> </div>
+    <br>
+
+    <% list = summary[:improvement_list] %>
+    <div><span class="sub_title">Improvements to make: <%= list.size %></span><br></div>
+    <div class="padded">
+      <% list.each_key do |improvement| %>
+          (<%= list[improvement] %>) <%= improvement %>
+          <br>
+      <% end %>
+      <br>
+    </div>
+    <% dead_steps_list = cuke_sniffer.get_dead_steps %>
+    <div><span class="sub_title">Dead Steps: <%= dead_steps_list.size %></span><br></div>
+    <div class="padded">
+      <% dead_steps_list.each do |dead_step| %>
+          <table>
+            <tr>
+              <td style="width:300px">
+                /<%= dead_step.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex] %>/
+              </td>
+              <td style="width:600px">
+                <%= dead_step.location %>
+              </td>
+            </tr>
+          </table>
+      <% end %>
+      <br>
+    </div>
+  </div>
+</div>
+<br><br>
+<div style="float:left;" class="title">
+  <a href=#feature_details style="color: white;font-style: normal;">
+    <span style="border-left-color:green;cursor: hand;" onclick="toggleById('feature_details',this)">+ Features</span>
+  </a>
+</div>
+<div class="links" style="float:right"></div>
+<br style="clear:both">
+<div class="sections">
+  <div name="feature_details" class="shrink_section" id="feature_details">
+    <% i=0 %>
+    <% cuke_sniffer.features.each do |feature| %>
+        <% next if feature.score == 0 %>
+        <div style="cursor: hand;" onclick="toggle(this,3)" class="feature <%= i%2==0 ? "even" : "odd" %>">
+          <div style="float:left;padding:4px;font-weight:bold;color:red; width:3%"><%= feature.score %></div>
+
+          <div style=" float:left;">
+            <font class="featurename"><%= feature.location[feature.location.rindex("/")..-1] %></font></div>
+          <div style="width:60%;padding:4px; float:right">
+            <font class="featurepath"><%= feature.location[0..feature.location.rindex("/")] %></font></div>
+          <br style="clear:both;">
+
+          <div class="scenarios" style="display:none;">
+
+            <table>
+              <tr>
+                <td style="width: 600px;vertical-align:top;">
+                  <b style="text-indent:5px">Feature: <%= feature.name %></b>
+                  <br>
+                  <b style="text-indent:5px">Scenarios: <%= feature.scenarios.size %></b>
+                </td>
+                <td style="width: 600px;vertical-align:top;">
+                  <% unless feature.feature_rules_hash.empty? %>
+                      <b>Feature Improvements:</b>
+
+                      <div style="padding: 1%">
+                        <% feature.feature_rules_hash.each_key do |rule| %>
+                            <%= rule %>
+                            <br>
+                        <% end %>
+                      </div>
+                  <% end %>
+                </td>
+              </tr>
+            </table>
+            <br>
+            <% feature.scenarios = [feature.background, feature.scenarios].flatten unless feature.background.nil? %>
+            <table style="border-bottom:2px solid lightgreen">
+              <% feature.scenarios.each do |scenario| %>
+                  <% next if scenario.rules_hash.empty? %>
+                  <tr>
+                    <td style="border-top:2px solid lightblue;width: 600px;vertical-align:top;">
+                      <b style="padding:1%;"><%= scenario.type %>: <%= scenario.name %></b>
+                      <br>
+                      <% scenario.steps.each do |step| %>
+                          <div style="text-indent:15px">
+                            <%= step %>
+                          </div>
+                      <% end %>
+                      <br>
+                    </td>
+                    <td style="border-top:2px solid lightblue;width: 600px;vertical-align:top;">
+                      <b>Score: <%= scenario.score %></b>
+                      <br>
+                      <%= scenario.location %>
+                      <br>
+                      <b>Scenario Improvements:</b>
+                      <br>
+                      <% scenario.rules_hash.each_key do |rule| %>
+                          <div style="text-indent:15px">
+                            <%= rule %>
+                          </div>
+                      <% end %>
+                    </td>
+                  </tr>
+              <% end %>
+            </table>
+          </div>
+        </div>
+        <% i+=1 %>
+    <% end %>
+  </div>
+</div>
+<br><br>
+<div style="float:left;" class="title">
+  <a href=#step_definitions style="color: white;font-style: normal;">
+    <span style="border-left-color:green;cursor: hand;" onclick="toggleById('step_definitions',this)">+ Step Definitions</span>
+  </a>
+</div>
+<div class="links" style="float:right"></div>
+<br style="clear:both">
+<div class="sections">
+  <div name="step_definitions" class="shrink_section" id="step_definitions">
+    <% 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? %>
+          <div style="float:left;padding:4px;font-weight:bold;color:red;"><%= step_definition.score %></div>
+          <div style="width:55%;padding:4px; float:left;">
+
+            <% parameters = "" %>
+            <% step_definition.parameters.each do |param| %>
+                <% if param == step_definition.parameters.first %>
+                    <% parameters << "| " %>
+                <% end %>
+                <% parameters << param %>
+
+                <% if param == step_definition.parameters.last %>
+                    <% parameters << " |" %>
+                <% else %>
+                    <% parameters << ", " %>
+                <% end %>
+            <% end %>
+            <font class="featurename"><%= "/" + step_definition.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex] + "/ do " + parameters %></font>
+          </div>
+          <% if step_definition.calls.empty? %>
+              <div style="float:left; width:10%;padding:4px;"><span class="rule"><b>Dead step!</b></span></div>
+          <% else %>
+              <div style="float:left; width:10%;padding:4px;">&nbsp;</div>
+          <% end %>
+          <div style="width:30%;padding:4px; float:left;">
+            <font class="featurepath"><%= step_definition.location[step_definition.location.rindex("/")..-1] %></font>
+          </div>
+          <br style="clear:both;">
+
+          <div class="steps" style="display:none;">
+            <table>
+              <tr>
+                <td style="width: 600px;vertical-align:top;">
+                  <b>Calls: <%= step_definition.calls.size %></b>
+                  <% step_definition.calls.each_key do |call| %>
+                      <div style="text-indent: 15px;"><%= step_definition.calls[call] %></div>
+                      <div style="text-indent: 30px;"><%= call %></div>
+                  <% end %>
+                </td>
+                <td style="width: 600px;vertical-align:top;">
+                  <b>Step Definition improvements:</b>
+                  <br>
+                  <% step_definition.rules_hash.each_key do |improvement| %>
+                      <div style="text-indent: 15px;">
+                        (<%= step_definition.rules_hash[improvement] %>) <%= improvement %>
+                      </div>
+                  <% end %>
+                </td>
+              </tr>
+            </table>
+          </div>
+        </div>
+        <% i+=1 %>
+    <% end %>
+  </div>
+</div>

data/lib/cuke_sniffer/rule_config.rb

@@ -0,0 +1,161 @@
+
+
+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,
+      },
+    }
+
+    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.",
+        :score => INFO,
+      },
+    }
+
+  end
+end

data/lib/cuke_sniffer/rules_evaluator.rb

@@ -0,0 +1,41 @@
+module CukeSniffer
+  class RulesEvaluator
+    attr_accessor :location, :score, :rules_hash
+
+    def initialize(location)
+      @location = location
+      @score = 0
+      @rules_hash = {}
+    end
+
+    def evaluate_score
+    end
+
+    def store_rule(rule)
+      if rule[:enabled]
+        @score += rule[:score]
+        @rules_hash[rule[:phrase]] ||= 0
+        @rules_hash[rule[:phrase]] += 1
+      end
+    end
+
+    def store_updated_rule(rule, phrase)
+      store_rule({:enabled => rule[:enabled], :score => rule[:score], :phrase => phrase})
+    end
+
+
+    def is_comment?(line)
+      if line =~ /^\#.*$/
+        true
+      else
+        false
+      end
+    end
+
+    def == (comparison_object)
+      comparison_object.location == location
+      comparison_object.score == score
+      comparison_object.rules_hash == rules_hash
+    end
+  end
+end

data/lib/cuke_sniffer/scenario.rb

@@ -0,0 +1,163 @@
+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
+
+    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
+          index += 1
+        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|
+        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
+      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_empty_scenario
+      store_rule(SCENARIO_RULES[:no_steps]) if @steps.empty?
+    end
+
+    def rule_too_many_steps
+      rule = SCENARIO_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)
+    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)
+    end
+
+    def rule_asterisk_step
+      get_step_order.count('*').times { store_rule(SCENARIO_RULES[:asterisk_step]) }
+    end
+
+    def rule_commented_step
+      @steps.each do |step|
+        store_rule(SCENARIO_RULES[:commented_step]) if is_comment?(step)
+      end
+    end
+
+    def rule_implementation_words
+      rule = SHARED_RULES[:implementation_word]
+      @steps.each do |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(SCENARIO_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?
+    end
+
+    def rule_no_examples
+      store_rule(SCENARIO_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])
+    end
+
+    def rule_too_many_examples
+      store_rule(SCENARIO_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)
+      end
+    end
+
+  end
+end

data/lib/cuke_sniffer/step_definition.rb

@@ -0,0 +1,116 @@
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+
+module CukeSniffer
+  class StepDefinition < RulesEvaluator
+    include CukeSniffer::Constants
+    include CukeSniffer::RuleConfig
+    
+    attr_accessor :start_line, :regex, :code, :parameters, :calls, :nested_steps
+
+    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 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
+          regex = END_COMPLEX_WITH_STEP_REGEX
+          multi_line_step_flag = false
+        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
+          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 ==(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
+    end
+
+    def rule_no_code
+      store_rule(STEP_DEFINITION_RULES[:no_code]) if code.empty?
+    end
+
+    def rule_too_many_parameters
+      rule = STEP_DEFINITION_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?
+    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
+      end
+    end
+
+    def rule_commented_code
+      code.each do |line|
+        store_rule(STEP_DEFINITION_RULES[:commented_code]) if is_comment?(line)
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: cuke_sniffer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Robert Cochran
+- Chris Vaughn
+- Robert Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-15 00:00:00.000000000 Z
+dependencies: []
+description: A ruby library used to root out smells in your cukes.
+email: 
+executables:
+- cuke_sniffer.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cuke_sniffer.rb
+- lib/cuke_sniffer/constants.rb
+- lib/cuke_sniffer/feature.rb
+- lib/cuke_sniffer/feature_rules_evaluator.rb
+- lib/cuke_sniffer/rules_evaluator.rb
+- lib/cuke_sniffer/rule_config.rb
+- lib/cuke_sniffer/scenario.rb
+- lib/cuke_sniffer/step_definition.rb
+- lib/cuke_sniffer/report/markup.rhtml
+- lib/cuke_sniffer/cli.rb
+- bin/cuke_sniffer.rb
+homepage: https://github.com/r-cochran/cuke_sniffer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: CukeSniffer
+test_files: []