chutney 1.6.3 → 2.0.0.rc1

data/lib/chutney.rb

@@ -1,13 +1,14 @@
-require 'gherkin/parser'
+require 'amatch'
+require 'chutney/configuration'
 require 'chutney/linter'
+require 'chutney/linter/avoid_full_stop'
 require 'chutney/linter/avoid_outline_for_single_example'
-require 'chutney/linter/avoid_period'
 require 'chutney/linter/avoid_scripting'
 require 'chutney/linter/background_does_more_than_setup'
 require 'chutney/linter/background_requires_multiple_scenarios'
 require 'chutney/linter/bad_scenario_name'
-require 'chutney/linter/be_declarative'
 require 'chutney/linter/file_name_differs_feature_name'
+require 'chutney/linter/givens_after_background'
 require 'chutney/linter/invalid_file_name'
 require 'chutney/linter/invalid_step_flow'
 require 'chutney/linter/missing_example_name'
@@ -30,103 +31,78 @@ require 'chutney/linter/unknown_variable'
 require 'chutney/linter/unused_variable'
 require 'chutney/linter/use_background'
 require 'chutney/linter/use_outline'
-require 'multi_json'
+require 'forwardable'
+require 'gherkin/dialect'
+require 'gherkin/parser'
+require 'i18n'
 require 'set'
-require 'chutney/configuration'
+require 'yaml'
 
 module Chutney
   # gherkin linter
   class ChutneyLint
+    extend Forwardable
     attr_accessor :verbose
-    default_file = File.expand_path('..', __dir__), '**/config', 'default.yml'
-    DEFAULT_CONFIG = Dir.glob(File.join(default_file)).first.freeze
-    LINTER = Linter.descendants
-
-    def initialize(path = nil)
-      @files = {}
-      @linter = []
-      @config = Configuration.new path || DEFAULT_CONFIG
-      @verbose = false
-    end
-
-    def enabled(linter_name, value)
-      @config.config[linter_name]['Enabled'] = value if @config.config.key? linter_name
+    attr_reader :files
+    attr_reader :results
+    
+    def_delegators :@files, :<<, :clear, :delete, :include?
+
+    def initialize(*files)
+      @files = files
+      @results = Hash.new { |h, k| h[k] = [] }
+      i18n_paths = Dir[File.expand_path(File.join(__dir__, 'config/locales')) + '/*.yml']
+      return if I18n.load_path.include?(i18n_paths)
+
+      I18n.load_path << i18n_paths
     end
-
-    def enable(enabled_linters)
-      enabled_linters.each do |linter|
-        enabled linter, true
-      end
-    end
-
-    def disable(disabled_linters)
-      disabled_linters.each do |linter|
-        enabled linter, false
-      end
-    end
-
-    # Testing feature
-    def disable_all
-      @config.config.each do |member|
-        @config.config[member[0]]['Enabled'] = false
+    
+    def configuration
+      unless @config
+        default_file = [File.expand_path('..', __dir__), '**/config', 'chutney.yml']
+        config_file = Dir.glob(File.join(default_file)).first.freeze
+        @config = Configuration.new(config_file)
       end
+      @config
     end
-
-    def set_linter
-      @linter = []
-      LINTER.each do |linter|
-        new_linter = linter.new
-        linter_enabled = @config.config[new_linter.class.name.split('::').last]['Enabled']
-        evaluate_members(new_linter) if linter_enabled
-        @linter.push new_linter if linter_enabled
-      end
+    
+    def configuration=(config)
+      @config = config
     end
-
-    def evaluate_members(linter)
-      @config.config[linter.class.name.split('::').last].each do |member, value|
-        next if member.downcase.casecmp('enabled').zero?
-        
-        member = member.downcase.to_sym
-        raise 'Member not found! Check the YAML' unless linter.respond_to? member
-        
-        linter.public_send(member, value)
+    
+    def analyse
+      files.each do |f|
+        lint(f)
       end
+      @results
     end
-
-    def analyze(file)
-      @files[file] = parse file
-    end
-
-    def parse(file)
-      to_json File.read(file)
-    end
-
-    def report
-      issues = @linter.map do |linter|
-        linter.lint_files(@files, disable_tags)
-        linter.issues
-      end.flatten
-
-      print issues
-      return 0 if issues.select { |issue| issue.class == Error }.empty?
-      
-      -1
+    # alias for non-british English
+    # https://dictionary.cambridge.org/dictionary/english/analyse
+    alias analyze analyse
+    
+    def linters
+      @linters ||= Linter.descendants.filter { |l| configuration.dig(l.linter_name, 'Enabled') }
     end
-
-    def disable_tags
-      LINTER.map { |lint| "disable#{lint.new.class.name.split('::').last}" }
+    
+    def linters=(*linters)
+      @linters = linters
     end
-
-    def to_json(input)
-      parser = Gherkin::Parser.new
-      scanner = Gherkin::TokenScanner.new input
-
-      parser.parse(scanner)
+    
+    private
+    
+    def parse(text)
+      @parser ||= Gherkin::Parser.new
+      scanner = Gherkin::TokenScanner.new(text)
+      @parser.parse(scanner)
     end
-
-    def print(issues)
-      puts 'There are no issues' if issues.empty? && @verbose
-      issues.each { |issue| puts issue.render }
+    
+    def lint(file)
+      parsed = parse(File.read(file))
+      linters.each do |linter_class|
+        linter = linter_class.new(file, parsed, configuration[linter_class.linter_name])
+        linter.lint
+        @results[file] << { linter: linter.linter_name, issues: linter.issues }
+      end
     end
   end
 end

data/lib/chutney/configuration.rb

@@ -1,13 +1,12 @@
-require 'yaml'
-module Chutney
+require 'delegate'
+module Chutney 
   # gherkin_lint configuration object
-  class Configuration
-    attr_reader :config
-
+  class Configuration < SimpleDelegator
     def initialize(path)
       @path = path
-      @config = load_configuration || ''
+      @config = load_configuration || {}
       load_user_configuration
+      super(@config)
     end
 
     def configuration_path
@@ -15,7 +14,7 @@ module Chutney
     end
 
     def load_configuration
-      YAML.load_file configuration_path || '' if File.exist? configuration_path
+      YAML.load_file configuration_path || '' if configuration_path
     end
 
     def load_user_configuration

data/lib/chutney/formatter.rb

@@ -0,0 +1,21 @@
+module Chutney
+  # base class for all formatters
+  class Formatter
+    attr_accessor :results
+    
+    def initialize
+      @results = {}
+    end  
+    
+    def format(results); 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

@@ -0,0 +1,8 @@
+module Chutney
+  # Plain old JSON formatter
+  class JSONFormatter < Formatter
+    def format
+      puts @results.to_json
+    end
+  end
+end

data/lib/chutney/formatter/pie_formatter.rb

@@ -0,0 +1,78 @@
+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|
+        {
+          name: offence.first,
+          value: offence.last,
+          color: colour_loop,
+          fill: char_loop
+        }
+      end
+      print_report(data)
+    end
+    
+    def print_report(data)
+      unless data.empty?
+        print TTY::Pie.new(data: data, radius: 8, legend: { format: '%<label>s %<name>s %<value>i' })
+        puts
+      end
+      #       put_summary
+    end
+    
+    def top_offences
+      offence = Hash.new(0)
+      files_with_issues.each do |_file, linter|
+        linter.each do |lint|
+          offence[lint[:linter]] += lint[:issues].count
+        end
+      end
+      offence.reject { |_k, v| v.zero? }.sort_by { |_linter, count| -count }
+    end
+    
+    def char_loop
+      @char_looper ||= Fiber.new do 
+        chars = %w[• x + @ * / -]
+        current = 0
+        loop do
+          current = 0 if current >= chars.count
+          Fiber.yield chars[current]
+          current += 1
+        end
+      end
+      @char_looper.resume
+    end
+    
+    def colour_loop
+      @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
+          Fiber.yield colours[current]
+          current += 1
+        end
+      end
+      @colour_looper.resume
+    end
+    
+    def put_summary
+      pastel = Pastel.new
+      print "#{files.count} features inspected, "
+      if files_with_issues.count.zero?
+        puts pastel.green('all taste delicious')
+      else
+        puts pastel.red("#{files_with_issues.count} taste nasty")
+      end
+    end
+    
+  end
+end

data/lib/chutney/formatter/rainbow_formatter.rb

@@ -0,0 +1,47 @@
+require 'pastel'
+
+module Chutney
+  # pretty formatter
+  class RainbowFormatter < Formatter
+  
+    def initialize
+      super
+      
+      @pastel = Pastel.new
+    end
+  
+    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) }
+        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]}"
+    end
+    
+    def put_summary
+      print "#{files.count} features inspected, "
+      if files_with_issues.count.zero?
+        puts @pastel.green('all taste delicious')
+      else
+        puts @pastel.red("#{files_with_issues.count} taste nasty")
+      end
+    end
+    
+  end
+end

data/lib/chutney/linter.rb

@@ -1,149 +1,181 @@
-require 'chutney/issue'
-
 # gherkin utilities
 module Chutney
   # base class for all linters
   class Linter
-    attr_reader :issues
+    attr_accessor :issues
+    attr_reader :filename
+    attr_reader :configuration
+  
+    Lint = Struct.new(:message, :gherkin_type, :location, :feature, :scenario, :step, keyword_init: true)
 
     def self.descendants
       ObjectSpace.each_object(::Class).select { |klass| klass < self }
     end
 
-    def initialize
+    def initialize(filename, content, configuration)
+      @content = content
+      @filename = filename
       @issues = []
-      @files = {}
+      @configuration = configuration
+      language = @content.dig(:feature, :language) || 'en'
+      @dialect = Gherkin::Dialect.for(language)
     end
 
-    def features
-      @files.each do |file, content|
-        feature = content[:feature]
-        next if feature.nil?
-        
-        yield(file, feature)
+    def lint
+      raise 'not implemented'
+    end
+    
+    def and_word?(word)
+      @dialect.and_keywords.include?(word)
+    end
+    
+    def background_word?(word)
+      @dialect.background_keywords.include?(word)
+    end
+    
+    def but_word?(word)
+      @dialect.but_keywords.include?(word)
+    end
+    
+    def examples_word?(word)
+      @dialect.example_keywords.include?(word)
+    end
+    
+    def feature_word?(word)
+      @dialect.feature_keywords.include?(word)
+    end
+    
+    def given_word?(word)
+      @dialect.given_keywords.include?(word)
+    end
+    
+    def scenario_outline_word?(word)
+      @dialect.scenario_outline_keywords.include?(word)
+    end
+    
+    def then_word?(word)
+      @dialect.then_keywords.include?(word)
+    end
+    
+    def when_word?(word)
+      @dialect.when_keywords.include?(word)
+    end
+  
+    def tags_for(element)
+      return [] unless element.include? :tags
+
+      element[:tags].map { |tag| tag[:name][1..-1] }
+    end
+    
+    def add_issue(message, feature, scenario = nil, step = 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
+      ).to_h
+    end
+    
+    def location(feature, scenario, step)
+      if step
+        step[:location]
+      else
+        scenario ? scenario[:location] : feature[:location]
       end
     end
-
-    def files
-      @files.each_key { |file| yield file }
+    
+    def type(_feature, scenario, step)
+      if step
+        :step
+      else
+        scenario ? :scenario : :feature
+      end
     end
 
-    def scenarios
-      elements do |file, feature, scenario|
-        next if scenario[:type] == :Background
-        
-        yield(file, feature, scenario)
+    def feature
+      if block_given?
+        yield(@content[:feature]) if @content[:feature]
+      else
+        @content[:feature]
       end
     end
-
-    def filled_scenarios
-      scenarios do |file, feature, scenario|
-        next unless scenario.include? :steps
-        next if scenario[:steps].empty?
+    
+    def elements
+      if block_given? 
+        feature[:children].each do |child|
+          next if off_switch?(child)
         
-        yield(file, feature, scenario)
+          yield(feature, child)
+        end
+      else
+        feature[:children]
       end
     end
-
-    def steps
-      elements do |file, feature, scenario|
-        next unless scenario.include? :steps
-        
-        scenario[:steps].each { |step| yield(file, feature, scenario, step) }
+    
+    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 ||= off_switch?(feature) unless element == feature
+      off_switch
+    end
+    
+    def background
+      if block_given?
+        elements do |feature, child|
+          next unless child[:type] == :Background
+          
+          yield(feature, child)
+        end
+      else
+        elements.filter { |child| child[:type] == :Background }
       end
     end
-
-    def backgrounds
-      elements do |file, feature, scenario|
-        next unless scenario[:type] == :Background
+    
+    def scenarios
+      if block_given?
+        elements do |feature, child|
+          next unless %i[ScenarioOutline Scenario].include? child[:type]
         
-        yield(file, feature, scenario)
+          yield(feature, child)
+        end
+      else
+        elements.filter { |child| %i[ScenarioOutline Scenario].include? child[:type] }
       end
     end
-
-    def elements
-      @files.each do |file, content|
-        feature = content[:feature]
-        next if feature.nil?
-        next unless feature.key? :children
+    
+    def filled_scenarios
+      if block_given?
+        scenarios do |feature, scenario|
+          next unless scenario.include? :steps
+          next if scenario[:steps].empty?
         
-        feature[:children].each do |scenario|
-          yield(file, feature, scenario)
+          yield(feature, scenario)
         end
+      else
+        scenarios.filter { |s| !s[:steps].empty? }
       end
     end
-
-    def name
-      self.class.name.split('::').last
-    end
-
-    def lint_files(files, tags_to_suppress)
-      @files = files
-      @files = filter_tag(@files, "disable#{name}")
-      @files = suppress_tags(@files, tags_to_suppress)
-      lint
-    end
-
-    def filter_tag(data, tag)
-      return data.reject { |item| tag?(item, tag) }.map { |item| filter_tag(item, tag) } if data.class == Array
-      return {} if (data.class == Hash) && (data.include? :feature) && tag?(data[:feature], tag)
-      return data unless data.respond_to? :each_pair
-      
-      result = {}
-      data.each_pair { |key, value| result[key] = filter_tag(value, tag) }
-      result
-    end
-
-    def tag?(data, tag)
-      return false if data.class != Hash
-      return false unless data.include? :tags
-      
-      data[:tags].map { |item| item[:name] }.include? "@#{tag}"
-    end
-
-    def suppress_tags(data, tags)
-      return data.map { |item| suppress_tags(item, tags) } if data.class == Array
-      return data unless data.class == Hash
-      
-      result = {}
-
-      data.each_pair do |key, value|
-        value = suppress(value, tags) if key == :tags
-        result[key] = suppress_tags(value, tags)
+    
+    def steps
+      elements do |feature, child|
+        next unless child.include? :steps
+        
+        child[:steps].each { |step| yield(feature, child, step) }
       end
-      result
     end
 
-    def suppress(data, tags)
-      data.reject { |item| tags.map { |tag| "@#{tag}" }.include? item[:name] }
+    def self.linter_name
+      name.split('::').last
     end
-
-    def lint
-      raise 'not implemented'
-    end
-
-    def reference(file, feature = nil, scenario = nil, step = nil)
-      return file if feature.nil? || feature[:name].empty?
-      
-      result = "#{file} (#{line(feature, scenario, step)}): #{feature[:name]}"
-      result += ".#{scenario[:name]}" unless scenario.nil? || scenario[:name].empty?
-      result += " step: #{step[:text]}" unless step.nil?
-      result
-    end
-
-    def line(feature, scenario, step)
-      line = feature.nil? ? nil : feature[:location][:line]
-      line = scenario[:location][:line] unless scenario.nil?
-      line = step[:location][:line] unless step.nil?
-      line
-    end
-
-    def add_error(references, description = nil)
-      @issues.push Error.new(name, references, description)
-    end
-
-    def add_warning(references, description = nil)
-      @issues.push Warning.new(name, references, description)
+    
+    def linter_name
+      self.class.linter_name
     end
 
     def render_step(step)
@@ -151,7 +183,7 @@ module Chutney
       value += render_step_argument step[:argument] if step.include? :argument
       value
     end
-
+    
     def render_step_argument(argument)
       return "\n#{argument[:content]}" if argument[:type] == :DocString