cuke_sniffer 0.0.5 → 0.0.6

data/lib/cuke_sniffer/constants.rb

@@ -10,12 +10,15 @@ module CukeSniffer
     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_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:
+    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>.*)\|)?/
 
+    MARKUP_SOURCE = File.join(File.dirname(__FILE__), 'report')
+    DEFAULT_OUTPUT_FILE_NAME = "cuke_sniffer_result"
+
     # hash: Stores scores to compare against for determining if an object is good
     # * Key: String of the object name
     #  Project, Feature, Scenario, StepDefinition

data/lib/cuke_sniffer/cuke_sniffer_helper.rb

@@ -0,0 +1,165 @@
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Static class used for aiding cuke_sniffer in various tasks
+  class CukeSnifferHelper
+
+    # Iterates over the passed features list and returns all steps found in scenarios and backgrounds.
+    def self.extract_steps_from_features(features)
+      steps = {}
+      features.each do |feature|
+        steps.merge! extract_scenario_steps(feature.background) unless feature.background.nil?
+        feature.scenarios.each do |scenario|
+          if scenario.type == "Scenario Outline"
+            steps.merge! extract_scenario_outline_steps(scenario)
+          else
+            steps.merge! extract_scenario_steps(scenario)
+          end
+        end
+      end
+      steps
+    end
+
+    # Iterates over the passed features list and returns all scenarios and backgrounds found.
+    def self.get_all_scenarios(features)
+      scenarios = []
+      features.each do |feature|
+        scenarios << feature.background unless feature.background.nil?
+        scenarios << feature.scenarios
+      end
+      scenarios.flatten
+    end
+
+    # Grabs the values from an example without the bars
+    def self.extract_variables_from_example(example)
+      example = example[example.index('|')..example.length]
+      example.split(/\s*\|\s*/) - [""]
+    end
+
+    # Creates a step call from the details of an example table
+    def self.build_updated_step_from_example(step, variable_list, row_variables)
+      new_step = step.dup
+      variable_list.each do |variable|
+        if step.include? variable
+          table_variable_to_insert = row_variables[variable_list.index(variable)]
+          table_variable_to_insert ||= ""
+          new_step.gsub!("<#{variable}>", table_variable_to_insert)
+        end
+      end
+      new_step
+    end
+
+    # Creates a hash of steps with the build up example step calls.
+    def self.extract_scenario_outline_steps(scenario)
+      steps = {}
+      examples = scenario.examples_table
+      return {} if examples.empty?
+      variable_list = extract_variables_from_example(examples.first)
+      (1...examples.size).each do |example_counter|
+        #TODO Abstraction needed for this regex matcher (constants?)
+        next if examples[example_counter] =~ /^\#.*$/
+        row_variables = extract_variables_from_example(examples[example_counter])
+        step_counter = 1
+        scenario.steps.each do |step|
+          step_line = scenario.start_line + step_counter
+          location = "#{scenario.location.gsub(/\d+$/, step_line.to_s)}(Example #{example_counter})"
+          steps[location] = build_updated_step_from_example(step, variable_list, row_variables)
+          step_counter += 1
+        end
+      end
+      steps
+    end
+
+    # Returns all steps found in a scenario
+    def self.extract_scenario_steps(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
+
+    # Builds a list of rule objects out of a hash. See CukeSniffer::RulesConfig for hash example.
+    def self.build_rules(rules)
+      return [] if rules.nil?
+      rules.collect do |key, value|
+        CukeSniffer::CukeSnifferHelper.build_rule(value)
+      end
+    end
+
+    # Builds rule object out of a hash. See CukeSniffer::RulesConfig for hash example.
+    def self.build_rule(rule_hash)
+      rule = CukeSniffer::Rule.new
+      rule.phrase = rule_hash[:phrase]
+      rule.score = rule_hash[:score]
+      rule.enabled = rule_hash[:enabled]
+      conditional_keys = rule_hash.keys - [:phrase, :score, :enabled, :targets, :reason]
+      conditions = {}
+      conditional_keys.each do |key|
+        conditions[key] = (rule_hash[key].kind_of? Array) ? Array.new(rule_hash[key]) : rule_hash[key]
+      end
+      rule.conditions = conditions
+      rule.reason = rule_hash[:reason]
+      rule.targets = rule_hash[:targets]
+      rule
+    end
+
+    # Returns a list of all nested step calls found in a step definition.
+    def self.extract_steps_from_step_definitions(step_definitions)
+      steps = {}
+      step_definitions.each do |definition|
+        definition.nested_steps.each_key do |key|
+          steps[key] = definition.nested_steps[key]
+        end
+      end
+      steps
+    end
+
+    # Returns a fuzzy match for a step definition for cataloging steps.
+    def self.convert_steps_with_expressions(steps_with_expressions)
+      step_regex_hash = {}
+      steps_with_expressions.each do |step_location, step_value|
+        modified_step = step_value.gsub(/\#{[^}]*}/, '.*')
+        step_regex_hash[step_location] = Regexp.new('^' + modified_step + '$')
+      end
+      step_regex_hash
+    end
+
+    # Extracts all possible step calls from the passed features and step definitions.
+    def self.get_all_steps(features, step_definitions)
+      feature_steps = CukeSniffer::CukeSnifferHelper.extract_steps_from_features(features)
+      step_definition_steps = CukeSniffer::CukeSnifferHelper.extract_steps_from_step_definitions(step_definitions)
+      feature_steps.merge step_definition_steps
+    end
+
+    # Applies all possible fuzzy calls to a step definition.
+    def self.catalog_possible_dead_steps(step_definitions, steps_with_expressions)
+      step_definitions.each do |step_definition|
+        next unless step_definition.calls.empty?
+        regex_as_string = step_definition.regex.to_s.gsub(/\(\?-mix:\^?/, "").gsub(/\$\)$/, "")
+        steps_with_expressions.each do |step_location, step_value|
+          if regex_as_string =~ step_value
+            step_definition.add_call(step_location, step_value)
+          end
+        end
+      end
+      step_definitions
+    end
+
+    # Returns a list of all step definitions with a capture group
+    def self.get_steps_with_expressions(steps)
+      steps_with_expressions = {}
+      steps.each do |step_location, step_value|
+        if step_value =~ /\#{.*}/
+          steps_with_expressions[step_location] = step_value
+        end
+      end
+      steps_with_expressions
+    end
+
+  end
+end

data/lib/cuke_sniffer/dead_steps_helper.rb

@@ -0,0 +1,54 @@
+module CukeSniffer
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Mixins: CukeSniffer::Constants
+  # A static class to aid in the identification of dead steps.
+  class DeadStepsHelper
+    include CukeSniffer::Constants
+
+    # Returns a hash of dead steps for displaying in the html.
+    def self.build_dead_steps_hash(step_definitions)
+      dead_steps_hash = gather_all_dead_steps_by_file(step_definitions)
+      sort_dead_steps_in_file!(dead_steps_hash)
+      dead_steps_hash[:total] = count_dead_steps(dead_steps_hash)
+      dead_steps_hash
+    end
+
+    # Returns all dead step definitions in a file
+    def self.gather_all_dead_steps_by_file(step_definitions)
+      dead_steps_hash = {}
+      step_definitions.each do |step_definition|
+        location_match = step_definition.location.match(/(?<file>.*).rb:(?<line>\d+)/)
+        file_name = location_match[:file]
+        regex = format_step_definition_regex(step_definition.regex)
+        if step_definition.calls.empty?
+          dead_steps_hash[file_name] ||= []
+          dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/"
+        end
+      end
+      dead_steps_hash
+    end
+
+    # Formats the regex of a step definition to remove the (?-mix) part of the to_s
+    def self.format_step_definition_regex(regex)
+      regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
+    end
+
+    # Sorts the dead steps found in a hash by the line number in the file
+    def self.sort_dead_steps_in_file!(dead_steps_hash)
+      dead_steps_hash.each_key do |file|
+        dead_steps_hash[file].sort_by! { |row| row[/^\d+/].to_i }
+      end
+    end
+
+    # Returns the count of all possible dead steps in each file
+    def self.count_dead_steps(dead_steps_hash)
+      count = 0
+      dead_steps_hash.each_value do |dead_steps_in_file_list|
+        count += dead_steps_in_file_list.size
+      end
+      count
+    end
+  end
+end

data/lib/cuke_sniffer/feature.rb

@@ -6,9 +6,9 @@ module CukeSniffer
   # Handles feature files and disassembles and evaluates
   # its components.
   # Extends CukeSniffer::FeatureRulesEvaluator
-  class Feature < FeatureRulesEvaluator
+  class Feature < FeatureRuleTarget
 
-    xml_accessor :scenarios, :as => [CukeSniffer::FeatureRulesEvaluator], :in => "scenarios"
+    xml_accessor :scenarios, :as => [CukeSniffer::FeatureRuleTarget], :in => "scenarios"
 
     SCENARIO_TITLE_REGEX = /#{COMMENT_REGEX}#{SCENARIO_TITLE_STYLES}(?<name>.*)/ # :nodoc:
 
@@ -24,20 +24,17 @@ module CukeSniffer
     # int: Total score of the feature and its scenarios
     attr_accessor :total_score
 
+    # String array: A list of all the lines in a feature file
+    attr_accessor :feature_lines
+
     # file_name must be in the format of "file_path\file_name.feature"
     def initialize(file_name)
       super(file_name)
       @scenarios = []
       @scenarios_score = 0
       @total_score = 0
-      feature_lines = extract_feature_from_file(file_name)
-      if feature_lines == []
-        rule = RULES[:empty_feature]
-        store_rule(rule)
-      else
-        split_feature(file_name, feature_lines)
-        evaluate_score
-      end
+      @feature_lines = IO.readlines(file_name)
+      split_feature(file_name, feature_lines) unless @feature_lines == []
     end
 
     def ==(comparison_object) # :nodoc:
@@ -45,16 +42,14 @@ module CukeSniffer
           comparison_object.scenarios == scenarios
     end
 
-    private
-
-    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
+    def update_score
+      @scenarios_score += @background.score unless @background.nil?
+      @scenarios.each { |scenario| @scenarios_score += scenario.score }
+      @total_score = @scenarios_score + @score
     end
 
+    private
+
     def split_feature(file_name, feature_lines)
       index = 0
       until feature_lines[index].match /Feature:\s*(?<name>.*)/
@@ -99,74 +94,11 @@ 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
         @scenarios << scenario
       end
     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 { |scenario| @scenarios_score += scenario.score }
-    end
-
-    def rule_no_scenarios
-      rule = RULES[:no_scenarios]
-      store_rule(rule) if @scenarios.empty?
-    end
-
-    def rule_too_many_scenarios
-      rule = RULES[:too_many_scenarios]
-      store_rule(rule) if @scenarios.size >= rule[:max]
-    end
-
-    def rule_background_with_no_scenarios
-      rule = RULES[:background_with_no_scenarios]
-      store_rule(rule) if @scenarios.empty? and !@background.nil?
-    end
-
-    def rule_background_with_one_scenario
-      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,115 +1,56 @@
-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
-
+require 'cuke_sniffer/constants'
+require 'cuke_sniffer/rule_config'
+require 'cuke_sniffer/rule_target'
+
+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::RuleTarget
+  class FeatureRuleTarget < RuleTarget
+
+    # 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
+
+  end
+end
+