cucumber-expressions 6.0.0 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4e80f6b342fd980a7e30ed217e54f83d5ee4da8198e93487470daff410e4959
-  data.tar.gz: 9cb0efc96dfc3f26257ac35998bdce354470543ccafdb604e227645fb6f5dd75
+  metadata.gz: a9d12cb9c8cd02a9bd908fd7a7f8a4fc7923bafb4b5aa0b4ef6339cb74d634dd
+  data.tar.gz: ae0fe8368985342ea0395a1077cab630c4c699ebd65e4c392d69d577fdbf3cd6
 SHA512:
-  metadata.gz: 844a25bb968e193a071b4bdfef1a79cc9bd3da3f5211c75adeef363b74ba3e34f7b6cbe578c06fbaf7e6d8f118eae33be2acdca0af5ecd70c8c77c42aac78252
-  data.tar.gz: e9359ff92fccbc88eb457bec080607397d723d6c488ee4ce87053b360e43268d8a5b3bd4523c3415e76ac8c1b79965db9aff7d4ae6ddb486f3acf02e08e32c7c
+  metadata.gz: baacf4121341d24159301ac93259656f4ca28710c6bd63a4dbbc946e7476003b85aca70f11760130d626a6dccf81fcc32e10645aac27e347f040d4897457d3f6
+  data.tar.gz: 2da1c94551f4d7d2de12360f437d080364bea94805d7eeb5bdcef2af09b03d59c9471bdf3c12c77b3d8a59a419313de66bb18c47541dd24299906aa0546a2233

data/cucumber-expressions.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = 'cucumber-expressions'
-  s.version     = '6.0.0'
+  s.version     = '6.0.1'
   s.authors     = ["Aslak Hellesøy"]
   s.description = 'Cucumber Expressions - a simpler alternative to Regular Expressions'
   s.summary     = "cucumber-expressions-#{s.version}"

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -80,6 +80,7 @@ module Cucumber
             "\\{#{$2}\\}"
           else
             type_name = $2
+            ParameterType.check_parameter_type_name(type_name)
             parameter_type = parameter_type_registry.lookup_by_type_name(type_name)
             raise UndefinedParameterTypeError.new(type_name) if parameter_type.nil?
             @parameter_types.push(parameter_type)

data/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -3,8 +3,20 @@ require 'cucumber/cucumber_expressions/errors'
 module Cucumber
   module CucumberExpressions
     class ParameterType
+      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/
+      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/
+
       attr_reader :name, :type, :regexps
 
+      def self.check_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
+      end
+
       def prefer_for_regexp_match?
         @prefer_for_regexp_match
       end
@@ -23,19 +35,19 @@ module Cucumber
       # @param prefer_for_regexp_match true if this should be preferred over similar types
       #
       def initialize(name, regexp, type, transformer, use_for_snippets, prefer_for_regexp_match)
-        raise "name can't be nil" if name.nil?
         raise "regexp can't be nil" if regexp.nil?
         raise "type can't be nil" if type.nil?
         raise "transformer can't be nil" if transformer.nil?
         raise "use_for_snippets can't be nil" if use_for_snippets.nil?
         raise "prefer_for_regexp_match can't be nil" if prefer_for_regexp_match.nil?
 
+        self.class.check_parameter_type_name(name) unless name.nil?
         @name, @type, @transformer, @use_for_snippets, @prefer_for_regexp_match = name, type, transformer, use_for_snippets, prefer_for_regexp_match
         @regexps = string_array(regexp)
       end
 
       def transform(self_obj, group_values)
-        group_values.empty? ? nil : self_obj.instance_exec(*group_values, &@transformer)
+        self_obj.instance_exec(*group_values, &@transformer)
       end
 
       def <=>(other)

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -14,10 +14,10 @@ module Cucumber
         @parameter_type_by_name = {}
         @parameter_types_by_regexp = Hash.new {|hash, regexp| hash[regexp] = []}
 
-        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, lambda {|s| s.to_i}, true, true))
-        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, lambda {|s| s.to_f}, true, false))
-        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, lambda {|s| s}, false, false))
-        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, lambda {|s| s.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
+        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))
       end
 
       def lookup_by_type_name(name)
@@ -42,10 +42,12 @@ module Cucumber
       end
 
       def define_parameter_type(parameter_type)
-        if @parameter_type_by_name.has_key?(parameter_type.name)
-          raise CucumberExpressionError.new("There is already a parameter with name #{parameter_type.name}")
+        if parameter_type.name
+          if @parameter_type_by_name.has_key?(parameter_type.name)
+            raise CucumberExpressionError.new("There is already a parameter with name #{parameter_type.name}")
+          end
+          @parameter_type_by_name[parameter_type.name] = parameter_type
         end
-        @parameter_type_by_name[parameter_type.name] = parameter_type
 
         parameter_type.regexps.each do |parameter_type_regexp|
           parameter_types = @parameter_types_by_regexp[parameter_type_regexp]

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -20,7 +20,7 @@ module Cucumber
             @expression_regexp,
             text
           ) || ParameterType.new(
-            parameter_type_regexp,
+            nil,
             parameter_type_regexp,
             String,
             lambda {|*s| s[0]},

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -76,6 +76,12 @@ module Cucumber
         expect(match("{float}", ".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

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -43,11 +43,11 @@ module Cucumber
       end
     end
 
-    describe "Custom parameter" do
+    describe "Custom parameter type" do
       before do
-        parameter_registry = ParameterTypeRegistry.new
+        parameter_type_registry = ParameterTypeRegistry.new
         ### [add-color-parameter-type]
-        parameter_registry.define_parameter_type(ParameterType.new(
+        parameter_type_registry.define_parameter_type(ParameterType.new(
             'color',                   # name
             /red|blue|yellow/,         # regexp
             Color,                     # type
@@ -56,7 +56,20 @@ module Cucumber
             false                      # prefer_for_regexp_match
         ))
         ### [add-color-parameter-type]
-        @parameter_type_registry = parameter_registry
+        @parameter_type_registry = parameter_type_registry
+      end
+
+      it "throws exception for illegal character in parameter name" do
+        expect do
+          ParameterType.new(
+              '[string]',
+              /.*/,
+              String,
+              lambda {|s| s},
+              true,
+              false
+          )
+        end.to raise_error("Illegal character '[' in parameter name {[string]}")
       end
 
       describe CucumberExpression do
@@ -168,8 +181,18 @@ module Cucumber
       end
 
       describe RegularExpression do
-        it "matches arguments with custom parameter type" do
-          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, @parameter_type_registry)
+        it "matches arguments with custom parameter type without name" do
+          parameter_type_registry = ParameterTypeRegistry.new
+          parameter_type_registry.define_parameter_type(ParameterType.new(
+              nil,
+              /red|blue|yellow/,
+              Color,
+              lambda {|s| Color.new(s)},
+              true,
+              false
+          ))
+
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
           value = expression.match("I have a red ball")[0].value(nil)
           expect(value).to eq(Color.new('red'))
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-expressions
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.0.1
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-30 00:00:00.000000000 Z
+date: 2018-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,7 +134,7 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-6.0.0
+summary: cucumber-expressions-6.0.1
 test_files:
 - spec/capture_warnings.rb
 - spec/coverage.rb