cucumber-cucumber-expressions 16.1.2 → 17.0.2

data/spec/cucumber/cucumber_expressions/cucumber_expression_tokenizer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/cucumber_expression_tokenizer'
 require 'cucumber/cucumber_expressions/errors'
@@ -8,12 +10,12 @@ module Cucumber
       Dir['../testdata/cucumber-expression/tokenizer/*.yaml'].each do |path|
         expectation = YAML.load_file(path)
         it "tokenizes #{path}" do
-          tokenizer = CucumberExpressionTokenizer.new
+          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}
+            token_hashes = tokens.map { |token| token.to_hash }
             expect(token_hashes).to eq(expectation['expected_tokens'])
           end
         end

data/spec/cucumber/cucumber_expressions/cucumber_expression_transformation_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'
@@ -11,11 +13,11 @@ module Cucumber
           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 { |arg| arg.value(nil) }
             expect(values).to eq(expectation['expected_args'])

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -40,54 +42,56 @@ module Cucumber
       end
     end
 
-    describe "Custom parameter type" do
+    describe 'Custom parameter type' do
       before do
         parameter_type_registry = ParameterTypeRegistry.new
-        parameter_type_registry.define_parameter_type(ParameterType.new(
+        parameter_type_registry.define_parameter_type(
+          ParameterType.new(
             'color',                   # name
             /red|blue|yellow/,         # regexp
             Color,                     # type
-            lambda {|s| Color.new(s)}, # transform
+            ->(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
+      it 'throws exception for illegal character in parameter name' do
         expect do
           ParameterType.new(
-              '[string]',
-              /.*/,
-              String,
-              lambda {|s| s},
-              true,
-              false
+            '[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 = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
-          transformed_argument_value = expression.match("I have a red ball")[0].value(nil)
+        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(
+        it 'matches parameters with multiple capture groups' do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'coordinate',
               /(\d+),\s*(\d+),\s*(\d+)/,
               Coordinate,
-              lambda {|x, y, z| Coordinate.new(x.to_i, y.to_i, z.to_i)},
+              ->(x, y, z) { Coordinate.new(x.to_i, y.to_i, z.to_i) },
               true,
               false
-          ))
-
-          expression = CucumberExpression.new(
-              'A {int} thick line from {coordinate} to {coordinate}',
-              @parameter_type_registry
+            )
           )
+
+          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)
@@ -100,95 +104,110 @@ module Cucumber
           expect(to).to eq(Coordinate.new(40, 50, 60))
         end
 
-        it "matches parameters with custom parameter type using optional capture group" do
+        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(
+          parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'color',
               [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
               Color,
-              lambda {|s| Color.new(s)},
+              ->(s) { Color.new(s) },
               true,
               false
-          ))
-          expression = CucumberExpression.new("I have a {color} ball", parameter_type_registry)
-          transformed_argument_value = expression.match("I have a dark red ball")[0].value(nil)
+            )
+          )
+          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(
+        it 'defers transformation until queried from argument' do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'throwing',
               /bad/,
               CssColor,
-              lambda {|s| raise "Can't transform [#{s}]"},
+              ->(s) { raise "Can't transform [#{s}]" },
               true,
               false
-          ))
-          expression = CucumberExpression.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]")
+            )
+          )
+          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
+        describe 'conflicting parameter type' do
+          it 'is detected for type name' do
             expect {
-              @parameter_type_registry.define_parameter_type(ParameterType.new(
+              @parameter_type_registry.define_parameter_type(
+                ParameterType.new(
                   'color',
                   /.*/,
                   CssColor,
-                  lambda {|s| CssColor.new(s)},
+                  ->(s) { CssColor.new(s) },
                   true,
                   false
-              ))
-            }.to raise_error("There is already a parameter with name color")
+                )
+              )
+            }.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(
+          it 'is not detected for type' do
+            @parameter_type_registry.define_parameter_type(
+              ParameterType.new(
                 'whatever',
                 /.*/,
                 Color,
-                lambda {|s| Color.new(s)},
+                ->(s) { Color.new(s) },
                 false,
                 false
-            ))
+              )
+            )
           end
 
-          it "is not detected for regexp" do
-            @parameter_type_registry.define_parameter_type(ParameterType.new(
+          it 'is not detected for regexp' do
+            @parameter_type_registry.define_parameter_type(
+              ParameterType.new(
                 'css-color',
                 /red|blue|yellow/,
                 CssColor,
-                lambda {|s| CssColor.new(s)},
+                ->(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'))
 
-            css_color = CucumberExpression.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)
 
-            color = CucumberExpression.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"))
+            expect(color_value).to eq(Color.new('blue'))
           end
         end
       end
 
       describe RegularExpression do
-        it "matches arguments with custom parameter type without name" 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(
+          parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               nil,
               /red|blue|yellow/,
               Color,
-              lambda {|s| Color.new(s)},
+              ->(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)
 
-          expression = RegularExpression.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

data/spec/cucumber/cucumber_expressions/expression_factory_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/expression_factory'
 
 module Cucumber
   module CucumberExpressions
     describe ExpressionFactory do
       before do
-        @expression_factory = ExpressionFactory.new(ParameterTypeRegistry.new)
+        @expression_factory = described_class.new(ParameterTypeRegistry.new)
       end
 
       it 'creates a RegularExpression' do

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -1,86 +1,81 @@
+# 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
 
-    CAPITALISED_WORD = /[A-Z]+\w+/
-
-    class Name
-    end
-
-    class Person
-    end
-
-    class Place
-    end
+    class Name; end
+    class Person; end
+    class Place; end
 
     describe ParameterTypeRegistry do
       before do
-        @registry = ParameterTypeRegistry.new
+        @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, lambda {|s| Name.new}, true, true))
-        @registry.define_parameter_type(ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false))
+        @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, lambda {|s| Place.new}, true, true))
+          @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 preferential parameter types, {name} and {place}"
-               )
+          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, lambda {|s| Name.new}, true, false)
-        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, true)
-        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+        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)
+        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, lambda {|s| Name.new}, true, false)
-        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false)
-        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+        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)
+          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"
-               )
+          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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type'
 
 module Cucumber
@@ -5,10 +7,11 @@ module Cucumber
     describe ParameterType do
       it 'does not allow ignore flag on regexp' do
         expect do
-          ParameterType.new("case-insensitive", /[a-z]+/i, String, lambda {|s| s}, true, true)
+          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")
+          "ParameterType Regexps can't use option Regexp::IGNORECASE"
+        )
       end
     end
   end

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/regular_expression'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -7,68 +9,74 @@ module Cucumber
     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 = RegularExpression.new(Regexp.new(expectation['expression']), parameter_registry)
+          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 no transform by default" do
-        expect( match(/(\d\d)/, "22") ).to eq(["22"])
+      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"])
+      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])
+      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])
+      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
+      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([''])
+      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])
+      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'])
+      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"])
+      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
+      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])
+
+        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 parenthesis" do
-        expect( match(/Across the line\(s\)/, 'Across the line(s)') ).to eq([])
+      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
+      it 'exposes source and regexp' do
         regexp = /I have (\d+) cukes? in my (\+) now/
-        expression = RegularExpression.new(regexp, ParameterTypeRegistry.new)
+        expression = described_class.new(regexp, ParameterTypeRegistry.new)
+
         expect(expression.regexp).to eq(regexp)
         expect(expression.source).to eq(regexp.source)
       end
@@ -77,6 +85,7 @@ module Cucumber
         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