cucumber-cucumber-expressions 16.1.2 → 17.0.2

data/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_spec.rb

@@ -0,0 +1,41 @@
+# 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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/cucumber_expression_generator'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/parameter_type'
@@ -11,206 +13,207 @@ module Cucumber
 
       before do
         @parameter_type_registry = ParameterTypeRegistry.new
-        @generator = CucumberExpressionGenerator.new(@parameter_type_registry)
+        @generator = described_class.new(@parameter_type_registry)
       end
 
-      it "documents expression generation" do
+      it 'documents expression generation' do
         parameter_registry = ParameterTypeRegistry.new
         ### [generate-expression]
-        generator = CucumberExpressionGenerator.new(parameter_registry)
-        undefined_step_text = "I have 2 cucumbers and 1.5 tomato"
+        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.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")
+      it 'generates expression for no args' do
+        assert_expression('hello', [], 'hello')
       end
 
-      it "generates expression with escaped left parenthesis" do
-        assert_expression(
-          "\\(iii)", [],
-          "(iii)")
+      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}")
+      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")
+      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")
+      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\'')
+      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')
+      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")
+      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")
+      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,
-          lambda {|s| Currency.new(s)},
-          true,
-          true
-        ))
+      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")
+        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 generated expression" do
-        expression = @generator.generate_expressions("I have 2 cukes and 1.5 euro")[0]
+      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(
+      it 'matches parameter types with optional capture groups' do
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
             'optional-flight',
             /(1st flight)?/,
             String,
-            lambda {|s| s},
+            ->(s) { s },
             true,
             false
-        ))
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
+          )
+        )
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
             'optional-hotel',
             /(1 hotel)?/,
             String,
-            lambda {|s| s},
+            ->(s) { s },
             true,
             false
-        ))
+          )
+        )
 
-        expression = @generator.generate_expressions("I reach Stage 4: 1st flight -1 hotel")[0]
+        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")
+
+        expect(expression.source).to eq('I reach Stage {int}: {optional-flight} {int} hotel')
       end
 
-      it "generates at most 256 expressions" do
+      it 'generates at most 256 expressions' do
         for i in 0..3
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               "my-type-#{i}",
               /([a-z] )*?[a-z]/,
               String,
-              lambda {|s| s},
+              ->(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")
+        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(
+      it 'prefers expression with longest non empty match' do
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
             'zero-or-more',
             /[a-z]*/,
             String,
-            lambda {|s| s},
+            ->(s) { s },
             true,
             false
-        ))
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
+          )
+        )
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
             'exactly-one',
             /[a-z]/,
             String,
-            lambda {|s| s},
+            ->(s) { s },
             true,
             false
-        ))
+          )
+        )
+        expressions = @generator.generate_expressions('a simple step')
 
-        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}")
+        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
+      context 'does not suggest parameter when match is' do
         before do
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'direction',
               /(up|down)/,
               String,
-              lambda {|s| s},
+              ->(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")
+        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")
+        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")
+        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
+      context 'does suggest parameter when match is' do
         before do
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'direction',
               /(up|down)/,
               String,
-              lambda {|s| s},
+              ->(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}")
+        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}.")
+          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
 
@@ -221,9 +224,9 @@ module Cucumber
 
         cucumber_expression = CucumberExpression.new(generated_expression.source, @parameter_type_registry)
         match = cucumber_expression.match(text)
-        if match.nil?
-          raise "Expected text '#{text}' to match generated expression '#{generated_expression.source}'"
-        end
+
+        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

data/spec/cucumber/cucumber_expressions/cucumber_expression_parser_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/cucumber_expression_parser'
 require 'cucumber/cucumber_expressions/errors'
@@ -8,7 +10,7 @@ module Cucumber
       Dir['../testdata/cucumber-expression/parser/*.yaml'].each do |path|
         expectation = YAML.load_file(path)
         it "parses #{path}" do
-          parser = CucumberExpressionParser.new
+          parser = described_class.new
           if expectation['exception']
             expect { parser.parse(expectation['expression']) }.to raise_error(expectation['exception'])
           else

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -5,18 +7,18 @@ 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 = CucumberExpression.new(expectation['expression'], parameter_registry)
+              cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
               cucumber_expression.match(expectation['text'])
             }.to raise_error(expectation['exception'])
           else
-            cucumber_expression = CucumberExpression.new(expectation['expression'], parameter_registry)
+            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)
@@ -36,115 +38,110 @@ module Cucumber
         end
       end
 
-      it "documents match arguments" do
+      it 'documents match arguments' do
         parameter_registry = ParameterTypeRegistry.new
 
         ### [capture-match-arguments]
-        expr = "I have {int} cuke(s)"
-        expression = CucumberExpression.new(expr, parameter_registry)
-        args = expression.match("I have 7 cukes")
+        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])
+      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])
+      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"])
+      it 'matches anonymous' do
+        expect(match('{}', '0.22')).to eq(['0.22'])
       end
 
-      it "exposes source" do
-        expr = "I have {int} cuke(s)"
-        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
+      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(CucumberExpression.new(expr, ParameterTypeRegistry.new).to_s).to eq(expr.inspect)
+      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
+      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 = CucumberExpression.new(
-            '{textAndOrNumber}',
-            parameter_type_registry
+          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
+        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"])
+        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
+      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
-            )
+          ParameterType.new(
+            'widget',
+            /\w+/,
+            Object,
+            ->(s) { self.create_widget(s) },
+            false,
+            true
+          )
         )
-        expression = CucumberExpression.new(
-            'I have a {widget}',
-            parameter_type_registry
+        expression = described_class.new(
+          'I have a {widget}',
+          parameter_type_registry
         )
 
         class World
@@ -153,27 +150,27 @@ module Cucumber
           end
         end
 
-        args = expression.match("I have a bolt")
+        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
+      it 'reports undefined parameter type name' do
         parameter_type_registry = ParameterTypeRegistry.new
 
-        begin
-          CucumberExpression.new(
-              'I have {int} {widget}(s) in {word}',
-              parameter_type_registry
-          )
-        rescue UndefinedParameterTypeError => e
-          expect(e.undefined_parameter_type_name).to eq('widget')
-        end
+        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