cucumber-cucumber-expressions 10.2.0 → 10.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5807f447d5dce48e6b1153547119c4ca61b20003f470728ec3e3d6675265aef2
-  data.tar.gz: 12896256efd40509d7267019c02e3561b81d4f2be1b481fac1696400e5be7d04
+  metadata.gz: 5bba8569a4b4b7ae2a05e97b5d2e5f7b8c455b6843175475a6d55d4fb58fe8e5
+  data.tar.gz: 443f0d744039bdd83e4aff50ef3e71738222e3436d8c094195b1e916f33078cd
 SHA512:
-  metadata.gz: 3c2eaff08f07d7cacc6d8f643b30dc51941c3bc2acb38e3f63f5d7c3dac7239c04982f41f2da73837c643a11d8c9ad55aee72944e31c1c6e8bd070e4e3ad6973
-  data.tar.gz: 1ef0bb4db4c9ba93a4baa484cf4158169fcd4174659fa6e3d41588f8bee3307928d508319699957d75dd3f63d2242dc0dc481263ad2a07c3574511ac0051d9d7
+  metadata.gz: 3548b8ae4d3ac5f91f8a5ad31bda608cf3bdf1d24150bb0c95206966e6e5ace38506830cdda614a1b0957e257a6be78607037ddba77e73521da05011eabdb84c
+  data.tar.gz: 89b1992ef048d7bdcf5c62aaa0038508bf80fbb5d5383a1cd96746c9f6dcf50223f44b7ddf5ac943d0e51515da2f631d6e03cce662c52660f59617c0eb822081

data/VERSION

@@ -1 +1 @@
-10.2.0
+10.2.1

data/examples.txt

@@ -29,3 +29,7 @@ I have 22 cukes in my belly now
 I have {} cuke(s) in my {} now
 I have 22 cukes in my belly now
 ["22","belly"]
+---
+/^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
+a purchase for $33
+[null,33]

data/lib/cucumber/cucumber_expressions/group.rb

@@ -11,7 +11,7 @@ module Cucumber
       end
 
       def values
-        (children.empty? ? [self] : children).map(&:value).compact
+        (children.empty? ? [self] : children).map(&:value)
       end
     end
   end

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -18,7 +18,7 @@ module Cucumber
         define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, true, true))
         define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, lambda {|s = nil| s && s.to_f}, true, false))
         define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, lambda {|s = nil| s}, false, false))
-        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, lambda {|s = nil| s && s.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
+        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, lambda { |s1, s2| arg = s1 != nil ? s1 : s2; arg.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
         define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, lambda {|s = nil| s}, false, true))
       end
 

data/lib/cucumber/cucumber_expressions/tree_regexp.rb

@@ -8,68 +8,75 @@ module Cucumber
 
       def initialize(regexp)
         @regexp = regexp.is_a?(Regexp) ? regexp : Regexp.new(regexp)
-        @stack = [GroupBuilder.new]
+        @group_builder = create_group_builder(@regexp)
+      end
+
+      def match(s)
+        match = @regexp.match(s)
+        return nil if match.nil?
+        group_indices = (0..match.length).to_a.to_enum
+        @group_builder.build(match, group_indices)
+      end
+
+      private def is_non_capturing(source, i)
+        # Regex is valid. Bounds check not required.
+        if source[i+1] != '?'
+          # (X)
+          return false
+        end
+
+        if source[i+2] != '<'
+          # (?:X)
+          # (?idmsuxU-idmsuxU)
+          # (?idmsux-idmsux:X)
+          # (?=X)
+          # (?!X)
+          # (?>X)
+          return true
+        end
+
+        if source[i+3] == '=' || source[i+3] == '!'
+          # (?<=X)
+          # (?<!X)
+          return true
+        end
+
+        # (?<name>X)
+        raise CucumberExpressionError.new("Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329")
+      end
+
+      private def create_group_builder(regexp)
+        source = regexp.source
+        stack = [GroupBuilder.new]
         group_start_stack = []
-        last = nil
         escaping = false
-        @non_capturing_maybe = false
-        @name_capturing_maybe = false
         char_class = false
-
-        @regexp.source.each_char.with_index do |c, n|
+        source.each_char.with_index do |c, i|
           if c == '[' && !escaping
             char_class = true
           elsif c == ']' && !escaping
             char_class = false
           elsif c == '(' && !escaping && !char_class
-            @stack.push(GroupBuilder.new)
-            group_start_stack.push(n + 1)
-            @non_capturing_maybe = false
+            group_start_stack.push(i)
+            group_builder = GroupBuilder.new
+            non_capturing = is_non_capturing(source, i)
+            if non_capturing
+              group_builder.set_non_capturing!
+            end
+            stack.push(group_builder)
           elsif c == ')' && !escaping && !char_class
-            gb = @stack.pop
+            gb = stack.pop
             group_start = group_start_stack.pop
             if gb.capturing?
-              gb.source = @regexp.source[group_start...n]
-              @stack.last.add(gb)
+              gb.source = source[group_start + 1...i]
+              stack.last.add(gb)
             else
-              gb.move_children_to(@stack.last)
+              gb.move_children_to(stack.last)
             end
-            end_group
-          elsif c == '?' && last == '('
-            @non_capturing_maybe = true
-          elsif (c == '<') && @non_capturing_maybe
-            @name_capturing_maybe = true
-          elsif (c == ':' || c == '!' || c == '=') && last == '?' && @non_capturing_maybe
-            end_non_capturing_group
-          elsif (c == '=' || c == '!') && last == '<' && @name_capturing_maybe
-            end_non_capturing_group
-          elsif @name_capturing_maybe
-            raise CucumberExpressionError.new("Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329")
           end
-
           escaping = c == '\\' && !escaping
-          last = c
         end
-        @group_builder = @stack.pop
-      end
-
-      def match(s)
-        match = @regexp.match(s)
-        return nil if match.nil?
-        group_indices = (0..match.length).to_a.to_enum
-        @group_builder.build(match, group_indices)
-      end
-
-      private
-
-      def end_non_capturing_group
-        @stack.last.set_non_capturing!
-        end_group
-      end
-
-      def end_group
-        @non_capturing_maybe = false
-        @name_capturing_maybe = false
+        stack.pop
       end
     end
   end

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -201,6 +201,33 @@ module Cucumber
         end
       end
 
+
+      it "unmatched optional groups have undefined values" do
+        parameter_type_registry = ParameterTypeRegistry.new
+        parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+                'textAndOrNumber',
+                /([A-Z]+)?(?: )?([0-9]+)?/,
+                Object,
+                -> (s1, s2) {
+                  [s1, s2]
+                },
+                false,
+                true
+            )
+        )
+        expression = CucumberExpression.new(
+            '{textAndOrNumber}',
+            parameter_type_registry
+        )
+
+        class World
+        end
+
+        expect(expression.match("TLA")[0].value(World.new)).to eq(["TLA", nil])
+        expect(expression.match("123")[0].value(World.new)).to eq([nil, "123"])
+      end
+
       def match(expression, text)
         cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
         args = cucumber_expression.match(text)

data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -22,6 +22,7 @@ module Cucumber
         group = tr.match('abc')
         expect(group.value).to eq('abc')
         expect(group.children.length).to eq 1
+        expect(group.children[0].value).to eq('c')
       end
 
       it 'ignores `?!` as a non-capturing group' do
@@ -55,6 +56,28 @@ module Cucumber
         expect(group.children.length).to eq 1
       end
 
+      it 'ignores `?<!` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(.+)(?<!b)$/)
+        group = tr.match('abc')
+        expect(group.value).to eq('abc')
+        expect(group.children[0].value).to eq('bc')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'ignores `?>` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(?>b)c/)
+        group = tr.match('abc')
+        expect(group.value).to eq('abc')
+        expect(group.children.length).to eq 0
+      end
+
+      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/)
+      end
+
       it 'matches optional group' do
         tr = TreeRegexp.new(/^Something( with an optional argument)?/)
         group = tr.match('Something')
@@ -122,12 +145,42 @@ module Cucumber
         expect(group.children.length).to eq(1)
       end
 
-      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/)
+      it 'works with inline flags' do
+        tr = TreeRegexp.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)/)
+        group = tr.match('hello')
+        expect(group.value).to eq('hello')
+        expect(group.children.length).to eq 0
       end
+
+      it 'works with empty capturing group' do
+        tr = TreeRegexp.new(/()/)
+        group = tr.match('')
+        expect(group.value).to eq('')
+        expect(group.children[0].value).to eq('')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'works with empty non-capturing group' do
+        tr = TreeRegexp.new(/(?:)/)
+        group = tr.match('')
+        expect(group.value).to eq('')
+        expect(group.children.length).to eq 0
+      end
+
+      it 'works with empty non-look ahead' do
+        tr = TreeRegexp.new(/(?<=)/)
+        group = tr.match('')
+        expect(group.value).to eq('')
+        expect(group.children.length).to eq 0
+      end
+
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-cucumber-expressions
 version: !ruby/object:Gem::Version
-  version: 10.2.0
+  version: 10.2.1
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-28 00:00:00.000000000 Z
+date: 2020-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -123,11 +123,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-10.2.0
+summary: cucumber-expressions-10.2.1
 test_files:
 - spec/capture_warnings.rb
 - spec/cucumber/cucumber_expressions/argument_spec.rb