chutney 1.6.3 → 2.0.0.rc1

data/lib/chutney/linter/same_tag_for_all_scenarios.rb

@@ -4,65 +4,61 @@ module Chutney
   # service class to lint for using same tag on all scenarios
   class SameTagForAllScenarios < Linter
     def lint
-      features do |file, feature|
-        next unless feature.include? :children
-
-        lint_scenarios file, feature
-        lint_examples file, feature
-      end
+      lint_scenarios if feature.include? :children
+      lint_examples  if feature.include? :children
     end
 
-    def lint_scenarios(file, feature)
-      tags = gather_same_tags feature
-      return if tags.nil?
-      return if tags.empty?
+    def lint_scenarios
+      tags = scenario_tags
+      return if tags.nil? || tags.empty?
       return unless feature[:children].length > 1
-      
-      references = [reference(file, feature)]
+            
       tags.each do |tag|
-        next if tag == '@skip'
+        next if tag == 'skip'
 
-        add_error(references, "Tag '#{tag}' should be used at Feature level")
+        add_issue(
+          I18n.t('linters.same_tag_for_all_scenarios.feature_level', 
+                 tag: tag), 
+          feature
+        )
       end
     end
 
-    def lint_examples(file, feature)
+    def lint_examples
       feature[:children].each do |scenario|
-        tags = gather_same_tags_for_outline scenario
+        tags = example_tags(scenario)
         next if tags.nil? || tags.empty?
         next unless scenario[:examples].length > 1
         
-        references = [reference(file, feature, scenario)]
         tags.each do |tag|
-          next if tag == '@skip'
+          next if tag == 'skip'
 
-          add_error(references, "Tag '#{tag}' should be used at Scenario Outline level")
+          add_issue(I18n.t('linters.same_tag_for_all_scenarios.example_level', 
+                           tag: tag), feature, scenario)        
         end
       end
     end
 
-    def gather_same_tags(feature)
+    def scenario_tags
       result = nil
-      feature[:children].each do |scenario|
+      scenarios do |_feature, scenario|
         next if scenario[:type] == :Background
-        return nil unless scenario.include? :tags
-        
-        tags = scenario[:tags].map { |tag| tag[:name] }
-        result = tags if result.nil?
-        
+
+        tags = tags_for(scenario)
+        result ||= tags
         result &= tags
       end
       result
     end
 
-    def gather_same_tags_for_outline(scenario)
+    def example_tags(scenario)
       result = nil
       return result unless scenario.include? :examples
       
       scenario[:examples].each do |example|
         return nil unless example.include? :tags
         
-        tags = example[:tags].map { |tag| tag[:name] }
+        tags = tags_for(example)
         result = tags if result.nil?
         
         result &= tags

data/lib/chutney/linter/scenario_names_match.rb

@@ -7,17 +7,15 @@ module Chutney
   
 
     def lint
-      scenarios do |file, feature, scenario|
+      scenarios do |feature, scenario|
         name = scenario.key?(:name) ? scenario[:name].strip : ''
-        references = [reference(file, feature, scenario)]
-        next unless (name =~ /#{@pattern}/).nil?
+        next unless (name =~ /#{configuration['Matcher']}/).nil?
         
-        add_warning(references, MESSAGE)
+        add_issue(
+          I18n.t('linters.scenario_names_match', 
+                 pattern: configuration['Matcher']), feature, scenario
+        )
       end
     end
-    
-    def matcher(pattern)
-      @pattern = pattern
-    end
   end
 end

data/lib/chutney/linter/tag_used_multiple_times.rb

@@ -1,23 +1,16 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for tags used multiple times
   class TagUsedMultipleTimes < Linter
     def lint
-      scenarios do |file, feature, scenario|
-        references = [reference(file, feature, scenario)]
-        total_tags = tags(feature) + tags(scenario)
+      scenarios do |feature, scenario|
+        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_error(references, "Tag #{double_used_tags.join(' and ')} used multiple times")
+                
+        add_issue(
+          I18n.t('linters.tag_used_multiple_times', tags: double_used_tags.join(',')), feature
+        )
       end
     end
-
-    def tags(element)
-      return [] unless element.include? :tags
-      
-      element[:tags].map { |a| a[:name] }
-    end
   end
 end

data/lib/chutney/linter/too_clumsy.rb

@@ -3,14 +3,14 @@ require 'chutney/linter'
 module Chutney
   # service class to lint for too clumsy scenarios
   class TooClumsy < Linter
-    MESSAGE = 'This scenario is too long at %d characters'.freeze
     def lint
-      filled_scenarios do |file, feature, scenario|
+      filled_scenarios do |feature, scenario|
         characters = scenario[:steps].map { |step| step[:text].length }.inject(0, :+)
         next if characters < 400
         
-        references = [reference(file, feature, scenario)]
-        add_error(references, MESSAGE % characters)
+        add_issue(
+          I18n.t('linters.too_clumsy', length: characters), feature, scenario
+        )
       end
     end
   end

data/lib/chutney/linter/too_long_step.rb

@@ -1,29 +1,19 @@
-require 'chutney/linter'
-
-# rubocop:disable Lint/MissingCopEnableDirective
 module Chutney
   # service class to lint for too long steps
   class TooLongStep < Linter
-    
-    def initialize
-      @maxlength = 80
-      super
-    end
-  
-    MESSAGE = 'This step is too long at %d characters'.freeze
-    
     def lint
-      steps do |file, feature, scenario, step|
-        next if step[:text].length <= @maxlength
+      steps do |feature, scenario, step|
+        next if step[:text].length <= maxlength
         
-        references = [reference(file, feature, scenario, step)]
-        add_error(references, MESSAGE % step[:text].length)
+        add_issue(
+          I18n.t('linters.too_long_step', length: step[:text].length, max: maxlength), 
+          feature, scenario
+        )
       end
     end
     
-    # rubocop:disable Style/TrivialAccessors
-    def maxlength(length)
-      @maxlength = length
+    def maxlength
+      configuration['MaxLength'] || '120'
     end
   end
 end

data/lib/chutney/linter/too_many_different_tags.rb

@@ -1,45 +1,24 @@
-require 'chutney/linter'
-require 'chutney/linter/tag_collector'
-
 module Chutney
   # service class to lint for too many different tags
   class TooManyDifferentTags < Linter
-    include TagCollector
-
     def lint
-      overall_tags = []
-      overall_references = []
-      features do |file, feature|
-        tags = tags_for_feature(feature)
-        overall_tags += tags
-        references = [reference(file, feature)]
-        overall_references += references unless tags.empty?
-        
-        warn_single_feature(references, tags)
-      end
-      warn_across_all_features(overall_references, overall_tags)
-    end
-
-    def warn_single_feature(references, tags)
-      tags.uniq!
-      references.uniq!
-      return false unless tags.length >= 3
+      tags = all_tags
+      return if tags.length <= maxcount
       
-      add_error(references, "Used #{tags.length} Tags within single Feature")
+      add_issue(
+        I18n.t('linters.too_many_different_tags', count: tags.length, max: maxcount), 
+        feature
+      )
     end
-
-    def warn_across_all_features(references, tags)
-      tags.uniq!
-      references.uniq!
-      return false unless tags.length >= 10
-      
-      add_error(references, "Used #{tags.length} Tags across all Features")
+    
+    def maxcount 
+      configuration['MaxCount']&.to_i || 3
     end
-
-    def tags_for_feature(feature)
-      return [] unless feature.include? :children
+    
+    def all_tags
+      return [] unless feature.include?(:children)
       
-      gather_tags(feature) + feature[:children].map { |scenario| gather_tags(scenario) }.flatten
+      tags_for(feature) + feature[:children].map { |scenario| tags_for(scenario) }.flatten
     end
   end
 end

data/lib/chutney/linter/too_many_steps.rb

@@ -1,15 +1,19 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for too many steps
   class TooManySteps < Linter
     def lint
-      filled_scenarios do |file, feature, scenario|
-        next if scenario[:steps].length < 10
+      filled_scenarios do |feature, scenario|
+        next if scenario[:steps].length <= maxcount
         
-        references = [reference(file, feature, scenario)]
-        add_error(references, "Scenario is too long at #{scenario[:steps].length} steps")
+        add_issue(
+          I18n.t('linters.too_many_steps', count: scenario[:steps].length, max: maxcount), 
+          feature
+        )
       end
     end
+    
+    def maxcount
+      configuration['MaxCount']&.to_i || 10
+    end
   end
 end

data/lib/chutney/linter/too_many_tags.rb

@@ -1,19 +1,20 @@
-require 'chutney/linter'
-require 'chutney/linter/tag_collector'
-
 module Chutney
   # service class to lint for too many tags
   class TooManyTags < Linter
-    include TagCollector
-
     def lint
-      scenarios do |file, feature, scenario|
-        tags = gather_tags(feature) + gather_tags(scenario)
-        next unless tags.length >= 3
+      scenarios do |feature, scenario|
+        tags = tags_for(feature) + tags_for(scenario)
+        next unless tags.length > maxcount
         
-        references = [reference(file, feature, scenario)]
-        add_error(references, "Used #{tags.length} Tags")
+        add_issue(
+          I18n.t('linters.too_many_tags', count: tags.length, max: maxcount), 
+          feature
+        )
       end
     end
+    
+    def maxcount
+      configuration['MaxCount']&.to_i || 3
+    end
   end
 end

data/lib/chutney/linter/unique_scenario_names.rb

@@ -1,22 +1,28 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for unique scenario names
   class UniqueScenarioNames < Linter
     def lint
-      references_by_name = Hash.new []
-      scenarios do |file, feature, scenario|
+      references_by_name = {}
+      scenarios do |feature, scenario|
         next unless scenario.key? :name
-        
-        scenario_name = "#{feature[:name]}.#{scenario[:name]}"
-        references_by_name[scenario_name] = references_by_name[scenario_name] + [reference(file, feature, scenario)]
-      end
-      
-      references_by_name.each do |name, references|
-        next if references.length <= 1
-        
-        add_error(references, "Scenario name should be unique, '#{name}' used #{references.length} times")
+
+        name = scenario[:name]
+        if references_by_name[name]
+          issue(name, references_by_name[name], scenario)
+        else
+          references_by_name[name] = location(feature, scenario, nil)
+        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]), 
+        feature, scenario
+      )
+    end
   end
 end

data/lib/chutney/linter/unknown_variable.rb

@@ -1,17 +1,16 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for unknown variables
   class UnknownVariable < Linter
     def lint
-      filled_scenarios do |file, feature, scenario|
-        known_vars = Set.new known_variables scenario
+      filled_scenarios do |feature, scenario|
+        known_vars = Set.new(known_variables(scenario))
         scenario[:steps].each do |step|
           step_vars(step).each do |used_var|
             next if known_vars.include? used_var
             
-            references = [reference(file, feature, scenario)]
-            add_error(references, "Variable '<#{used_var}>' is unknown")
+            add_issue(
+              I18n.t('linters.unknown_variable', variable: used_var), feature, scenario
+            )
           end
         end
       end

data/lib/chutney/linter/unused_variable.rb

@@ -1,18 +1,17 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for unused variables
   class UnusedVariable < Linter
     def lint
-      scenarios do |file, feature, scenario|
-        next unless scenario.key? :examples
+      scenarios do |feature, scenario|
+        next unless scenario.key?(:examples)
         
         scenario[:examples].each do |example|
-          next unless example.key? :tableHeader
+          next unless example.key?(:tableHeader)
           
           example[:tableHeader][:cells].map { |cell| cell[:value] }.each do |variable|
-            references = [reference(file, feature, scenario)]
-            add_error(references, "Variable '<#{variable}>' is unused") unless used?(variable, scenario)
+            next if used?(variable, scenario)
+
+            add_issue(I18n.t('linters.unused_variable', variable: variable), feature, scenario, example)
           end
         end
       end

data/lib/chutney/linter/use_background.rb

@@ -1,36 +1,18 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for using background
   class UseBackground < Linter
     def lint
-      features do |file, feature|
-        next if scenarios_with_steps(feature) <= 1
-        
-        givens = gather_givens feature
-        next if givens.nil?
-        next if givens.length <= 1
-        next if givens.uniq.length > 1
-        
-        references = [reference(file, feature)]
-        add_error(references, "Step '#{givens.uniq.first}' should be part of background")
-      end
-    end
+      return unless filled_scenarios.count > 1
 
-    def scenarios_with_steps(feature)
-      scenarios = 0
-      return 0 unless feature.key? :children
-      
-      feature[:children].each do |scenario|
-        next unless scenario.include? :steps
-        next if scenario[:steps].empty?
-        
-        scenarios += 1
-      end
-      scenarios
+      givens = gather_givens
+      return if givens.nil?
+      return if givens.length <= 1
+      return if givens.uniq.length > 1
+
+      add_issue(I18n.t('linters.use_background', step: givens.uniq.first), feature)
     end
 
-    def gather_givens(feature)
+    def gather_givens
       return unless feature.include? :children
       
       has_non_given_step = false
@@ -38,16 +20,16 @@ module Chutney
         next unless scenario.include? :steps
         next if scenario[:steps].empty?
         
-        has_non_given_step = true unless scenario[:steps].first[:keyword] == 'Given '
+        has_non_given_step = true unless given_word?(scenario[:steps].first[:keyword])
       end
       return if has_non_given_step
 
       result = []
-      expanded_steps(feature) { |given| result.push given }
+      expanded_steps { |given| result.push given }
       result
     end
 
-    def expanded_steps(feature)
+    def expanded_steps
       feature[:children].each do |scenario|
         next unless scenario[:type] != :Background
         next unless scenario.include? :steps