cucumber-cucumber-expressions 17.0.1 → 17.0.2

data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -13,13 +13,13 @@ 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
         parameter_registry = ParameterTypeRegistry.new
         ### [generate-expression]
-        generator = CucumberExpressionGenerator.new(parameter_registry)
+        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')
@@ -69,7 +69,7 @@ module Cucumber
             'currency',
             '[A-Z]{3}',
             Currency,
-            ->(s) { Currency.new(s)},
+            ->(s) { Currency.new(s) },
             true,
             true
           )
@@ -91,7 +91,7 @@ module Cucumber
             'optional-flight',
             /(1st flight)?/,
             String,
-            ->(s) { s},
+            ->(s) { s },
             true,
             false
           )
@@ -101,7 +101,7 @@ module Cucumber
             'optional-hotel',
             /(1 hotel)?/,
             String,
-            ->(s) { s},
+            ->(s) { s },
             true,
             false
           )
@@ -121,7 +121,7 @@ module Cucumber
               "my-type-#{i}",
               /([a-z] )*?[a-z]/,
               String,
-              ->(s) { s},
+              ->(s) { s },
               true,
               false
             )
@@ -139,7 +139,7 @@ module Cucumber
             'zero-or-more',
             /[a-z]*/,
             String,
-            ->(s) { s},
+            ->(s) { s },
             true,
             false
           )
@@ -149,7 +149,7 @@ module Cucumber
             'exactly-one',
             /[a-z]/,
             String,
-            ->(s) { s},
+            ->(s) { s },
             true,
             false
           )
@@ -168,7 +168,7 @@ module Cucumber
               'direction',
               /(up|down)/,
               String,
-              ->(s) { s},
+              ->(s) { s },
               true,
               false
             )
@@ -198,7 +198,7 @@ module Cucumber
               'direction',
               /(up|down)/,
               String,
-              ->(s) { s},
+              ->(s) { s },
               true,
               false
             )

data/spec/cucumber/cucumber_expressions/cucumber_expression_parser_spec.rb

@@ -10,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

@@ -14,11 +14,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 do |arg|
               value = arg.value(nil)
@@ -43,7 +43,7 @@ module Cucumber
 
         ### [capture-match-arguments]
         expr = 'I have {int} cuke(s)'
-        expression = CucumberExpression.new(expr, parameter_registry)
+        expression = described_class.new(expr, parameter_registry)
         args = expression.match('I have 7 cukes')
 
         expect(args[0].value(nil)).to eq(7)
@@ -96,13 +96,13 @@ module Cucumber
       it 'exposes source' do
         expr = 'I have {int} cuke(s)'
 
-        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
+        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)
+        expect(described_class.new(expr, ParameterTypeRegistry.new).to_s).to eq(expr.inspect)
       end
 
       it 'unmatched optional groups have undefined values' do
@@ -117,7 +117,7 @@ module Cucumber
             true
           )
         )
-        expression = CucumberExpression.new('{textAndOrNumber}', parameter_type_registry)
+        expression = described_class.new('{textAndOrNumber}', parameter_type_registry)
 
         class World; end
 
@@ -139,7 +139,7 @@ module Cucumber
             true
           )
         )
-        expression = CucumberExpression.new(
+        expression = described_class.new(
           'I have a {widget}',
           parameter_type_registry
         )
@@ -158,7 +158,7 @@ module Cucumber
       it 'reports undefined parameter type name' do
         parameter_type_registry = ParameterTypeRegistry.new
 
-        CucumberExpression.new(
+        described_class.new(
           'I have {int} {widget}(s) in {word}',
           parameter_type_registry
         )

data/spec/cucumber/cucumber_expressions/cucumber_expression_tokenizer_spec.rb

@@ -10,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

@@ -13,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

@@ -73,7 +73,7 @@ module Cucumber
 
       describe CucumberExpression do
         it 'matches parameters with custom parameter type' do
-          expression = CucumberExpression.new('I have a {color} ball', @parameter_type_registry)
+          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'))
@@ -91,7 +91,7 @@ module Cucumber
             )
           )
 
-          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)
@@ -116,7 +116,7 @@ module Cucumber
               false
             )
           )
-          expression = CucumberExpression.new('I have a {color} ball', parameter_type_registry)
+          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'))
@@ -133,7 +133,7 @@ module Cucumber
               false
             )
           )
-          expression = CucumberExpression.new('I have a {throwing} parameter', @parameter_type_registry)
+          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]")
@@ -179,12 +179,12 @@ module Cucumber
                 false
               )
             )
-            css_color = CucumberExpression.new('I have a {css-color} ball', @parameter_type_registry)
+            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 = CucumberExpression.new('I have a {color} ball', @parameter_type_registry)
+            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'))
@@ -205,7 +205,7 @@ module Cucumber
               false
             )
           )
-          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
+          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'))

data/spec/cucumber/cucumber_expressions/expression_factory_spec.rb

@@ -6,7 +6,7 @@ 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

@@ -14,24 +14,24 @@ module Cucumber
 
     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, ->(s) { Name.new }, true, true))
-        @registry.define_parameter_type(ParameterType.new('person', CAPITALISED_WORD, Person, ->(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, ->(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}'
+          '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, ->(s) { Name.new }, true, false)
-        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new }, true, true)
-        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(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)
@@ -41,9 +41,9 @@ module Cucumber
       end
 
       it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
-        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new }, true, false)
-        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new }, true, false)
-        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(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)

data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
     describe ParameterType do
       it 'does not allow ignore flag on regexp' do
         expect do
-          ParameterType.new('case-insensitive', /[a-z]+/i, String, ->(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"

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -12,7 +12,7 @@ module Cucumber
 
         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) }
 
@@ -75,7 +75,7 @@ module Cucumber
 
       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)

data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -6,12 +6,12 @@ module Cucumber
   module CucumberExpressions
     describe TreeRegexp do
       it 'exposes the group source' do
-        tr = TreeRegexp.new(/(a(?:b)?)(c)/)
+        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 = TreeRegexp.new(/(a(?:b)?)(c)/)
+        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')
@@ -20,7 +20,7 @@ module Cucumber
       end
 
       it 'ignores `?:` as a non-capturing group' do
-        tr = TreeRegexp.new(/a(?:b)(c)/)
+        tr = described_class.new(/a(?:b)(c)/)
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children.length).to eq 1
@@ -28,14 +28,14 @@ module Cucumber
       end
 
       it 'ignores `?!` as a non-capturing group' do
-        tr = TreeRegexp.new(/a(?!b)(.+)/)
+        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 = TreeRegexp.new(/a(?=b)(.+)$/)
+        tr = described_class.new(/a(?=b)(.+)$/)
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children[0].value).to eq('bc')
@@ -43,7 +43,7 @@ module Cucumber
       end
 
       it 'ignores `?<=` as a non-capturing group' do
-        tr = TreeRegexp.new(/a(.+)(?<=c)$/)
+        tr = described_class.new(/a(.+)(?<=c)$/)
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children[0].value).to eq('bc')
@@ -51,7 +51,7 @@ module Cucumber
       end
 
       it 'ignores `?<!` as a non-capturing group' do
-        tr = TreeRegexp.new(/a(.+)(?<!b)$/)
+        tr = described_class.new(/a(.+)(?<!b)$/)
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children[0].value).to eq('bc')
@@ -59,7 +59,7 @@ module Cucumber
       end
 
       it 'ignores `?<!` as a non-capturing group' do
-        tr = TreeRegexp.new(/a(.+)(?<!b)$/)
+        tr = described_class.new(/a(.+)(?<!b)$/)
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children[0].value).to eq('bc')
@@ -67,7 +67,7 @@ module Cucumber
       end
 
       it 'ignores `?>` as a non-capturing group' do
-        tr = TreeRegexp.new(/a(?>b)c/)
+        tr = described_class.new(/a(?>b)c/)
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children.length).to eq 0
@@ -75,19 +75,18 @@ module Cucumber
 
       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 {
-          TreeRegexp.new(/^I am a person( named "(?<first_name>.+) (?<last_name>.+)")?$/)
-        }.to raise_error(/Named capture groups are not supported/)
+        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 = TreeRegexp.new(/^Something( with an optional argument)?/)
+        tr = described_class.new(/^Something( with an optional argument)?/)
         group = tr.match('Something')
-        expect(group.children[0].value).to eq(nil)
+        expect(group.children[0].value).to be_nil
       end
 
       it 'matches nested groups' do
-        tr = TreeRegexp.new(/^A (\d+) thick line from ((\d+),\s*(\d+),\s*(\d+)) to ((\d+),\s*(\d+),\s*(\d+))/)
+        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')
@@ -102,31 +101,31 @@ module Cucumber
       end
 
       it 'detects multiple non-capturing groups' do
-        tr = TreeRegexp.new(/(?:a)(:b)(\?c)(d)/)
+        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 = TreeRegexp.new(/foo\\(bar|baz)/)
+        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 = TreeRegexp.new(/^I go to '\/(.+)'$/)
+        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 = TreeRegexp.new(/^(\d) (\w+)$/)
+        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 = TreeRegexp.new(/the stdout(?: from "(.*?)")?/)
+        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)
@@ -134,13 +133,13 @@ module Cucumber
       end
 
       it 'works with flags' do
-        tr = TreeRegexp.new(/HELLO/i)
+        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 = TreeRegexp.new(/^drawings: ([A-Z_, ()]+)$/)
+        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)')
@@ -148,21 +147,21 @@ module Cucumber
       end
 
       it 'works with inline flags' do
-        tr = TreeRegexp.new(/(?i)HELLO/)
+        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 = TreeRegexp.new(/(?i:HELLO)/)
+        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 = TreeRegexp.new(/()/)
+        tr = described_class.new(/()/)
         group = tr.match('')
         expect(group.value).to eq('')
         expect(group.children[0].value).to eq('')
@@ -170,14 +169,14 @@ module Cucumber
       end
 
       it 'works with empty non-capturing groups' do
-        tr = TreeRegexp.new(/(?:)/)
+        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 = TreeRegexp.new(/(?<=)/)
+        tr = described_class.new(/(?<=)/)
         group = tr.match('')
         expect(group.value).to eq('')
         expect(group.children.length).to eq 0

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-cucumber-expressions
 version: !ruby/object:Gem::Version
-  version: 17.0.1
+  version: 17.0.2
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-24 00:00:00.000000000 Z
+date: 2024-02-20 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,6 +78,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.27.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 description: Cucumber Expressions - a simpler alternative to Regular Expressions
 email: cukes@googlegroups.com
 executables: []
@@ -94,7 +150,7 @@ files:
 - lib/cucumber/cucumber_expressions/regular_expression.rb
 - lib/cucumber/cucumber_expressions/tree_regexp.rb
 - spec/cucumber/cucumber_expressions/argument_spec.rb
-- spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb
+- spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_parser_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
@@ -106,7 +162,7 @@ files:
 - spec/cucumber/cucumber_expressions/parameter_type_spec.rb
 - spec/cucumber/cucumber_expressions/regular_expression_spec.rb
 - spec/cucumber/cucumber_expressions/tree_regexp_spec.rb
-homepage: https://github.com/cucumber/cucumber-expressions-ruby#readme
+homepage: https://github.com/cucumber/cucumber-expressions
 licenses:
 - MIT
 metadata:
@@ -131,8 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-17.0.1
+summary: cucumber-expressions-17.0.2
 test_files: []