cucumber-expressions 1.0.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b8ed8f5d21a95380e884f0c080d076e2e89d17f
-  data.tar.gz: 7682387d1c85962fb28b6c21683bb48157ef3b49
+  metadata.gz: 882d05ea05136cc6af4f3bc4ef6bccfe42531645
+  data.tar.gz: 42c7abf6782587c48aa8e264598637a459bbdc86
 SHA512:
-  metadata.gz: a66f2c66cc3de2a570ac6cc317f54eb4988bc4d99185b8e9649cff3c26b85670cbea82754cf8ad4483f60351494de83890068e3f970e3c7fa870e83d0e23a709
-  data.tar.gz: c34c94c1760c2a8a264c338000a0473b0d557fffe253e6bf1793f0e006d106de1ab59f47b9e2ebed1a4565c05b4715c79fddc103e4e2b26156a8b761252e7051
+  metadata.gz: 598ce9757f1518d1e9eae317a3f9718efb6339001fa36a5dea1e03fd690f44abd34524652f7b195c271c8b5128082676ffbd2dfef8b2a9aa2ee4bc6cd71ba3c7
+  data.tar.gz: 38121b06c1d4ca408a28f407cb0ae3b0f47de3464fe20128de05667ab34fdd93b5f369dbb2d24b26b4f9f742a93744e1dbccbb0d930478c8de3633b305fa8891

data/cucumber-expressions.gemspec

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

data/examples.txt

@@ -2,10 +2,14 @@ I have {n} cuke(s) in my {bodypart} now
 I have 22 cukes in my belly now
 ["22","belly"]
 ---
-I have {n:int} cuke(s) in my {bodypart} now
+I have {int} cuke(s) in my {bodypart} now
 I have 1 cuke in my belly now
 [1,"belly"]
 ---
+I have {int} cuke(s) and some \[]^$.|?*+ {something}
+I have 1 cuke and some \[]^$.|?*+ characters
+[1,"characters"]
+---
 /I have (\d+) cukes? in my (.+) now/
 I have 22 cukes in my belly now
 [22,"belly"]

data/lib/cucumber/cucumber_expressions/{argument_matcher.rb → argument_builder.rb}

@@ -2,14 +2,14 @@ require 'cucumber/cucumber_expressions/argument'
 
 module Cucumber
   module CucumberExpressions
-    class ArgumentMatcher
-      def self.match_arguments(regexp, text, transforms)
+    class ArgumentBuilder
+      def self.build_arguments(regexp, text, parameters)
         m = regexp.match(text)
         return nil if m.nil?
         (1...m.length).map do |index|
           value = m[index]
-          transform = transforms[index-1]
-          transformed_value = transform.transform(value)
+          parameter = parameters[index-1]
+          transformed_value = parameter.transform(value)
           Argument.new(m.offset(index)[0], value, transformed_value)
         end
       end

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -1,22 +1,25 @@
-require 'cucumber/cucumber_expressions/argument_matcher'
-require 'cucumber/cucumber_expressions/transform'
+require 'cucumber/cucumber_expressions/argument_builder'
+require 'cucumber/cucumber_expressions/parameter'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpression
       PARAMETER_PATTERN = /\{([^}:]+)(:([^}]+))?}/
-      OPTIONAL_PATTERN = /\(([^\)]+)\)/
+      OPTIONAL_PATTERN = /\(([^)]+)\)/
 
       attr_reader :source
 
-      def initialize(expression, types, transform_lookup)
+      def initialize(expression, types, parameter_registry)
         @source = expression
-        @transforms = []
+        @parameters = []
         regexp = "^"
         type_index = 0
         match = nil
         match_offset = 0
 
+        # Does not include (){} because they have special meaning
+        expression = expression.gsub(/([\\\^\[$.|?*+\]])/, '\\\\\1')
+
         # Create non-capturing, optional capture groups from parenthesis
         expression = expression.gsub(OPTIONAL_PATTERN, '(?:\1)?')
 
@@ -26,26 +29,30 @@ module Cucumber
 
           parameter_name = match[1]
           type_name = match[3]
+          if type_name
+            $stderr.puts("Cucumber expression parameter syntax {#{parameter_name}:#{type_name}} is deprecated. Please use {#{type_name}} instead.")
+          end
+
           type = types.length <= type_index ? nil : types[type_index]
           type_index += 1
 
-          transform = nil
-          if (type)
-            transform = transform_lookup.lookup_by_type(type)
+          parameter = nil
+          if type
+            parameter = parameter_registry.lookup_by_type(type)
           end
-          if (transform.nil? && type_name)
-            transform = transform_lookup.lookup_by_type_name(type_name, false)
+          if parameter.nil? && type_name
+            parameter = parameter_registry.lookup_by_type_name(type_name)
           end
-          if (transform.nil?)
-            transform = transform_lookup.lookup_by_type_name(parameter_name, true)
+          if parameter.nil?
+            parameter = parameter_registry.lookup_by_type_name(parameter_name)
           end
-          if (transform.nil?)
-            transform = transform_lookup.create_anonymous_lookup(lambda {|s| s})
+          if parameter.nil?
+            parameter = parameter_registry.create_anonymous_lookup(lambda {|s| s})
           end
-          @transforms.push(transform)
+          @parameters.push(parameter)
 
           text = expression.slice(match_offset...match.offset(0)[0])
-          capture_regexp = capture_group_regexp(transform.capture_group_regexps)
+          capture_regexp = capture_group_regexp(parameter.capture_group_regexps)
           match_offset = match.offset(0)[1]
           regexp += text
           regexp += capture_regexp
@@ -56,7 +63,7 @@ module Cucumber
       end
 
       def match(text)
-        ArgumentMatcher.match_arguments(@regexp, text, @transforms)
+        ArgumentBuilder.build_arguments(@regexp, text, @parameters)
       end
 
       private

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -1,46 +1,44 @@
-require 'cucumber/cucumber_expressions/transform_matcher'
+require 'cucumber/cucumber_expressions/parameter_matcher'
 require 'cucumber/cucumber_expressions/generated_expression'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpressionGenerator
-      def initialize(transform_lookup)
-        @transform_lookup = transform_lookup
+      def initialize(parameter_registry)
+        @parameter_registry = parameter_registry
       end
 
-      def generate_expression(text, typed)
-        argumentNames = []
-        transform_matchers = create_transform_matchers(text)
-        transforms = []
+      def generate_expression(text)
+        parameter_names = []
+        parameter_matchers = create_parameter_matchers(text)
+        parameters = []
+        usage_by_type_name = Hash.new(0)
 
         expression = ""
-        arg_counter = 0
         pos = 0
 
         loop do
-          matching_transform_matchers = []
-          transform_matchers.each do |transform_matcher|
-            advanced_transform_matcher = transform_matcher.advance_to(pos)
-            if advanced_transform_matcher.find
-              matching_transform_matchers.push(advanced_transform_matcher)
+          matching_parameter_matchers = []
+          parameter_matchers.each do |parameter_matcher|
+            advanced_parameter_matcher = parameter_matcher.advance_to(pos)
+            if advanced_parameter_matcher.find
+              matching_parameter_matchers.push(advanced_parameter_matcher)
             end
           end
 
-          if matching_transform_matchers.any?
-            argumentName = "arg#{arg_counter += 1}"
-            argumentNames.push(argumentName)
-            matching_transform_matchers = matching_transform_matchers.sort
-            best_transform_matcher = matching_transform_matchers[0]
-            transforms.push(best_transform_matcher.transform)
+          if matching_parameter_matchers.any?
+            matching_parameter_matchers = matching_parameter_matchers.sort
+            best_parameter_matcher = matching_parameter_matchers[0]
+            parameter = best_parameter_matcher.parameter
+            parameters.push(parameter)
 
-            expression += text.slice(pos...best_transform_matcher.start)
-            expression += "{#{argumentName}"
+            parameter_name = get_parameter_name(parameter.type_name, usage_by_type_name)
+            parameter_names.push(parameter_name)
 
-            if typed
-              expression += ":#{best_transform_matcher.transform.type_name}"
-            end
-            expression += "}"
-            pos = best_transform_matcher.start + best_transform_matcher.group.length
+            expression += text.slice(pos...best_parameter_matcher.start)
+            expression += "{#{parameter.type_name}}"
+
+            pos = best_parameter_matcher.start + best_parameter_matcher.group.length
           else
             break
           end
@@ -51,25 +49,30 @@ module Cucumber
         end
 
         expression += text.slice(pos..-1)
-        GeneratedExpression.new(expression, argumentNames, transforms)
+        GeneratedExpression.new(expression, parameter_names, parameters)
       end
 
     private
 
-      def create_transform_matchers(text)
-        transform_matchers = []
-        @transform_lookup.transforms.each do |transform|
-          transform_matchers += create_transform_matchers2(transform, text)
+      def get_parameter_name(type_name, usage_by_type_name)
+        count = (usage_by_type_name[type_name] += 1)
+        count == 1 ? type_name : "#{type_name}#{count}"
+      end
+
+      def create_parameter_matchers(text)
+        parameter_matchers = []
+        @parameter_registry.parameters.each do |parameter|
+          parameter_matchers += create_parameter_matchers2(parameter, text)
         end
-        transform_matchers
+        parameter_matchers
       end
 
-      def create_transform_matchers2(transform, text)
+      def create_parameter_matchers2(parameter, text)
         result = []
-        capture_group_regexps = transform.capture_group_regexps
+        capture_group_regexps = parameter.capture_group_regexps
         capture_group_regexps.each do |capture_group_regexp|
           regexp = Regexp.new("(#{capture_group_regexp})")
-          result.push(TransformMatcher.new(transform, regexp, text))
+          result.push(ParameterMatcher.new(parameter, regexp, text))
         end
         result
       end

data/lib/cucumber/cucumber_expressions/generated_expression.rb

@@ -1,10 +1,10 @@
 module Cucumber
   module CucumberExpressions
     class GeneratedExpression
-      attr_reader :source, :argumentNames, :transforms
+      attr_reader :source, :parameter_names, :parameters
 
-      def initialize(source, argumentNames, transforms)
-        @source, @argumentNames, @transforms = source, argumentNames, transforms
+      def initialize(source, parameter_names, parameters)
+        @source, @parameter_names, @parameters = source, parameter_names, parameters
       end
     end
   end

data/lib/cucumber/cucumber_expressions/{transform.rb → parameter.rb}

@@ -1,22 +1,29 @@
 module Cucumber
   module CucumberExpressions
-    class Transform
+    class Parameter
       attr_reader :type_name, :type, :capture_group_regexps
 
-      # Create a new Transform
+      # Create a new Parameter
       #
       # @param type_name [Array] array of class or type name to use in {arg:type_name}
       # @param capture_group_regexps [Array] list of regexps for capture groups.
-      # @param transformer lambda that transforms a String to another type
+      # @param transformer lambda that transforms a String to (possibly) another type
       #
       def initialize(type_name, type, capture_group_regexps, transformer)
         @type_name, @type, @transformer = type_name, type, transformer
-        @capture_group_regexps = capture_group_regexps.is_a?(String) ? [capture_group_regexps] : capture_group_regexps
+        @capture_group_regexps = string_array(capture_group_regexps)
       end
 
       def transform(value)
         @transformer.call(value)
       end
+
+      private
+
+      def string_array(capture_group_regexps)
+        array = capture_group_regexps.is_a?(Array) ? capture_group_regexps : [capture_group_regexps]
+        array.map { |r| r.is_a?(String) ? r : r.source }
+      end
     end
   end
 end

data/lib/cucumber/cucumber_expressions/{transform_matcher.rb → parameter_matcher.rb}

@@ -1,15 +1,15 @@
 module Cucumber
   module CucumberExpressions
-    class TransformMatcher
-      attr_reader :transform
+    class ParameterMatcher
+      attr_reader :parameter
 
-      def initialize(transform, regexp, text, match_position=0)
-        @transform, @regexp, @text = transform, regexp, text
+      def initialize(parameter, regexp, text, match_position=0)
+        @parameter, @regexp, @text = parameter, regexp, text
         @match = @regexp.match(@text, match_position)
       end
 
       def advance_to(new_match_position)
-        self.class.new(@transform, @regexp, @text, new_match_position)
+        self.class.new(parameter, @regexp, @text, new_match_position)
       end
 
       def find

data/lib/cucumber/cucumber_expressions/parameter_registry.rb

@@ -0,0 +1,64 @@
+require 'cucumber/cucumber_expressions/parameter'
+
+module Cucumber
+  module CucumberExpressions
+    class ParameterRegistry
+      INTEGER_REGEXPS = ['-?\d+', '\d+']
+      FLOATING_POINT_REGEXPS = ['-?\d*\.?\d+']
+
+      def initialize
+        @parameters_by_type_name = {}
+        @parameters_by_capture_group_regexp = {}
+        @parameters_by_class = {}
+
+        add_parameter(Parameter.new('int', Integer, INTEGER_REGEXPS, lambda {|s| s.to_i}))
+        add_parameter(Parameter.new('float', Float, FLOATING_POINT_REGEXPS, lambda {|s| s.to_f}))
+      end
+
+      def lookup_by_type(type)
+        if type.is_a?(Class)
+          lookup_by_class(type)
+        elsif type.is_a?(String)
+          lookup_by_type_name(type)
+        else
+          raise Exception.new("Type must be string or class, but was #{type} of type #{type.class}")
+        end
+      end
+
+      def lookup_by_class(clazz)
+        parameter = @parameters_by_class[clazz]
+        if parameter.nil?
+          create_anonymous_lookup(lambda {|s| clazz.new(s)})
+        else
+          parameter
+        end
+      end
+
+      def lookup_by_type_name(type_name)
+        @parameters_by_type_name[type_name]
+      end
+
+      def lookup_by_capture_group_regexp(capture_group_regexp)
+        @parameters_by_capture_group_regexp[capture_group_regexp]
+      end
+
+      def create_anonymous_lookup(proc)
+        Parameter.new(nil, nil, ['.+'], proc)
+      end
+
+      def add_parameter(parameter)
+        @parameters_by_type_name[parameter.type_name] = parameter
+        @parameters_by_class[parameter.type] = parameter
+
+        parameter.capture_group_regexps.each do |capture_group_regexp|
+          @parameters_by_capture_group_regexp[capture_group_regexp] = parameter
+        end
+      end
+
+      def parameters
+        @parameters_by_type_name.values
+      end
+
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -1,13 +1,13 @@
-require 'cucumber/cucumber_expressions/argument_matcher'
+require 'cucumber/cucumber_expressions/argument_builder'
 
 module Cucumber
   module CucumberExpressions
     class RegularExpression
       CAPTURE_GROUP_PATTERN = /\(([^(]+)\)/
 
-      def initialize(regexp, types, transform_lookup)
+      def initialize(regexp, types, parameter_registry)
         @regexp = regexp
-        @transforms = []
+        @parameters = []
 
         type_index = 0
         match = nil
@@ -21,24 +21,24 @@ module Cucumber
           type = types.length <= type_index ? nil : types[type_index]
           type_index += 1
 
-          transform = nil
+          parameter = nil
           if (type)
-            transform = transform_lookup.lookup_by_type(type)
+            parameter = parameter_registry.lookup_by_type(type)
           end
-          if (transform.nil?)
-            transform = transform_lookup.lookup_by_capture_group_regexp(capture_group_pattern)
+          if (parameter.nil?)
+            parameter = parameter_registry.lookup_by_capture_group_regexp(capture_group_pattern)
           end
-          if (transform.nil?)
-            transform = transform_lookup.create_anonymous_lookup(lambda {|s| s})
+          if (parameter.nil?)
+            parameter = parameter_registry.create_anonymous_lookup(lambda {|s| s})
           end
 
-          @transforms.push(transform)
+          @parameters.push(parameter)
           match_offset = match.offset(0)[1]
         end
       end
 
       def match(text)
-        ArgumentMatcher.match_arguments(@regexp, text, @transforms)
+        ArgumentBuilder.build_arguments(@regexp, text, @parameters)
       end
 
       def source

data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -1,6 +1,6 @@
 require 'cucumber/cucumber_expressions/cucumber_expression_generator'
-require 'cucumber/cucumber_expressions/transform'
-require 'cucumber/cucumber_expressions/transform_lookup'
+require 'cucumber/cucumber_expressions/parameter'
+require 'cucumber/cucumber_expressions/parameter_registry'
 
 module Cucumber
   module CucumberExpressions
@@ -9,69 +9,66 @@ module Cucumber
       end
 
       before do
-        @transform_lookup = TransformLookup.new
-        @generator = CucumberExpressionGenerator.new(@transform_lookup)
+        @parameter_registry = ParameterRegistry.new
+        @generator = CucumberExpressionGenerator.new(@parameter_registry)
       end
 
       it "documents expression generation" do
-        transform_lookup = TransformLookup.new
+        parameter_registry = ParameterRegistry.new
         ### [generate-expression]
-        generator = CucumberExpressionGenerator.new(transform_lookup)
+        generator = CucumberExpressionGenerator.new(parameter_registry)
         undefined_step_text = "I have 2 cucumbers and 1.5 tomato"
-        generated_expression = generator.generate_expression(undefined_step_text, true)
-        expect(generated_expression.source).to eq("I have {arg1:int} cucumbers and {arg2:float} tomato")
-        expect(generated_expression.argumentNames[0]).to eq("arg1")
-        expect(generated_expression.transforms[1].type).to eq(Float)
+        generated_expression = generator.generate_expression(undefined_step_text)
+        expect(generated_expression.source).to eq("I have {int} cucumbers and {float} tomato")
+        expect(generated_expression.parameters[1].type).to eq(Float)
         ### [generate-expression]
       end
 
       it "generates expression for no args" do
-        assert_typed_expression("hello", "hello")
+        assert_expression("hello", [], "hello")
       end
 
-      it "generates expression for int double arg" do
-        assert_typed_expression(
-          "I have {arg1:int} cukes and {arg2:float} euro",
+      it "generates expression for int float arg" do
+        assert_expression(
+          "I have {int} cukes and {float} euro", ["int", "float"],
           "I have 2 cukes and 1.5 euro")
       end
 
       it "generates expression for just int" do
-        assert_typed_expression(
-          "{arg1:int}",
+        assert_expression(
+          "{int}", ["int"],
           "99999")
       end
 
-      it "generates expression without expression type" do
-        assert_untyped_expression(
-          "I have {arg1} cukes and {arg2} euro",
-          "I have 2 cukes and 1.5 euro")
+      it "numbers only second argument when builtin type is not reserved keyword" do
+        assert_expression(
+          "I have {int} cukes and {int} euro", ["int", "int2"],
+          "I have 2 cukes and 5 euro")
       end
 
-      it "generates expression for custom type" do
-        @transform_lookup.add_transform(Transform.new(
+      it "numbers only second argument when type is not reserved keyword" do
+        @parameter_registry.add_parameter(Parameter.new(
           'currency',
           Currency,
           '[A-Z]{3}',
           nil
         ))
 
-        assert_typed_expression(
-          "I have a {arg1:currency} account",
-          "I have a EUR account")
+        assert_expression(
+          "I have a {currency} account and a {currency} account", ["currency", "currency2"],
+          "I have a EUR account and a GBP account")
       end
 
-      it "exposes transforms in generated expression" do
-        expression = @generator.generate_expression("I have 2 cukes and 1.5 euro", true)
-        types = expression.transforms.map(&:type)
+      it "exposes parameters in generated expression" do
+        expression = @generator.generate_expression("I have 2 cukes and 1.5 euro")
+        types = expression.parameters.map(&:type)
         expect(types).to eq([Integer, Float])
       end
 
-      def assert_typed_expression(expected, text)
-        expect(@generator.generate_expression(text, true).source).to eq(expected)
-      end
-
-      def assert_untyped_expression(expected, text)
-        expect(@generator.generate_expression(text, false).source).to eq(expected)
+      def assert_expression(expected_expression, expected_argument_names, text)
+        generated_expression = @generator.generate_expression(text)
+        expect(generated_expression.parameter_names).to eq(expected_argument_names)
+        expect(generated_expression.source).to eq(expected_expression)
       end
     end
   end

data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb

@@ -1,12 +1,12 @@
 require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/transform_lookup'
+require 'cucumber/cucumber_expressions/parameter_registry'
 
 module Cucumber
   module CucumberExpressions
     describe CucumberExpression do
       context "Regexp translation" do
         def assert_regexp(expression, regexp)
-          cucumber_expression = CucumberExpression.new(expression, [], TransformLookup.new)
+          cucumber_expression = CucumberExpression.new(expression, [], ParameterRegistry.new)
           expect(regexp).to eq(cucumber_expression.instance_variable_get('@regexp'))
         end
 
@@ -26,7 +26,7 @@ module Cucumber
 
         it "translates three typed arguments" do
           assert_regexp(
-            "I have {n:float} cukes in my {bodypart} at {time:int} o'clock",
+            "I have {float} cukes in my {bodypart} at {int} o'clock",
             /^I have (-?\d*\.?\d+) cukes in my (.+) at ((?:-?\d+)|(?:\d+)) o'clock$/
           )
         end

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,28 +1,28 @@
 require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/transform_lookup'
+require 'cucumber/cucumber_expressions/parameter_registry'
 
 module Cucumber
   module CucumberExpressions
     describe CucumberExpression do
       it "documents match arguments" do
-        transform_lookup = TransformLookup.new
+        parameter_registry = ParameterRegistry.new
 
         ### [capture-match-arguments]
         expr = "I have {n} cuke(s) in my {bodypart} now"
         types = ['int', nil]
-        expression = CucumberExpression.new(expr, types, transform_lookup)
+        expression = CucumberExpression.new(expr, types, parameter_registry)
         args = expression.match("I have 7 cukes in my belly now")
         expect( args[0].transformed_value ).to eq(7)
         expect( args[1].transformed_value ).to eq("belly")
         ### [capture-match-arguments]
       end
 
-      it "transforms nothing by default" do
+      it "does no transform by default" do
         expect( match("{what}", "22") ).to eq(["22"])
       end
 
-      it "transforms to int by expression type" do
-        expect( match("{what:int}", "22") ).to eq([22])
+      it "transforms to int by parameter type" do
+        expect( match("{int}", "22") ).to eq([22])
       end
 
       it "transforms to int by explicit type" do
@@ -30,17 +30,17 @@ module Cucumber
       end
 
       # Ruby-specific
-      it "transforms to Integer by explicit type" do
+      it "parameters to Integer by explicit type" do
         expect( match("{what}", "22", [Integer]) ).to eq([22])
       end
 
-      it "doesn't match a float to an int" do
-        expect( match("{what:int}", "1.22") ).to be_nil
+      it "doesn't match a float with an int parameter" do
+        expect( match("{int}", "1.22") ).to be_nil
       end
 
-      it "transforms to float by expression type" do
-        expect( match("{what:float}", "0.22") ).to eq([0.22])
-        expect( match("{what:float}",  ".22") ).to eq([0.22])
+      it "transforms to float by parameter type" do
+        expect( match("{float}", "0.22") ).to eq([0.22])
+        expect( match("{float}",  ".22") ).to eq([0.22])
       end
 
       it "transforms to float by explicit type" do
@@ -48,26 +48,41 @@ module Cucumber
         expect( match("{what}",  ".22", ['float']) ).to eq([0.22])
       end
 
-      it "doesn't transform unknown type" do
-        expect { match("{what:unknown}", "something") }.to raise_error(
-          'No transform for type name "unknown"')
+      it "leaves unknown type untransformed" do
+        expect( match("{unknown}", "something") ).to eq(["something"])
+      end
+
+      it "supports deprecated {name:type} syntax for now" do
+        expect( match("{param:unknown}", "something") ).to eq(["something"])
       end
 
       it "exposes source" do
-        expr = "I have {n:int} cuke(s) in my {bodypart} now"
-        expect(CucumberExpression.new(expr, [], TransformLookup.new).source).to eq(expr)
+        expr = "I have {int} cuke(s) in my {bodypart} now"
+        expect(CucumberExpression.new(expr, [], ParameterRegistry.new).source).to eq(expr)
       end
 
       it "exposes offset and value" do
-        expr = "I have {n:int} cuke(s) in my {bodypart} now"
-        expression = CucumberExpression.new(expr, [], TransformLookup.new)
+        expr = "I have {int} cuke(s) in my {bodypart} now"
+        expression = CucumberExpression.new(expr, [], ParameterRegistry.new)
         arg1 = expression.match("I have 800 cukes in my brain now")[0]
         expect(arg1.offset).to eq(7)
         expect(arg1.value).to eq("800")
       end
 
+      describe "RegExp special characters" do
+        %w(\\ [ ] ^ $ . | ? * +).each do |character|
+          it "escapes #{character}" do
+            expr = "I have {int} cuke(s) and #{character}"
+            expression = CucumberExpression.new(expr, [], ParameterRegistry.new)
+            arg1 = expression.match("I have 800 cukes and #{character}")[0]
+            expect(arg1.offset).to eq(7)
+            expect(arg1.value).to eq("800")
+          end
+        end
+      end
+
       def match(expression, text, types = [])
-        cucumber_expression = CucumberExpression.new(expression, types, TransformLookup.new)
+        cucumber_expression = CucumberExpression.new(expression, types, ParameterRegistry.new)
         args = cucumber_expression.match(text)
         return nil if args.nil?
         args.map { |arg| arg.transformed_value }

data/spec/cucumber/cucumber_expressions/custom_parameter_spec.rb

@@ -0,0 +1,87 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_registry'
+
+module Cucumber
+  module CucumberExpressions
+    class Color
+      attr_reader :name
+
+      ### [color-constructor]
+      def initialize(name)
+        @name = name
+      end
+      ### [color-constructor]
+
+      def ==(other)
+        other.is_a?(Color) && other.name == name
+      end
+    end
+
+    describe "Custom parameter" do
+      before do
+        @parameter_registry = ParameterRegistry.new
+        ### [add-color-parameter]
+        @parameter_registry.add_parameter(Parameter.new(
+          'color',
+          Color,
+          [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
+          lambda { |s| Color.new(s) }
+        ))
+        ### [add-color-parameter]
+      end
+
+      describe CucumberExpression do
+        it "matches typed parameters" do
+          expression = CucumberExpression.new("I have a {color} ball", [], @parameter_registry)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "matches typed parameters with optional group" do
+          expression = CucumberExpression.new("I have a {color} ball", [], @parameter_registry)
+          parametered_argument_value = expression.match("I have a dark red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('dark red'))
+        end
+
+        it "matches untyped parameters with explicit type" do
+          expression = CucumberExpression.new("I have a {color} ball", [Color], @parameter_registry)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "matches untyped parameters with same name as type" do
+          expression = CucumberExpression.new("I have a {color} ball", [], @parameter_registry)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "matches parameters with explicit type that isn't registered" do
+          expression = CucumberExpression.new("I have a {color} ball", [Color], ParameterRegistry.new)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+      end
+
+      describe RegularExpression do
+        it "matches parameters with explicit constructor" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [Color], @parameter_registry)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "matches parameters without explicit constructor" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [], @parameter_registry)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "matches parameters with explicit type that isn't registered" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [Color], ParameterRegistry.new)
+          parametered_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( parametered_argument_value ).to eq(Color.new('red'))
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb

@@ -1,6 +1,6 @@
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/transform_lookup'
+require 'cucumber/cucumber_expressions/parameter_registry'
 require 'json'
 
 module Cucumber
@@ -8,8 +8,8 @@ module Cucumber
     describe 'examples.txt' do
       def match(expression_text, text)
         expression = expression_text =~ /\/(.*)\// ?
-          RegularExpression.new(Regexp.new($1), [], TransformLookup.new) :
-          CucumberExpression.new(expression_text, [], TransformLookup.new)
+          RegularExpression.new(Regexp.new($1), [], ParameterRegistry.new) :
+          CucumberExpression.new(expression_text, [], ParameterRegistry.new)
 
         arguments = expression.match(text)
         return nil if arguments.nil?

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,47 +1,47 @@
 require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/transform_lookup'
+require 'cucumber/cucumber_expressions/parameter_registry'
 
 module Cucumber
   module CucumberExpressions
     describe RegularExpression do
       it "documents match arguments" do
-        transform_lookup = TransformLookup.new
+        parameter_registry = ParameterRegistry.new
 
         ### [capture-match-arguments]
         expr = /I have (\d+) cukes? in my (\w*) now/
         types = ['int', nil]
-        expression = RegularExpression.new(expr, types, transform_lookup)
+        expression = RegularExpression.new(expr, types, parameter_registry)
         args = expression.match("I have 7 cukes in my belly now")
         expect( args[0].transformed_value ).to eq(7)
         expect( args[1].transformed_value ).to eq("belly")
         ### [capture-match-arguments]
       end
 
-      it "transforms to string by default" do
+      it "does no transform by default" do
         expect( match(/(\d\d)/, "22") ).to eq(["22"])
       end
 
-      it "transforms integer to double using explicit type name" do
+      it "transforms int to float by explicit type name" do
         expect( match(/(.*)/, "22", ['float']) ).to eq([22.0])
       end
 
-      it "transforms integer to double using explicit type" do
+      it "transforms int to float by explicit function" do
         expect( match(/(.*)/, "22", [Float]) ).to eq([22.0])
       end
 
-      it "transforms to int using capture group pattern" do
+      it "transforms int by parameter pattern" do
         expect( match(/(-?\d+)/, "22") ).to eq([22])
       end
 
-      it "transforms to int by alternate capture group pattern" do
+      it "transforms int by alternate parameter pattern" do
         expect( match(/(\d+)/, "22") ).to eq([22])
       end
 
-      it "transforms double without integer value" do
+      it "transforms float without integer part" do
         expect( match(/(.*)/, ".22", ['float']) ).to eq([0.22])
       end
 
-      it "transforms double with sign" do
+      it "transforms float with sign" do
         expect( match(/(.*)/, "-1.22", ['float']) ).to eq([-1.22])
       end
 
@@ -57,11 +57,11 @@ module Cucumber
 
       it "exposes source" do
         expr = /I have (\d+) cukes? in my (\+) now/
-        expect(RegularExpression.new(expr, [], TransformLookup.new).source).to eq(expr)
+        expect(RegularExpression.new(expr, [], ParameterRegistry.new).source).to eq(expr)
       end
 
       def match(expression, text, types = [])
-        regular_expression = RegularExpression.new(expression, types, TransformLookup.new)
+        regular_expression = RegularExpression.new(expression, types, ParameterRegistry.new)
         arguments = regular_expression.match(text)
         return nil if arguments.nil?
         arguments.map { |arg| arg.transformed_value }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-expressions
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-20 00:00:00.000000000 Z
+date: 2017-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,20 +82,20 @@ files:
 - cucumber-expressions.gemspec
 - examples.txt
 - lib/cucumber/cucumber_expressions/argument.rb
-- lib/cucumber/cucumber_expressions/argument_matcher.rb
+- lib/cucumber/cucumber_expressions/argument_builder.rb
 - lib/cucumber/cucumber_expressions/cucumber_expression.rb
 - lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb
 - lib/cucumber/cucumber_expressions/generated_expression.rb
+- lib/cucumber/cucumber_expressions/parameter.rb
+- lib/cucumber/cucumber_expressions/parameter_matcher.rb
+- lib/cucumber/cucumber_expressions/parameter_registry.rb
 - lib/cucumber/cucumber_expressions/regular_expression.rb
-- lib/cucumber/cucumber_expressions/transform.rb
-- lib/cucumber/cucumber_expressions/transform_lookup.rb
-- lib/cucumber/cucumber_expressions/transform_matcher.rb
 - spec/capture_warnings.rb
 - spec/coverage.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
-- spec/cucumber/cucumber_expressions/custom_transform_spec.rb
+- spec/cucumber/cucumber_expressions/custom_parameter_spec.rb
 - spec/cucumber/cucumber_expressions/expression_examples_spec.rb
 - spec/cucumber/cucumber_expressions/regular_expression_spec.rb
 homepage: https://github.com/cucumber/cucumber-expressions-ruby#readme
@@ -119,16 +119,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.2
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-1.0.4
+summary: cucumber-expressions-2.0.0
 test_files:
 - spec/capture_warnings.rb
 - spec/coverage.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
 - spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
-- spec/cucumber/cucumber_expressions/custom_transform_spec.rb
+- spec/cucumber/cucumber_expressions/custom_parameter_spec.rb
 - spec/cucumber/cucumber_expressions/expression_examples_spec.rb
 - spec/cucumber/cucumber_expressions/regular_expression_spec.rb

data/lib/cucumber/cucumber_expressions/transform_lookup.rb

@@ -1,70 +0,0 @@
-require 'cucumber/cucumber_expressions/transform'
-
-module Cucumber
-  module CucumberExpressions
-    class TransformLookup
-      INTEGER_REGEXPS = ['-?\d+', '\d+']
-      FLOATING_POINT_REGEXPS = ['-?\d*\.?\d+']
-
-      def initialize
-        @transforms_by_type_name = {}
-        @transforms_by_capture_group_regexp = {}
-        @transforms_by_class = {}
-
-        add_transform(Transform.new('int', Integer, INTEGER_REGEXPS, lambda {|s| s.to_i}))
-        add_transform(Transform.new('float', Float, FLOATING_POINT_REGEXPS, lambda {|s| s.to_f}))
-      end
-
-      def lookup_by_type(type)
-        if type.is_a?(Class)
-          lookup_by_class(type)
-        elsif type.is_a?(String)
-          lookup_by_type_name(type, false)
-        else
-          raise Exception.new("Type must be string or class, but was #{type} of type #{type.class}")
-        end
-      end
-
-      def lookup_by_class(clazz)
-        transform = @transforms_by_class[clazz]
-        if transform.nil?
-          create_anonymous_lookup(lambda {|s| clazz.new(s)})
-        else
-          transform
-        end
-      end
-
-      def lookup_by_type_name(type_name, ignore_unknown_type_name)
-        transform = @transforms_by_type_name[type_name]
-        if transform.nil?
-          return nil if ignore_unknown_type_name
-          raise Exception.new("No transform for type name \"#{type_name}\"")
-        else
-          transform
-        end
-      end
-
-      def lookup_by_capture_group_regexp(capture_group_regexp)
-        @transforms_by_capture_group_regexp[capture_group_regexp]
-      end
-
-      def create_anonymous_lookup(proc)
-        Transform.new(nil, nil, ['.+'], proc)
-      end
-
-      def add_transform(transform)
-        @transforms_by_type_name[transform.type_name] = transform
-        @transforms_by_class[transform.type] = transform
-
-        transform.capture_group_regexps.each do |capture_group_regexp|
-          @transforms_by_capture_group_regexp[capture_group_regexp] = transform
-        end
-      end
-
-      def transforms
-        @transforms_by_type_name.values
-      end
-
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/custom_transform_spec.rb

@@ -1,87 +0,0 @@
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/transform_lookup'
-
-module Cucumber
-  module CucumberExpressions
-    class Color
-      attr_reader :name
-
-      ### [color-constructor]
-      def initialize(name)
-        @name = name
-      end
-      ### [color-constructor]
-
-      def ==(other)
-        other.is_a?(Color) && other.name == name
-      end
-    end
-
-    describe "Custom transform" do
-      before do
-        @transform_lookup = TransformLookup.new
-        ### [add-color-transform]
-        @transform_lookup.add_transform(Transform.new(
-          'color',
-          Color,
-          ['red|blue|yellow', '(?:dark|light) (?:red|blue|yellow)'],
-          lambda { |s| Color.new(s) }
-        ))
-        ### [add-color-transform]
-      end
-
-      describe CucumberExpression do
-        it "transforms arguments with expression type I" do
-          expression = CucumberExpression.new("I have a {color:color} ball", [], @transform_lookup)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-
-        it "transforms arguments with expression type II" do
-          expression = CucumberExpression.new("I have a {color:color} ball", [], @transform_lookup)
-          transformed_argument_value = expression.match("I have a dark red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('dark red'))
-        end
-
-        it "transforms arguments with explicit type" do
-          expression = CucumberExpression.new("I have a {color} ball", [Color], @transform_lookup)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-
-        it "transforms arguments using argument name as type" do
-          expression = CucumberExpression.new("I have a {color} ball", [], @transform_lookup)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-
-        it "transforms arguments with explicit type using constructor directly" do
-          expression = CucumberExpression.new("I have a {color} ball", [Color], TransformLookup.new)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-      end
-
-      describe RegularExpression do
-        it "transforms arguments with expression type" do
-          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [], @transform_lookup)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-
-        it "transforms arguments with explicit type" do
-          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, ['color'], @transform_lookup)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-
-        it "transforms arguments with explicit type using constructor directly" do
-          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [Color], TransformLookup.new)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-      end
-    end
-  end
-end