cucumber 2.99.0 → 3.0.0

data/scripts/update-changelog

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+require 'octokit'
+
+class PullRequest
+  attr_reader :gh, :num
+
+  def initialize(gh, num)
+    @gh = gh
+    @num = num
+  end
+
+  def entry
+    pr = gh.pull_request('cucumber/cucumber-ruby', num)
+    username = pr['user']['login']
+    url = pr['html_url']
+    title = pr['title']
+    "#{title} ([##{num}](#{url}) [@#{username}](https://github.com/#{username}))"
+  end
+
+  def labels
+    gh.labels_for_issue('cucumber/cucumber-ruby', num).map { |label| label['name'] }
+  end
+
+  def type_label
+    types = labels.select { |label| label =~ /^type: / }
+    if types.empty?
+      raise('This pull request does not have a \'type\' label on it. Please add one.')
+    end
+
+    if types.length > 1
+      raise('This pull request has more than one \'type\' label on it. Please choose just one.')
+    end
+
+    types.first
+  end
+end
+
+class Changelog
+  def self.open(path, &block)
+    full_path = File.expand_path(File.dirname(__FILE__) + '/' + path + '/CHANGELOG.md')
+    log = new(File.read(full_path))
+    log.instance_exec(&block)
+    File.write(full_path, log.body)
+  end
+
+  attr_reader :lines
+
+  def initialize(body)
+    @lines = body.lines
+  end
+
+  def insert(label, entry)
+    section_index = lines.index { |line| line.strip == heading_for(label) }
+    unless section_index
+      raise("Unable to find matching heading in CHANGELOG.md for '#{label}' (#{heading_for(label)})")
+    end
+    lines.insert(section_index + 2, "* #{entry}\n")
+  end
+
+  def heading_for(label)
+    text = {
+      'type: new feature' => 'Added',
+      'type: bug' => 'Fixed',
+      'type: refactoring / developer experience' => 'Changed'
+    }.fetch(label)
+    "### #{text}"
+  end
+
+  def body
+    lines.join
+  end
+end
+
+begin
+  token = ENV['GITHUB_TOKEN'] || raise('You need to set GITHUB_TOKEN')
+  num = (ARGV[0] || raise("syntax: #{$0} <PULL-REQUEST-NUMBER>")).to_i
+
+  gh = Octokit::Client.new(access_token: token)
+  pr = PullRequest.new(gh, num)
+
+  Changelog.open('..') do
+    insert(pr.type_label, pr.entry)
+  end
+rescue StandardError => error
+  abort error.message
+end

data/spec/cucumber/cli/configuration_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'yaml'
 
@@ -37,7 +38,7 @@ module Cli
 
     attr_reader :out, :error
 
-    it "uses the default profile when no profile is defined" do
+    it 'uses the default profile when no profile is defined' do
       given_cucumber_yml_defined_as({'default' => '--require some_file'})
 
       config.parse!(%w{--format progress})
@@ -48,16 +49,16 @@ module Cli
     context '--profile' do
       include RSpec::WorkInProgress
 
-      it "expands args from profiles in the cucumber.yml file" do
+      it 'expands args from profiles in the cucumber.yml file' do
         given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
 
         config.parse!(%w{--format progress --profile bongo})
 
-        expect(config.options[:formats]).to eq [['progress', out]]
+        expect(config.options[:formats]).to eq [['progress', {}, out]]
         expect(config.options[:require]).to eq ['from/yml']
       end
 
-      it "expands args from the default profile when no flags are provided" do
+      it 'expands args from the default profile when no flags are provided' do
         given_cucumber_yml_defined_as({'default' => '--require from/yml'})
 
         config.parse!([])
@@ -65,15 +66,27 @@ module Cli
         expect(config.options[:require]).to eq ['from/yml']
       end
 
-      it "allows --strict to be set by a profile" do
+      it 'allows --strict to be set by a profile' do
         given_cucumber_yml_defined_as({'bongo' => '--strict'})
 
         config.parse!(%w{--profile bongo})
 
-        expect(config.options[:strict]).to be true
+        expect(config.options[:strict].strict?(:undefined)).to be true
+        expect(config.options[:strict].strict?(:pending)).to be true
+        expect(config.options[:strict].strict?(:flaky)).to be true
       end
 
-      it "parses ERB syntax in the cucumber.yml file" do
+      it 'allows --strict from a profile to be selectively overridden' do
+        given_cucumber_yml_defined_as({'bongo' => '--strict'})
+
+        config.parse!(%w{--profile bongo --no-strict-flaky})
+
+        expect(config.options[:strict].strict?(:undefined)).to be true
+        expect(config.options[:strict].strict?(:pending)).to be true
+        expect(config.options[:strict].strict?(:flaky)).to be false
+      end
+
+      it 'parses ERB syntax in the cucumber.yml file' do
         given_cucumber_yml_defined_as("---\ndefault: \"<%=\"--require some_file\"%>\"\n")
 
         config.parse!([])
@@ -81,7 +94,7 @@ module Cli
         expect(config.options[:require]).to include('some_file')
       end
 
-      it "parses ERB in cucumber.yml that makes uses nested ERB sessions" do
+      it 'parses ERB in cucumber.yml that makes uses nested ERB sessions' do
         given_cucumber_yml_defined_as(<<ERB_YML)
 <%= ERB.new({'standard' => '--require some_file'}.to_yaml).result %>
 <%= ERB.new({'enhanced' => '--require other_file'}.to_yaml).result %>
@@ -92,7 +105,7 @@ ERB_YML
         expect(config.options[:require]).to include('some_file')
       end
 
-      it "provides a helpful error message when a specified profile does not exists in cucumber.yml" do
+      it 'provides a helpful error message when a specified profile does not exists in cucumber.yml' do
         given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
 
         expected_message = <<-END_OF_MESSAGE
@@ -106,42 +119,42 @@ END_OF_MESSAGE
         expect(-> { config.parse!(%w{--profile i_do_not_exist}) }).to raise_error(ProfileNotFound, expected_message)
       end
 
-      it "allows profiles to be defined in arrays" do
+      it 'allows profiles to be defined in arrays' do
         given_cucumber_yml_defined_as({'foo' => ['-f','progress']})
 
         config.parse!(%w{--profile foo})
 
-        expect(config.options[:formats]).to eq [['progress', out]]
+        expect(config.options[:formats]).to eq [['progress', {}, out]]
       end
 
-      it "disregards default STDOUT formatter defined in profile when another is passed in (via cmd line)" do
+      it 'disregards default STDOUT formatter defined in profile when another is passed in (via cmd line)' do
         given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
         config.parse!(%w{--format progress --profile foo})
 
-        expect(config.options[:formats]).to eq [['progress', out]]
+        expect(config.options[:formats]).to eq [['progress', {}, out]]
       end
 
-      ["--no-profile", "-P"].each do |flag|
+      ['--no-profile', '-P'].each do |flag|
         context 'when none is specified with #{flag}' do
-          it "disables profiles" do
+          it 'disables profiles' do
             given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
 
-            config.parse!("#{flag} --require some_file.rb".split(" "))
+            config.parse!("#{flag} --require some_file.rb".split(' '))
 
             expect(config.options[:require]).to eq ['some_file.rb']
           end
 
-          it "notifies the user that the profiles are being disabled" do
+          it 'notifies the user that the profiles are being disabled' do
             given_cucumber_yml_defined_as({'default' => '-v'})
 
-            config.parse!("#{flag} --require some_file.rb".split(" "))
+            config.parse!("#{flag} --require some_file.rb".split(' '))
 
-            expect(out.string).to match /Disabling profiles.../
+            expect(out.string).to match(/Disabling profiles.../)
           end
         end
       end
 
-      it "issues a helpful error message when a specified profile exists but is nil or blank" do
+      it 'issues a helpful error message when a specified profile exists but is nil or blank' do
         [nil, '   '].each do |bad_input|
           given_cucumber_yml_defined_as({'foo' => bad_input})
 
@@ -151,7 +164,7 @@ END_OF_MESSAGE
         end
       end
 
-      it "issues a helpful error message when no YAML file exists and a profile is specified" do
+      it 'issues a helpful error message when no YAML file exists and a profile is specified' do
         expect(File).to receive(:exist?).with('cucumber.yml') { false }
 
         expected_error = /cucumber\.yml was not found/
@@ -159,10 +172,10 @@ END_OF_MESSAGE
         expect(-> { config.parse!(%w{--profile i_do_not_exist}) }).to raise_error(expected_error)
       end
 
-      it "issues a helpful error message when cucumber.yml is blank or malformed" do
+      it 'issues a helpful error message when cucumber.yml is blank or malformed' do
           expected_error_message = /cucumber\.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage./
 
-        ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
+        ['', 'sfsadfs', "--- \n- an\n- array\n", '---dddfd'].each do |bad_input|
           given_cucumber_yml_defined_as(bad_input)
 
           expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
@@ -171,149 +184,149 @@ END_OF_MESSAGE
         end
       end
 
-      it "issues a helpful error message when cucumber.yml can not be parsed" do
+      it 'issues a helpful error message when cucumber.yml can not be parsed' do
         expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage./
 
-        given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
+        given_cucumber_yml_defined_as('input that causes an exception in YAML loading')
 
         expect(YAML).to receive(:load).and_raise(ArgumentError)
         expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
       end
 
-      it "issues a helpful error message when cucumber.yml can not be parsed by ERB" do
+      it 'issues a helpful error message when cucumber.yml can not be parsed by ERB' do
         expected_error_message = /cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage./
-        given_cucumber_yml_defined_as("<% this_fails %>")
+        given_cucumber_yml_defined_as('<% this_fails %>')
 
         expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
       end
     end
 
-    it "accepts --dry-run option" do
+    it 'accepts --dry-run option' do
       config.parse!(%w{--dry-run})
 
       expect(config.options[:dry_run]).to be true
     end
-    
-    it "implies --no-duration with --dry-run option" do
+
+    it 'implies --no-duration with --dry-run option' do
       config.parse!(%w{--dry-run})
-      
+
       expect(config.options[:duration]).to be false
     end
 
-    it "accepts --no-source option" do
+    it 'accepts --no-source option' do
       config.parse!(%w{--no-source})
 
       expect(config.options[:source]).to be false
     end
 
-    it "accepts --no-snippets option" do
+    it 'accepts --no-snippets option' do
       config.parse!(%w{--no-snippets})
 
       expect(config.options[:snippets]).to be false
     end
 
-    it "sets snippets and source and duration to false with --quiet option" do
+    it 'sets snippets and source and duration to false with --quiet option' do
       config.parse!(%w{--quiet})
 
       expect(config.options[:snippets]).to be false
       expect(config.options[:source]).to be false
       expect(config.options[:duration]).to be false
     end
-    
-    it "sets duration to false with --no-duration" do
+
+    it 'sets duration to false with --no-duration' do
       config.parse!(%w{--no-duration})
-      
+
       expect(config.options[:duration]).to be false
     end
 
-    it "accepts --verbose option" do
+    it 'accepts --verbose option' do
       config.parse!(%w{--verbose})
 
       expect(config.options[:verbose]).to be true
     end
 
-    it "accepts --out option" do
+    it 'accepts --out option' do
       config.parse!(%w{--out jalla.txt})
 
-      expect(config.formats).to eq [['pretty', 'jalla.txt']]
+      expect(config.formats).to eq [['pretty', {}, 'jalla.txt']]
     end
 
-    it "accepts multiple --out options" do
+    it 'accepts multiple --out options' do
       config.parse!(%w{--format progress --out file1 --out file2})
 
-      expect(config.formats).to eq [['progress', 'file2']]
+      expect(config.formats).to eq [['progress', {}, 'file2']]
     end
 
-    it "accepts multiple --format options and put the STDOUT one first so progress is seen" do
+    it 'accepts multiple --format options and put the STDOUT one first so progress is seen' do
       config.parse!(%w{--format pretty --out pretty.txt --format progress})
 
-      expect(config.formats).to eq [['progress', out], ['pretty', 'pretty.txt']]
+      expect(config.formats).to eq [['progress', {}, out], ['pretty', {}, 'pretty.txt']]
     end
 
-    it "does not accept multiple --format options when both use implicit STDOUT" do
-      expect(-> { config.parse!(%w{--format pretty --format progress}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+    it 'does not accept multiple --format options when both use implicit STDOUT' do
+      expect(-> { config.parse!(%w{--format pretty --format progress}) }).to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
     end
 
-    it "does not accept multiple --format options when both use implicit STDOUT (using profile with no formatters)" do
+    it 'does not accept multiple --format options when both use implicit STDOUT (using profile with no formatters)' do
       given_cucumber_yml_defined_as({'default' => ['-q']})
-      expect(-> { config.parse!(%w{--format pretty --format progress}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+      expect(-> { config.parse!(%w{--format pretty --format progress}) }).to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
     end
 
-    it "accepts same --format options with implicit STDOUT, and keep only one" do
+    it 'accepts same --format options with implicit STDOUT, and keep only one' do
       config.parse!(%w{--format pretty --format pretty})
 
-      expect(config.formats).to eq [["pretty", out]]
+      expect(config.formats).to eq [['pretty', {}, out]]
     end
 
-    it "does not accept multiple --out streams pointing to the same place" do
-      expect(-> { config.parse!(%w{--format pretty --out file1 --format progress --out file1}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+    it 'does not accept multiple --out streams pointing to the same place' do
+      expect(-> { config.parse!(%w{--format pretty --out file1 --format progress --out file1}) }).to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
     end
 
-    it "does not accept multiple --out streams pointing to the same place (one from profile, one from command line)" do
+    it 'does not accept multiple --out streams pointing to the same place (one from profile, one from command line)' do
       given_cucumber_yml_defined_as({'default' => ['-f','progress', '--out', 'file1']})
-      expect(-> { config.parse!(%w{--format pretty --out file1}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+      expect(-> { config.parse!(%w{--format pretty --out file1}) }).to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
     end
 
-    it "associates --out to previous --format" do
+    it 'associates --out to previous --format' do
       config.parse!(%w{--format progress --out file1 --format profile --out file2})
 
-      expect(config.formats).to eq [["progress", "file1"], ["profile" ,"file2"]]
+      expect(config.formats).to eq [['progress', {}, 'file1'], ['profile', {}, 'file2']]
     end
 
-    it "accepts same --format options with same --out streams and keep only one" do
+    it 'accepts same --format options with same --out streams and keep only one' do
       config.parse!(%w{--format html --out file --format pretty --format html --out file})
 
-      expect(config.formats).to eq [["pretty", out], ["html", "file"]]
+      expect(config.formats).to eq [['pretty', {}, out], ['html', {}, 'file']]
     end
 
-    it "accepts same --format options with different --out streams" do
+    it 'accepts same --format options with different --out streams' do
       config.parse!(%w{--format html --out file1 --format html --out file2})
 
-      expect(config.formats).to eq [["html", "file1"], ["html", "file2"]]
+      expect(config.formats).to eq [['html', {}, 'file1'], ['html', {}, 'file2']]
     end
 
-    it "accepts --color option" do
+    it 'accepts --color option' do
       expect(Cucumber::Term::ANSIColor).to receive(:coloring=).with(true)
 
       config.parse!(['--color'])
     end
 
-    it "accepts --no-color option" do
+    it 'accepts --no-color option' do
       expect(Cucumber::Term::ANSIColor).to receive(:coloring=).with(false)
 
       config = Configuration.new(StringIO.new)
       config.parse!(['--no-color'])
     end
 
-    describe "--backtrace" do
+    describe '--backtrace' do
       before do
         Cucumber.use_full_backtrace = false
       end
 
-      it "shows full backtrace when --backtrace is present" do
+      it 'shows full backtrace when --backtrace is present' do
         Main.new(['--backtrace'])
         begin
-          expect("x").to eq "y"
+          expect('x').to eq 'y'
         rescue RSpec::Expectations::ExpectationNotMetError => e
           expect(e.backtrace[0]).not_to eq "#{__FILE__}:#{__LINE__ - 2}"
         end
@@ -324,108 +337,106 @@ END_OF_MESSAGE
       end
     end
 
-    it "accepts multiple --name options" do
-      config.parse!(['--name', "User logs in", '--name', "User signs up"])
+    it 'accepts multiple --name options' do
+      config.parse!(['--name', 'User logs in', '--name', 'User signs up'])
 
       expect(config.options[:name_regexps]).to include(/User logs in/)
       expect(config.options[:name_regexps]).to include(/User signs up/)
     end
 
-    it "accepts multiple -n options" do
-      config.parse!(['-n', "User logs in", '-n', "User signs up"])
+    it 'accepts multiple -n options' do
+      config.parse!(['-n', 'User logs in', '-n', 'User signs up'])
 
       expect(config.options[:name_regexps]).to include(/User logs in/)
       expect(config.options[:name_regexps]).to include(/User signs up/)
     end
 
-    it "should allow specifying environment variables on the command line" do
-      config.parse!(["foo=bar"])
+    it 'should allow specifying environment variables on the command line' do
+      config.parse!(['foo=bar'])
 
-      expect(ENV["foo"]).to eq "bar"
+      expect(ENV['foo']).to eq 'bar'
       expect(config.paths).not_to include('foo=bar')
     end
 
-    it "allows specifying environment variables in profiles" do
+    it 'allows specifying environment variables in profiles' do
       given_cucumber_yml_defined_as({'selenium' => 'RAILS_ENV=selenium'})
-      config.parse!(["--profile", "selenium"])
+      config.parse!(['--profile', 'selenium'])
 
-      expect(ENV["RAILS_ENV"]).to eq "selenium"
+      expect(ENV['RAILS_ENV']).to eq 'selenium'
       expect(config.paths).not_to include('RAILS_ENV=selenium')
     end
 
-    describe "#tag_expression" do
-      include RSpec::WorkInProgress
-
-      it "returns an empty expression when no tags are specified" do
+    describe '#tag_expressions' do
+      it 'returns an empty expression when no tags are specified' do
         config.parse!([])
 
-        expect(config.tag_expression).to be_empty
+        expect(config.tag_expressions).to be_empty
       end
 
-      it "returns an expression when tags are specified" do
+      it 'returns an expression when tags are specified' do
         config.parse!(['--tags','@foo'])
 
-        expect(config.tag_expression).not_to be_empty
+        expect(config.tag_expressions).not_to be_empty
       end
     end
 
     describe '#tag_limits' do
-      it "returns an empty hash when no limits are specified" do
+      it 'returns an empty hash when no limits are specified' do
         config.parse!([])
 
         expect(config.tag_limits).to eq({ })
       end
 
-      it "returns a hash of limits when limits are specified" do
+      it 'returns a hash of limits when limits are specified' do
         config.parse!(['--tags','@foo:1'])
 
-        expect(config.tag_limits).to eq({ "@foo" => 1 })
+        expect(config.tag_limits).to eq({ '@foo' => 1 })
       end
     end
 
-    describe "#dry_run?" do
-      it "returns true when --dry-run was specified on in the arguments" do
+    describe '#dry_run?' do
+      it 'returns true when --dry-run was specified on in the arguments' do
         config.parse!(['--dry-run'])
 
         expect(config.dry_run?).to be true
       end
 
-      it "returns true when --dry-run was specified in yaml file" do
+      it 'returns true when --dry-run was specified in yaml file' do
         given_cucumber_yml_defined_as({'default' => '--dry-run'})
         config.parse!([])
 
         expect(config.dry_run?).to be true
       end
 
-      it "returns false by default" do
+      it 'returns false by default' do
         config.parse!([])
 
         expect(config.dry_run?).to be false
       end
     end
 
-    describe "#snippet_type" do
-      it "returns the snippet type when it was set" do
-        config.parse!(["--snippet-type", "classic"])
+    describe '#snippet_type' do
+      it 'returns the snippet type when it was set' do
+        config.parse!(['--snippet-type', 'classic'])
 
         expect(config.snippet_type).to eq :classic
       end
 
-      it "returns the snippet type when it was set with shorthand option" do
-        config.parse!(["-I", "classic"])
+      it 'returns the snippet type when it was set with shorthand option' do
+        config.parse!(['-I', 'classic'])
 
         expect(config.snippet_type).to eq :classic
       end
 
-      it "returns the default snippet type if it was not set" do
+      it 'returns the default snippet type if it was not set' do
         config.parse!([])
 
-        expect(config.snippet_type).to eq :regexp
+        expect(config.snippet_type).to eq :cucumber_expression
       end
     end
 
-    describe "#retry_attempts" do 
-      it "returns the specified number of retries" do 
+    describe '#retry_attempts' do
+      it 'returns the specified number of retries' do
         config.parse!(['--retry=3'])
         expect(config.retry_attempts).to eql 3
       end

data/spec/cucumber/cli/main_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'yaml'
 
@@ -16,15 +17,15 @@ module Cucumber
       let(:kernel) { double(:kernel) }
       subject { Main.new(args, stdin, stdout, stderr, kernel)}
 
-      describe "#execute!" do
-        context "passed an existing runtime" do
+      describe '#execute!' do
+        context 'passed an existing runtime' do
           let(:existing_runtime) { double('runtime').as_null_object }
 
           def do_execute
             subject.execute!(existing_runtime)
           end
 
-          it "configures that runtime" do
+          it 'configures that runtime' do
             expected_configuration = double('Configuration').as_null_object
 
             allow(Configuration).to receive(:new) { expected_configuration }
@@ -34,7 +35,7 @@ module Cucumber
             do_execute
           end
 
-          it "uses that runtime for running and reporting results" do
+          it 'uses that runtime for running and reporting results' do
             expected_results = double('results', :failure? => true)
 
             expect(existing_runtime).to receive(:run!)
@@ -45,12 +46,12 @@ module Cucumber
           end
         end
 
-        context "interrupted with ctrl-c" do
+        context 'interrupted with ctrl-c' do
           after do
             Cucumber.wants_to_quit = false
           end
 
-          it "exits with error code" do
+          it 'exits with error code' do
             results = double('results', :failure? => false)
 
             allow_any_instance_of(Runtime).to receive(:run!)
@@ -70,7 +71,7 @@ module Cucumber
           configuration = double('configuration')
 
           allow(Configuration).to receive(:new) { configuration }
-          allow(configuration).to receive(:parse!).and_raise(exception_klass.new("error message"))
+          allow(configuration).to receive(:parse!).and_raise(exception_klass.new('error message'))
           allow(kernel).to receive(:exit).with(2)
 
           subject.execute!