cucumber-cucumber-expressions 10.0.0 → 10.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50c9796de315f381ef13e5ce25d8e6342b71c02a2e0b15067858806e3e312716
-  data.tar.gz: c21a0b6a20af97e368833ba1ef95e22c7316d3fd9db677895c9ad0d2653b5f3e
+  metadata.gz: 705a1aa48bf85408fc0db737e50091584f930c7e73e6ffe485f5c8cdf0c8a9f4
+  data.tar.gz: 3d40ff2d7b847cb5b44aa547ab6e46791e769abccf7beaf14e5de9f0440710e3
 SHA512:
-  metadata.gz: 56bb332b0b0bab9c250e855c13d94bd166ff660e3c6f054946a4f3b65dfc2ec9d79ef360ff4d2bf93fa73d943e396c38ac1405aaa348a5fa0bf9f35c65755339
-  data.tar.gz: b60ff154a2f586a4765271e5ff838331d89337c3a13c32e039169a81d3ad42ebfc22332f9a6fcb518577ff17edc543781e83eb2849e45076f0a207379b4747d8
+  metadata.gz: e9407c5108c578c553831398255986de2bee9393500adb35f3528b359e05ae0cc3df966b163da15052623b0dfe01efb2b64e624a1976030dc0c9d355e279cf89
+  data.tar.gz: 51ce8f4c93b3948dbb36c34cd221f48aa29c2eb812fb4d7a582b2644b4118d1e6373d1de644c5d78470525bc80a9ab4dae6f414eec27ef55e3c6a76fedce2ee1

data/VERSION

@@ -0,0 +1 @@
+10.3.0

data/cucumber-cucumber-expressions.gemspec

@@ -1,7 +1,10 @@
 # -*- encoding: utf-8 -*-
+
+version = File.read(File.expand_path("VERSION", __dir__)).strip
+
 Gem::Specification.new do |s|
   s.name        = 'cucumber-cucumber-expressions'
-  s.version     = '10.0.0'
+  s.version     = version
   s.authors     = ["Aslak Hellesøy"]
   s.description = 'Cucumber Expressions - a simpler alternative to Regular Expressions'
   s.summary     = "cucumber-expressions-#{s.version}"

data/default.mk

@@ -3,6 +3,10 @@ RUBY_SOURCE_FILES = $(shell find . -name "*.rb")
 GEMSPEC = $(shell find . -name "*.gemspec")
 LIBNAME := $(shell basename $$(dirname $$(pwd)))
 GEM := cucumber-$(LIBNAME)-$(NEW_VERSION).gem
+IS_TESTDATA = $(findstring -testdata,${CURDIR})
+
+# https://stackoverflow.com/questions/2483182/recursive-wildcards-in-gnu-make
+rwildcard=$(foreach d,$(wildcard $(1:=/*)),$(call rwildcard,$d,$2) $(filter $(subst *,%,$2),$d))
 
 default: .tested
 .PHONY: default
@@ -45,22 +49,25 @@ pre-release: remove-local-dependencies update-version update-dependencies gem
 .PHONY: pre-release
 
 update-version:
+ifeq ($(IS_TESTDATA),-testdata)
+	# no-op
+else
 ifdef NEW_VERSION
-ifneq (,$(GEMSPEC))
-	sed -i "s/\(s\.version *= *'\)[0-9]*\.[0-9]*\.[0-9]*\('\)/\1$(NEW_VERSION)\2/" $(GEMSPEC)
+	@echo "$(NEW_VERSION)" > VERSION
 endif
-else
-	@echo -e "\033[0;31mNEW_VERSION is not defined. Can't update version :-(\033[0m"
-	exit 1
 endif
 .PHONY: update-version
 
 publish: gem
+ifeq ($(IS_TESTDATA),-testdata)
+	# no-op
+else
 ifneq (,$(GEMSPEC))
 	gem push $(GEM)
 else
 	@echo "Not publishing because there is no gemspec"
 endif
+endif
 .PHONY: publish
 
 post-release:
@@ -72,5 +79,5 @@ clean: clean-ruby
 .PHONY: clean
 
 clean-ruby:
-	rm -f .deps .linked .tested* Gemfile.lock *.gem
+	rm -rf .deps .linked .tested* Gemfile.lock *.gem acceptance
 .PHONY: clean-ruby

data/examples.txt

@@ -29,3 +29,11 @@ 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]
+---
+Some ${float} of cukes at {int}° Celsius
+Some $3.50 of cukes at 42° Celsius
+[3.5,42]

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_matcher.rb

@@ -47,12 +47,12 @@ module Cucumber
 
       def space_before_match_or_sentence_start?
         match_begin = @match.begin(0)
-        match_begin == 0 || @text[match_begin - 1].match(/\s|\p{P}/)
+        match_begin == 0 || @text[match_begin - 1].match(/\p{Z}|\p{P}|\p{S}/)
       end
 
       def space_after_match_or_sentence_end?
         match_end = @match.end(0)
-        match_end == @text.length || @text[match_end].match(/\s|\p{P}/)
+        match_end == @text.length || @text[match_end].match(/\p{Z}|\p{P}|\p{S}/)
       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.0.0
+  version: 10.3.0
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-31 00:00:00.000000000 Z
+date: 2020-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,6 +66,7 @@ files:
 - Makefile
 - README.md
 - Rakefile
+- VERSION
 - cucumber-cucumber-expressions.gemspec
 - default.mk
 - examples.txt
@@ -122,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.0.0
+summary: cucumber-expressions-10.3.0
 test_files:
 - spec/capture_warnings.rb
 - spec/cucumber/cucumber_expressions/argument_spec.rb