cucumber-cucumber-expressions 17.1.0 → 18.0.0

data/spec/cucumber/cucumber_expressions/argument_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/argument'
-require 'cucumber/cucumber_expressions/tree_regexp'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe Argument do
-      it 'exposes parameter_type' do
-        tree_regexp = TreeRegexp.new(/three (.*) mice/)
-        parameter_type_registry = ParameterTypeRegistry.new
-        arguments = described_class.build(tree_regexp, 'three blind mice', [parameter_type_registry.lookup_by_type_name('string')])
-        argument = arguments[0]
-        expect(argument.parameter_type.name).to eq('string')
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/cucumber_expressions/combinatorial_generated_expression_factory'
-
-describe Cucumber::CucumberExpressions::CombinatorialGeneratedExpressionFactory do
-  let(:klazz) { Class.new }
-  let(:color_parameter_type) do
-    Cucumber::CucumberExpressions::ParameterType.new('color', /red|blue|yellow/, klazz, ->(_) { klazz.new }, true, false)
-  end
-  let(:css_color_parameter_type) do
-    Cucumber::CucumberExpressions::ParameterType.new('csscolor', /red|blue|yellow/, klazz, ->(_) { klazz.new }, true, false)
-  end
-  let(:date_parameter_type) do
-    Cucumber::CucumberExpressions::ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, klazz, ->(_) { klazz.new }, true, false)
-  end
-  let(:date_time_parameter_type) do
-    Cucumber::CucumberExpressions::ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, klazz, ->(_) { klazz.new }, true, false)
-  end
-  let(:timestamp_parameter_type) do
-    Cucumber::CucumberExpressions::ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, klazz, ->(_) { klazz.new }, true, false)
-  end
-
-  it 'generates multiple expressions' do
-    parameter_type_combinations = [
-      [color_parameter_type, css_color_parameter_type],
-      [date_parameter_type, date_time_parameter_type, timestamp_parameter_type]
-    ]
-
-    factory = described_class.new('I bought a {%s} ball on {%s}', parameter_type_combinations)
-    expressions = factory.generate_expressions.map { |generated_expression| generated_expression.source }
-    expect(expressions).to eq([
-      'I bought a {color} ball on {date}',
-      'I bought a {color} ball on {datetime}',
-      'I bought a {color} ball on {timestamp}',
-      'I bought a {csscolor} ball on {date}',
-      'I bought a {csscolor} ball on {datetime}',
-      'I bought a {csscolor} ball on {timestamp}',
-    ])
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -1,234 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/cucumber_expressions/cucumber_expression_generator'
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpressionGenerator do
-      class Currency
-      end
-
-      before do
-        @parameter_type_registry = ParameterTypeRegistry.new
-        @generator = described_class.new(@parameter_type_registry)
-      end
-
-      it 'documents expression generation' do
-        parameter_registry = ParameterTypeRegistry.new
-        ### [generate-expression]
-        generator = described_class.new(parameter_registry)
-        undefined_step_text = 'I have 2 cucumbers and 1.5 tomato'
-        generated_expression = generator.generate_expressions(undefined_step_text)[0]
-        expect(generated_expression.source).to eq('I have {int} cucumbers and {float} tomato')
-        expect(generated_expression.parameter_types[1].type).to eq(Float)
-        ### [generate-expression]
-      end
-
-      it 'generates expression for no args' do
-        assert_expression('hello', [], 'hello')
-      end
-
-      it 'generates expression with escaped left parenthesis' do
-        assert_expression('\\(iii)', [], '(iii)')
-      end
-
-      it 'generates expression with escaped left curly brace' do
-        assert_expression('\\{iii}', [], '{iii}')
-      end
-
-      it 'generates expression with escaped slashes' do
-        assert_expression('The {int}\\/{int}\\/{int} hey', ['int', 'int2', 'int3'], 'The 1814/05/17 hey')
-      end
-
-      it 'generates expression for int float arg' do
-        assert_expression('I have {int} cukes and {float} euro', ['int', 'float'], 'I have 2 cukes and 1.5 euro')
-      end
-
-      it 'generates expression for strings' do
-        assert_expression('I like {string} and {string}', ['string', 'string2'], 'I like "bangers" and \'mash\'')
-      end
-
-      it 'generates expression with % sign' do
-        assert_expression('I am {int}% foobar', ['int'], 'I am 20% foobar')
-      end
-
-      it 'generates expression for just int' do
-        assert_expression('{int}', ['int'], '99999')
-      end
-
-      it 'numbers only second argument when builtin type is not reserved keyword' do
-        assert_expression('I have {int} cukes and {int} euro', ['int', 'int2'], 'I have 2 cukes and 5 euro')
-      end
-
-      it 'numbers only second argument when type is not reserved keyword' do
-        @parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'currency',
-            '[A-Z]{3}',
-            Currency,
-            ->(s) { Currency.new(s) },
-            true,
-            true
-          )
-        )
-
-        assert_expression('I have a {currency} account and a {currency} account', ['currency', 'currency2'], 'I have a EUR account and a GBP account')
-      end
-
-      it 'exposes parameters in a generated expression' do
-        expression = @generator.generate_expressions('I have 2 cukes and 1.5 euro')[0]
-        types = expression.parameter_types.map(&:type)
-
-        expect(types).to eq([Integer, Float])
-      end
-
-      it 'matches parameter types with optional capture groups' do
-        @parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'optional-flight',
-            /(1st flight)?/,
-            String,
-            ->(s) { s },
-            true,
-            false
-          )
-        )
-        @parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'optional-hotel',
-            /(1 hotel)?/,
-            String,
-            ->(s) { s },
-            true,
-            false
-          )
-        )
-
-        expression = @generator.generate_expressions('I reach Stage 4: 1st flight -1 hotel')[0]
-        # While you would expect this to be `I reach Stage {int}: {optional-flight} -{optional-hotel}`
-        # the `-1` causes {int} to match just before {optional-hotel}.
-
-        expect(expression.source).to eq('I reach Stage {int}: {optional-flight} {int} hotel')
-      end
-
-      it 'generates at most 256 expressions' do
-        for i in 0..3
-          @parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              "my-type-#{i}",
-              /([a-z] )*?[a-z]/,
-              String,
-              ->(s) { s },
-              true,
-              false
-            )
-          )
-        end
-        # This would otherwise generate 4^11=4194300 expressions and consume just shy of 1.5GB.
-        expressions = @generator.generate_expressions('a s i m p l e s t e p')
-
-        expect(expressions.length).to eq(256)
-      end
-
-      it 'prefers expression with longest non empty match' do
-        @parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'zero-or-more',
-            /[a-z]*/,
-            String,
-            ->(s) { s },
-            true,
-            false
-          )
-        )
-        @parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'exactly-one',
-            /[a-z]/,
-            String,
-            ->(s) { s },
-            true,
-            false
-          )
-        )
-        expressions = @generator.generate_expressions('a simple step')
-
-        expect(expressions.length).to eq(2)
-        expect(expressions[0].source).to eq('{exactly-one} {zero-or-more} {zero-or-more}')
-        expect(expressions[1].source).to eq('{zero-or-more} {zero-or-more} {zero-or-more}')
-      end
-
-      context 'does not suggest parameter when match is' do
-        before do
-          @parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              'direction',
-              /(up|down)/,
-              String,
-              ->(s) { s },
-              true,
-              false
-            )
-          )
-        end
-
-        it 'at the beginning of a word' do
-          expect(@generator.generate_expressions('When I download a picture')[0].source).not_to eq('When I {direction}load a picture')
-          expect(@generator.generate_expressions('When I download a picture')[0].source).to eq('When I download a picture')
-        end
-
-        it 'inside a word' do
-          expect(@generator.generate_expressions('When I watch the muppet show')[0].source).not_to eq('When I watch the m{direction}pet show')
-          expect(@generator.generate_expressions('When I watch the muppet show')[0].source).to eq('When I watch the muppet show')
-        end
-
-        it 'at the end of a word' do
-          expect(@generator.generate_expressions('When I create a group')[0].source).not_to eq('When I create a gro{direction}')
-          expect(@generator.generate_expressions('When I create a group')[0].source).to eq('When I create a group')
-        end
-      end
-
-      context 'does suggest parameter when match is' do
-        before do
-          @parameter_type_registry.define_parameter_type(
-            ParameterType.new(
-              'direction',
-              /(up|down)/,
-              String,
-              ->(s) { s },
-              true,
-              false
-            )
-          )
-        end
-
-        it 'a full word' do
-          expect(@generator.generate_expressions('When I go down the road')[0].source).to eq('When I go {direction} the road')
-          expect(@generator.generate_expressions('When I walk up the hill')[0].source).to eq('When I walk {direction} the hill')
-          expect(@generator.generate_expressions('up the hill, the road goes down')[0].source).to eq('{direction} the hill, the road goes {direction}')
-        end
-
-        it 'wrapped around punctuation characters' do
-          expect(@generator.generate_expressions('When direction is:down')[0].source).to eq('When direction is:{direction}')
-          expect(@generator.generate_expressions('Then direction is down.')[0].source).to eq('Then direction is {direction}.')
-        end
-      end
-
-      def assert_expression(expected_expression, expected_argument_names, text)
-        generated_expression = @generator.generate_expressions(text)[0]
-        expect(generated_expression.parameter_names).to eq(expected_argument_names)
-        expect(generated_expression.source).to eq(expected_expression)
-
-        cucumber_expression = CucumberExpression.new(generated_expression.source, @parameter_type_registry)
-        match = cucumber_expression.match(text)
-
-        raise "Expected text '#{text}' to match generated expression '#{generated_expression.source}'" if match.nil?
-
-        expect(match.length).to eq(expected_argument_names.length)
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_parser_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'cucumber/cucumber_expressions/cucumber_expression_parser'
-require 'cucumber/cucumber_expressions/errors'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpressionParser do
-      Dir['../testdata/cucumber-expression/parser/*.yaml'].each do |path|
-        expectation = YAML.load_file(path)
-        it "parses #{path}" do
-          parser = described_class.new
-          if expectation['exception']
-            expect { parser.parse(expectation['expression']) }.to raise_error(expectation['exception'])
-          else
-            node = parser.parse(expectation['expression'])
-            node_hash = node.to_hash
-            expect(node_hash).to eq(expectation['expected_ast'])
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpression do
-      Dir['../testdata/cucumber-expression/matching/*.yaml'].each do |path|
-        expectation = YAML.load_file(path)
-
-        it "matches #{path}" do
-          parameter_registry = ParameterTypeRegistry.new
-          if expectation['exception']
-            expect {
-              cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
-              cucumber_expression.match(expectation['text'])
-            }.to raise_error(expectation['exception'])
-          else
-            cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
-            matches = cucumber_expression.match(expectation['text'])
-            values = matches.nil? ? nil : matches.map do |arg|
-              value = arg.value(nil)
-              case value
-              when BigDecimal
-                # Format {bigdecimal} as string (because it must be a string in matches-bigdecimal.yaml)
-                value.to_s('f')
-              when Integer
-                # Format {bigint} as string (because it must be a string in matches-bigint.yaml)
-                value.bit_length > 64 ? value.to_s : value
-              else
-                value
-              end
-            end
-            expect(values).to eq(expectation['expected_args'])
-          end
-        end
-      end
-
-      it 'documents match arguments' do
-        parameter_registry = ParameterTypeRegistry.new
-
-        ### [capture-match-arguments]
-        expr = 'I have {int} cuke(s)'
-        expression = described_class.new(expr, parameter_registry)
-        args = expression.match('I have 7 cukes')
-
-        expect(args[0].value(nil)).to eq(7)
-        ### [capture-match-arguments]
-      end
-
-      it 'matches float' do
-        expect(match('{float}', '')).to eq(nil)
-        expect(match('{float}', '.')).to eq(nil)
-        expect(match('{float}', ',')).to eq(nil)
-        expect(match('{float}', '-')).to eq(nil)
-        expect(match('{float}', 'E')).to eq(nil)
-        expect(match('{float}', '1,')).to eq(nil)
-        expect(match('{float}', ',1')).to eq(nil)
-        expect(match('{float}', '1.')).to eq(nil)
-
-        expect(match('{float}', '1')).to eq([1])
-        expect(match('{float}', '-1')).to eq([-1])
-        expect(match('{float}', '1.1')).to eq([1.1])
-        expect(match('{float}', '1,000')).to eq(nil)
-        expect(match('{float}', '1,000,0')).to eq(nil)
-        expect(match('{float}', '1,000.1')).to eq(nil)
-        expect(match('{float}', '1,000,10')).to eq(nil)
-        expect(match('{float}', '1,0.1')).to eq(nil)
-        expect(match('{float}', '1,000,000.1')).to eq(nil)
-        expect(match('{float}', '-1.1')).to eq([-1.1])
-
-        expect(match('{float}', '.1')).to eq([0.1])
-        expect(match('{float}', '-.1')).to eq([-0.1])
-        expect(match('{float}', '-.1000001')).to eq([-0.1000001])
-        expect(match('{float}', '1E1')).to eq([10.0])
-        expect(match('{float}', '.1E1')).to eq([1])
-        expect(match('{float}', 'E1')).to eq(nil)
-        expect(match('{float}', '-.1E-1')).to eq([-0.01])
-        expect(match('{float}', '-.1E-2')).to eq([-0.001])
-        expect(match('{float}', '-.1E+1')).to eq([-1])
-        expect(match('{float}', '-.1E+2')).to eq([-10])
-        expect(match('{float}', '-.1E1')).to eq([-1])
-        expect(match('{float}', '-.1E2')).to eq([-10])
-      end
-
-      it 'float with zero' do
-        expect(match('{float}', '0')).to eq([0.0])
-      end
-
-      it 'matches anonymous' do
-        expect(match('{}', '0.22')).to eq(['0.22'])
-      end
-
-      it 'exposes source' do
-        expr = 'I have {int} cuke(s)'
-
-        expect(described_class.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
-      end
-
-      it 'exposes source via #to_s' do
-        expr = 'I have {int} cuke(s)'
-
-        expect(described_class.new(expr, ParameterTypeRegistry.new).to_s).to eq(expr.inspect)
-      end
-
-      it 'unmatched optional groups have undefined values' do
-        parameter_type_registry = ParameterTypeRegistry.new
-        parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'textAndOrNumber',
-            /([A-Z]+)?(?: )?([0-9]+)?/,
-            Object,
-            ->(s1, s2) { [s1, s2] },
-            false,
-            true
-          )
-        )
-        expression = described_class.new('{textAndOrNumber}', parameter_type_registry)
-
-        class World; end
-
-        expect(expression.match('TLA')[0].value(World.new)).to eq(['TLA', nil])
-        expect(expression.match('123')[0].value(World.new)).to eq([nil, '123'])
-      end
-
-      # Ruby specific
-
-      it 'delegates transform to custom object' do
-        parameter_type_registry = ParameterTypeRegistry.new
-        parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-            'widget',
-            /\w+/,
-            Object,
-            ->(s) { self.create_widget(s) },
-            false,
-            true
-          )
-        )
-        expression = described_class.new(
-          'I have a {widget}',
-          parameter_type_registry
-        )
-
-        class World
-          def create_widget(s)
-            "widget:#{s}"
-          end
-        end
-
-        args = expression.match('I have a bolt')
-
-        expect(args[0].value(World.new)).to eq('widget:bolt')
-      end
-
-      it 'reports undefined parameter type name' do
-        parameter_type_registry = ParameterTypeRegistry.new
-
-        described_class.new(
-          'I have {int} {widget}(s) in {word}',
-          parameter_type_registry
-        )
-      rescue UndefinedParameterTypeError => e
-        expect(e.undefined_parameter_type_name).to eq('widget')
-      end
-
-      def match(expression, text)
-        cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
-        args = cucumber_expression.match(text)
-        return nil if args.nil?
-
-        args.map { |arg| arg.value(nil) }
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_tokenizer_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'cucumber/cucumber_expressions/cucumber_expression_tokenizer'
-require 'cucumber/cucumber_expressions/errors'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpressionTokenizer do
-      Dir['../testdata/cucumber-expression/tokenizer/*.yaml'].each do |path|
-        expectation = YAML.load_file(path)
-        it "tokenizes #{path}" do
-          tokenizer = described_class.new
-          if expectation['exception']
-            expect { tokenizer.tokenize(expectation['expression']) }.to raise_error(expectation['exception'])
-          else
-            tokens = tokenizer.tokenize(expectation['expression'])
-            token_hashes = tokens.map { |token| token.to_hash }
-            expect(token_hashes).to eq(expectation['expected_tokens'])
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_transformation_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpression do
-      Dir['../testdata/cucumber-expression/transformation/*.yaml'].each do |path|
-        expectation = YAML.load_file(path)
-        it "transforms #{path}" do
-          parameter_registry = ParameterTypeRegistry.new
-          if expectation['exception']
-            expect {
-              cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
-              cucumber_expression.match(expectation['text'])
-            }.to raise_error(expectation['exception'])
-          else
-            cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
-            matches = cucumber_expression.match(expectation['text'])
-            values = matches.nil? ? nil : matches.map { |arg| arg.value(nil) }
-            expect(values).to eq(expectation['expected_args'])
-          end
-        end
-      end
-    end
-  end
-end