cucumber-cucumber-expressions 10.2.0 → 11.0.1

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

@@ -9,12 +9,16 @@ module Cucumber
       attr_reader :name, :type, :regexps
 
       def self.check_parameter_type_name(type_name)
+        unless is_valid_parameter_type_name(type_name)
+          raise CucumberExpressionError.new("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '[]()$.|?*+'")
+        end
+      end
+
+      def self.is_valid_parameter_type_name(type_name)
         unescaped_type_name = type_name.gsub(UNESCAPE_PATTERN) do
           $2
         end
-        if ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name
-          raise CucumberExpressionError.new("Illegal character '#{$1}' in parameter name {#{unescaped_type_name}}")
-        end
+        !(ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name)
       end
 
       def prefer_for_regexp_match?
@@ -58,16 +62,17 @@ module Cucumber
 
       private
 
+
       def string_array(regexps)
         array = regexps.is_a?(Array) ? regexps : [regexps]
-        array.map {|regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp)}
+        array.map { |regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp) }
       end
 
       def regexp_source(regexp)
         [
-          'EXTENDED',
-          'IGNORECASE',
-          'MULTILINE'
+            'EXTENDED',
+            'IGNORECASE',
+            'MULTILINE'
         ].each do |option_name|
           option = Regexp.const_get(option_name)
           if regexp.options & option != 0

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

@@ -0,0 +1,24 @@
+require 'yaml'
+require 'json'
+require 'cucumber/cucumber_expressions/cucumber_expression_parser'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    describe 'Cucumber expression parser' do
+      Dir['testdata/ast/*.yaml'].each do |testcase|
+        expectation = YAML.load_file(testcase) # encoding?
+        it "#{testcase}" do
+          parser = CucumberExpressionParser.new
+          if expectation['exception'].nil?
+            node = parser.parse(expectation['expression'])
+            node_hash = node.to_hash
+            expect(node_hash).to eq(JSON.parse(expectation['expected']))
+          else
+            expect { parser.parse(expectation['expression']) }.to raise_error(expectation['exception'])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,9 +1,39 @@
+require 'yaml'
+require 'json'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
 
 module Cucumber
   module CucumberExpressions
     describe CucumberExpression do
+
+      Dir['testdata/expression/*.yaml'].each do |testcase|
+        expectation = YAML.load_file(testcase) # encoding?
+        it "#{testcase}" do
+          parameter_registry = ParameterTypeRegistry.new
+          if expectation['exception'].nil?
+            cucumber_expression = CucumberExpression.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(JSON.parse(expectation['expected']))
+          else
+            expect {
+              cucumber_expression = CucumberExpression.new(expectation['expression'], parameter_registry)
+              cucumber_expression.match(expectation['text'])
+            }.to raise_error(expectation['exception'])
+          end
+        end
+      end
+
+      Dir['testdata/regex/*.yaml'].each do |testcase|
+        expectation = YAML.load_file(testcase) # encoding?
+        it "#{testcase}" do
+          parameter_registry = ParameterTypeRegistry.new
+          cucumber_expression = CucumberExpression.new(expectation['expression'], parameter_registry)
+          expect(cucumber_expression.regexp.source).to eq(expectation['expected'])
+        end
+      end
+
       it "documents match arguments" do
         parameter_registry = ParameterTypeRegistry.new
 
@@ -15,82 +45,6 @@ module Cucumber
         ### [capture-match-arguments]
       end
 
-      it "matches word" do
-        expect(match("three {word} mice", "three blind mice")).to eq(['blind'])
-      end
-
-      it('matches double quoted string') do
-        expect(match('three {string} mice', 'three "blind" mice')).to eq(['blind'])
-      end
-
-      it('matches multiple double quoted strings') do
-        expect(match('three {string} and {string} mice', 'three "blind" and "crippled" mice')).to eq(['blind', 'crippled'])
-      end
-
-      it('matches single quoted string') do
-        expect(match('three {string} mice', "three 'blind' mice")).to eq(['blind'])
-      end
-
-      it('matches multiple single quoted strings') do
-        expect(match('three {string} and {string} mice', "three 'blind' and 'crippled' mice")).to eq(['blind', 'crippled'])
-      end
-
-      it('does not match misquoted string') do
-        expect(match('three {string} mice', 'three "blind\' mice')).to eq(nil)
-      end
-
-      it('matches single quoted string with double quotes') do
-        expect(match('three {string} mice', 'three \'"blind"\' mice')).to eq(['"blind"'])
-      end
-
-      it('matches double quoted string with single quotes') do
-        expect(match('three {string} mice', 'three "\'blind\'" mice')).to eq(["'blind'"])
-      end
-
-      it('matches double quoted string with escaped double quote') do
-        expect(match('three {string} mice', 'three "bl\\"nd" mice')).to eq(['bl"nd'])
-      end
-
-      it('matches single quoted string with escaped single quote') do
-        expect(match('three {string} mice', "three 'bl\\'nd' mice")).to eq(["bl'nd"])
-      end
-
-      it('matches single quoted empty string as empty string') do
-        expect(match('three {string} mice', "three '' mice")).to eq([''])
-      end
-
-      it('matches double quoted empty string as empty string') do
-        expect(match('three {string} mice', 'three "" mice')).to eq([''])
-      end
-
-      it('matches single quoted empty string as empty string, along with other strings') do
-        expect(match('three {string} and {string} mice', "three '' and 'handsome' mice")).to eq(['', 'handsome'])
-      end
-
-      it('matches double quoted empty string as empty string, along with other strings') do
-        expect(match('three {string} and {string} mice', 'three "" and "handsome" mice')).to eq(['', 'handsome'])
-      end
-
-      it 'matches escaped parentheses' do
-        expect(match('three \\(exceptionally) {string} mice', 'three (exceptionally) "blind" mice')).to eq(['blind'])
-      end
-
-      it "matches escaped slash" do
-        expect(match("12\\/2020", "12/2020")).to eq([])
-      end
-
-      it "matches int" do
-        expect(match("{int}", "22")).to eq([22])
-      end
-
-      it "doesn't match float as int" do
-        expect(match("{int}", "1.22")).to be_nil
-      end
-
-      it "matches int as float" do
-        expect(match("{float}", "0")).to eq([0.0])
-      end
-
       it "matches float" do
         expect(match("{float}", "")).to eq(nil)
         expect(match("{float}", ".")).to eq(nil)
@@ -126,58 +80,64 @@ module Cucumber
         expect(match("{float}", "-.1E2")).to eq([-10])
       end
 
-      it "matches anonymous" do
-        expect(match("{}", "0.22")).to eq(["0.22"])
-      end
-
-      '[]()$.|?*+'.split('').each do |char|
-        it "does not allow parameter type with #{char}" do
-          expect {match("{#{char}string}", "something")}.to raise_error("Illegal character '#{char}' in parameter name {#{char}string}")
-        end
+      it "float with zero" do
+        expect(match("{float}", "0")).to eq([0.0])
       end
 
-      it "throws unknown parameter type" do
-        expect {match("{unknown}", "something")}.to raise_error('Undefined parameter type {unknown}')
+      it "matches anonymous" do
+        expect(match("{}", "0.22")).to eq(["0.22"])
       end
 
-      it "does not allow optional parameter types" do
-        expect {match("({int})", "3")}.to raise_error('Parameter types cannot be optional: ({int})')
+      it "exposes source" do
+        expr = "I have {int} cuke(s)"
+        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
       end
 
-      it "does allow escaped optional parameter types" do
-        expect(match("\\({int})", "(3)")).to eq([3])
-      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
+        )
 
-      it "does not allow text/parameter type alternation" do
-        expect {match("x/{int}", "3")}.to raise_error('Parameter types cannot be alternative: x/{int}')
-      end
+        class World
+        end
 
-      it "does not allow parameter type/text alternation" do
-        expect {match("{int}/x", "3")}.to raise_error('Parameter types cannot be alternative: {int}/x')
+        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
 
-      it "exposes source" do
-        expr = "I have {int} cuke(s)"
-        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
-      end
+      # Ruby specific
 
       it "delegates transform to custom object" do
         parameter_type_registry = ParameterTypeRegistry.new
         parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-                  'widget',
-                  /\w+/,
-                  Object,
-                  -> (s) {
-                    self.create_widget(s)
-                  },
-                  false,
-                  true
-              )
+            ParameterType.new(
+                'widget',
+                /\w+/,
+                Object,
+                -> (s) {
+                  self.create_widget(s)
+                },
+                false,
+                true
+            )
         )
         expression = CucumberExpression.new(
-          'I have a {widget}',
-          parameter_type_registry
+            'I have a {widget}',
+            parameter_type_registry
         )
 
         class World
@@ -190,22 +150,11 @@ module Cucumber
         expect(args[0].value(World.new)).to eq('widget:bolt')
       end
 
-      describe "escapes special characters" do
-        %w(\\ [ ] ^ $ . | ? * +).each do |character|
-          it "escapes #{character}" do
-            expr = "I have {int} cuke(s) and #{character}"
-            expression = CucumberExpression.new(expr, ParameterTypeRegistry.new)
-            arg1 = expression.match("I have 800 cukes and #{character}")[0]
-            expect(arg1.value(nil)).to eq(800)
-          end
-        end
-      end
-
       def match(expression, text)
         cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
         args = cucumber_expression.match(text)
         return nil if args.nil?
-        args.map {|arg| arg.value(nil)}
+        args.map { |arg| arg.value(nil) }
       end
     end
   end