chutney 2.1.1 → 3.0.1

data/lib/chutney/issue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'term/ansicolor'
 
 module Chutney

data/lib/chutney/linter.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 # gherkin utilities
 
 module Chutney
   # base class for all linters
   class Linter
     attr_accessor :issues
-    attr_reader :filename
-    attr_reader :configuration
-  
+    attr_reader :filename, :configuration
+
     Lint = Struct.new(:message, :gherkin_type, :location, :feature, :scenario, :step, keyword_init: true)
 
     def self.descendants
@@ -18,75 +19,83 @@ module Chutney
       @filename = filename
       @issues = []
       @configuration = configuration
-      language = @content.dig(:feature, :language) || 'en'
-      @dialect = Gherkin::Dialect.for(language)
+      #       language = @content.dig(:feature, :language) || 'en'
+      #       @dialect = Gherkin::Dialect.for(language)
     end
 
     def lint
       raise 'not implemented'
     end
-    
+
     def and_word?(word)
-      @dialect.and_keywords.include?(word)
+      dialect_word(:and).include?(word)
     end
-    
+
     def background_word?(word)
-      @dialect.background_keywords.include?(word)
+      dialect_word(:background).include?(word)
     end
-    
+
     def but_word?(word)
-      @dialect.but_keywords.include?(word)
+      dialect_word(:but).include?(word)
     end
-    
+
     def examples_word?(word)
-      @dialect.example_keywords.include?(word)
+      dialect_word(:examples).include?(word)
     end
-    
+
     def feature_word?(word)
-      @dialect.feature_keywords.include?(word)
+      dialect_word(:feature).include?(word)
     end
-    
+
     def given_word?(word)
-      @dialect.given_keywords.include?(word)
+      dialect_word(:given).include?(word)
     end
-    
+
     def scenario_outline_word?(word)
-      @dialect.scenario_outline_keywords.include?(word)
+      dialect_word(:scenarioOutline).include?(word)
     end
-    
+
     def then_word?(word)
-      @dialect.then_keywords.include?(word)
+      dialect_word(:then).include?(word)
     end
-    
+
     def when_word?(word)
-      @dialect.when_keywords.include?(word)
+      dialect_word(:when).include?(word)
+    end
+
+    def dialect_word(word)
+      CukeModeler::Parsing.dialects[dialect][word.to_s].map(&:strip)
+    end
+
+    def dialect
+      @content.feature&.parsing_data&.dig(:language) || 'en'
     end
-  
-    def tags_for(element)
-      return [] unless element.include? :tags
 
-      element[:tags].map { |tag| tag[:name][1..-1] }
+    def tags_for(element)
+      element.tags.map { |tag| tag.name[1..-1] }
     end
-    
-    def add_issue(message, feature, scenario = nil, step = nil)
+
+    def add_issue(message, feature = nil, scenario = nil, item = nil)
       issues << Lint.new(
         message: message,
-        gherkin_type: type(feature, scenario, step),
-        location: location(feature, scenario, step),
-        feature: feature[:name],
-        scenario: scenario ? scenario[:name] : nil,
-        step: step ? step[:text] : nil
+        gherkin_type: type(feature, scenario, item),
+        location: location(feature, scenario, item),
+        feature: feature&.name,
+        scenario: scenario&.name,
+        step: item&.parsing_data&.dig(:name)
       ).to_h
     end
-    
+
     def location(feature, scenario, step)
       if step
-        step[:location]
+        step.parsing_data[:location]
+      elsif scenario
+        scenario.parsing_data.dig(:scenario, :location) || scenario.parsing_data.dig(:background, :location)
       else
-        scenario ? scenario[:location] : feature[:location]
+        feature ? feature.parsing_data[:location] : { line: 0, column: 0 }
       end
     end
-    
+
     def type(_feature, scenario, step)
       if step
         :step
@@ -97,101 +106,103 @@ module Chutney
 
     def feature
       if block_given?
-        yield(@content[:feature]) if @content[:feature]
+        yield(@content.feature) if @content.feature
       else
-        @content[:feature]
+        @content.feature
       end
     end
-    
-    def elements 
+
+    def elements
       return [] unless feature
-      
-      if block_given? 
-        feature[:children].each do |child|
+
+      if block_given?
+        feature.children.each do |child|
           next if off_switch?(child)
-        
+
           yield(feature, child)
         end
       else
-        feature[:children]
+        feature.children
       end
     end
 
     def off_switch?(element = feature)
-      off_switch = element[:tags]
-                   .then { |tags| tags || [] }
-                   .filter { |tag| tag[:type] == :Tag }
-                   .filter { |tag| tag[:name] == "@disable#{linter_name}" }
-                   .count
-                   .positive?
+      # require 'pry'; binding.pry
+      off_switch = element.tags
+                          .map(&:name)
+                          .then { |tags| tags || [] }
+                          .filter { |tag_name| tag_name == "@disable#{linter_name}" }
+                          .count
+                          .positive?
       off_switch ||= off_switch?(feature) unless element == feature
       off_switch
     end
-    
+
     def background
+      return unless feature&.background
+      return if off_switch?(feature)
+
       if block_given?
-        elements do |feature, child|
-          next unless child[:type] == :Background
-          
-          yield(feature, child)
-        end
+        yield(feature, feature.background)
       else
-        elements.filter { |child| child[:type] == :Background }
+        feature.background
       end
     end
-    
+
     def scenarios
       if block_given?
-        elements do |feature, child|
-          next unless %i[ScenarioOutline Scenario].include? child[:type]
-        
-          yield(feature, child)
+        feature&.tests&.each do |test|
+          next if off_switch?(test)
+
+          yield(feature, test)
         end
+
       else
-        elements.filter { |child| %i[ScenarioOutline Scenario].include? child[:type] }
+        feature&.tests
       end
     end
-    
+
     def filled_scenarios
       if block_given?
         scenarios do |feature, scenario|
-          next unless scenario.include? :steps
-          next if scenario[:steps].empty?
-        
+          next if scenario.steps.empty?
+
           yield(feature, scenario)
         end
       else
-        scenarios.filter { |s| !s[:steps].empty? }
+        scenarios ? scenarios.filter { |s| !s.steps.empty? } : []
       end
     end
-    
+
     def steps
-      elements do |feature, child|
-        next unless child.include? :steps
-        
-        child[:steps].each { |step| yield(feature, child, step) }
+      feature&.tests&.each do |test|
+        next if off_switch?(test)
+
+        test.steps.each do |step|
+          yield(feature, test, step)
+        end
       end
     end
 
     def self.linter_name
       name.split('::').last
     end
-    
+
     def linter_name
       self.class.linter_name
     end
 
     def render_step(step)
-      value = "#{step[:keyword]}#{step[:text]}"
-      value += render_step_argument step[:argument] if step.include? :argument
+      value = "#{step.keyword} #{step.text}"
+      value += render_step_argument(step.block) if step.block
       value
     end
-    
+
     def render_step_argument(argument)
-      return "\n#{argument[:content]}" if argument[:type] == :DocString
-      
-      result = argument[:rows].map do |row|
-        "|#{row[:cells].map { |cell| cell[:value] }.join '|'}|"
+      return "\n#{argument.content}" if argument.is_a?(CukeModeler::DocString)
+
+      result = argument.rows.map do |row|
+        "|#{row.cells.map(&:value).join '|'}|"
       end.join "\n"
       "\n#{result}"
     end

data/lib/chutney/linter/avoid_full_stop.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for avoiding periods
-  class AvoidFullStop < Linter    
+  class AvoidFullStop < Linter
     def lint
       steps do |feature, child, step|
-        
-        add_issue(I18n.t('linters.avoid_full_stop'), feature, child, step) if step[:text].strip.end_with? '.'
-        
+        add_issue(I18n.t('linters.avoid_full_stop'), feature, child, step) if step.text.strip.end_with? '.'
       end
     end
   end

data/lib/chutney/linter/avoid_outline_for_single_example.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for avoiding outline for single example
   class AvoidOutlineForSingleExample < Linter
     def lint
       scenarios do |feature, scenario|
-        next unless scenario[:type] == :ScenarioOutline
+        next unless scenario.is_a? CukeModeler::Outline
+        next unless scenario.examples
+
+        next if scenario.examples.length > 1
+        next if scenario.examples.first.rows.length > 2 # first row is the header
 
-        next unless scenario.key? :examples
-        next if scenario[:examples].length > 1
-        next if scenario[:examples].first[:tableBody].length > 1
-        
         add_issue(I18n.t('linters.avoid_outline_for_single_example'), feature, scenario)
       end
     end

data/lib/chutney/linter/avoid_scripting.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for avoid scripting
-  class AvoidScripting < Linter  
+  class AvoidScripting < Linter
     def lint
       scenarios do |feature, scenario|
-        when_steps = filter_when_steps(scenario[:steps])
+        when_steps = filter_when_steps(scenario.steps)
         whens = when_steps.count
         add_issue(I18n.t('linters.avoid_scripting', count: whens), feature, scenario, when_steps.last) if whens > 1
       end
     end
-    
+
     def filter_when_steps(steps)
       steps
-        .drop_while { |step| !when_word?(step[:keyword]) }
-        .then { |s| s.reverse.drop_while { |step| !then_word?(step[:keyword]) }.reverse }
-        .then { |s| s.reject { |step| then_word?(step[:keyword]) } }
+        .drop_while { |step| !when_word?(step.keyword) }
+        .then { |s| s.reverse.drop_while { |step| !then_word?(step.keyword) }.reverse }
+        .then { |s| s.reject { |step| then_word?(step.keyword) } }
     end
   end
 end

data/lib/chutney/linter/avoid_typographers_quotes.rb

@@ -1,37 +1,39 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for avoid scripting
   class AvoidTypographersQuotes < Linter
     TYPOGRAPHER_QUOTES = ["\u201c", "\u201d", "\u2018", "\u2019"].map(&:encode)
 
     def lint
-      scenarios do |_feature, scenario|
-        lint_steps(scenario[:steps])
+      scenarios do |feature, scenario|
+        lint_steps(feature, scenario)
 
-        example_count = scenario[:examples]&.length || 0
+        example_count = scenario.is_a?(CukeModeler::Outline) ? scenario.examples.length : 0
         next unless example_count.positive?
 
-        lint_examples(scenario[:examples])
+        lint_examples(feature, scenario)
       end
     end
 
-    def lint_steps(steps)
-      steps.each do |step|
-        issue(step) if TYPOGRAPHER_QUOTES.any? { |tq| step[:text].include? tq }
+    def lint_steps(feature, scenario)
+      scenario.steps.each do |step|
+        issue(feature, scenario, step) if TYPOGRAPHER_QUOTES.any? { |tq| step.text.include? tq }
       end
     end
 
-    def lint_examples(examples)
-      examples.each do |example|
-        example[:tableBody].each do |body|
-          body[:cells].each do |cell|
-            issue(cell) if TYPOGRAPHER_QUOTES.any? { |tq| cell[:value].include? tq }
+    def lint_examples(feature, scenario)
+      scenario.examples.each do |example|
+        example.rows.each do |row|
+          row.cells.each do |cell|
+            issue(feature, scenario, cell) if TYPOGRAPHER_QUOTES.any? { |tq| cell.value.include? tq }
           end
         end
       end
     end
 
-    def issue(location)
-      add_issue(I18n.t('linters.avoid_typographers_quotes'), location)
+    def issue(feature, scenario, location)
+      add_issue(I18n.t('linters.avoid_typographers_quotes'), feature, scenario, location)
     end
   end
 end

data/lib/chutney/linter/background_does_more_than_setup.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 module Chutney
   # service class to lint for background that does more than setup
-  class BackgroundDoesMoreThanSetup < Linter   
+  class BackgroundDoesMoreThanSetup < Linter
     def lint
       background do |feature, background|
-        next unless background.key? :steps
-        
-        invalid_steps = background[:steps].select do |step| 
-          when_word?(step[:keyword]) || then_word?(step[:keyword])
+        invalid_steps = background&.steps&.select do |step|
+          when_word?(step.keyword) || then_word?(step.keyword)
         end
-        next if invalid_steps.empty?
 
-        add_issue(I18n.t('linters.background_does_more_than_setup'), feature, background)
+        next if invalid_steps.nil? || invalid_steps.empty?
+
+        add_issue(I18n.t('linters.background_does_more_than_setup'), feature, background, invalid_steps.first)
       end
     end
   end

data/lib/chutney/linter/background_requires_multiple_scenarios.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require 'chutney/linter'
 
 module Chutney
   # service class for check that there are multiple scenarios once a background is used
   class BackgroundRequiresMultipleScenarios < Linter
-    MESSAGE = 'Avoid using Background steps for just one scenario'.freeze
-  
+    MESSAGE = 'Avoid using Background steps for just one scenario'
+
     def lint
       background do |feature, background|
-        scenarios = feature[:children].reject { |element| element[:type] == :Background }
-        next if scenarios.length >= 2
+        next unless background
+        next unless feature&.tests
+        next if feature.tests.length >= 2
 
         add_issue(I18n.t('linters.background_requires_multiple_scenarios'), feature, background)
       end