cuke_sniffer 0.0.3 → 0.0.5

data/bin/{cuke_sniffer.rb → cuke_sniffer}

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
 require 'cuke_sniffer'
 
 help_cmd_txt = "Welcome to CukeSniffer!
@@ -19,7 +21,8 @@ if ARGV.include? "-h" or ARGV.include? "--help"
 end
 
 cuke_sniffer = nil
-if (ARGV[0] != nil and File.directory?(ARGV[0])) and (ARGV[1] != nil and File.directory?(ARGV[1]))
+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

data/lib/cuke_sniffer.rb

@@ -1,15 +1,16 @@
-require 'nokogiri'
-require 'roxml'
-
-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
+require 'nokogiri'
+require 'roxml'
+
+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/hook'
+require 'cuke_sniffer/cli'
+
+module CukeSniffer
+
+end

data/lib/cuke_sniffer/cli.rb

@@ -2,6 +2,11 @@ require 'erb'
 require 'roxml'
 
 module CukeSniffer
+
+  # Author::    Robert Cochran  (mailto:cochrarj@miamioh.edu)
+  # Copyright:: Copyright (C) 2013 Robert Cochran
+  # License::   Distributes under the MIT License
+  # Mixins: CukeSniffer::Constants, ROXML
   class CLI
     include CukeSniffer::Constants
     include ROXML
@@ -14,26 +19,80 @@ module CukeSniffer
       xml_accessor :good
       xml_accessor :bad
       xml_accessor :threshold
-    end
+    end # :nodoc:
 
     xml_name "cuke_sniffer"
     xml_accessor :features_summary, :as => SummaryNode
     xml_accessor :scenarios_summary, :as => SummaryNode
     xml_accessor :step_definitions_summary, :as => SummaryNode
-    xml_accessor :improvement_list, :as => {:key => "rule", :value => "total"}, :in =>  "improvement_list", :from => "improvement"
+    xml_accessor :hooks_summary, :as => SummaryNode
+    xml_accessor :improvement_list, :as => {:key => "rule", :value => "total"}, :in => "improvement_list", :from => "improvement"
     xml_accessor :features, :as => [CukeSniffer::Feature], :in => "features"
     xml_accessor :step_definitions, :as => [CukeSniffer::StepDefinition], :in => "step_definitions"
+    xml_accessor :hooks, :as => [CukeSniffer::Hook], :in => "hooks"
+
+
+    # Feature array: All Features gathered from the specified folder
+    attr_accessor :features
+
+    # StepDefinition Array: All StepDefinitions objects gathered from the specified folder
+    attr_accessor :step_definitions
+
+    # Hash: Summary objects and improvement lists
+    # * Key: symbol, :total_score, :features, :step_definitions, :improvement_list
+    # * Value: hash or array
+    attr_accessor :summary
+
+    # string: Location of the feature file or root folder that was searched in
+    attr_accessor :features_location
 
-    attr_accessor :summary, :features_location, :step_definitions_location, :scenarios
+    # string: Location of the step definition file or root folder that was searched in
+    attr_accessor :step_definitions_location
 
-    def initialize(features_location = Dir.getwd, step_definitions_location = Dir.getwd)
+    # string: Location of the hook file or root folder that was searched in
+    attr_accessor :hooks_location
+
+    # Scenario array: All Scenarios found in the features from the specified folder
+    attr_accessor :scenarios
+
+    # Hook array: All Hooks found in the current directory
+    attr_accessor :hooks
+
+
+    # Does analysis against the passed features and step definition locations
+    #
+    # Can be called in several ways.
+    #
+    #
+    # No argument(assumes current directory is the project)
+    #  cuke_sniffer = CukeSniffer::CLI.new
+    #
+    # Against single files
+    #  cuke_sniffer = CukeSniffer::CLI.new("my_feature.feature", nil)
+    # Or
+    #  cuke_sniffer = CukeSniffer::CLI.new(nil, "my_steps.rb")
+    #
+    #
+    # Against folders
+    #  cuke_sniffer = CukeSniffer::CLI.new("my_features_directory\", "my_steps_directory\")
+    #
+    # You can mix and match all of the above examples
+    #
+    # Displays the sequence and a . indicator for each new loop in that process.
+    # Handles creation of all Feature and StepDefinition objects
+    # Then catalogs all step definition calls to be used for rules and identification
+    # of dead steps.
+    def initialize(features_location = Dir.getwd, step_definitions_location = Dir.getwd, hooks_location = Dir.getwd)
       @features_location = features_location
       @step_definitions_location = step_definitions_location
+      @hooks_location = hooks_location
       @features = []
       @scenarios = []
       @step_definitions = []
+      @hooks = []
 
       puts "\nFeatures:"
+      #extract this to a method that accepts a block and yields for the build pattern
       unless features_location.nil?
         if File.file?(features_location)
           @features = [CukeSniffer::Feature.new(features_location)]
@@ -58,12 +117,26 @@ module CukeSniffer
           }
         end
       end
-
       @step_definitions.flatten!
+
+      puts("\nHooks:")
+      unless hooks_location.nil?
+        if File.file?(hooks_location)
+          @hooks = [build_hooks(hooks_location)]
+        else
+          build_file_list_from_folder(hooks_location, ".rb").each { |location|
+            @hooks << build_hooks(location)
+            print '.'
+          }
+        end
+      end
+      @hooks.flatten!
+
       @summary = {
           :total_score => 0,
           :features => {},
           :step_definitions => {},
+          :hooks => {},
           :improvement_list => {}
       }
       puts "\nCataloging Step Calls: "
@@ -74,6 +147,165 @@ module CukeSniffer
       @features_summary = load_summary_data(@summary[:features])
       @scenarios_summary = load_summary_data(@summary[:scenarios])
       @step_definitions_summary = load_summary_data(@summary[:step_definitions])
+      @hooks_summary = load_summary_data(@summary[:hooks])
+    end
+
+    # Returns the status of the overall project based on a comparison of the score to the threshold score
+    def good?
+      @summary[:total_score] <= Constants::THRESHOLDS["Project"]
+    end
+
+    # Calculates the score to threshold percentage of an object
+    # Return: Float
+    def problem_percentage
+      @summary[:total_score].to_f / Constants::THRESHOLDS["Project"].to_f
+    end
+
+    # Prints out a summary of the results and the list of improvements to be made
+    def output_results
+      feature_results = @summary[:features]
+      step_definition_results = @summary[:step_definitions]
+      hooks_results = @summary[:hooks]
+      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]}
+    Hooks (#@hooks_location)
+      Min: #{hooks_results[:min]} (#{hooks_results[:min_file]})
+      Max: #{hooks_results[:max]} (#{hooks_results[:max_file]})
+      Average: #{hooks_results[:average]}
+  Improvements to make:"
+      create_improvement_list.each { |item| output << "\n    #{item}" }
+      output
+    end
+
+    # Creates a html file with the collected project details
+    # file_name defaults to "cuke_sniffer_results.html" unless specified
+    # Second parameter used for passing into the markup.
+    #  cuke_sniffer.output_html
+    # Or
+    #  cuke_sniffer.output_html("results01-01-0001.html")
+    def output_html(file_name = "cuke_sniffer_results.html", cuke_sniffer = self)
+      @features = @features.sort_by { |feature| feature.total_score }.reverse
+      @step_definitions = @step_definitions.sort_by { |step_definition| step_definition.score }.reverse
+      @hooks = @hooks.sort_by { |hook| hook.score }.reverse
+
+      markup_erb = ERB.new extract_markup
+      output = markup_erb.result(binding)
+      File.open(file_name, 'w') do |f|
+        f.write(output)
+      end
+    end
+
+    # Creates a xml file with the collected project details
+    # file_name defaults to "cuke_sniffer.xml" unless specified
+    #  cuke_sniffer.output_xml
+    # Or
+    #  cuke_sniffer.output_xml("cuke_sniffer01-01-0001.xml")
+    def output_xml(file_name = "cuke_sniffer.xml")
+      doc = Nokogiri::XML::Document.new
+      doc.root = self.to_xml
+      open(file_name, "w") do |file|
+        file << doc.serialize
+      end
+    end
+
+    # Gathers all StepDefinitions that have no calls
+    # Returns a hash that has two different types of records
+    # 1: String of the file with a dead step with an array of the line and regex of each dead step
+    # 2: Symbol of :total with an integer that is the total number of dead steps
+    def get_dead_steps
+      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 = step_definition.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
+        dead_steps_hash[file_name] ||= []
+        dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/" if step_definition.calls.empty?
+      end
+      total = 0
+      dead_steps_hash.each_key do |key|
+        unless dead_steps_hash[key] == []
+          total += dead_steps_hash[key].size
+          dead_steps_hash[key].sort_by! { |row| row[/^\d+/].to_i }
+        else
+          dead_steps_hash.delete(key)
+        end
+      end
+      dead_steps_hash[:total] = total
+      dead_steps_hash
+    end
+
+    # Determines all normal and nested step calls and assigns them to the corresponding step definition.
+    # Does direct and fuzzy matching
+    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].gsub(STEP_STYLES, "")) }
+      end
+
+      converted_steps = convert_steps_with_expressions(get_steps_with_expressions(steps))
+      catalog_possible_dead_steps(converted_steps)
+    end
+
+    private
+
+    def extract_variables_from_example(example)
+      example = example[example.index('|')..example.length]
+      example.split(/\s*\|\s*/) - [""]
+    end
+
+    def assess_score
+      @summary[:features] = assess_array(@features, "Feature")
+      @summary[:scenarios] = assess_array(@scenarios, "Scenario")
+      @summary[:step_definitions] = assess_array(@step_definitions, "StepDefinition")
+      @summary[:hooks] = assess_array(@hooks, "Hook")
+      sort_improvement_list
+    end
+
+    def get_all_steps
+      feature_steps = extract_steps_from_features
+      step_definition_steps = extract_steps_from_step_definitions
+      feature_steps.merge step_definition_steps
+    end
+
+    def 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
+
+    def catalog_possible_dead_steps(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
+    end
+
+    def convert_steps_with_expressions(steps_with_expressions)
+      step_regexs = {}
+      steps_with_expressions.each do |step_location, step_value|
+        modified_step = step_value.gsub(/\#{[^}]*}/, '.*')
+        step_regexs[step_location] = Regexp.new('^' + modified_step + '$')
+      end
+      step_regexs
     end
 
     def load_summary_data(summary_hash)
@@ -87,14 +319,6 @@ module CukeSniffer
       summary_node
     end
 
-    def good?
-      @summary[:total_score] <= Constants::THRESHOLDS["Project"]
-    end
-
-    def problem_percentage
-      @summary[:total_score].to_f / Constants::THRESHOLDS["Project"].to_f
-    end
-
     def build_file_list_from_folder(folder_name, extension)
       list = []
       Dir.entries(folder_name).each_entry do |file_name|
@@ -129,7 +353,7 @@ module CukeSniffer
         step_code << step_file_lines[counter].strip
         counter+=1
       end
-      step_definitions << CukeSniffer::StepDefinition.new("#{file_name}:#{counter+1}", step_code) unless step_code.empty? or !found_first_step
+      step_definitions << CukeSniffer::StepDefinition.new("#{file_name}:#{counter+1 -step_code.count}", step_code) unless step_code.empty? or !found_first_step
       step_definitions
     end
 
@@ -139,22 +363,24 @@ module CukeSniffer
       good = 0
       bad = 0
       total_score = 0
-      array.each do |node|
-        score = node.score
-        @summary[:total_score] += score
-        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)
-        if node.good?
-          good += 1
-        else
-          bad += 1
+      unless array.empty?
+        array.each do |node|
+          score = node.score
+          @summary[:total_score] += score
+          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)
+          if node.good?
+            good += 1
+          else
+            bad += 1
+          end
+          total += score
         end
-        total += score
       end
       {
           :total => array.count,
@@ -170,13 +396,6 @@ module CukeSniffer
       }
     end
 
-    def assess_score
-      @summary[:features] = assess_array(@features, "Feature")
-      @summary[:scenarios] = assess_array(@scenarios, "Scenario")
-      @summary[:step_definitions] = assess_array(@step_definitions, "StepDefinition") unless @step_definitions.empty?
-      sort_improvement_list
-    end
-
     def get_all_scenarios(features)
       scenarios = []
       features.each do |feature|
@@ -194,31 +413,28 @@ module CukeSniffer
       }
     end
 
-    def output_results
-      feature_results = @summary[:features]
-      step_definition_results = @summary[:step_definitions]
-      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 extract_steps_hash(scenario)
+    def extract_steps_from_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
+
+    def extract_scenario_steps(scenario)
       steps_hash = {}
       counter = 1
       scenario.steps.each do |step|
@@ -229,57 +445,46 @@ module CukeSniffer
       steps_hash
     end
 
-    def get_all_steps
+    def extract_scenario_outline_steps(scenario)
       steps = {}
-      @features.each do |feature|
-        unless feature.background.nil?
-          background_steps = extract_steps_hash(feature.background)
-          background_steps.each_key { |key| steps[key] = background_steps[key] }
-        end
-        feature.scenarios.each do |scenario|
-          scenario_steps = extract_steps_hash(scenario)
-          scenario_steps.each_key { |key| steps[key] = scenario_steps[key] }
-        end
-      end
-      @step_definitions.each do |definition|
-        definition.nested_steps.each_key do |key|
-          steps[key] = definition.nested_steps[key]
+      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
 
-    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].gsub(STEP_STYLES, ""))
-        }
+    def 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
 
-    def get_dead_steps
-      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 = step_definition.regex.to_s.match(/\(\?\-mix\:(?<regex>.*)\)/)[:regex]
-        dead_steps_hash[file_name] ||= []
-        dead_steps_hash[file_name] << "#{location_match[:line]}: /#{regex}/" if step_definition.calls.empty?
-      end
-      total = 0
-      dead_steps_hash.each_key do |key|
-        unless dead_steps_hash[key] == []
-          total += dead_steps_hash[key].size
-          dead_steps_hash[key].sort_by! {|row| row[/^\d+/].to_i}
-        else
-          dead_steps_hash.delete(key)
+    def extract_steps_from_step_definitions
+      steps = {}
+      @step_definitions.each do |definition|
+        definition.nested_steps.each_key do |key|
+          steps[key] = definition.nested_steps[key]
         end
       end
-      dead_steps_hash[:total] = total
-      dead_steps_hash
+      steps
     end
 
     def extract_markup
@@ -291,24 +496,28 @@ module CukeSniffer
       markup
     end
 
-    def output_html(file_name = "cuke_sniffer_results.html", cuke_sniffer = self)
-      @features = @features.sort_by { |feature| feature.total_score }.reverse
-      @step_definitions = @step_definitions.sort_by { |step_definition| step_definition.score }.reverse
+    def build_hooks(file_name)
+      hooks_file_lines = []
+      hooks_file = File.open(file_name)
+      hooks_file.each_line { |line| hooks_file_lines << line }
+      hooks_file.close
 
-      markup_erb = ERB.new extract_markup
-      output = markup_erb.result(binding)
-      File.open(file_name, 'w') do |f|
-        f.write(output)
+      counter = 0
+      hooks_code = []
+      hooks = []
+      found_first_hook = false
+      until counter >= hooks_file_lines.length
+        if hooks_file_lines[counter] =~ HOOK_REGEX and !hooks_code.empty? and found_first_hook
+          hooks << CukeSniffer::Hook.new("#{file_name}:#{counter+1 - hooks_code.count}", hooks_code)
+          hooks_code = []
+        end
+        found_first_hook = true if hooks_file_lines[counter] =~ HOOK_REGEX
+        hooks_code << hooks_file_lines[counter].strip
+        counter+=1
       end
+      hooks << CukeSniffer::Hook.new("#{file_name}:#{counter+1 -hooks_code.count}", hooks_code) unless hooks_code.empty? or !found_first_hook
+      hooks
     end
 
-    def output_xml(file_name = "cuke_sniffer.xml")
-      doc = Nokogiri::XML::Document.new
-      doc.root = self.to_xml
-      open(file_name, "w") do |file|
-        file << doc.serialize
-      end
-
-    end
   end
 end