cucumber-cucumber-expressions 17.1.0 → 18.0.0

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    class Color
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-
-      def ==(other)
-        other.is_a?(Color) && other.name == name
-      end
-    end
-
-    class CssColor
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-
-      def ==(other)
-        other.is_a?(CssColor) && other.name == name
-      end
-    end
-
-    class Coordinate
-      attr_reader :x, :y, :z
-
-      def initialize(x, y, z)
-        @x, @y, @z = x, y, z
-      end
-
-      def ==(other)
-        other.is_a?(Coordinate) && other.x == x && other.y == y && other.z == z
-      end
-    end
-
-    describe 'Custom parameter type' do
-      before do
-        parameter_type_registry = ParameterTypeRegistry.new
-        parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'color',                   # name
-            /red|blue|yellow/,         # regexp
-            Color,                     # type
-            ->(s) { Color.new(s) },    # transform
-            true,                      # use_for_snippets
-            false                      # prefer_for_regexp_match
-          )
-        )
-        @parameter_type_registry = parameter_type_registry
-      end
-
-      it 'throws exception for illegal character in parameter name' do
-        expect do
-          ParameterType.new(
-            '[string]',
-            /.*/,
-            String,
-            ->(s) { s },
-            true,
-            false
-          )
-        end.to raise_error("Illegal character in parameter name {[string]}. Parameter names may not contain '[]()$.|?*+'")
-      end
-
-      describe CucumberExpression do
-        it 'matches parameters with custom parameter type' do
-          expression = described_class.new('I have a {color} ball', @parameter_type_registry)
-          transformed_argument_value = expression.match('I have a red ball')[0].value(nil)
-
-          expect(transformed_argument_value).to eq(Color.new('red'))
-        end
-
-        it 'matches parameters with multiple capture groups' do
-          @parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              'coordinate',
-              /(\d+),\s*(\d+),\s*(\d+)/,
-              Coordinate,
-              ->(x, y, z) { Coordinate.new(x.to_i, y.to_i, z.to_i) },
-              true,
-              false
-            )
-          )
-
-          expression = described_class.new('A {int} thick line from {coordinate} to {coordinate}', @parameter_type_registry)
-          args = expression.match('A 5 thick line from 10,20,30 to 40,50,60')
-
-          thick = args[0].value(nil)
-          expect(thick).to eq(5)
-
-          from = args[1].value(nil)
-          expect(from).to eq(Coordinate.new(10, 20, 30))
-
-          to = args[2].value(nil)
-          expect(to).to eq(Coordinate.new(40, 50, 60))
-        end
-
-        it 'matches parameters with custom parameter type using optional capture group' do
-          parameter_type_registry = ParameterTypeRegistry.new
-          parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              'color',
-              [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
-              Color,
-              ->(s) { Color.new(s) },
-              true,
-              false
-            )
-          )
-          expression = described_class.new('I have a {color} ball', parameter_type_registry)
-          transformed_argument_value = expression.match('I have a dark red ball')[0].value(nil)
-
-          expect(transformed_argument_value).to eq(Color.new('dark red'))
-        end
-
-        it 'defers transformation until queried from argument' do
-          @parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              'throwing',
-              /bad/,
-              CssColor,
-              ->(s) { raise "Can't transform [#{s}]" },
-              true,
-              false
-            )
-          )
-          expression = described_class.new('I have a {throwing} parameter', @parameter_type_registry)
-          args = expression.match('I have a bad parameter')
-
-          expect { args[0].value(nil) }.to raise_error("Can't transform [bad]")
-        end
-
-        describe 'conflicting parameter type' do
-          it 'is detected for type name' do
-            expect {
-              @parameter_type_registry.define_parameter_type(
-                ParameterType.new(
-                  'color',
-                  /.*/,
-                  CssColor,
-                  ->(s) { CssColor.new(s) },
-                  true,
-                  false
-                )
-              )
-            }.to raise_error('There is already a parameter with name color')
-          end
-
-          it 'is not detected for type' do
-            @parameter_type_registry.define_parameter_type(
-              ParameterType.new(
-                'whatever',
-                /.*/,
-                Color,
-                ->(s) { Color.new(s) },
-                false,
-                false
-              )
-            )
-          end
-
-          it 'is not detected for regexp' do
-            @parameter_type_registry.define_parameter_type(
-              ParameterType.new(
-                'css-color',
-                /red|blue|yellow/,
-                CssColor,
-                ->(s) { CssColor.new(s) },
-                true,
-                false
-              )
-            )
-            css_color = described_class.new('I have a {css-color} ball', @parameter_type_registry)
-            css_color_value = css_color.match('I have a blue ball')[0].value(nil)
-
-            expect(css_color_value).to eq(CssColor.new('blue'))
-
-            color = described_class.new('I have a {color} ball', @parameter_type_registry)
-            color_value = color.match('I have a blue ball')[0].value(nil)
-
-            expect(color_value).to eq(Color.new('blue'))
-          end
-        end
-      end
-
-      describe RegularExpression do
-        it 'matches arguments with custom parameter types without a name' do
-          parameter_type_registry = ParameterTypeRegistry.new
-          parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              nil,
-              /red|blue|yellow/,
-              Color,
-              ->(s) { Color.new(s) },
-              true,
-              false
-            )
-          )
-          expression = described_class.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
-          value = expression.match('I have a red ball')[0].value(nil)
-
-          expect(value).to eq(Color.new('red'))
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/expression_factory_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/expression_factory'
-
-module Cucumber
-  module CucumberExpressions
-    describe ExpressionFactory do
-      before do
-        @expression_factory = described_class.new(ParameterTypeRegistry.new)
-      end
-
-      it 'creates a RegularExpression' do
-        expect(@expression_factory.create_expression(/x/).class).to eq(RegularExpression)
-      end
-
-      it 'creates a CucumberExpression' do
-        expect(@expression_factory.create_expression('{int}').class).to eq(CucumberExpression)
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/cucumber_expressions/errors'
-
-module Cucumber
-  module CucumberExpressions
-    CAPITALISED_WORD = /[A-Z]+\w+/.freeze
-
-    class Name; end
-    class Person; end
-    class Place; end
-
-    describe ParameterTypeRegistry do
-      before do
-        @registry = described_class.new
-      end
-
-      it 'does not allow more than one prefer_for_regexp_match parameter type for each regexp' do
-        @registry.define_parameter_type(ParameterType.new('name', CAPITALISED_WORD, Name, ->(_) { Name.new }, true, true))
-        @registry.define_parameter_type(ParameterType.new('person', CAPITALISED_WORD, Person, ->(_) { Person.new }, true, false))
-        expect do
-          @registry.define_parameter_type(ParameterType.new('place', CAPITALISED_WORD, Place, ->(_) { Place.new }, true, true))
-        end.to raise_error(
-          CucumberExpressionError,
-          'There can only be one preferential parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two: {name} and {place}'
-        )
-      end
-
-      it 'looks up prefer_for_regexp_match parameter type by regexp' do
-        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(_) { Name.new }, true, false)
-        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(_) { Person.new }, true, true)
-        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(_) { Place.new }, true, false)
-
-        @registry.define_parameter_type(name)
-        @registry.define_parameter_type(person)
-        @registry.define_parameter_type(place)
-
-        expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, 'Lisa and Bob')).to eq(person)
-      end
-
-      it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
-        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(_) { Name.new }, true, false)
-        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(_) { Person.new }, true, false)
-        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(_) { Place.new }, true, false)
-
-        @registry.define_parameter_type(name)
-        @registry.define_parameter_type(person)
-        @registry.define_parameter_type(place)
-
-        expect do
-          expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, 'Lisa and Bob')).to eq(person)
-        end.to raise_error(
-          CucumberExpressionError,
-          "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" \
-          "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n   " \
-          "{name}\n   " \
-          "{person}\n   " \
-          "{place}\n" \
-          "\n" \
-          "I couldn't decide which one to use. You have two options:\n" \
-          "\n" \
-          "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n   " \
-          "{name} and {name}\n   " \
-          "{name} and {person}\n   " \
-          "{name} and {place}\n   " \
-          "{person} and {name}\n   " \
-          "{person} and {person}\n   " \
-          "{person} and {place}\n   " \
-          "{place} and {name}\n   " \
-          "{place} and {person}\n   " \
-          "{place} and {place}\n" \
-          "\n" \
-          "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" \
-          "\n"
-        )
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/parameter_type'
-
-module Cucumber
-  module CucumberExpressions
-    describe ParameterType do
-      it 'does not allow ignore flag on regexp' do
-        expect do
-          described_class.new('case-insensitive', /[a-z]+/i, String, ->(s) { s }, true, true)
-        end.to raise_error(
-          CucumberExpressionError,
-          "ParameterType Regexps can't use option Regexp::IGNORECASE"
-        )
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe RegularExpression do
-      Dir['../testdata/regular-expression/matching/*.yaml'].each do |path|
-        expectation = YAML.load_file(path)
-
-        it "matches #{path}" do
-          parameter_registry = ParameterTypeRegistry.new
-          expression = described_class.new(Regexp.new(expectation['expression']), parameter_registry)
-          matches = expression.match(expectation['text'])
-          values = matches.map { |arg| arg.value(nil) }
-
-          expect(values).to eq(expectation['expected_args'])
-        end
-      end
-
-      it 'does not transform by default' do
-        expect(match(/(\d\d)/, '22')).to eq(['22'])
-      end
-
-      it 'does not transform anonymous' do
-        expect(match(/(.*)/, '22')).to eq(['22'])
-      end
-
-      it 'transforms negative int' do
-        expect(match(/(-?\d+)/, '-22')).to eq([-22])
-      end
-
-      it 'transforms positive int' do
-        expect(match(/(\d+)/, '22')).to eq([22])
-      end
-
-      it 'returns nil when there is no match' do
-        expect(match(/hello/, 'world')).to be_nil
-      end
-
-      it 'matches empty string when there is an empty string match' do
-        expect(match(/^The value equals "([^"]*)"$/, 'The value equals ""')).to eq([''])
-      end
-
-      it 'matches nested capture group without match' do
-        expect(match(/^a user( named "([^"]*)")?$/, 'a user')).to eq([nil])
-      end
-
-      it 'matches nested capture group with match' do
-        expect(match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"')).to eq(['Charlie'])
-      end
-
-      it 'ignores non capturing groups' do
-        expect(
-          match(
-            /(\S+) ?(can|cannot) (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
-            'I can cancel the 1st slide upload'
-          )
-        ).to eq(['I', 'can', 1, 'slide'])
-      end
-
-      it 'matches capture group nested in optional one' do
-        regexp = /^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
-
-        expect(match(regexp, 'a purchase')).to eq([nil, nil])
-        expect(match(regexp, 'a purchase for $33')).to eq([nil, 33])
-        expect(match(regexp, 'a pre buyer fee model purchase')).to eq(['pre buyer fee model ', nil])
-      end
-
-      it 'works with escaped parentheses' do
-        expect(match(/Across the line\(s\)/, 'Across the line(s)')).to eq([])
-      end
-
-      it 'exposes source and regexp' do
-        regexp = /I have (\d+) cukes? in my (\+) now/
-        expression = described_class.new(regexp, ParameterTypeRegistry.new)
-
-        expect(expression.regexp).to eq(regexp)
-        expect(expression.source).to eq(regexp.source)
-      end
-
-      def match(expression, text)
-        regular_expression = RegularExpression.new(expression, ParameterTypeRegistry.new)
-        arguments = regular_expression.match(text)
-        return nil if arguments.nil?
-
-        arguments.map { |arg| arg.value(nil) }
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/tree_regexp'
-
-module Cucumber
-  module CucumberExpressions
-    describe TreeRegexp do
-      it 'exposes the group source' do
-        tr = described_class.new(/(a(?:b)?)(c)/)
-        expect(tr.group_builder.children.map { |gb| gb.source }).to eq(['a(?:b)?', 'c'])
-      end
-
-      it 'builds a tree' do
-        tr = described_class.new(/(a(?:b)?)(c)/)
-        group = tr.match('ac')
-        expect(group.value).to eq('ac')
-        expect(group.children[0].value).to eq('a')
-        expect(group.children[0].children).to eq([])
-        expect(group.children[1].value).to eq('c')
-      end
-
-      it 'ignores `?:` as a non-capturing group' do
-        tr = described_class.new(/a(?:b)(c)/)
-        group = tr.match('abc')
-        expect(group.value).to eq('abc')
-        expect(group.children.length).to eq 1
-        expect(group.children[0].value).to eq('c')
-      end
-
-      it 'ignores `?!` as a non-capturing group' do
-        tr = described_class.new(/a(?!b)(.+)/)
-        group = tr.match('aBc')
-        expect(group.value).to eq('aBc')
-        expect(group.children.length).to eq 1
-      end
-
-      it 'ignores `?=` as a non-capturing group' do
-        tr = described_class.new(/a(?=b)(.+)$/)
-        group = tr.match('abc')
-        expect(group.value).to eq('abc')
-        expect(group.children[0].value).to eq('bc')
-        expect(group.children.length).to eq 1
-      end
-
-      it 'ignores `?<=` as a non-capturing group' do
-        tr = described_class.new(/a(.+)(?<=c)$/)
-        group = tr.match('abc')
-        expect(group.value).to eq('abc')
-        expect(group.children[0].value).to eq('bc')
-        expect(group.children.length).to eq 1
-      end
-
-      it 'ignores `?<!` as a non-capturing group' do
-        tr = described_class.new(/a(.+)(?<!b)$/)
-        group = tr.match('abc')
-        expect(group.value).to eq('abc')
-        expect(group.children[0].value).to eq('bc')
-        expect(group.children.length).to eq 1
-      end
-
-      it 'ignores `?<!` as a non-capturing group' do
-        tr = described_class.new(/a(.+)(?<!b)$/)
-        group = tr.match('abc')
-        expect(group.value).to eq('abc')
-        expect(group.children[0].value).to eq('bc')
-        expect(group.children.length).to eq 1
-      end
-
-      it 'ignores `?>` as a non-capturing group' do
-        tr = described_class.new(/a(?>b)c/)
-        group = tr.match('abc')
-        expect(group.value).to eq('abc')
-        expect(group.children.length).to eq 0
-      end
-
-      it 'throws an error when there are named capture groups because they are buggy in Ruby' do
-        # https://github.com/cucumber/cucumber/issues/329
-        expect { described_class.new(/^I am a person( named "(?<first_name>.+) (?<last_name>.+)")?$/) }
-          .to raise_error(/Named capture groups are not supported/)
-      end
-
-      it 'matches an optional group' do
-        tr = described_class.new(/^Something( with an optional argument)?/)
-        group = tr.match('Something')
-        expect(group.children[0].value).to be_nil
-      end
-
-      it 'matches nested groups' do
-        tr = described_class.new(/^A (\d+) thick line from ((\d+),\s*(\d+),\s*(\d+)) to ((\d+),\s*(\d+),\s*(\d+))/)
-        group = tr.match('A 5 thick line from 10,20,30 to 40,50,60')
-
-        expect(group.children[0].value).to eq('5')
-        expect(group.children[1].value).to eq('10,20,30')
-        expect(group.children[1].children[0].value).to eq('10')
-        expect(group.children[1].children[1].value).to eq('20')
-        expect(group.children[1].children[2].value).to eq('30')
-        expect(group.children[2].value).to eq('40,50,60')
-        expect(group.children[2].children[0].value).to eq('40')
-        expect(group.children[2].children[1].value).to eq('50')
-        expect(group.children[2].children[2].value).to eq('60')
-      end
-
-      it 'detects multiple non-capturing groups' do
-        tr = described_class.new(/(?:a)(:b)(\?c)(d)/)
-        group = tr.match('a:b?cd')
-        expect(group.children.length).to eq(3)
-      end
-
-      it 'works with escaped backslashes' do
-        tr = described_class.new(/foo\\(bar|baz)/)
-        group = tr.match('foo\\bar')
-        expect(group.children.length).to eq(1)
-      end
-
-      it 'works with escaped slashes' do
-        tr = described_class.new(/^I go to '\/(.+)'$/)
-        group = tr.match("I go to '/hello'")
-        expect(group.children.length).to eq(1)
-      end
-
-      it 'works with digit and word regexp metacharacters' do
-        tr = described_class.new(/^(\d) (\w+)$/)
-        group = tr.match('2 you')
-        expect(group.children.length).to eq(2)
-      end
-
-      it 'captures non-capturing groups with capturing groups inside' do
-        tr = described_class.new(/the stdout(?: from "(.*?)")?/)
-        group = tr.match('the stdout')
-        expect(group.value).to eq('the stdout')
-        expect(group.children[0].value).to eq(nil)
-        expect(group.children.length).to eq(1)
-      end
-
-      it 'works with flags' do
-        tr = described_class.new(/HELLO/i)
-        group = tr.match('hello')
-        expect(group.value).to eq('hello')
-      end
-
-      it('does not consider parentheses in regexp character classes as a group') do
-        tr = described_class.new(/^drawings: ([A-Z_, ()]+)$/)
-        group = tr.match('drawings: ONE, TWO(ABC)')
-        expect(group.value).to eq('drawings: ONE, TWO(ABC)')
-        expect(group.children[0].value).to eq('ONE, TWO(ABC)')
-        expect(group.children.length).to eq(1)
-      end
-
-      it 'works with inline flags' do
-        tr = described_class.new(/(?i)HELLO/)
-        group = tr.match('hello')
-        expect(group.value).to eq('hello')
-        expect(group.children.length).to eq 0
-      end
-
-      it 'works with non-capturing inline flags' do
-        tr = described_class.new(/(?i:HELLO)/)
-        group = tr.match('hello')
-        expect(group.value).to eq('hello')
-        expect(group.children.length).to eq 0
-      end
-
-      it 'works with empty capturing groups' do
-        tr = described_class.new(/()/)
-        group = tr.match('')
-        expect(group.value).to eq('')
-        expect(group.children[0].value).to eq('')
-        expect(group.children.length).to eq 1
-      end
-
-      it 'works with empty non-capturing groups' do
-        tr = described_class.new(/(?:)/)
-        group = tr.match('')
-        expect(group.value).to eq('')
-        expect(group.children.length).to eq 0
-      end
-
-      it 'works with empty non-look ahead groups' do
-        tr = described_class.new(/(?<=)/)
-        group = tr.match('')
-        expect(group.value).to eq('')
-        expect(group.children.length).to eq 0
-      end
-    end
-  end
-end