cuke_sniffer 0.0.5 → 0.0.6

data/lib/cuke_sniffer/rule_target.rb

@@ -0,0 +1,62 @@
+require 'roxml'
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Parent class for all objects that have rules executed against it
+  # Mixins: CukeSniffer::Constants, CukeSniffer::RuleConfig, ROXML
+  class RuleTarget
+    include CukeSniffer::Constants
+    include CukeSniffer::RuleConfig
+    include ROXML
+
+    xml_accessor :score, :location
+    xml_accessor :rules_hash, :as => {:key => "phrase", :value => "score"}, :in => "rules", :from => "rule"
+
+    # int: Sum of the rules fired
+    attr_accessor :score
+
+    # string: Location in which the object was found
+    attr_accessor :location
+
+    # hash: Contains the phrase every rule fired against the object and times it fired
+    # * Key: string
+    # * Value: int
+    attr_accessor :rules_hash
+
+    # Location must be in the format of "file_path\file_name.rb:line_number"
+    def initialize(location)
+      @location = location
+      @score = 0
+      @rules_hash = {}
+      @class_type = self.class.to_s.gsub(/.*::/, "")
+    end
+
+    # Compares the score against the objects threshold
+    # If a score is below the threshold it is good and returns true
+    # Return: Boolean
+    def good?
+      score <= Constants::THRESHOLDS[@class_type]
+    end
+
+    # Calculates the score to threshold percentage of an object
+    # Return: Float
+    def problem_percentage
+      score.to_f / Constants::THRESHOLDS[@class_type].to_f
+    end
+
+    def == (comparison_object) # :nodoc:
+      comparison_object.location == location &&
+      comparison_object.score == score &&
+      comparison_object.rules_hash == rules_hash
+    end
+
+    private
+
+    #TODO Abstraction needed for this regex matcher (constants?)
+    def is_comment?(line)
+      true if line =~ /^\#.*$/
+    end
+  end
+end

data/lib/cuke_sniffer/rules_evaluator.rb

@@ -1,70 +1,65 @@
-require 'roxml'
-module CukeSniffer
-
-  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
-  # Copyright:: Copyright (C) 2013 Robert Cochran
-  # License::   Distributes under the MIT License
-  # Parent class for all objects that have rules executed against it
-  # Mixins: CukeSniffer::Constants, CukeSniffer::RuleConfig, ROXML
-  class RulesEvaluator
-    include CukeSniffer::Constants
-    include CukeSniffer::RuleConfig
-    include ROXML
-
-    xml_accessor :score, :location
-    xml_accessor :rules_hash, :as => {:key => "phrase", :value => "score"}, :in => "rules", :from => "rule"
-
-    # int: Sum of the rules fired
-    attr_accessor :score
-
-    # string: Location in which the object was found
-    attr_accessor :location
-
-    # hash: Contains the phrase every rule fired against the object and times it fired
-    # * Key: string
-    # * Value: int
-    attr_accessor :rules_hash
-
-    # Location must be in the format of "file_path\file_name.rb:line_number"
-    def initialize(location)
-      @location = location
-      @score = 0
-      @rules_hash = {}
-      @class_type = self.class.to_s.gsub(/.*::/, "")
-    end
-
-    # Compares the score against the objects threshold
-    # If a score is below the threshold it is good and returns true
-    # Return: Boolean
-    def good?
-      score <= Constants::THRESHOLDS[@class_type]
-    end
-
-    # Calculates the score to threshold percentage of an object
-    # Return: Float
-    def problem_percentage
-      score.to_f / Constants::THRESHOLDS[@class_type].to_f
-    end
-
-    def == (comparison_object) # :nodoc:
-      comparison_object.location == location &&
-      comparison_object.score == score &&
-      comparison_object.rules_hash == rules_hash
-    end
-
-    def store_rule(rule, phrase = rule[:phrase])
-      if rule[:enabled]
-        @score += rule[:score]
-        @rules_hash[phrase] ||= 0
-        @rules_hash[phrase] += 1
-      end
-    end
-
-    private
-
-    #TODO Abstraction needed for this regex matcher (constants?)
-    def is_comment?(line)
-      true if line =~ /^\#.*$/
-    end
-  end
-end
+require 'roxml'
+
+module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Evaluates all cucumber components found in CukeSniffer with the passed rules
+  class RulesEvaluator
+    include CukeSniffer::Constants
+    attr_accessor :rules
+
+    def initialize(cli, rules)
+      raise "A CLI must be provided for evaluation." if cli.nil?
+      raise "Rules must be provided for evaluation." if rules.nil? or rules.empty?
+      @rules = rules
+      judge_features(cli.features)
+      judge_objects(cli.step_definitions, "StepDefinition")
+      judge_objects(cli.hooks, "Hook")
+    end
+
+    private
+
+    def judge_features(features)
+      features.each do |feature|
+        judge_feature(feature)
+      end
+    end
+
+    def judge_feature(feature)
+      judge_object(feature, "Feature")
+      judge_object(feature.background, "Background") unless feature.background.nil?
+      judge_objects(feature.scenarios, "Scenario")
+      feature.total_score += feature.update_score
+
+    end
+
+    def judge_objects(objects, type)
+      objects.each do | object |
+        judge_object(object, type)
+      end
+    end
+
+    def judge_object(object, type)
+      @rules.each do |rule|
+        fail "No targets for rule: #{rule.phrase}" if rule.targets.nil? or rule.targets.empty?
+        next unless rule.targets.include? type and rule.enabled
+        if eval(rule.reason) == true
+          phrase = rule.phrase.gsub("{class}", type)
+          store_rule(object, rule, phrase)
+        end
+      end
+    end
+
+    def store_rule(object, rule, phrase = rule.phrase)
+      object.score += rule.score
+      object.rules_hash[phrase] ||= 0
+      object.rules_hash[phrase] += 1
+    end
+
+    def is_comment?(line)
+      true if line =~ /^\#.*$/
+    end
+  end
+end

data/lib/cuke_sniffer/scenario.rb

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