chutney 0.5.0

data/lib/chutney/linter/file_name_differs_feature_name.rb

@@ -0,0 +1,27 @@
+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
+        
+        expected_feature_name = title_case file
+        next 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
+    end
+
+    def title_case(value)
+      value = File.basename(value, '.feature')
+      value.split('_').collect(&:capitalize).join(' ')
+    end
+
+    def ignore_whitespaces(value)
+      value.delete('-').delete('_').delete(' ')
+    end
+  end
+end

data/lib/chutney/linter/invalid_file_name.rb

@@ -0,0 +1,16 @@
+require 'chutney/linter'
+
+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')
+      end
+    end
+  end
+end

data/lib/chutney/linter/invalid_step_flow.rb

@@ -0,0 +1,41 @@
+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 ' }
+        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)
+      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 '
+    end
+
+    def given_after_non_given(file, 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 '
+        last_step = step
+      end
+    end
+
+    def verification_before_action(file, feature, scenario, steps)
+      steps.each do |step|
+        break if step[:keyword] == 'When '
+        
+        references = [reference(file, feature, scenario, step)]
+        add_error(references, 'Missing Action step') if step[:keyword] == 'Then '
+      end
+    end
+  end
+end

data/lib/chutney/linter/missing_example_name.rb

@@ -0,0 +1,23 @@
+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
+        
+        scenario[:examples].each do |example|
+          name = example.key?(:name) ? example[:name].strip : ''
+          next unless name.empty?
+          
+          references = [reference(file, feature, scenario)]
+          add_error(references, MESSAGE)
+        end
+      end
+    end
+  end
+end

data/lib/chutney/linter/missing_feature_description.rb

@@ -0,0 +1,17 @@
+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
+    end
+  end
+end

data/lib/chutney/linter/missing_feature_name.rb

@@ -0,0 +1,18 @@
+require 'chutney/linter'
+
+module Chutney
+  # service class to lint for missing feature names
+  class MissingFeatureName < Linter
+    MESSAGE = 'All features should have a name'.freeze
+    
+    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
+    end
+  end
+end

data/lib/chutney/linter/missing_scenario_name.rb

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

data/lib/chutney/linter/missing_test_action.rb

@@ -0,0 +1,16 @@
+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 ' }
+        next unless when_steps.empty?
+        
+        references = [reference(file, feature, scenario)]
+        add_error(references, 'No \'When\'-Step')
+      end
+    end
+  end
+end

data/lib/chutney/linter/missing_verification.rb

@@ -0,0 +1,16 @@
+require 'chutney/linter'
+
+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 ' }
+        next unless then_steps.empty?
+        
+        references = [reference(file, feature, scenario)]
+        add_error(references, 'No \'Then\' step')
+      end
+    end
+  end
+end

data/lib/chutney/linter/required_tags_starts_with.rb

@@ -0,0 +1,16 @@
+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 match_pattern?(target)
+      target.each do |t|
+        return true if t.delete!('@').start_with?(*@pattern)
+      end
+      false
+    end
+  end
+end

data/lib/chutney/linter/same_tag_for_all_scenarios.rb

@@ -0,0 +1,73 @@
+require 'chutney/linter'
+
+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
+    end
+
+    def lint_scenarios(file, feature)
+      tags = gather_same_tags feature
+      return if tags.nil?
+      return if tags.empty?
+      return unless feature[:children].length > 1
+      
+      references = [reference(file, feature)]
+      tags.each do |tag|
+        next if tag == '@skip'
+
+        add_error(references, "Tag '#{tag}' should be used at Feature level")
+      end
+    end
+
+    def lint_examples(file, feature)
+      feature[:children].each do |scenario|
+        tags = gather_same_tags_for_outline 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'
+
+          add_error(references, "Tag '#{tag}' should be used at Scenario Outline level")
+        end
+      end
+    end
+
+    def gather_same_tags(feature)
+      result = nil
+      feature[:children].each do |scenario|
+        next if scenario[:type] == :Background
+        return nil unless scenario.include? :tags
+        
+        tags = scenario[:tags].map { |tag| tag[:name] }
+        result = tags if result.nil?
+        
+        result &= tags
+      end
+      result
+    end
+
+    def gather_same_tags_for_outline(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] }
+        result = tags if result.nil?
+        
+        result &= tags
+      end
+      result
+    end
+  end
+end

data/lib/chutney/linter/tag_collector.rb

@@ -0,0 +1,10 @@
+module Chutney
+  # Mixin to lint for tags based on their relationship to eachother
+  module TagCollector
+    def gather_tags(element)
+      return [] unless element.include? :tags
+      
+      element[:tags].map { |tag| tag[:name][1..-1] }
+    end
+  end
+end

data/lib/chutney/linter/tag_constraint.rb

@@ -0,0 +1,35 @@
+module Chutney
+  # Mixin to lint for tags that have certain string contraints
+  module TagConstraint
+    def lint
+      scenarios do |file, feature, scenario|
+        next if match_pattern? tags(feature)
+        next if match_pattern? tags(scenario)
+        
+        references = [reference(file, feature, scenario)]
+        add_error(references, 'Required Tag not found')
+      end
+    end
+
+    def tags(element)
+      return [] unless element.include? :tags
+      
+      element[:tags].map { |a| a[:name] }
+    end
+
+    def matcher(pattern)
+      @pattern = pattern
+      validate_input
+    end
+
+    def match_pattern?(_tags)
+      raise NoMethodError, 'This is an abstraction that must be implemented by the includer'
+    end
+
+    def validate_input
+      raise 'No Tags provided in the YAML' if @pattern.nil?
+      
+      warn 'Required Tags matcher has no value' if @pattern.empty?
+    end
+  end
+end

data/lib/chutney/linter/tag_used_multiple_times.rb

@@ -0,0 +1,23 @@
+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)
+        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")
+      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

@@ -0,0 +1,17 @@
+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|
+        characters = scenario[:steps].map { |step| step[:text].length }.inject(0, :+)
+        next if characters < 400
+        
+        references = [reference(file, feature, scenario)]
+        add_error(references, MESSAGE % characters)
+      end
+    end
+  end
+end

data/lib/chutney/linter/too_long_step.rb

@@ -0,0 +1,17 @@
+require 'chutney/linter'
+
+module Chutney
+  # service class to lint for too long steps
+  class TooLongStep < Linter
+    MESSAGE = 'This step is too long at %d characters'.freeze
+    
+    def lint
+      steps do |file, feature, scenario, step|
+        next if step[:text].length < 80
+        
+        references = [reference(file, feature, scenario, step)]
+        add_error(references, MESSAGE % step[:text].length)
+      end
+    end
+  end
+end

data/lib/chutney/linter/too_many_different_tags.rb

@@ -0,0 +1,45 @@
+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
+      
+      add_error(references, "Used #{tags.length} Tags within single 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")
+    end
+
+    def tags_for_feature(feature)
+      return [] unless feature.include? :children
+      
+      gather_tags(feature) + feature[:children].map { |scenario| gather_tags(scenario) }.flatten
+    end
+  end
+end

data/lib/chutney/linter/too_many_steps.rb

@@ -0,0 +1,15 @@
+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
+        
+        references = [reference(file, feature, scenario)]
+        add_error(references, "Scenario is too long at #{scenario[:steps].length} steps")
+      end
+    end
+  end
+end

data/lib/chutney/linter/too_many_tags.rb

@@ -0,0 +1,19 @@
+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
+        
+        references = [reference(file, feature, scenario)]
+        add_error(references, "Used #{tags.length} Tags")
+      end
+    end
+  end
+end

data/lib/chutney/linter/unique_scenario_names.rb

@@ -0,0 +1,22 @@
+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|
+        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")
+      end
+    end
+  end
+end

data/lib/chutney/linter/unknown_variable.rb

@@ -0,0 +1,47 @@
+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
+        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")
+          end
+        end
+      end
+    end
+
+    def step_vars(step)
+      vars = gather_vars step[:text]
+      return vars unless step.include? :argument
+      
+      vars + gather_vars_from_argument(step[:argument])
+    end
+
+    def gather_vars_from_argument(argument)
+      return gather_vars argument[:content] if argument[:type] == :DocString
+      
+      (argument[:rows] || []).map do |row|
+        row[:cells].map { |value| gather_vars value[:value] }.flatten
+      end.flatten
+    end
+
+    def gather_vars(string)
+      string.scan(/<.+?>/).map { |val| val[1..-2] }
+    end
+
+    def known_variables(scenario)
+      (scenario[:examples] || []).map do |example|
+        next unless example.key? :tableHeader
+        
+        example[:tableHeader][:cells].map { |cell| cell[:value].strip }
+      end.flatten
+    end
+  end
+end

data/lib/chutney/linter/unused_variable.rb

@@ -0,0 +1,47 @@
+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
+        
+        scenario[:examples].each do |example|
+          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)
+          end
+        end
+      end
+    end
+
+    def used?(variable, scenario)
+      variable = "<#{variable}>"
+      return false unless scenario.key? :steps
+      
+      scenario[:steps].each do |step|
+        return true if step[:text].include? variable
+        next unless step.include? :argument
+        return true if used_in_docstring?(variable, step)
+        return true if used_in_table?(variable, step)
+      end
+      false
+    end
+
+    def used_in_docstring?(variable, step)
+      step[:argument][:type] == :DocString && step[:argument][:content].include?(variable)
+    end
+
+    def used_in_table?(variable, step)
+      return false unless step[:argument][:type] == :DataTable
+      
+      step[:argument][:rows].each do |row|
+        row[:cells].each { |value| return true if value[:value].include?(variable) }
+      end
+      false
+    end
+  end
+end

data/lib/chutney/linter/use_background.rb

@@ -0,0 +1,82 @@
+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
+
+    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
+    end
+
+    def gather_givens(feature)
+      return unless feature.include? :children
+      
+      has_non_given_step = false
+      feature[:children].each do |scenario|
+        next unless scenario.include? :steps
+        next if scenario[:steps].empty?
+        
+        has_non_given_step = true unless scenario[:steps].first[:keyword] == 'Given '
+      end
+      return if has_non_given_step
+
+      result = []
+      expanded_steps(feature) { |given| result.push given }
+      result
+    end
+
+    def expanded_steps(feature)
+      feature[:children].each do |scenario|
+        next unless scenario[:type] != :Background
+        next unless scenario.include? :steps
+        next if scenario[:steps].empty?
+        
+        prototypes = [render_step(scenario[:steps].first)]
+        prototypes = expand_examples(scenario[:examples], prototypes) if scenario.key? :examples
+        prototypes.each { |prototype| yield prototype }
+      end
+    end
+
+    def expand_examples(examples, prototypes)
+      examples.each do |example|
+        prototypes = prototypes.map { |prototype| expand_outlines(prototype, example) }.flatten
+      end
+      prototypes
+    end
+
+    def expand_outlines(sentence, example)
+      result = []
+      headers = example[:tableHeader][:cells].map { |cell| cell[:value] }
+      example[:tableBody].each do |row| # .slice(1, example[:tableBody].length).each do |row|
+        modified_sentence = sentence.dup
+        headers.zip(row[:cells].map { |cell| cell[:value] }).map do |key, value|
+          modified_sentence.gsub!("<#{key}>", value)
+        end
+        result.push modified_sentence
+      end
+      result
+    end
+  end
+end