cucumber-cucumber-expressions 10.3.0 → 11.0.0

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/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,34 +80,12 @@ 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
-      end
-
-      it "throws unknown parameter type" do
-        expect {match("{unknown}", "something")}.to raise_error('Undefined parameter type {unknown}')
-      end
-
-      it "does not allow optional parameter types" do
-        expect {match("({int})", "3")}.to raise_error('Parameter types cannot be optional: ({int})')
-      end
-
-      it "does allow escaped optional parameter types" do
-        expect(match("\\({int})", "(3)")).to eq([3])
-      end
-
-      it "does not allow text/parameter type alternation" do
-        expect {match("x/{int}", "3")}.to raise_error('Parameter types cannot be alternative: x/{int}')
+      it "float with zero" do
+        expect(match("{float}", "0")).to eq([0.0])
       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')
+      it "matches anonymous" do
+        expect(match("{}", "0.22")).to eq(["0.22"])
       end
 
       it "exposes source" do
@@ -161,78 +93,68 @@ module Cucumber
         expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
       end
 
-      it "delegates transform to custom object" do
+      it "unmatched optional groups have undefined values" 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(
+                'textAndOrNumber',
+                /([A-Z]+)?(?: )?([0-9]+)?/,
+                Object,
+                -> (s1, s2) {
+                  [s1, s2]
+                },
+                false,
+                true
+            )
         )
         expression = CucumberExpression.new(
-          'I have a {widget}',
-          parameter_type_registry
+            '{textAndOrNumber}',
+            parameter_type_registry
         )
 
         class World
-          def create_widget(s)
-            "widget:#{s}"
-          end
         end
 
-        args = expression.match("I have a bolt")
-        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
+        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
 
+      # Ruby specific
 
-      it "unmatched optional groups have undefined values" do
+      it "delegates transform to custom object" do
         parameter_type_registry = ParameterTypeRegistry.new
         parameter_type_registry.define_parameter_type(
             ParameterType.new(
-                'textAndOrNumber',
-                /([A-Z]+)?(?: )?([0-9]+)?/,
+                'widget',
+                /\w+/,
                 Object,
-                -> (s1, s2) {
-                  [s1, s2]
+                -> (s) {
+                  self.create_widget(s)
                 },
                 false,
                 true
             )
         )
         expression = CucumberExpression.new(
-            '{textAndOrNumber}',
+            'I have a {widget}',
             parameter_type_registry
         )
 
         class World
+          def create_widget(s)
+            "widget:#{s}"
+          end
         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"])
+        args = expression.match("I have a bolt")
+        expect(args[0].value(World.new)).to eq('widget:bolt')
       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

data/spec/cucumber/cucumber_expressions/cucumber_expression_tokenizer_spec.rb

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

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -69,7 +69,7 @@ module Cucumber
               true,
               false
           )
-        end.to raise_error("Illegal character '[' in parameter name {[string]}")
+        end.to raise_error("Illegal character in parameter name {[string]}. Parameter names may not contain '[]()$.|?*+'")
       end
 
       describe CucumberExpression do

data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
   module CucumberExpressions
     describe 'examples.txt' do
       def match(expression_text, text)
-        expression = expression_text =~ /\/(.*)\// ?
+        expression = expression_text =~ /^\/(.*)\/$/ ?
           RegularExpression.new(Regexp.new($1), ParameterTypeRegistry.new) :
           CucumberExpression.new(expression_text, ParameterTypeRegistry.new)
 

data/spec/cucumber/cucumber_expressions/expression_factory_spec.rb

@@ -14,10 +14,6 @@ module Cucumber
       it 'creates a CucumberExpression' do
         expect(@expression_factory.create_expression('{int}').class).to eq(CucumberExpression)
       end
-
-      it 'creates a XXXRegularExpression' do
-        expect {@expression_factory.create_expression('hello {x}')}.to raise_error("Undefined parameter type {x}")
-      end
     end
   end
 end

data/testdata/ast/alternation-followed-by-optional.yaml

@@ -0,0 +1,17 @@
+expression: three blind\ rat/cat(s)
+expected: |-
+  {"type": "EXPRESSION_NODE", "start": 0, "end": 23, "nodes": [
+    {"type": "TEXT_NODE", "start": 0, "end": 5, "token": "three"},
+    {"type": "TEXT_NODE", "start": 5, "end": 6, "token": " "},
+    {"type": "ALTERNATION_NODE", "start": 6, "end": 23, "nodes": [
+      {"type": "ALTERNATIVE_NODE", "start": 6, "end": 16, "nodes": [
+        {"type": "TEXT_NODE", "start": 6, "end": 16, "token": "blind rat"}
+      ]},
+      {"type": "ALTERNATIVE_NODE", "start": 17, "end": 23, "nodes": [
+        {"type": "TEXT_NODE", "start": 17, "end": 20, "token": "cat"},
+        {"type": "OPTIONAL_NODE", "start": 20, "end": 23, "nodes": [
+          {"type": "TEXT_NODE", "start": 21, "end": 22, "token": "s"}
+        ]}
+      ]}
+    ]}
+  ]}

data/testdata/ast/alternation-phrase.yaml

@@ -0,0 +1,16 @@
+expression: three hungry/blind mice
+expected: |-
+  {"type": "EXPRESSION_NODE", "start": 0, "end": 23, "nodes": [
+    {"type": "TEXT_NODE", "start": 0, "end": 5, "token": "three"},
+    {"type": "TEXT_NODE", "start": 5, "end": 6, "token": " "},
+    {"type": "ALTERNATION_NODE", "start": 6, "end": 18, "nodes": [
+      {"type": "ALTERNATIVE_NODE", "start": 6, "end": 12, "nodes": [
+        {"type": "TEXT_NODE", "start": 6, "end": 12, "token": "hungry"}
+      ]},
+      {"type": "ALTERNATIVE_NODE", "start": 13, "end": 18, "nodes": [
+        {"type": "TEXT_NODE", "start": 13, "end": 18, "token": "blind"}
+      ]}
+    ]},
+    {"type": "TEXT_NODE", "start": 18, "end": 19, "token": " "},
+    {"type": "TEXT_NODE", "start": 19, "end": 23, "token": "mice"}
+  ]}

data/testdata/ast/alternation-with-parameter.yaml

@@ -0,0 +1,27 @@
+expression: I select the {int}st/nd/rd/th
+expected: |-
+  {"type": "EXPRESSION_NODE", "start": 0, "end": 29, "nodes": [
+    {"type": "TEXT_NODE", "start": 0, "end": 1, "token": "I"},
+    {"type": "TEXT_NODE", "start": 1, "end": 2, "token": " "},
+    {"type": "TEXT_NODE", "start": 2, "end": 8, "token": "select"},
+    {"type": "TEXT_NODE", "start": 8, "end": 9, "token": " "},
+    {"type": "TEXT_NODE", "start": 9, "end": 12, "token": "the"},
+    {"type": "TEXT_NODE", "start": 12, "end": 13, "token": " "},
+    {"type": "PARAMETER_NODE", "start": 13, "end": 18, "nodes": [
+      {"type": "TEXT_NODE", "start": 14, "end": 17, "token": "int"}
+    ]},
+    {"type": "ALTERNATION_NODE", "start": 18, "end": 29, "nodes": [
+      {"type": "ALTERNATIVE_NODE", "start": 18, "end": 20, "nodes": [
+        {"type": "TEXT_NODE", "start": 18, "end": 20, "token": "st"}
+      ]},
+      {"type": "ALTERNATIVE_NODE", "start": 21, "end": 23, "nodes": [
+        {"type": "TEXT_NODE", "start": 21, "end": 23, "token": "nd"}
+      ]},
+      {"type": "ALTERNATIVE_NODE", "start": 24, "end": 26, "nodes": [
+        {"type": "TEXT_NODE", "start": 24, "end": 26, "token": "rd"}
+      ]},
+      {"type": "ALTERNATIVE_NODE", "start": 27, "end": 29, "nodes": [
+        {"type": "TEXT_NODE", "start": 27, "end": 29, "token": "th"}
+      ]}
+    ]}
+  ]}