cucumber-expressions 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8c5e8a795eb6fea91f46e61cc01985a8af0572d
-  data.tar.gz: 92fa95001cddb0f9d931a02602c0e2d793678d53
+  metadata.gz: 8ec8564fdc53d2078266f3cfb82f7eb8db6e8957
+  data.tar.gz: 2bb4c9234813e74029bd93c6448ff41ae1a85abb
 SHA512:
-  metadata.gz: 7baf62e65277d441049bce8133cc50a6b44a48027cdf53a921b14006cac39358b45ba838890d43d1b1f7ec0edd8a74197e32b2979bfe8885bc5c4b1c963f0c12
-  data.tar.gz: 44b4dd881b1b7d8649f185b4f60a31ecf91f4ff1ccf6b7934ecd9d1b143200bf0c2ee74f4913c3f4ea308457943ffbacf02d3bfede92dca31746cc698e522749
+  metadata.gz: a3c592d0e6e4fad991e45fd27e1f54c466f418f204ba2f65f304c9f9400d9c5289b9472712e19a71637a71fedc762ccea4ef4bf3e00a7600d68dba2c02992dc4
+  data.tar.gz: 26195cf45a0624e6920e44fb1a6c99e05300603ec053be5cb13f99df70d55e48a98ecdfda78fb085cbeadaddc394ddceb2149bb244399d1bfde199ad498550d0

data/cucumber-expressions.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = 'cucumber-expressions'
-  s.version     = '2.0.1'
+  s.version     = '3.0.0'
   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/argument.rb

@@ -3,12 +3,12 @@ module Cucumber
     class Argument
       attr_reader :offset, :value
 
-      def initialize(offset, value, parameter)
-        @offset, @value, @parameter = offset, value, parameter
+      def initialize(offset, value, parameter_type)
+        @offset, @value, @parameter_type = offset, value, parameter_type
       end
 
       def transformed_value
-        @parameter.transform(@value)
+        @parameter_type.transform(@value)
       end
     end
   end

data/lib/cucumber/cucumber_expressions/argument_builder.rb

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

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -1,58 +1,62 @@
 require 'cucumber/cucumber_expressions/argument_builder'
-require 'cucumber/cucumber_expressions/parameter'
+require 'cucumber/cucumber_expressions/parameter_type'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpression
-      PARAMETER_PATTERN = /\{([^}:]+)(:([^}]+))?}/
-      OPTIONAL_PATTERN = /\(([^)]+)\)/
+      PARAMETER_REGEXP = /\{([^}:]+)(:([^}]+))?}/
+      OPTIONAL_REGEXP = /\(([^)]+)\)/
+      ALTERNATIVE_WORD_REGEXP = /([[:alpha:]]+)((\/[[:alpha:]]+)+)/
 
       attr_reader :source
 
-      def initialize(expression, types, parameter_registry)
+      def initialize(expression, types, parameter_type_registry)
         @source = expression
-        @parameters = []
+        @parameter_types = []
         regexp = "^"
         type_index = 0
-        match = nil
         match_offset = 0
 
-        # Does not include (){} because they have special meaning
+        # Escape 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)?')
+        expression = expression.gsub(OPTIONAL_REGEXP, '(?:\1)?')
+
+        expression = expression.gsub(ALTERNATIVE_WORD_REGEXP) do |_|
+          "(?:#{$1}#{$2.tr('/', '|')})"
+        end
 
         loop do
-          match = PARAMETER_PATTERN.match(expression, match_offset)
+          match = PARAMETER_REGEXP.match(expression, match_offset)
           break if match.nil?
 
           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.")
+          parameter_type_name = match[3]
+          if parameter_type_name
+            $stderr.puts("Cucumber expression parameter syntax {#{parameter_name}:#{parameter_type_name}} is deprecated. Please use {#{parameter_type_name}} instead.")
           end
 
           type = types.length <= type_index ? nil : types[type_index]
           type_index += 1
 
-          parameter = nil
+          parameter_type = nil
           if type
-            parameter = parameter_registry.lookup_by_type(type)
+            parameter_type = parameter_type_registry.lookup_by_type(type)
           end
-          if parameter.nil? && type_name
-            parameter = parameter_registry.lookup_by_type_name(type_name)
+          if parameter_type.nil? && parameter_type_name
+            parameter_type = parameter_type_registry.lookup_by_name(parameter_type_name)
           end
-          if parameter.nil?
-            parameter = parameter_registry.lookup_by_type_name(parameter_name)
+          if parameter_type.nil?
+            parameter_type = parameter_type_registry.lookup_by_name(parameter_name)
           end
-          if parameter.nil?
-            parameter = parameter_registry.create_anonymous_lookup(lambda {|s| s})
+          if parameter_type.nil?
+            parameter_type = parameter_type_registry.create_anonymous_lookup(lambda {|s| s})
           end
-          @parameters.push(parameter)
+          @parameter_types.push(parameter_type)
 
           text = expression.slice(match_offset...match.offset(0)[0])
-          capture_regexp = capture_group_regexp(parameter.capture_group_regexps)
+          capture_regexp = regexp(parameter_type.regexps)
           match_offset = match.offset(0)[1]
           regexp += text
           regexp += capture_regexp
@@ -63,14 +67,14 @@ module Cucumber
       end
 
       def match(text)
-        ArgumentBuilder.build_arguments(@regexp, text, @parameters)
+        ArgumentBuilder.build_arguments(@regexp, text, @parameter_types)
       end
 
       private
 
-      def capture_group_regexp(capture_group_regexps)
-        return "(#{capture_group_regexps[0]})" if capture_group_regexps.size == 1
-        capture_groups = capture_group_regexps.map { |group| "(?:#{group})" }
+      def regexp(regexps)
+        return "(#{regexps[0]})" if regexps.size == 1
+        capture_groups = regexps.map { |group| "(?:#{group})" }
         "(#{capture_groups.join('|')})"
       end
     end

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -1,44 +1,44 @@
-require 'cucumber/cucumber_expressions/parameter_matcher'
+require 'cucumber/cucumber_expressions/parameter_type_matcher'
 require 'cucumber/cucumber_expressions/generated_expression'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpressionGenerator
-      def initialize(parameter_registry)
-        @parameter_registry = parameter_registry
+      def initialize(parameter_type_registry)
+        @parameter_type_registry = parameter_type_registry
       end
 
       def generate_expression(text)
         parameter_names = []
-        parameter_matchers = create_parameter_matchers(text)
-        parameters = []
-        usage_by_type_name = Hash.new(0)
+        parameter_type_matchers = create_parameter_type_matchers(text)
+        parameter_types = []
+        usage_by_name = Hash.new(0)
 
         expression = ""
         pos = 0
 
         loop do
-          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)
+          matching_parameter_type_matchers = []
+          parameter_type_matchers.each do |parameter_type_matcher|
+            advanced_parameter_type_matcher = parameter_type_matcher.advance_to(pos)
+            if advanced_parameter_type_matcher.find
+              matching_parameter_type_matchers.push(advanced_parameter_type_matcher)
             end
           end
 
-          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)
+          if matching_parameter_type_matchers.any?
+            matching_parameter_type_matchers = matching_parameter_type_matchers.sort
+            best_parameter_type_matcher = matching_parameter_type_matchers[0]
+            parameter_type = best_parameter_type_matcher.parameter
+            parameter_types.push(parameter_type)
 
-            parameter_name = get_parameter_name(parameter.type_name, usage_by_type_name)
+            parameter_name = get_parameter_name(parameter_type.name, usage_by_name)
             parameter_names.push(parameter_name)
 
-            expression += text.slice(pos...best_parameter_matcher.start)
-            expression += "{#{parameter.type_name}}"
+            expression += text.slice(pos...best_parameter_type_matcher.start)
+            expression += "{#{parameter_type.name}}"
 
-            pos = best_parameter_matcher.start + best_parameter_matcher.group.length
+            pos = best_parameter_type_matcher.start + best_parameter_type_matcher.group.length
           else
             break
           end
@@ -49,30 +49,30 @@ module Cucumber
         end
 
         expression += text.slice(pos..-1)
-        GeneratedExpression.new(expression, parameter_names, parameters)
+        GeneratedExpression.new(expression, parameter_names, parameter_types)
       end
 
     private
 
-      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}"
+      def get_parameter_name(name, usage_by_name)
+        count = (usage_by_name[name] += 1)
+        count == 1 ? name : "#{name}#{count}"
       end
 
-      def create_parameter_matchers(text)
+      def create_parameter_type_matchers(text)
         parameter_matchers = []
-        @parameter_registry.parameters.each do |parameter|
-          parameter_matchers += create_parameter_matchers2(parameter, text)
+        @parameter_type_registry.parameter_types.each do |parameter_type|
+          parameter_matchers += create_parameter_type_matchers2(parameter_type, text)
         end
         parameter_matchers
       end
 
-      def create_parameter_matchers2(parameter, text)
+      def create_parameter_type_matchers2(parameter_type, text)
         result = []
-        capture_group_regexps = parameter.capture_group_regexps
-        capture_group_regexps.each do |capture_group_regexp|
-          regexp = Regexp.new("(#{capture_group_regexp})")
-          result.push(ParameterMatcher.new(parameter, regexp, text))
+        regexps = parameter_type.regexps
+        regexps.each do |regexp|
+          regexp = Regexp.new("(#{regexp})")
+          result.push(ParameterTypeMatcher.new(parameter_type, 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, :parameter_names, :parameters
+      attr_reader :source, :parameter_names, :parameter_types
 
-      def initialize(source, parameter_names, parameters)
-        @source, @parameter_names, @parameters = source, parameter_names, parameters
+      def initialize(source, parameter_names, parameters_types)
+        @source, @parameter_names, @parameter_types = source, parameter_names, parameters_types
       end
     end
   end

data/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -0,0 +1,29 @@
+module Cucumber
+  module CucumberExpressions
+    class ParameterType
+      attr_reader :name, :type, :regexps
+
+      # Create a new Parameter
+      #
+      # @param name the name of the parameter type
+      # @param regexps [Array] list of regexps for capture groups. A single regexp can also be used.
+      # @param transformer lambda that transforms a String to (possibly) another type
+      #
+      def initialize(name, type, regexp, transformer)
+        @name, @type, @transformer = name, type, transformer
+        @regexps = string_array(regexp)
+      end
+
+      def transform(value)
+        @transformer ? @transformer.call(value) : value
+      end
+
+      private
+
+      def string_array(regexp)
+        array = regexp.is_a?(Array) ? regexp : [regexp]
+        array.map { |r| r.is_a?(String) ? r : r.source }
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module Cucumber
   module CucumberExpressions
-    class ParameterMatcher
+    class ParameterTypeMatcher
       attr_reader :parameter
 
       def initialize(parameter, regexp, text, match_position=0)

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -0,0 +1,82 @@
+require 'cucumber/cucumber_expressions/parameter_type'
+
+module Cucumber
+  module CucumberExpressions
+    class ParameterTypeRegistry
+      INTEGER_REGEXPS = [/-?\d+/, /\d+/]
+      FLOAT_REGEXP = /-?\d*\.?\d+/
+
+      def initialize
+        @parameter_types_by_name = {}
+        @parameter_types_by_regexp = {}
+        @parameter_types_by_class = {}
+
+        define_predefined_parameter_type(ParameterType.new('int', Integer, INTEGER_REGEXPS, lambda { |s| s.to_i }))
+        define_predefined_parameter_type(ParameterType.new('float', Float, FLOAT_REGEXP, 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_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 = @parameter_types_by_class[clazz]
+        if parameter.nil?
+          create_anonymous_lookup(lambda { |s| clazz.new(s) })
+        else
+          parameter
+        end
+      end
+
+      def lookup_by_name(name)
+        @parameter_types_by_name[name]
+      end
+
+      def lookup_by_regexp(regexp)
+        @parameter_types_by_regexp[regexp]
+      end
+
+      def create_anonymous_lookup(proc)
+        ParameterType.new(nil, nil, ['.+'], proc)
+      end
+
+      def parameter_types
+        @parameter_types_by_name.values
+      end
+
+      def define_parameter_type(parameter_type)
+        define_parameter_type0(parameter_type, true)
+      end
+
+      private
+
+      def define_predefined_parameter_type(parameter_type)
+        define_parameter_type0(parameter_type, false)
+      end
+
+      def define_parameter_type0(parameter_type, check_conflicts)
+        if parameter_type.type
+          put(@parameter_types_by_class, parameter_type.type, parameter_type, "type", check_conflicts)
+        end
+        put(@parameter_types_by_name, parameter_type.name, parameter_type, "type name", check_conflicts)
+
+        parameter_type.regexps.each do |regexp|
+          put(@parameter_types_by_regexp, regexp, parameter_type, "regexp", check_conflicts)
+        end
+      end
+
+      def put(map, key, parameter, prop, check_conflicts)
+        if check_conflicts && map.has_key?(key)
+          raise "There is already a parameter with #{prop} #{key}"
+        end
+        map[key] = parameter
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -5,9 +5,9 @@ module Cucumber
     class RegularExpression
       CAPTURE_GROUP_PATTERN = /\(([^(]+)\)/
 
-      def initialize(regexp, types, parameter_registry)
+      def initialize(regexp, types, parameter_type_registry)
         @regexp = regexp
-        @parameters = []
+        @parameter_types = []
 
         type_index = 0
         match = nil
@@ -21,24 +21,24 @@ module Cucumber
           type = types.length <= type_index ? nil : types[type_index]
           type_index += 1
 
-          parameter = nil
+          parameter_type = nil
           if (type)
-            parameter = parameter_registry.lookup_by_type(type)
+            parameter_type = parameter_type_registry.lookup_by_type(type)
           end
-          if (parameter.nil?)
-            parameter = parameter_registry.lookup_by_capture_group_regexp(capture_group_pattern)
+          if (parameter_type.nil?)
+            parameter_type = parameter_type_registry.lookup_by_regexp(capture_group_pattern)
           end
-          if (parameter.nil?)
-            parameter = parameter_registry.create_anonymous_lookup(lambda {|s| s})
+          if (parameter_type.nil?)
+            parameter_type = parameter_type_registry.create_anonymous_lookup(lambda {|s| s})
           end
 
-          @parameters.push(parameter)
+          @parameter_types.push(parameter_type)
           match_offset = match.offset(0)[1]
         end
       end
 
       def match(text)
-        ArgumentBuilder.build_arguments(@regexp, text, @parameters)
+        ArgumentBuilder.build_arguments(@regexp, text, @parameter_types)
       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/parameter'
-require 'cucumber/cucumber_expressions/parameter_registry'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
 
 module Cucumber
   module CucumberExpressions
@@ -9,18 +9,18 @@ module Cucumber
       end
 
       before do
-        @parameter_registry = ParameterRegistry.new
-        @generator = CucumberExpressionGenerator.new(@parameter_registry)
+        @parameter_type_registry = ParameterTypeRegistry.new
+        @generator = CucumberExpressionGenerator.new(@parameter_type_registry)
       end
 
       it "documents expression generation" do
-        parameter_registry = ParameterRegistry.new
+        parameter_registry = ParameterTypeRegistry.new
         ### [generate-expression]
         generator = CucumberExpressionGenerator.new(parameter_registry)
         undefined_step_text = "I have 2 cucumbers and 1.5 tomato"
         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)
+        expect(generated_expression.parameter_types[1].type).to eq(Float)
         ### [generate-expression]
       end
 
@@ -47,7 +47,7 @@ module Cucumber
       end
 
       it "numbers only second argument when type is not reserved keyword" do
-        @parameter_registry.add_parameter(Parameter.new(
+        @parameter_type_registry.define_parameter_type(ParameterType.new(
           'currency',
           Currency,
           '[A-Z]{3}',
@@ -61,7 +61,7 @@ module Cucumber
 
       it "exposes parameters in generated expression" do
         expression = @generator.generate_expression("I have 2 cukes and 1.5 euro")
-        types = expression.parameters.map(&:type)
+        types = expression.parameter_types.map(&:type)
         expect(types).to eq([Integer, Float])
       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/parameter_registry'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
 
 module Cucumber
   module CucumberExpressions
     describe CucumberExpression do
       context "Regexp translation" do
         def assert_regexp(expression, regexp)
-          cucumber_expression = CucumberExpression.new(expression, [], ParameterRegistry.new)
+          cucumber_expression = CucumberExpression.new(expression, [], ParameterTypeRegistry.new)
           expect(regexp).to eq(cucumber_expression.instance_variable_get('@regexp'))
         end
 
@@ -17,6 +17,13 @@ module Cucumber
           )
         end
 
+        it "translates alternation" do
+          assert_regexp(
+            "I had/have a great/nice/charming friend",
+            /^I (?:had|have) a (?:great|nice|charming) friend$/
+          )
+        end
+
         it "translates two untyped arguments" do
           assert_regexp(
             "I have {n} cukes in my {bodypart} now",

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,11 +1,11 @@
 require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_registry'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
 
 module Cucumber
   module CucumberExpressions
     describe CucumberExpression do
       it "documents match arguments" do
-        parameter_registry = ParameterRegistry.new
+        parameter_registry = ParameterTypeRegistry.new
 
         ### [capture-match-arguments]
         expr = "I have {n} cuke(s) in my {bodypart} now"
@@ -58,12 +58,12 @@ module Cucumber
 
       it "exposes source" do
         expr = "I have {int} cuke(s) in my {bodypart} now"
-        expect(CucumberExpression.new(expr, [], ParameterRegistry.new).source).to eq(expr)
+        expect(CucumberExpression.new(expr, [], ParameterTypeRegistry.new).source).to eq(expr)
       end
 
       it "exposes offset and value" do
         expr = "I have {int} cuke(s) in my {bodypart} now"
-        expression = CucumberExpression.new(expr, [], ParameterRegistry.new)
+        expression = CucumberExpression.new(expr, [], ParameterTypeRegistry.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")
@@ -73,7 +73,7 @@ module Cucumber
         %w(\\ [ ] ^ $ . | ? * +).each do |character|
           it "escapes #{character}" do
             expr = "I have {int} cuke(s) and #{character}"
-            expression = CucumberExpression.new(expr, [], ParameterRegistry.new)
+            expression = CucumberExpression.new(expr, [], ParameterTypeRegistry.new)
             arg1 = expression.match("I have 800 cukes and #{character}")[0]
             expect(arg1.offset).to eq(7)
             expect(arg1.value).to eq("800")
@@ -82,7 +82,7 @@ module Cucumber
       end
 
       def match(expression, text, types = [])
-        cucumber_expression = CucumberExpression.new(expression, types, ParameterRegistry.new)
+        cucumber_expression = CucumberExpression.new(expression, types, ParameterTypeRegistry.new)
         args = cucumber_expression.match(text)
         return nil if args.nil?
         args.map { |arg| arg.transformed_value }

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -0,0 +1,164 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_type_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 = ParameterTypeRegistry.new
+        ### [add-color-parameter]
+        parameter_registry.define_parameter_type(ParameterType.new(
+          'color',
+          Color,
+          /red|blue|yellow/,
+          lambda { |s| Color.new(s) }
+        ))
+        ### [add-color-parameter]
+        @parameter_type_registry = parameter_registry
+      end
+
+      describe CucumberExpression do
+        it "matches parameters with custom parameter type" do
+          expression = CucumberExpression.new("I have a {color} ball", [], @parameter_type_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "matches parameters with custom parameter type using optional capture group" do
+          parameter_registry = ParameterTypeRegistry.new
+          parameter_registry.define_parameter_type(ParameterType.new(
+              'color',
+              Color,
+              [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
+              lambda { |s| Color.new(s) }
+          ))
+          expression = CucumberExpression.new("I have a {color} ball", [], parameter_registry)
+          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 "matches parameters with custom parameter type without constructor function and transform" do
+          parameter_registry = ParameterTypeRegistry.new
+          parameter_registry.define_parameter_type(ParameterType.new(
+              'color',
+              nil,
+              /red|blue|yellow/,
+              nil
+          ))
+          expression = CucumberExpression.new("I have a {color} ball", [], parameter_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq('red')
+        end
+
+        it "matches parameters with explicit type" do
+          expression = CucumberExpression.new("I have a {color} ball", [Color], @parameter_type_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_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], ParameterTypeRegistry.new)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_argument_value ).to eq(Color.new('red'))
+        end
+
+        it "defers transformation until queried from argument" do
+          @parameter_type_registry.define_parameter_type(ParameterType.new(
+              'throwing',
+              String,
+              /bad/,
+              lambda { |s| raise "Can't transform [#{s}]" }
+          ))
+          expression = CucumberExpression.new("I have a {throwing} parameter", [], @parameter_type_registry)
+          args = expression.match("I have a bad parameter")
+          expect { args[0].transformed_value }.to raise_error("Can't transform [bad]")
+        end
+
+        describe "conflicting parameter type" do
+          it "is detected for type name" do
+            expect {
+              @parameter_type_registry.define_parameter_type(ParameterType.new(
+                  'color',
+                  String,
+                  /.*/,
+                  lambda { |s| s }
+              ))
+            }.to raise_error("There is already a parameter with type name color")
+          end
+
+          it "is detected for type" do
+            expect {
+              @parameter_type_registry.define_parameter_type(ParameterType.new(
+                  'color2',
+                  Color,
+                  /.*/,
+                  lambda { |s| Color.new(s) }
+              ))
+            }.to raise_error("There is already a parameter with type Cucumber::CucumberExpressions::Color")
+          end
+
+          it "is detected for regexp" do
+            expect {
+              @parameter_type_registry.define_parameter_type(ParameterType.new(
+                  'color2',
+                  String,
+                  /red|blue|yellow/,
+                  lambda { |s| s }
+              ))
+            }.to raise_error("There is already a parameter with regexp red|blue|yellow")
+          end
+
+          it "is not detected when type is nil" do
+            @parameter_type_registry.define_parameter_type(ParameterType.new(
+                'foo',
+                nil,
+                /foo/,
+                lambda { |s| s }
+            ))
+            @parameter_type_registry.define_parameter_type(ParameterType.new(
+                'bar',
+                nil,
+                /bar/,
+                lambda { |s| s }
+            ))
+          end
+        end
+      end
+
+      describe RegularExpression do
+        it "matches parameters with explicit constructor" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, [Color], @parameter_type_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_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_type_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
+          expect( transformed_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], ParameterTypeRegistry.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

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/parameter_registry'
+require 'cucumber/cucumber_expressions/parameter_type_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), [], ParameterRegistry.new) :
-          CucumberExpression.new(expression_text, [], ParameterRegistry.new)
+          RegularExpression.new(Regexp.new($1), [], ParameterTypeRegistry.new) :
+          CucumberExpression.new(expression_text, [], ParameterTypeRegistry.new)
 
         arguments = expression.match(text)
         return nil if arguments.nil?

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,16 +1,16 @@
 require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/parameter_registry'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
 
 module Cucumber
   module CucumberExpressions
     describe RegularExpression do
       it "documents match arguments" do
-        parameter_registry = ParameterRegistry.new
+        parameter_type_registry = ParameterTypeRegistry.new
 
         ### [capture-match-arguments]
         expr = /I have (\d+) cukes? in my (\w*) now/
         types = ['int', nil]
-        expression = RegularExpression.new(expr, types, parameter_registry)
+        expression = RegularExpression.new(expr, types, parameter_type_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")
@@ -57,11 +57,11 @@ module Cucumber
 
       it "exposes source" do
         expr = /I have (\d+) cukes? in my (\+) now/
-        expect(RegularExpression.new(expr, [], ParameterRegistry.new).source).to eq(expr)
+        expect(RegularExpression.new(expr, [], ParameterTypeRegistry.new).source).to eq(expr)
       end
 
       def match(expression, text, types = [])
-        regular_expression = RegularExpression.new(expression, types, ParameterRegistry.new)
+        regular_expression = RegularExpression.new(expression, types, ParameterTypeRegistry.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: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,16 +86,16 @@ files:
 - 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/parameter_type.rb
+- lib/cucumber/cucumber_expressions/parameter_type_matcher.rb
+- lib/cucumber/cucumber_expressions/parameter_type_registry.rb
 - lib/cucumber/cucumber_expressions/regular_expression.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_parameter_spec.rb
+- spec/cucumber/cucumber_expressions/custom_parameter_type_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
@@ -122,13 +122,13 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-2.0.1
+summary: cucumber-expressions-3.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_parameter_spec.rb
+- spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb
 - spec/cucumber/cucumber_expressions/expression_examples_spec.rb
 - spec/cucumber/cucumber_expressions/regular_expression_spec.rb

data/lib/cucumber/cucumber_expressions/parameter.rb

@@ -1,29 +0,0 @@
-module Cucumber
-  module CucumberExpressions
-    class Parameter
-      attr_reader :type_name, :type, :capture_group_regexps
-
-      # 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 (possibly) another type
-      #
-      def initialize(type_name, type, capture_group_regexps, transformer)
-        @type_name, @type, @transformer = type_name, type, transformer
-        @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/parameter_registry.rb

@@ -1,64 +0,0 @@
-require 'cucumber/cucumber_expressions/parameter'
-
-module Cucumber
-  module CucumberExpressions
-    class ParameterRegistry
-      INTEGER_REGEXPS = [/-?\d+/, /\d+/]
-      FLOAT_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, FLOAT_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/spec/cucumber/cucumber_expressions/custom_parameter_spec.rb

@@ -1,100 +0,0 @@
-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
-        ### [add-color-parameter]
-        parameter_registry = ParameterRegistry.new
-        parameter_registry.add_parameter(Parameter.new(
-          'color',
-          Color,
-          [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
-          lambda { |s| Color.new(s) }
-        ))
-        ### [add-color-parameter]
-        @parameter_registry = parameter_registry
-      end
-
-      describe CucumberExpression do
-        it "matches typed parameters" do
-          expression = CucumberExpression.new("I have a {color} ball", [], @parameter_registry)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_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)
-          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 "matches untyped parameters with explicit type" do
-          expression = CucumberExpression.new("I have a {color} ball", [Color], @parameter_registry)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_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)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_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)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_argument_value ).to eq(Color.new('red'))
-        end
-
-        it("defers transformation until queried from argument") do
-          @parameter_registry.add_parameter(Parameter.new(
-              'throwing',
-              String,
-              /bad/,
-              lambda { |s| raise "Can't transform [#{s}]" }
-          ))
-          expression = CucumberExpression.new("I have a {throwing} parameter", [], @parameter_registry)
-          args = expression.match("I have a bad parameter")
-          expect { args[0].transformed_value }.to raise_error("Can't transform [bad]")
-        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)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_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)
-          transformed_argument_value = expression.match("I have a red ball")[0].transformed_value
-          expect( transformed_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)
-          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