chutney 2.2.1 → 3.1.0

data/lib/chutney/configuration.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'delegate'
-module Chutney 
+
+module Chutney
   # gherkin_lint configuration object
   class Configuration < SimpleDelegator
     def initialize(path)
@@ -18,7 +21,11 @@ module Chutney
     end
 
     def load_user_configuration
-      config_file = Dir.glob(File.join(Dir.pwd, '**', '.chutney.yml')).first
+      config_files = ['chutney.yml', '.chutney.yml'].map do |fname|
+        Dir.glob(File.join(Dir.pwd, '**', fname))
+      end.flatten
+
+      config_file = config_files.first
       merge_config(config_file) if !config_file.nil? && File.exist?(config_file)
     end
 

data/lib/chutney/formatter.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 module Chutney
   # base class for all formatters
   class Formatter
     attr_accessor :results
-    
+
     def initialize
       @results = {}
-    end  
-        
+    end
+
     def files
       results.map { |k, _v| k }
     end
-    
+
     def files_with_issues
       results.filter { |_k, v| v.any? { |r| r[:issues].count.positive? } }
     end
-    
   end
 end

data/lib/chutney/formatter/json_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Chutney
   # Plain old JSON formatter
   class JSONFormatter < Formatter

data/lib/chutney/formatter/pie_formatter.rb

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 require 'pastel'
 require 'tty/pie'
 
 module Chutney
   # format results as pie charts
   class PieFormatter < Formatter
-    def initialize
-      super
-    end
-    
     def format
       data = top_offences.map do |offence|
         {
@@ -19,14 +17,14 @@ module Chutney
       end
       print_report(data)
     end
-    
+
     def print_report(data)
       return if data.empty?
 
       print TTY::Pie.new(data: data, radius: 8, legend: { format: '%<label>s %<name>s %<value>i' })
       puts
     end
-    
+
     def top_offences
       offence = Hash.new(0)
       files_with_issues.each do |_file, linter|
@@ -36,9 +34,9 @@ module Chutney
       end
       offence.reject { |_k, v| v.zero? }.sort_by { |_linter, count| -count }
     end
-    
+
     def char_loop
-      @char_looper ||= Fiber.new do 
+      @char_looper ||= Fiber.new do
         chars = %w[• x + @ * / -]
         current = 0
         loop do
@@ -49,10 +47,10 @@ module Chutney
       end
       @char_looper.resume
     end
-    
+
     def colour_loop
-      @colour_looper ||= Fiber.new do 
-        colours = %i[bright_cyan bright_magenta bright_yellow bright_green] 
+      @colour_looper ||= Fiber.new do
+        colours = %i[bright_cyan bright_magenta bright_yellow bright_green]
         current = 0
         loop do
           current = 0 if current >= colours.count
@@ -62,7 +60,7 @@ module Chutney
       end
       @colour_looper.resume
     end
-    
+
     def put_summary
       pastel = Pastel.new
       print "#{files.count} features inspected, "
@@ -72,6 +70,5 @@ module Chutney
         puts pastel.red("#{files_with_issues.count} taste nasty")
       end
     end
-    
   end
 end

data/lib/chutney/formatter/rainbow_formatter.rb

@@ -1,39 +1,40 @@
+# frozen_string_literal: true
+
 require 'pastel'
 
 module Chutney
   # pretty formatter
   class RainbowFormatter < Formatter
-  
     def initialize
       super
-      
+
       @pastel = Pastel.new
     end
-  
-    def format      
+
+    def format
       files_with_issues.each do |file, linter|
         put_file(file)
         linter.filter { |l| !l[:issues].empty? }.each do |linter_with_issues|
-          
           put_linter(linter_with_issues)
-          linter_with_issues[:issues].each { |i| put_issue(i) }
+          linter_with_issues[:issues].each { |i| put_issue(file, i) }
         end
       end
       put_summary
     end
-    
+
     def put_file(file)
       puts @pastel.cyan(file.to_s)
     end
-    
+
     def put_linter(linter)
       puts @pastel.red("  #{linter[:linter]}")
     end
-    
-    def put_issue(issue)    
-      puts "    #{@pastel.dim(issue.dig(:location, :line))} #{issue[:message]}"
+
+    def put_issue(file, issue)
+      puts "    #{issue[:message]}"
+      puts "    #{@pastel.dim file.to_s}:#{@pastel.dim(issue.dig(:location, :line))}"
     end
-    
+
     def put_summary
       print "#{files.count} features inspected, "
       if files_with_issues.count.zero?
@@ -42,6 +43,5 @@ module Chutney
         puts @pastel.red("#{files_with_issues.count} taste nasty")
       end
     end
-    
   end
 end

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,77 +19,81 @@ module Chutney
       @filename = filename
       @issues = []
       @configuration = configuration
-      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..] }
     end
-    
-    def add_issue(message, feature = nil, 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 ? feature[:name] : nil,
-        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[:location]
-      else 
-        feature ? feature[:location] : 0
+        scenario.parsing_data.dig(:scenario, :location) || scenario.parsing_data.dig(:background, :location)
+      else
+        feature ? feature.parsing_data[:location] : { line: 0, column: 0 }
       end
     end
-    
+
     def type(_feature, scenario, step)
       if step
         :step
@@ -99,101 +104,102 @@ 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?
+      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