chutney 0.5.0

data/lib/chutney/linter/use_outline.rb

@@ -0,0 +1,53 @@
+require 'amatch'
+require 'chutney/linter'
+
+module Chutney
+  # service class to lint for using outline
+  class UseOutline < Linter
+    def lint
+      features do |file, feature|
+        check_similarity gather_scenarios(file, feature)
+      end
+    end
+
+    def check_similarity(scenarios)
+      scenarios.product(scenarios) do |lhs, rhs|
+        next if lhs == rhs
+        next if lhs[:reference] > rhs[:reference]
+        
+        similarity = determine_similarity(lhs[:text], rhs[:text])
+        next unless similarity >= 0.95
+        
+        similarity_pct = similarity.round(3) * 100
+        references = [lhs[:reference], rhs[:reference]]
+        add_error(references, "Scenarios are similar by #{similarity_pct} %, use Background steps to simplify")
+      end
+    end
+
+    def determine_similarity(lhs, rhs)
+      matcher = Amatch::Jaro.new lhs
+      matcher.match rhs
+    end
+
+    def gather_scenarios(file, feature)
+      scenarios = []
+      return scenarios unless feature.include? :children
+      
+      feature[:children].each do |scenario|
+        next unless scenario[:type] == :Scenario
+        next unless scenario.include? :steps
+        next if scenario[:steps].empty?
+        
+        scenarios.push generate_reference(file, feature, scenario)
+      end
+      scenarios
+    end
+
+    def generate_reference(file, feature, scenario)
+      reference = {}
+      reference[:reference] = reference(file, feature, scenario)
+      reference[:text] = scenario[:steps].map { |step| render_step(step) }.join ' '
+      reference
+    end
+  end
+end

data/lib/chutney/linter.rb

@@ -0,0 +1,164 @@
+require 'chutney/issue'
+
+# gherkin utilities
+module Chutney
+  # base class for all linters
+  class Linter
+    attr_reader :issues
+
+    def self.descendants
+      ObjectSpace.each_object(::Class).select { |klass| klass < self }
+    end
+
+    def initialize
+      @issues = []
+      @files = {}
+    end
+
+    def features
+      @files.each do |file, content|
+        feature = content[:feature]
+        next if feature.nil?
+        
+        yield(file, feature)
+      end
+    end
+
+    def files
+      @files.each_key { |file| yield file }
+    end
+
+    def scenarios
+      elements do |file, feature, scenario|
+        next if scenario[:type] == :Background
+        
+        yield(file, feature, scenario)
+      end
+    end
+
+    def filled_scenarios
+      scenarios do |file, feature, scenario|
+        next unless scenario.include? :steps
+        next if scenario[:steps].empty?
+        
+        yield(file, feature, scenario)
+      end
+    end
+
+    def steps
+      elements do |file, feature, scenario|
+        next unless scenario.include? :steps
+        
+        scenario[:steps].each { |step| yield(file, feature, scenario, step) }
+      end
+    end
+
+    def backgrounds
+      elements do |file, feature, scenario|
+        next unless scenario[:type] == :Background
+        
+        yield(file, feature, scenario)
+      end
+    end
+
+    def elements
+      @files.each do |file, content|
+        feature = content[:feature]
+        next if feature.nil?
+        next unless feature.key? :children
+        
+        feature[:children].each do |scenario|
+          yield(file, feature, scenario)
+        end
+      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)
+      end
+      result
+    end
+
+    def suppress(data, tags)
+      data.reject { |item| tags.map { |tag| "@#{tag}" }.include? item[:name] }
+    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)
+    end
+
+    def render_step(step)
+      value = "#{step[:keyword]}#{step[:text]}"
+      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
+      
+      result = argument[:rows].map do |row|
+        "|#{row[:cells].map { |cell| cell[:value] }.join '|'}|"
+      end.join "\n"
+      "\n#{result}"
+    end
+  end
+end

data/lib/chutney/version.rb

@@ -0,0 +1,3 @@
+module Chutney
+  VERSION = '0.5.0'.freeze
+end

data/lib/chutney.rb

@@ -0,0 +1,131 @@
+require 'gherkin/parser'
+require 'chutney/linter'
+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/invalid_file_name'
+require 'chutney/linter/invalid_step_flow'
+require 'chutney/linter/missing_example_name'
+require 'chutney/linter/missing_feature_description'
+require 'chutney/linter/missing_feature_name'
+require 'chutney/linter/missing_scenario_name'
+require 'chutney/linter/missing_test_action'
+require 'chutney/linter/missing_verification'
+require 'chutney/linter/required_tags_starts_with'
+require 'chutney/linter/same_tag_for_all_scenarios'
+require 'chutney/linter/tag_used_multiple_times'
+require 'chutney/linter/too_clumsy'
+require 'chutney/linter/too_long_step'
+require 'chutney/linter/too_many_different_tags'
+require 'chutney/linter/too_many_steps'
+require 'chutney/linter/too_many_tags'
+require 'chutney/linter/unique_scenario_names'
+require 'chutney/linter/unknown_variable'
+require 'chutney/linter/unused_variable'
+require 'chutney/linter/use_background'
+require 'chutney/linter/use_outline'
+require 'multi_json'
+require 'set'
+require 'chutney/configuration'
+
+module Chutney
+  # gherkin linter
+  class ChutneyLint
+    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
+    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
+      end
+    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
+    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)
+      end
+    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
+    end
+
+    def disable_tags
+      LINTER.map { |lint| "disable#{lint.new.class.name.split('::').last}" }
+    end
+
+    def to_json(input)
+      parser = Gherkin::Parser.new
+      scanner = Gherkin::TokenScanner.new input
+
+      parser.parse(scanner)
+    end
+
+    def print(issues)
+      puts 'There are no issues' if issues.empty? && @verbose
+      issues.each { |issue| puts issue.render }
+    end
+  end
+end

data/spec/chutney_spec.rb

@@ -0,0 +1,68 @@
+require 'rspec'
+require 'chutney'
+require 'chutney/linter/tag_constraint'
+require 'shared_contexts/file_exists'
+
+describe Chutney::ChutneyLint do
+  it 'should have the constant set' do
+    expect(Chutney::ChutneyLint.const_defined?(:LINTER)).to be true
+  end
+
+  subject { Chutney::ChutneyLint.new }
+
+  describe '#initialize' do
+    it 'sets the files instance variable to empty' do
+      expect(subject.instance_variable_get(:@files)).to eq({})
+    end
+
+    it 'sets the linter instance variable to empty' do
+      expect(subject.instance_variable_get(:@linter).size).to eq(0)
+    end
+  end
+
+  describe '#enable' do
+    it 'enables the linter passed in' do
+      subject.enable ['RequiredTagsStartsWith']
+      expect(subject.instance_variable_get(:@config).config).to include('RequiredTagsStartsWith' => { 'Enabled' => true })
+    end
+  end
+
+  context 'when user configuration is not present' do
+    let(:file) { 'config/default.yml' }
+    it 'should load the expected values from the config file' do
+      expect(subject.instance_variable_get(:@config).config).to include('AvoidOutlineForSingleExample' => { 'Enabled' => true })
+    end
+  end
+
+  context 'when user provided YAML is present' do
+    include_context 'a file exists'
+    let(:file) { '.chutney.yml' }
+    let(:file_content) do
+      <<-CONTENT
+---
+AvoidOutlineForSingleExample:
+    Enabled: false
+      CONTENT
+    end
+    it 'should load and merge the expected values from the user config file' do
+      expect(subject.instance_variable_get(:@config).config).to include('AvoidOutlineForSingleExample' => { 'Enabled' => false })
+    end
+  end
+
+  context 'when linter member value is passed by the user' do
+    include_context 'a file exists'
+    let(:file) { '.chutney.yml' }
+    let(:file_content) do
+      <<-CONTENT
+---
+RequiredTags:
+    Enabled: true
+    Member: Value
+      CONTENT
+    end
+
+    it 'updates the member in the config' do
+      expect(subject.instance_variable_get(:@config).config).to include('RequiredTags' => { 'Enabled' => true, 'Member' => 'Value' })
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,58 @@
+require 'rspec'
+require 'chutney/configuration'
+require 'shared_contexts/file_exists'
+
+describe Chutney::Configuration do
+  subject { Chutney::Configuration.new file }
+  let(:file) { 'default.yml' }
+
+  it 'should do something' do
+    expect(subject.config).to eq('')
+  end
+
+  it 'should have a default config path' do
+    expect(subject.configuration_path).not_to be nil
+  end
+  context 'when a empty config file is present' do
+    include_context 'a file exists'
+    let(:file_content) { '---' }
+    it 'should load a file from the config path' do
+      expect(subject.config).to eq ''
+    end
+  end
+
+  context 'when a non-YAML config file is present' do
+    include_context 'a file exists'
+    let(:file_content) do
+      <<-CONTENT
+      foo: [
+        ‘bar’, {
+          baz: 42
+         }
+      ]'
+      CONTENT
+    end
+
+    it 'should load a file from the config path but fail to parse' do
+      expect { subject.load_configuration }.to raise_error
+      expect { subject.config }.to raise_error
+    end
+  end
+  context 'when a valid YAML file is present' do
+    include_context 'a file exists'
+    let(:file_content) do
+      <<-CONTENT
+---
+:parent_key: parent_value
+:child_key: child_value
+      CONTENT
+    end
+    before :each do
+      subject.load_configuration
+    end
+
+    it 'should load the values from the config file' do
+      expect(subject.config).to eq(parent_key: 'parent_value', child_key: 'child_value')
+    end
+  end
+end

data/spec/required_tags_starts_with_spec.rb

@@ -0,0 +1,74 @@
+require 'rspec'
+require 'chutney/linter/required_tags_starts_with'
+require 'chutney'
+require 'shared_contexts/gherkin_linter'
+
+describe Chutney::RequiredTagsStartsWith do
+  let(:linter) { Chutney::ChutneyLint.new }
+  let(:file) { 'lint.feature' }
+  let(:pattern) { %w[MCC PB] }
+  describe '#matcher' do
+    it 'should raise an error when pattern is nil' do
+      expect { subject.matcher(nil) }.to raise_error('No Tags provided in the YAML')
+    end
+    it 'should raise an error when pattern is empty' do
+      expect { subject.matcher('') }.to output("Required Tags matcher has no value\n").to_stderr
+    end
+  end
+
+  describe '#issues' do
+    context 'before linting' do
+      it 'should have no issue' do
+        expect(subject.issues.size).to eq(0)
+      end
+    end
+
+    context 'after linting a feature file with valid PB tag at the feature level' do
+      include_context 'a gherkin linter'
+
+      let(:file_content) do
+        <<-CONTENT
+      @PB
+      Feature: Test
+        @scenario_tag
+        Scenario: A
+        CONTENT
+      end
+      it 'should have no issues' do
+        expect(subject.issues.size).to eq(0)
+      end
+    end
+
+    context 'after linting a file with a MCC tag at the scenario level' do
+      include_context 'a gherkin linter'
+      let(:file_content) do
+        <<-CONTENT
+      @feature_tag
+      Feature: Test
+        @MCC
+        Scenario: A
+        CONTENT
+      end
+
+      it 'should have no issues' do
+        expect(subject.issues.size).to eq(0)
+      end
+    end
+
+    context 'after linting a file with no required tags' do
+      include_context 'a gherkin linter'
+      let(:file_content) do
+        <<-CONTENT
+      @feature_tag
+      Feature: Test
+        @scenario_tag
+        Scenario: A
+        CONTENT
+      end
+
+      it 'should have issues after linting a file without PB or MCC tags' do
+        expect(subject.issues[0].name).to eq(subject.class.name.split('::').last)
+      end
+    end
+  end
+end

data/spec/shared_contexts/file_exists.rb

@@ -0,0 +1,12 @@
+# needs file and file_content defined
+shared_context 'a file exists' do
+  before :each do
+    File.open(file, 'w') do |f|
+      f.write file_content
+    end
+  end
+
+  after :each do
+    File.delete(file) if File.exist?(file)
+  end
+end

data/spec/shared_contexts/gherkin_linter.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+require_relative 'file_exists'
+
+shared_context 'a gherkin linter' do
+  include_context 'a file exists'
+
+  let(:files) { linter.analyze file }
+  let(:disable_tags) { linter.disable_tags }
+
+  before :each do
+    subject.instance_variable_set(:@pattern, pattern)
+    subject.lint_files({ file: files }, disable_tags)
+  end
+end