chutney 2.2.1 → 3.1.0

data/lib/chutney/linter/same_tag_different_case.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'chutney/linter'
+
+module Chutney
+  # service class to lint for missing verifications
+  class SameTagDifferentCase < Linter
+    def all_known_tags
+      # rubocop:disable Style/ClassVars
+      @@all_known_tags ||= []
+      # rubocop:enable Style/ClassVars
+    end
+
+    def lint
+      scenarios do |feature, scenario|
+        total_tags = tags_for(feature) + tags_for(scenario)
+
+        total_tags.each do |tag|
+          collision_with = case_collision(tag)
+          if collision_with
+            add_issue(I18n.t('linters.same_tag_different_case',
+                             existing_tag: collision_with, tag: tag),
+                      feature, scenario)
+          else
+            @@all_known_tags << tag
+          end
+        end
+      end
+    end
+
+    def case_collision(tag)
+      return nil if all_known_tags.include?(tag)
+
+      all_known_tags.select { |t| t.casecmp(tag).zero? }.first
+    end
+  end
+end

data/lib/chutney/linter/same_tag_for_all_scenarios.rb

@@ -1,40 +1,43 @@
+# frozen_string_literal: true
+
 require 'chutney/linter'
 
 module Chutney
   # service class to lint for using same tag on all scenarios
   class SameTagForAllScenarios < Linter
     def lint
-      lint_scenarios if feature&.include?(:children)
-      lint_examples  if feature&.include?(:children)
+      lint_scenarios if feature&.scenarios
+      lint_examples  if feature&.scenarios
     end
 
     def lint_scenarios
       tags = scenario_tags
       return if tags.nil? || tags.empty?
-      return unless feature[:children].length > 1
-            
+      return unless feature.tests.length > 1
+
       tags.each do |tag|
         next if tag == 'skip'
 
         add_issue(
-          I18n.t('linters.same_tag_for_all_scenarios.feature_level', 
-                 tag: tag), 
+          I18n.t('linters.same_tag_for_all_scenarios.feature_level',
+                 tag: tag),
           feature
         )
       end
     end
 
     def lint_examples
-      feature[:children].each do |scenario|
+      scenarios do |_feature, scenario|
         tags = example_tags(scenario)
         next if tags.nil? || tags.empty?
-        next unless scenario[:examples].length > 1
-        
+        next unless scenario.is_a? CukeModeler::Outline
+        next unless scenario.examples.length > 1
+
         tags.each do |tag|
           next if tag == 'skip'
 
-          add_issue(I18n.t('linters.same_tag_for_all_scenarios.example_level', 
-                           tag: tag), feature, scenario)        
+          add_issue(I18n.t('linters.same_tag_for_all_scenarios.example_level',
+                           tag: tag), feature, scenario)
         end
       end
     end
@@ -42,8 +45,6 @@ module Chutney
     def scenario_tags
       result = nil
       scenarios do |_feature, scenario|
-        next if scenario[:type] == :Background
-
         tags = tags_for(scenario)
         result ||= tags
         result &= tags
@@ -53,14 +54,14 @@ module Chutney
 
     def example_tags(scenario)
       result = nil
-      return result unless scenario.include? :examples
-      
-      scenario[:examples].each do |example|
-        return nil unless example.include? :tags
-        
+      return result unless scenario.is_a?(CukeModeler::Outline) && scenario.examples
+
+      scenario.examples.each do |example|
+        return nil unless example.tags
+
         tags = tags_for(example)
         result = tags if result.nil?
-        
+
         result &= tags
       end
       result

data/lib/chutney/linter/scenario_names_match.rb

@@ -1,18 +1,18 @@
+# frozen_string_literal: true
+
 require 'chutney/linter'
 
 module Chutney
   # service class to lint for tags used multiple times
   class ScenarioNamesMatch < Linter
-    MESSAGE = 'Scenario Name does not match pattern'.freeze
-  
+    MESSAGE = 'Scenario Name does not match pattern'
 
     def lint
       scenarios do |feature, scenario|
-        name = scenario.key?(:name) ? scenario[:name].strip : ''
-        next unless (name =~ /#{configuration['Matcher']}/).nil?
-        
+        next unless (scenario.name =~ /#{configuration['Matcher']}/).nil?
+
         add_issue(
-          I18n.t('linters.scenario_names_match', 
+          I18n.t('linters.scenario_names_match',
                  pattern: configuration['Matcher']), feature, scenario
         )
       end

data/lib/chutney/linter/tag_used_multiple_times.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for tags used multiple times
   class TagUsedMultipleTimes < Linter
@@ -6,7 +8,7 @@ module Chutney
         total_tags = tags_for(feature) + tags_for(scenario)
         double_used_tags = total_tags.find_all { |a| total_tags.count(a) > 1 }.uniq!
         next if double_used_tags.nil?
-                
+
         add_issue(
           I18n.t('linters.tag_used_multiple_times', tags: double_used_tags.join(',')), feature
         )

data/lib/chutney/linter/too_clumsy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'chutney/linter'
 
 module Chutney
@@ -5,9 +7,9 @@ module Chutney
   class TooClumsy < Linter
     def lint
       filled_scenarios do |feature, scenario|
-        characters = scenario[:steps].map { |step| step[:text].length }.inject(0, :+)
+        characters = scenario.steps.map { |step| step.text.length }.inject(0, :+)
         next if characters < 400
-        
+
         add_issue(
           I18n.t('linters.too_clumsy', length: characters), feature, scenario
         )

data/lib/chutney/linter/too_long_step.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for too long steps
   class TooLongStep < Linter
     def lint
       steps do |feature, scenario, step|
-        next if step[:text].length <= maxlength
-        
+        next if step.text.length <= maxlength
+
         add_issue(
-          I18n.t('linters.too_long_step', length: step[:text].length, max: maxlength), 
+          I18n.t('linters.too_long_step', length: step.text.length, max: maxlength),
           feature, scenario
         )
       end
     end
-    
+
     def maxlength
       configuration['MaxLength'] || '120'
     end

data/lib/chutney/linter/too_many_different_tags.rb

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for too many different tags
   class TooManyDifferentTags < Linter
     def lint
       tags = all_tags
       return if tags.length <= maxcount
-      
+
       add_issue(
-        I18n.t('linters.too_many_different_tags', count: tags.length, max: maxcount), 
+        I18n.t('linters.too_many_different_tags', count: tags.length, max: maxcount),
         feature
       )
     end
-    
-    def maxcount 
+
+    def maxcount
       configuration['MaxCount']&.to_i || 3
     end
-    
+
     def all_tags
-      return [] unless feature&.include?(:children)
-      
-      tags_for(feature) + feature[:children].map { |scenario| tags_for(scenario) }.flatten
+      return [] unless feature&.scenarios
+
+      tags_for(feature) + feature.scenarios.map { |scenario| tags_for(scenario) }.flatten
     end
   end
 end

data/lib/chutney/linter/too_many_steps.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for too many steps
   class TooManySteps < Linter
     def lint
       filled_scenarios do |feature, scenario|
-        next if scenario[:steps].length <= maxcount
-        
+        next if scenario.steps.length <= maxcount
+
         add_issue(
-          I18n.t('linters.too_many_steps', count: scenario[:steps].length, max: maxcount), 
+          I18n.t('linters.too_many_steps', count: scenario.steps.length, max: maxcount),
           feature
         )
       end
     end
-    
+
     def maxcount
       configuration['MaxCount']&.to_i || 10
     end

data/lib/chutney/linter/too_many_tags.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for too many tags
   class TooManyTags < Linter
@@ -5,14 +7,14 @@ module Chutney
       scenarios do |feature, scenario|
         tags = tags_for(feature) + tags_for(scenario)
         next unless tags.length > maxcount
-        
+
         add_issue(
-          I18n.t('linters.too_many_tags', count: tags.length, max: maxcount), 
+          I18n.t('linters.too_many_tags', count: tags.length, max: maxcount),
           feature
         )
       end
     end
-    
+
     def maxcount
       configuration['MaxCount']&.to_i || 3
     end

data/lib/chutney/linter/unique_scenario_names.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for unique scenario names
   class UniqueScenarioNames < Linter
     def lint
       references_by_name = {}
       scenarios do |feature, scenario|
-        next unless scenario.key? :name
-
-        name = scenario[:name]
+        name = scenario.name
         if references_by_name[name]
           issue(name, references_by_name[name], scenario)
         else
@@ -14,13 +14,13 @@ module Chutney
         end
       end
     end
-    
+
     def issue(name, first_location, scenario)
       add_issue(
         I18n.t('linters.unique_scenario_names',
                name: name,
                line: first_location[:line],
-               column: first_location[:column]), 
+               column: first_location[:column]),
         feature, scenario
       )
     end

data/lib/chutney/linter/unknown_variable.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for unknown variables
   class UnknownVariable < Linter
     def lint
       filled_scenarios do |feature, scenario|
         known_vars = Set.new(known_variables(scenario))
-        scenario[:steps].each do |step|
+        scenario.steps.each do |step|
           step_vars(step).each do |used_var|
             next if known_vars.include? used_var
-            
+
             add_issue(
               I18n.t('linters.unknown_variable', variable: used_var), feature, scenario
             )
@@ -17,17 +19,17 @@ module Chutney
     end
 
     def step_vars(step)
-      vars = gather_vars step[:text]
-      return vars unless step.include? :argument
-      
-      vars + gather_vars_from_argument(step[:argument])
+      vars = gather_vars step.text
+      return vars unless step.block
+
+      vars + gather_vars_from_argument(step.block)
     end
 
     def gather_vars_from_argument(argument)
-      return gather_vars argument[:content] if argument[:type] == :DocString
-      
-      (argument[:rows] || []).map do |row|
-        row[:cells].map { |value| gather_vars value[:value] }.flatten
+      return gather_vars argument.content if argument.is_a? CukeModeler::DocString
+
+      argument.rows.map do |row|
+        row.cells.map { |cell| gather_vars cell.value }.flatten
       end.flatten
     end
 
@@ -36,11 +38,9 @@ module Chutney
     end
 
     def known_variables(scenario)
-      (scenario[:examples] || []).map do |example|
-        next unless example.key? :tableHeader
-        
-        example[:tableHeader][:cells].map { |cell| cell[:value].strip }
-      end.flatten
+      return [] unless scenario.is_a? CukeModeler::Outline
+
+      scenario.examples.map { |ex| ex.rows.first.cells.map(&:value) }.flatten
     end
   end
 end

data/lib/chutney/linter/unused_variable.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for unused variables
   class UnusedVariable < Linter
     def lint
       scenarios do |feature, scenario|
-        next unless scenario.key?(:examples)
-        
-        scenario[:examples].each do |example|
-          next unless example.key?(:tableHeader)
-          
-          example[:tableHeader][:cells].map { |cell| cell[:value] }.each do |variable|
+        next unless scenario.is_a? CukeModeler::Outline
+
+        scenario.examples.each do |example|
+          example.rows.first.cells.map(&:value).each do |variable|
             next if used?(variable, scenario)
 
             add_issue(I18n.t('linters.unused_variable', variable: variable), feature, scenario, example)
@@ -19,11 +19,10 @@ module Chutney
 
     def used?(variable, scenario)
       variable = "<#{variable}>"
-      return false unless scenario.key? :steps
-      
-      scenario[:steps].each do |step|
-        return true if step[:text].include? variable
-        next unless step.include? :argument
+
+      scenario.steps.each do |step|
+        return true if step.text.include? variable
+        next unless step.block
         return true if used_in_docstring?(variable, step)
         return true if used_in_table?(variable, step)
       end
@@ -31,14 +30,14 @@ module Chutney
     end
 
     def used_in_docstring?(variable, step)
-      step[:argument][:type] == :DocString && step[:argument][:content].include?(variable)
+      step.block.is_a?(CukeModeler::DocString) && step.block.content.include?(variable)
     end
 
     def used_in_table?(variable, step)
-      return false unless step[:argument][:type] == :DataTable
-      
-      step[:argument][:rows].each do |row|
-        row[:cells].each { |value| return true if value[:value].include?(variable) }
+      return false unless step.block.is_a?(CukeModeler::Table)
+
+      step.block.rows.each do |row|
+        row.cells.each { |cell| return true if cell.value.include?(variable) }
       end
       false
     end

data/lib/chutney/linter/use_background.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for using background
   class UseBackground < Linter
@@ -13,14 +15,13 @@ module Chutney
     end
 
     def gather_givens
-      return unless feature.include? :children
-      
+      return unless feature.children
+
       has_non_given_step = false
-      feature[:children].each do |scenario|
-        next unless scenario.include? :steps
-        next if scenario[:steps].empty?
-        
-        has_non_given_step = true unless given_word?(scenario[:steps].first[:keyword])
+      scenarios do |_feature, scenario|
+        next unless scenario.steps
+
+        has_non_given_step = true unless given_word?(scenario.steps.first.keyword)
       end
       return if has_non_given_step
 
@@ -29,15 +30,13 @@ module Chutney
       result
     end
 
-    def expanded_steps
-      feature[:children].each do |scenario|
-        next unless scenario[:type] != :Background
-        next unless scenario.include? :steps
-        next if scenario[:steps].empty?
-        
-        prototypes = [render_step(scenario[:steps].first)]
-        prototypes = expand_examples(scenario[:examples], prototypes) if scenario.key? :examples
-        prototypes.each { |prototype| yield prototype }
+    def expanded_steps(&block)
+      scenarios do |_feature, scenario|
+        next unless scenario.steps
+
+        prototypes = [render_step(scenario.steps.first)]
+        prototypes = expand_examples(scenario.examples, prototypes) if scenario.is_a? CukeModeler::Outline
+        prototypes.each(&block)
       end
     end
 
@@ -50,10 +49,12 @@ module Chutney
 
     def expand_outlines(sentence, example)
       result = []
-      headers = example[:tableHeader][:cells].map { |cell| cell[:value] }
-      example[:tableBody].each do |row| # .slice(1, example[:tableBody].length).each do |row|
+      headers = example.rows.first.cells.map(&:value)
+      example.rows.each_with_index do |row, idx|
+        next if idx.zero? # skip the header
+
         modified_sentence = sentence.dup
-        headers.zip(row[:cells].map { |cell| cell[:value] }).map do |key, value|
+        headers.zip(row.cells.map(&:value)).map do |key, value|
           modified_sentence.gsub!("<#{key}>", value)
         end
         result.push modified_sentence