cucumber-cucumber-expressions 17.0.0 → 17.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee78437294610438135eff4c78486fa4c034890d72212456fdb6b9e5d4d2221c
-  data.tar.gz: 433dabe226348a05dd14d9b36f57ed1c3ddd94c930e1f8e81332f9f1bb7659f0
+  metadata.gz: cf1302afcc82ce4965f46efebeeea9315e680395bc915142f572ee1f025eecb0
+  data.tar.gz: 06d986ddaaaed001bd00e82059eb685cbb6507241b64b6081905c4373d620e96
 SHA512:
-  metadata.gz: e5a748f6a88bcc7b29c89ec6802f50fe1cab28740685f47ceb4e2cf53db64741006ea43dcb57d6bc420ad5a90d2fbb11f15a39fe0a596237ae1276926696fa6b
-  data.tar.gz: 51c50ce450733d911e8277e515fd1c7e0bd3621c065132e214fbb5b543965f6c873608b35b8436a8cccc87c49fab73d141bf731e2afe979e52c7819bb512e57f
+  metadata.gz: 4ca20260b78e485d7d5f3d085529843c7195a53c0289464b9d02f782bcd1431153dbfc5df1e58ea7c02432d04a9df8d7a60b648f31f4736632697efa1f9addd6
+  data.tar.gz: a66a69755c51e1d1e154ac51230e9f8b784b86a3336ba4b6f87c04c4fc445081bef66c733954ed76d908433ef8648fcff8e5805c5ea01a22d5e2ca1490f4ce21

data/VERSION

@@ -1 +1 @@
-17.0.0
+17.0.1

data/cucumber-cucumber-expressions.gemspec

@@ -16,20 +16,18 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.5'
 
   s.metadata = {
-                    'bug_tracker_uri'   => 'https://github.com/cucumber/cucumber/issues',
-                    'changelog_uri'     => 'https://github.com/cucumber/common/blob/main/cucumber-expressions/CHANGELOG.md',
-                    'documentation_uri' => 'https://cucumber.io/docs/cucumber/cucumber-expressions/',
-                    'mailing_list_uri'  => 'https://groups.google.com/forum/#!forum/cukes',
-                    'source_code_uri'   => 'https://github.com/cucumber/common/blob/main/cucumber-expressions/ruby',
-                  }
+    'bug_tracker_uri' => 'https://github.com/cucumber/cucumber/issues',
+    'changelog_uri'     => 'https://github.com/cucumber/common/blob/main/cucumber-expressions/CHANGELOG.md',
+    'documentation_uri' => 'https://cucumber.io/docs/cucumber/cucumber-expressions/',
+    'mailing_list_uri'  => 'https://groups.google.com/forum/#!forum/cukes',
+    'source_code_uri'   => 'https://github.com/cucumber/common/blob/main/cucumber-expressions/ruby',
+  }
 
   s.add_development_dependency 'rake', '~> 13.0', '>= 13.0.6'
   s.add_development_dependency 'rspec', '~> 3.11', '>= 3.11.0'
   s.add_development_dependency 'rubocop', '~> 1.27.0'
 
-  s.rubygems_version = '>= 3.0.8'
-  s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
-  s.test_files       = `git ls-files -- spec/*`.split("\n")
+  s.files            = `git ls-files`.split("\n").reject { |path| path =~ /\.gitignore$/ }
   s.rdoc_options     = ['--charset=UTF-8']
   s.require_path     = 'lib'
 end

data/lib/cucumber/cucumber_expressions/argument.rb

@@ -16,7 +16,8 @@ module Cucumber
 
         if arg_groups.length != parameter_types.length
           raise CucumberExpressionError.new(
-            "Expression #{tree_regexp.regexp.inspect} has #{arg_groups.length} capture groups (#{arg_groups.map(&:value)}), but there were #{parameter_types.length} parameter types (#{parameter_types.map(&:name)})"
+            "Expression #{tree_regexp.regexp.inspect} has #{arg_groups.length} capture groups (#{arg_groups.map(&:value)}), " \
+            "but there were #{parameter_types.length} parameter types (#{parameter_types.map(&:name)})"
           )
         end
 

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -64,7 +64,7 @@ module Cucumber
         ).generate_expressions
       end
 
-    private
+      private
 
       def create_parameter_type_matchers(text)
         parameter_matchers = []
@@ -84,9 +84,9 @@ module Cucumber
 
       def escape(s)
         s.gsub(/%/, '%%')
-        .gsub(/\(/, '\\(')
-        .gsub(/{/, '\\{')
-        .gsub(/\//, '\\/')
+         .gsub(/\(/, '\\(')
+         .gsub(/{/, '\\{')
+         .gsub(/\//, '\\/')
       end
     end
   end

data/lib/cucumber/cucumber_expressions/group_builder.rb

@@ -18,7 +18,7 @@ module Cucumber
 
       def build(match, group_indices)
         group_index = group_indices.next
-        children = @group_builders.map {|gb| gb.build(match, group_indices)}
+        children = @group_builders.map { |gb| gb.build(match, group_indices) }
         Group.new(match[group_index], match.offset(group_index)[0], match.offset(group_index)[1], children)
       end
 

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -16,19 +16,19 @@ module Cucumber
 
       def initialize
         @parameter_type_by_name = {}
-        @parameter_types_by_regexp = Hash.new {|hash, regexp| hash[regexp] = []}
+        @parameter_types_by_regexp = Hash.new { |hash, regexp| hash[regexp] = [] }
 
-        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i}, true, true))
-        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f}, true, false))
-        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, ->(s = nil) { s}, false, false))
-        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, ->(s1, s2) { arg = s1 != nil ? s1 : s2; arg.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
-        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, ->(s = nil) { s}, false, true))
-        define_parameter_type(ParameterType.new('bigdecimal', FLOAT_REGEXP, BigDecimal, ->(s = nil) { BigDecimal(s)}, false, false))
-        define_parameter_type(ParameterType.new('biginteger', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('byte', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('short', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('long', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('double', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f}, false, false))
+        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, true, true))
+        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f }, true, false))
+        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, ->(s = nil) { s }, false, false))
+        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, ->(s1, s2) { arg = s1 != nil ? s1 : s2; arg.gsub('\\"', '"').gsub("\\'", "'") }, true, false))
+        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, ->(s = nil) { s }, false, true))
+        define_parameter_type(ParameterType.new('bigdecimal', FLOAT_REGEXP, BigDecimal, ->(s = nil) { BigDecimal(s) }, false, false))
+        define_parameter_type(ParameterType.new('biginteger', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('byte', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('short', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('long', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('double', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f }, false, false))
       end
 
       def lookup_by_type_name(name)
@@ -68,7 +68,9 @@ module Cucumber
         parameter_type.regexps.each do |parameter_type_regexp|
           parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
           if parameter_types.any? && parameter_types[0].prefer_for_regexp_match && parameter_type.prefer_for_regexp_match
-            raise CucumberExpressionError.new("There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two preferential parameter types, {#{parameter_types[0].name}} and {#{parameter_type.name}}")
+            raise CucumberExpressionError.new(
+              "There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two: {#{parameter_types[0].name}} and {#{parameter_type.name}}"
+            )
           end
 
           parameter_types.push(parameter_type)

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -24,7 +24,7 @@ module Cucumber
             nil,
             parameter_type_regexp,
             String,
-            ->(*s) { s[0]},
+            ->(*s) { s[0] },
             false,
             false
           )

data/lib/cucumber/cucumber_expressions/tree_regexp.rb

@@ -23,12 +23,12 @@ module Cucumber
 
       private def is_non_capturing(source, i)
         # Regex is valid. Bounds check not required.
-        if source[i+1] != '?'
+        if source[i + 1] != '?'
           # (X)
           return false
         end
 
-        if source[i+2] != '<'
+        if source[i + 2] != '<'
           # (?:X)
           # (?idmsuxU-idmsuxU)
           # (?idmsux-idmsux:X)
@@ -38,7 +38,7 @@ module Cucumber
           return true
         end
 
-        if source[i+3] == '=' || source[i+3] == '!'
+        if source[i + 3] == '=' || source[i + 3] == '!'
           # (?<=X)
           # (?<!X)
           return true

data/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb

@@ -15,13 +15,13 @@ module Cucumber
       it 'generates multiple expressions' do
         parameter_type_combinations = [
           [
-            ParameterType.new('color', /red|blue|yellow/, Color, ->(s) { Color.new}, true, false),
-            ParameterType.new('csscolor', /red|blue|yellow/, CssColor, ->(s) { CssColor.new}, true, false)
+            ParameterType.new('color', /red|blue|yellow/, Color, ->(s) { Color.new }, true, false),
+            ParameterType.new('csscolor', /red|blue|yellow/, CssColor, ->(s) { CssColor.new }, true, false)
           ],
           [
-            ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, Date, ->(s) { Date.new}, true, false),
-            ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, DateTime, ->(s) { DateTime.new}, true, false),
-            ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, Timestamp, ->(s) { Timestamp.new}, true, false)
+            ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, Date, ->(s) { Date.new }, true, false),
+            ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, DateTime, ->(s) { DateTime.new }, true, false),
+            ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, Timestamp, ->(s) { Timestamp.new }, true, false)
           ]
         ]
 
@@ -29,7 +29,7 @@ module Cucumber
           'I bought a {%s} ball on {%s}',
           parameter_type_combinations
         )
-        expressions = factory.generate_expressions.map {|ge| ge.source}
+        expressions = factory.generate_expressions.map { |ge| ge.source }
         expect(expressions).to eq([
             'I bought a {color} ball on {date}',
             'I bought a {color} ball on {datetime}',

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -50,7 +50,7 @@ module Cucumber
             'color',                   # name
             /red|blue|yellow/,         # regexp
             Color,                     # type
-            ->(s) { Color.new(s)},     # transform
+            ->(s) { Color.new(s) },    # transform
             true,                      # use_for_snippets
             false                      # prefer_for_regexp_match
           )
@@ -64,7 +64,7 @@ module Cucumber
             '[string]',
             /.*/,
             String,
-            ->(s) { s},
+            ->(s) { s },
             true,
             false
           )
@@ -85,7 +85,7 @@ module Cucumber
               'coordinate',
               /(\d+),\s*(\d+),\s*(\d+)/,
               Coordinate,
-              ->(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
             )
@@ -111,7 +111,7 @@ module Cucumber
               'color',
               [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
               Color,
-              ->(s) { Color.new(s)},
+              ->(s) { Color.new(s) },
               true,
               false
             )
@@ -128,7 +128,7 @@ module Cucumber
               'throwing',
               /bad/,
               CssColor,
-              ->(s) { raise "Can't transform [#{s}]"},
+              ->(s) { raise "Can't transform [#{s}]" },
               true,
               false
             )
@@ -136,7 +136,7 @@ module Cucumber
           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]")
+          expect { args[0].value(nil) }.to raise_error("Can't transform [bad]")
         end
 
         describe 'conflicting parameter type' do
@@ -147,7 +147,7 @@ module Cucumber
                   'color',
                   /.*/,
                   CssColor,
-                  ->(s) { CssColor.new(s)},
+                  ->(s) { CssColor.new(s) },
                   true,
                   false
                 )
@@ -161,7 +161,7 @@ module Cucumber
                 'whatever',
                 /.*/,
                 Color,
-                ->(s) { Color.new(s)},
+                ->(s) { Color.new(s) },
                 false,
                 false
               )
@@ -174,7 +174,7 @@ module Cucumber
                 'css-color',
                 /red|blue|yellow/,
                 CssColor,
-                ->(s) { CssColor.new(s)},
+                ->(s) { CssColor.new(s) },
                 true,
                 false
               )
@@ -200,7 +200,7 @@ module Cucumber
               nil,
               /red|blue|yellow/,
               Color,
-              ->(s) { Color.new(s)},
+              ->(s) { Color.new(s) },
               true,
               false
             )

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -18,10 +18,10 @@ module Cucumber
       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, ->(s) { Name.new }, true, true))
+        @registry.define_parameter_type(ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { 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, ->(s) { 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}'
@@ -29,9 +29,9 @@ module Cucumber
       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, ->(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)
 
         @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, ->(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)
 
         @registry.define_parameter_type(name)
         @registry.define_parameter_type(person)
@@ -54,23 +54,23 @@ module Cucumber
         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" \
+          "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" \
+          "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"

data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb

@@ -7,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, ->(s) { s}, true, true)
+          ParameterType.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/tree_regexp_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
     describe TreeRegexp do
       it 'exposes the group source' do
         tr = TreeRegexp.new(/(a(?:b)?)(c)/)
-        expect(tr.group_builder.children.map {|gb| gb.source}).to eq(['a(?:b)?', 'c'])
+        expect(tr.group_builder.children.map { |gb| gb.source }).to eq(['a(?:b)?', 'c'])
       end
 
       it 'builds a tree' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-cucumber-expressions
 version: !ruby/object:Gem::Version
-  version: 17.0.0
+  version: 17.0.1
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-06 00:00:00.000000000 Z
+date: 2023-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -134,18 +134,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-17.0.0
-test_files:
-- spec/cucumber/cucumber_expressions/argument_spec.rb
-- spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.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
-- spec/cucumber/cucumber_expressions/cucumber_expression_tokenizer_spec.rb
-- spec/cucumber/cucumber_expressions/cucumber_expression_transformation_spec.rb
-- spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb
-- spec/cucumber/cucumber_expressions/expression_factory_spec.rb
-- spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb
-- spec/cucumber/cucumber_expressions/parameter_type_spec.rb
-- spec/cucumber/cucumber_expressions/regular_expression_spec.rb
-- spec/cucumber/cucumber_expressions/tree_regexp_spec.rb
+summary: cucumber-expressions-17.0.1
+test_files: []