chutney 1.6.3 → 2.0.0.rc1

data/lib/chutney/linter/avoid_full_stop.rb

@@ -0,0 +1,12 @@
+module Chutney
+  # service class to lint for avoiding periods
+  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? '.'
+        
+      end
+    end
+  end
+end

data/lib/chutney/linter/avoid_outline_for_single_example.rb

@@ -1,18 +1,15 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for avoiding outline for single example
   class AvoidOutlineForSingleExample < Linter
     def lint
-      scenarios do |file, feature, scenario|
+      scenarios do |feature, scenario|
         next unless scenario[:type] == :ScenarioOutline
 
         next unless scenario.key? :examples
         next if scenario[:examples].length > 1
         next if scenario[:examples].first[:tableBody].length > 1
-
-        references = [reference(file, feature, scenario)]
-        add_error(references, 'You have a Scenarion Outline with a single example - rewrite to use a Scenario')
+        
+        add_issue(I18n.t('linters.avoid_outline_for_single_example'), feature, scenario)
       end
     end
   end

data/lib/chutney/linter/avoid_scripting.rb

@@ -1,24 +1,19 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for avoid scripting
-  class AvoidScripting < Linter
-    MESSAGE = "You have multiple (%d) 'When' actions in your steps - you should only have one".freeze
-  
+  class AvoidScripting < Linter  
     def lint
-      filled_scenarios do |file, feature, scenario|
-        steps = filter_when_steps scenario[:steps]
-        next if steps.length <= 1
-        
-        references = [reference(file, feature, scenario)]
-        add_error(references, MESSAGE % steps.length)
+      scenarios do |feature, scenario|
+        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 = steps.drop_while { |step| step[:keyword] != 'When ' }
-      steps = steps.reverse.drop_while { |step| step[:keyword] != 'Then ' }.reverse
-      steps.reject { |step| step[:keyword] == 'Then ' }
+      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]) } }
     end
   end
 end

data/lib/chutney/linter/background_does_more_than_setup.rb

@@ -1,19 +1,16 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for background that does more than setup
-  class BackgroundDoesMoreThanSetup < Linter
-    MESSAGE = 'A Feature\'s Background should just contain \'Given\' steps'.freeze
-   
+  class BackgroundDoesMoreThanSetup < Linter   
     def lint
-      backgrounds do |file, feature, background|
+      background do |feature, background|
         next unless background.key? :steps
         
-        invalid_steps = background[:steps].select { |step| step[:keyword] == 'When ' || step[:keyword] == 'Then ' }
+        invalid_steps = background[:steps].select do |step| 
+          when_word?(step[:keyword]) || then_word?(step[:keyword])
+        end
         next if invalid_steps.empty?
-        
-        references = [reference(file, feature, background, invalid_steps[0])]
-        add_error(references, MESSAGE)
+
+        add_issue(I18n.t('linters.background_does_more_than_setup'), feature, background)
       end
     end
   end

data/lib/chutney/linter/background_requires_multiple_scenarios.rb

@@ -6,12 +6,11 @@ module Chutney
     MESSAGE = 'Avoid using Background steps for just one scenario'.freeze
   
     def lint
-      backgrounds do |file, feature, background|
+      background do |feature, background|
         scenarios = feature[:children].reject { |element| element[:type] == :Background }
         next if scenarios.length >= 2
 
-        references = [reference(file, feature, background)]
-        add_error(references, MESSAGE)
+        add_issue(I18n.t('linters.background_requires_multiple_scenarios'), feature, background)
       end
     end
   end

data/lib/chutney/linter/bad_scenario_name.rb

@@ -1,20 +1,13 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for bad scenario names  
   class BadScenarioName < Linter
-    MESSAGE = 'You should avoid using words like \'test\', \'check\' or \'verify\' ' \
-      'when naming your scenarios to keep them understandable'.freeze
-      
     def lint
-      scenarios do |file, feature, scenario|
+      scenarios do |feature, scenario|
         next if scenario[:name].empty?
         
-        references = [reference(file, feature, scenario)]
-        bad_words = %w[test verif check]
-        bad_words.each do |bad_word|
-          add_error(references, MESSAGE) if scenario[:name].downcase.include? bad_word
-        end
+        bad = /\w*(test|verif|check)\w*/i
+        match = scenario[:name].match(bad).to_a.first
+        add_issue(I18n.t('linters.bad_scenario_name', word: match), feature, scenario) if match
       end
     end
   end

data/lib/chutney/linter/file_name_differs_feature_name.rb

@@ -1,22 +1,17 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for file name differs feature name
   class FileNameDiffersFeatureName < Linter
     def lint
-      features do |file, feature|
-        next unless feature.include? :name
+      return unless feature.include? :name
         
-        expected_feature_name = title_case file
-        next if ignore_whitespaces(feature[:name]).casecmp(ignore_whitespaces(expected_feature_name)) == 0
+      expected_feature_name = title_case(filename)
+      return if ignore_whitespaces(feature[:name]).casecmp(ignore_whitespaces(expected_feature_name)) == 0
         
-        references = [reference(file, feature)]
-        add_error(references, "Feature name should be '#{expected_feature_name}'")
-      end
+      add_issue(I18n.t('linters.file_name_differs_feature_name', expected: expected_feature_name), feature) 
     end
 
     def title_case(value)
-      value = File.basename(value, '.feature')
+      value = File.basename(value, '.*')
       value.split('_').collect(&:capitalize).join(' ')
     end
 

data/lib/chutney/linter/givens_after_background.rb

@@ -0,0 +1,17 @@
+module Chutney
+  # service class to lint for bad scenario names  
+  class GivensAfterBackground < Linter
+    def lint
+      return if background.nil?
+      return if background.empty?
+      
+      filled_scenarios do |feature, scenario|
+        scenario[:steps].each do |step|
+          if given_word?(step[:keyword])
+            add_issue(I18n.t('linters.givens_after_background'), feature, scenario, step)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chutney/linter/invalid_file_name.rb

@@ -4,13 +4,21 @@ module Chutney
   # service class to lint for invalid file names
   class InvalidFileName < Linter
     def lint
-      files do |file|
-        base = File.basename file
-        next unless base != base.downcase || base =~ /[ -]/
-        
-        references = [reference(file)]
-        add_error(references, 'Feature files should be snake_cased')
+      feature do |f|
+        base = File.basename(filename, '.*')
+        if base != base.downcase || base =~ /[ -]/
+          add_issue(I18n.t('linters.invalid_file_name', recommended_name: recommend(filename)), f)
+        end
       end
     end
+    
+    def recommend(filename)
+      File.basename(filename, '.*').gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .tr(' ', '_')
+          .downcase << '.feature'
+    end
   end
 end

data/lib/chutney/linter/invalid_step_flow.rb

@@ -1,40 +1,40 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for invalid step flow
   class InvalidStepFlow < Linter
     def lint
-      filled_scenarios do |file, feature, scenario|
-        steps = scenario[:steps].select { |step| step[:keyword] != 'And ' && step[:keyword] != 'But ' }
+      filled_scenarios do |feature, scenario|
+        steps = scenario[:steps].select { |step| !and_word?(step[:keyword]) && !but_word?(step[:keyword]) }
         next if steps.empty?
         
-        last_step_is_an_action(file, feature, scenario, steps)
-        given_after_non_given(file, feature, scenario, steps)
-        verification_before_action(file, feature, scenario, steps)
+        last_step_is_an_action(feature, scenario, steps)
+        given_after_non_given(feature, scenario, steps)
+        verification_before_action(feature, scenario, steps)
       end
     end
 
-    def last_step_is_an_action(file, feature, scenario, steps)
-      references = [reference(file, feature, scenario, steps.last)]
-      add_error(references, 'Last step is an action') if steps.last[:keyword] == 'When '
+    def last_step_is_an_action(feature, scenario, steps)
+      return unless when_word?(steps.last[:keyword])
+
+      add_issue(I18n.t('linters.invalid_step_flow.action_last'), feature, scenario, steps.last)
     end
 
-    def given_after_non_given(file, feature, scenario, steps)
+    def given_after_non_given(feature, scenario, steps)
       last_step = steps.first
       steps.each do |step|
-        references = [reference(file, feature, scenario, step)]
-        description = 'Given after Action or Verification'
-        add_error(references, description) if step[:keyword] == 'Given ' && last_step[:keyword] != 'Given '
+        if given_word?(step[:keyword]) && !given_word?(last_step[:keyword])
+          add_issue(I18n.t('linters.invalid_step_flow.given_order'), feature, scenario, step)
+        end
         last_step = step
       end
     end
 
-    def verification_before_action(file, feature, scenario, steps)
+    def verification_before_action(feature, scenario, steps)
       steps.each do |step|
-        break if step[:keyword] == 'When '
+        break if when_word?(step[:keyword])
         
-        references = [reference(file, feature, scenario, step)]
-        add_error(references, 'Missing Action step') if step[:keyword] == 'Then '
+        if then_word?(step[:keyword])
+          add_issue(I18n.t('linters.invalid_step_flow.missing_action'), feature, scenario)
+        end
       end
     end
   end

data/lib/chutney/linter/missing_example_name.rb

@@ -1,23 +1,25 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for missing example names
   class MissingExampleName < Linter
-    MESSAGE = 'You have an unnamed or ambiguously named example'.freeze
   
     def lint
-      scenarios do |file, feature, scenario|
-        next unless scenario.key? :examples
-        next unless scenario[:examples].length > 1
-        
+      scenarios do |_feature, scenario|
+        next unless scenario[:examples]
+
         scenario[:examples].each do |example|
-          name = example.key?(:name) ? example[:name].strip : ''
-          next unless name.empty?
+          example_count = scenario[:examples]&.length || 0
+          next unless example_count > 1
           
-          references = [reference(file, feature, scenario)]
-          add_error(references, MESSAGE)
+          check_example(scenario, example)
         end
       end
+    end               
+
+    def check_example(scenario, example)
+      name = example.key?(:name) ? example[:name].strip : ''
+      duplicate_name_count = scenario[:examples].filter { |e| e[:name] == name }.count
+      add_issue(I18n.t('linters.missing_example_name'), feature, scenario, example) if duplicate_name_count >= 2
     end
+    
   end
 end

data/lib/chutney/linter/missing_feature_description.rb

@@ -1,17 +1,10 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for missing feature descriptions
   class MissingFeatureDescription < Linter
     MESSAGE = 'Features should have a description so that its purpose is clear'.freeze
     def lint
-      features do |file, feature|
-        name = feature.key?(:description) ? feature[:description].strip : ''
-        next unless name.empty?
-        
-        references = [reference(file, feature)]
-        add_error(references, MESSAGE)
-      end
+      name = feature.key?(:description) ? feature[:description].strip : ''
+      add_issue(I18n.t('linters.missing_feature_description'), feature) if name.empty?
     end
   end
 end

data/lib/chutney/linter/missing_feature_name.rb

@@ -1,18 +1,9 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for missing feature names
-  class MissingFeatureName < Linter
-    MESSAGE = 'All features should have a name'.freeze
-    
+  class MissingFeatureName < Linter    
     def lint
-      features do |file, feature|
-        name = feature.key?(:name) ? feature[:name].strip : ''
-        next unless name.empty?
-        
-        references = [reference(file, feature)]
-        add_error(references, MESSAGE)
-      end
+      name = feature.key?(:name) ? feature[:name].strip : ''
+      add_issue(I18n.t('linters.missing_feature_name'), feature) if name.empty?
     end
   end
 end

data/lib/chutney/linter/missing_scenario_name.rb

@@ -1,17 +1,13 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for missing scenario names
-  class MissingScenarioName < Linter
-    MESSAGE = 'All scenarios should have a name'.freeze
+  class MissingScenarioName < Linter  
   
     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.empty?
         
-        add_error(references, MESSAGE)
+        add_issue(I18n.t('linters.missing_scenario_name'), feature, scenario) if name.empty?
       end
     end
   end

data/lib/chutney/linter/missing_test_action.rb

@@ -1,15 +1,12 @@
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for missing test actions
   class MissingTestAction < Linter
     def lint
-      filled_scenarios do |file, feature, scenario|
-        when_steps = scenario[:steps].select { |step| step[:keyword] == 'When ' }
+      filled_scenarios do |feature, scenario|
+        when_steps = scenario[:steps].select { |step| when_word?(step[:keyword]) }
         next unless when_steps.empty?
         
-        references = [reference(file, feature, scenario)]
-        add_error(references, 'No \'When\'-Step')
+        add_issue(I18n.t('linters.missing_test_action'), feature, scenario)
       end
     end
   end

data/lib/chutney/linter/missing_verification.rb

@@ -4,12 +4,11 @@ module Chutney
   # service class to lint for missing verifications
   class MissingVerification < Linter
     def lint
-      filled_scenarios do |file, feature, scenario|
-        then_steps = scenario[:steps].select { |step| step[:keyword] == 'Then ' }
+      filled_scenarios do |feature, scenario|
+        then_steps = scenario[:steps].select { |step| then_word?(step[:keyword]) }
         next unless then_steps.empty?
         
-        references = [reference(file, feature, scenario)]
-        add_error(references, 'No \'Then\' step')
+        add_issue(I18n.t('linters.missing_test_verification'), feature, scenario)
       end
     end
   end

data/lib/chutney/linter/required_tags_starts_with.rb

@@ -1,14 +1,29 @@
-require 'chutney/linter/tag_constraint'
-require 'chutney/linter'
-
 module Chutney
   # service class to lint for tags used multiple times
   class RequiredTagsStartsWith < Linter
-    include TagConstraint
+        
+    def lint
+      return unless pattern
 
+      scenarios do |feature, scenario|
+        next if match_pattern? tags_for(feature)
+        next if match_pattern? tags_for(scenario)
+        
+        add_issue(
+          I18n.t('linters.required_tags_starts_with', 
+                 allowed: pattern.join(', ')), 
+          feature, scenario
+        )
+      end
+    end
+    
+    def pattern
+      configuration['Matcher'] || nil
+    end
+  
     def match_pattern?(target)
       target.each do |t|
-        return true if t.delete!('@').start_with?(*@pattern)
+        return true if t.start_with?(*pattern)
       end
       false
     end