cuke_sniffer 0.0.3 → 0.0.5

data/lib/cuke_sniffer/constants.rb

@@ -1,22 +1,34 @@
-module CukeSniffer
-  module Constants
-    FILE_IGNORE_LIST = %w(. .. .svn)
-    DATE_REGEX = /(?<date>\d{2}\/\d{2}\/\d{4})/
-    COMMENT_REGEX = /#?\s*/
-
-    TAG_REGEX = /(?<tag>@\S*)/
-
-    SCENARIO_TITLE_STYLES = /(?<type>Background|Scenario|Scenario Outline|Scenario Template):\s*/
-
-    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>.*)\|)?$/
-
-    THRESHOLDS = {
-        "Project" => 1000,
-        "Feature" => 30,
-        "Scenario" => 30,
-        "StepDefinition" => 20
-    }
-  end
-end
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # A collection of constants that are used throughout the gem
+  module Constants
+
+    FILE_IGNORE_LIST = %w(. .. .svn) # :nodoc:
+    DATE_REGEX = /(?<date>\d{2}\/\d{2}\/\d{4})/ # :nodoc:
+    COMMENT_REGEX = /#?\s*/ # :nodoc:
+    TAG_REGEX = /(^|\s+)(?<tag>@\S*)/ # :nodoc:
+    SCENARIO_TITLE_STYLES = /^\s*\#*\s*(?<type>Background|Scenario|Scenario Outline|Scenario Template):\s*/ # :nodoc:
+    STEP_STYLES = /(?<style>Given|When|Then|And|Or|But|Transform|\*)\s+/ # :nodoc:
+    STEP_REGEX = /^#{COMMENT_REGEX}#{STEP_STYLES}(?<step_string>.*)/ # :nodoc:
+    STEP_DEFINITION_REGEX = /^#{STEP_STYLES}\/(?<step>.+)\/\sdo\s?(\|(?<parameters>.*)\|)?$/ # :nodoc:
+    HOOK_STYLES = /(?<type>Before|After|AfterConfiguration|at_exit|Around|AfterStep)/ # :nodoc:
+    HOOK_REGEX = /^#{HOOK_STYLES}(\((?<tags>.*)\)\sdo|\s+do)(\s\|(?<parameters>.*)\|)?/
+
+    # hash: Stores scores to compare against for determining if an object is good
+    # * Key: String of the object name
+    #  Project, Feature, Scenario, StepDefinition
+    # * Value: Integer of the highest acceptable value an object can have
+    # Customizable for a projects level of acceptable score
+    #  CukeSniffer::Constants::THRESHOLDS["Project"] = 95000
+    THRESHOLDS = {
+        "Project" => 1000,
+        "Feature" => 30,
+        "Scenario" => 30,
+        "StepDefinition" => 20,
+        "Hook" => 20
+    }
+
+  end
+end

data/lib/cuke_sniffer/feature.rb

@@ -1,30 +1,52 @@
 module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Handles feature files and disassembles and evaluates
+  # its components.
+  # Extends CukeSniffer::FeatureRulesEvaluator
   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>.*)/
+    SCENARIO_TITLE_REGEX = /#{COMMENT_REGEX}#{SCENARIO_TITLE_STYLES}(?<name>.*)/ # :nodoc:
+
+    # Scenario: The background of a Feature, created as a Scenario object
+    attr_accessor :background
+
+    # Scenario array: A list of all scenarios contained in a feature file
+    attr_accessor :scenarios
 
-    attr_accessor :background, :scenarios, :scenarios_score,:total_score
+    # int: Total score from all of the scenarios contained in the feature
+    attr_accessor :scenarios_score
 
+    # int: Total score of the feature and its scenarios
+    attr_accessor :total_score
+
+    # file_name must be in the format of "file_path\file_name.feature"
     def initialize(file_name)
       super(file_name)
       @scenarios = []
-      @RULES_hash = {}
       @scenarios_score = 0
       @total_score = 0
       feature_lines = extract_feature_from_file(file_name)
       if feature_lines == []
-        store_rule(RULES[:empty_feature])
+        rule = RULES[:empty_feature]
+        store_rule(rule)
       else
         split_feature(file_name, feature_lines)
         evaluate_score
       end
     end
 
+    def ==(comparison_object) # :nodoc:
+      super(comparison_object) &&
+          comparison_object.scenarios == scenarios
+    end
+
+    private
+
     def extract_feature_from_file(file_name)
       feature_lines = []
       feature_file = File.open(file_name)
@@ -49,10 +71,20 @@ module CukeSniffer
       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)
+        if scenario_title_found and feature_lines[index].match SCENARIO_TITLE_REGEX
+          not_our_code = []
+          code_block.reverse.each do |line|
+            break if line =~ /#{SCENARIO_TITLE_STYLES}|#{STEP_STYLES}|^\|.*\||Examples:/
+            not_our_code << line
+          end
+
+          if not_our_code.empty?
+            add_scenario_to_feature(code_block, index_of_title)
+          else
+            add_scenario_to_feature(code_block[0...(-1 * not_our_code.length)], index_of_title)
+          end
           scenario_title_found = false
-          code_block = []
+          code_block = not_our_code.reverse
         end
         code_block << feature_lines[index].strip
         if feature_lines[index].match SCENARIO_TITLE_REGEX
@@ -67,6 +99,7 @@ module CukeSniffer
 
     def add_scenario_to_feature(code_block, index_of_title)
       scenario = CukeSniffer::Scenario.new(index_of_title, code_block)
+      feature_applied_scenario_rules(scenario)
       if scenario.type == "Background"
         @background = scenario
       else
@@ -74,30 +107,51 @@ module CukeSniffer
       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
+      rule_scenario_same_tag
       get_scenarios_score
       @total_score = score + @scenarios_score
     end
 
+    def feature_applied_scenario_rules(scenario)
+      rule_feature_same_tags(scenario)
+    end
+
+    def rule_feature_same_tags(scenario)
+      rule = RULES[:feature_same_tag]
+      tags.each do |tag|
+        scenario.store_rule(rule, rule[:phrase]) if scenario.tags.include?(tag)
+      end
+    end
+
+    def rule_scenario_same_tag
+      rule = RULES[:scenario_same_tag]
+      unless scenarios.empty?
+        base_tag_list = scenarios.first.tags.clone
+        scenarios.each do |scenario|
+          base_tag_list.each do |tag|
+            base_tag_list.delete(tag) unless scenario.tags.include?(tag)
+          end
+        end
+        base_tag_list.count.times do
+          store_rule(rule, rule[:phrase])
+        end
+      end
+    end
+
     def get_scenarios_score
       @scenarios_score += @background.score unless @background.nil?
-      @scenarios.each do |scenario|
-        @scenarios_score += scenario.score
-      end
+      @scenarios.each { |scenario| @scenarios_score += scenario.score }
     end
 
     def rule_no_scenarios
-      store_rule(RULES[:no_scenarios]) if @scenarios.empty?
+      rule = RULES[:no_scenarios]
+      store_rule(rule) if @scenarios.empty?
     end
 
     def rule_too_many_scenarios
@@ -106,12 +160,13 @@ module CukeSniffer
     end
 
     def rule_background_with_no_scenarios
-      store_rule( RULES[:background_with_no_scenarios]) if @scenarios.empty? and !@background.nil?
+      rule = RULES[:background_with_no_scenarios]
+      store_rule(rule) if @scenarios.empty? and !@background.nil?
     end
 
     def rule_background_with_one_scenario
-      store_rule(RULES[:background_with_one_scenario]) if @scenarios.size == 1 and !@background.nil?
+      rule = RULES[:background_with_one_scenario]
+      store_rule(rule) if @scenarios.size == 1 and !@background.nil?
     end
-
   end
 end

data/lib/cuke_sniffer/feature_rules_evaluator.rb

@@ -1,69 +1,115 @@
-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
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+require 'cuke_sniffer/rules_evaluator'
+
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Parent class for Feature and Scenario objects
+  # holds shared attributes and rules.
+  # Extends CukeSniffer::RulesEvaluator
+  class FeatureRulesEvaluator < RulesEvaluator
+
+    # string array: Contains all tags attached to a Feature or Scenario
+    attr_accessor :tags
+
+    # string: Name of the Feature or Scenario
+    attr_accessor :name
+
+    # Location must be in the format of "file_path\file_name.rb:line_number"
+    def initialize(location)
+      @name = ""
+      @tags = []
+      super(location)
+    end
+
+    def == (comparison_object) # :nodoc:
+      super(comparison_object) &&
+      comparison_object.name == name &&
+      comparison_object.tags == tags
+    end
+
+    private
+
+    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)
+      comment_start = (line =~ /([^@\w]#)|(^#)/)
+
+      if comment_start
+        line[0...comment_start].split.each { |single_tag| @tags << single_tag }
+        @tags << line[comment_start..line.length].strip
+      else
+        line.split.each { |single_tag| @tags << single_tag }
+      end
+    end
+
+    def evaluate_score
+      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)
+      rule_commas_in_description(cls_name)
+      rule_comment_after_tag(cls_name)
+      rule_commented_tag(cls_name)
+    end
+
+    def rule_too_many_tags(type)
+      rule = RULES[:too_many_tags]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if tags.size >= rule[:max]
+    end
+
+    def rule_no_description(type)
+      rule = RULES[:no_description]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if name.empty?
+    end
+
+    def rule_numbers_in_name(type)
+      rule = RULES[:numbers_in_description]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if name =~ /\d/
+    end
+
+    def rule_long_name(type)
+      rule = RULES[:long_name]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if name.size >= rule[:max]
+    end
+
+    def rule_commas_in_description(type)
+      rule = RULES[:commas_in_description]
+      rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+      store_rule(rule, rule_phrase) if name.include?(',')
+    end
+
+    def rule_comment_after_tag(type)
+      rule = RULES[:comment_after_tag]
+
+      last_comment_index = tags.rindex { |single_tag| is_comment?(single_tag) }
+      if last_comment_index
+        comment_after_tag = tags[0...last_comment_index].any? { |single_tag| !is_comment?(single_tag) }
+        rule_phrase = rule[:phrase].gsub(/{.*}/, type)
+        store_rule(rule, rule_phrase) if comment_after_tag
+      end
+    end
+
+    def rule_commented_tag(type)
+      rule = RULES[:commented_tag]
+      tags.each do |tag|
+        store_rule(rule, rule[:phrase].gsub(/{.*}/, type)) if is_comment?(tag) && tag.match(/@\S*/)
+      end
+    end
+
+  end
+end
+

data/lib/cuke_sniffer/hook.rb

@@ -0,0 +1,160 @@
+require 'roxml'
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Cucumber Hook class used for evaluating rules
+  # Extends CukeSniffer::RulesEvaluator
+  class Hook < RulesEvaluator
+
+    xml_accessor :start_line
+    xml_accessor :type
+    xml_accessor :tags, :as => [], :in => "tags"
+    xml_accessor :parameters, :as => [], :in => "parameters"
+    xml_accessor :code, :as => [], :in => "code"
+
+    # The type of the hook: AfterConfiguration, After, AfterStep, Around, Before, at_exit
+    attr_accessor :type
+
+    # The list of tags used as a filter for the hook
+    attr_accessor :tags
+
+    # The parameters that are declared on the hook
+    attr_accessor :parameters
+
+    # Integer of the line in which the hook was found
+    attr_accessor :start_line
+
+    # Array of strings that contain the code kept in the hook
+    attr_accessor :code
+
+
+    # location must be in the format of "file_path\file_name.rb:line_number"
+    # raw_code is an array of strings that represents the step definition
+    # must contain the hook declaration line and the pairing end
+    def initialize(location, raw_code)
+      super(location)
+
+      @start_line = location.match(/:(?<line>\d*)$/)[:line].to_i
+      @type = nil
+      @tags = []
+      @parameters = []
+
+      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 =~ HOOK_REGEX
+          matches = HOOK_REGEX.match(line)
+          @type = matches[:type]
+          hook_tag_regexp = /["']([^"']*)["']/
+          matches[:tags].scan(hook_tag_regexp).each { |tag| @tags << tag[0] } if matches[:tags]
+          @parameters = matches[:parameters].split(/,\s*/) if matches[:parameters]
+        end
+      end
+      evaluate_score
+    end
+
+    def ==(comparison_object) # :nodoc:
+      super(comparison_object) &&
+          comparison_object.type == type &&
+          comparison_object.tags == tags &&
+          comparison_object.parameters == parameters &&
+          comparison_object.code == code
+    end
+
+    private
+
+    def evaluate_score
+      rule_empty_hook
+      rule_hook_not_in_hooks_file
+      rule_no_debugging
+      rule_all_comments
+      rule_conflicting_tags
+      rule_duplicate_tags
+      if @type == "Around"
+        rule_around_hook_without_2_parameters
+        rule_around_hook_no_block_call
+      end
+    end
+
+    def rule_empty_hook
+      rule = RULES[:empty_hook]
+      store_rule(rule) if @code == []
+    end
+
+    def rule_hook_not_in_hooks_file
+      rule = RULES[:hook_not_in_hooks_file]
+      store_rule(rule) unless @location.include?(rule[:file])
+    end
+
+    def rule_around_hook_without_2_parameters
+      rule = RULES[:around_hook_without_2_parameters]
+      store_rule(rule) unless @parameters.count == 2
+    end
+
+    def rule_around_hook_no_block_call
+      return if rule_stored?(:around_hook_without_2_parameters)
+      rule = RULES[:around_hook_no_block_call]
+      block_call = "#{@parameters[1]}.call"
+      @code.each do |line|
+        return if line.include?(block_call)
+      end
+      store_rule(rule)
+    end
+
+    def rule_stored?(rule_symbol)
+      @rules_hash.keys.include?(RULES[rule_symbol][:phrase])
+    end
+
+    def rule_no_debugging
+      return if rule_stored?(:empty_hook)
+      rule = RULES[:hook_no_debugging]
+      begin_found = false
+      rescue_found = false
+      @code.each do |line|
+        begin_found = true if line.include?("begin")
+        rescue_found = true if line.include?("rescue")
+        break if begin_found and rescue_found
+      end
+      store_rule(rule) unless begin_found and rescue_found
+    end
+
+    def rule_all_comments
+      rule = RULES[:hook_all_comments]
+      @code.each do |line|
+        return unless is_comment?(line)
+      end
+      store_rule(rule)
+    end
+
+    def rule_conflicting_tags
+      rule = RULES[:hook_conflicting_tags]
+      all_tags = flatten_tags
+
+      all_tags.each do |single_tag|
+        tag = single_tag.gsub("~", "")
+        if all_tags.include?(tag) and all_tags.include?("~#{tag}")
+          store_rule(rule)
+          return
+        end
+      end
+    end
+
+    def flatten_tags
+      all_tags = []
+      @tags.each { |single_tag| all_tags << single_tag.split(',') }
+      all_tags.flatten
+    end
+
+    def rule_duplicate_tags
+      rule = RULES[:hook_duplicate_tags]
+      all_tags = flatten_tags
+      unique_tags = all_tags.uniq
+
+      store_rule(rule) unless all_tags == unique_tags
+    end
+
+  end
+end