cucumber-expressions 3.0.0 → 4.0.0

data/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -1,21 +1,54 @@
+require 'cucumber/cucumber_expressions/errors'
+
 module Cucumber
   module CucumberExpressions
     class ParameterType
       attr_reader :name, :type, :regexps
 
+      def prefer_for_regexp_match?
+        @prefer_for_regexp_match
+      end
+
+      def use_for_snippets?
+        @use_for_snippets
+      end
+
       # 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 regexp [Array] list of regexps for capture groups. A single regexp can also be used
+      # @param type the return type of the transformed
       # @param transformer lambda that transforms a String to (possibly) another type
+      # @param use_for_snippets true if this should be used for snippet generation
+      # @param prefer_for_regexp_match true if this should be preferred over similar types
       #
-      def initialize(name, type, regexp, transformer)
-        @name, @type, @transformer = name, type, transformer
+      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?
+
+        @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(value)
-        @transformer ? @transformer.call(value) : value
+      def transform(group_values)
+        if @transformer.arity == 1
+          non_nil_group_values = group_values.compact
+          raise CucumberExpressionError.new(
+              "Single transformer unexpectedly matched 2 values - \"#{non_nil_group_values[0]}\" and \"${non_nil_group_values[1]}\""
+          ) if non_nil_group_values.length >= 2
+          return @transformer.call(non_nil_group_values[0])
+        end
+        @transformer.call(*group_values)
+      end
+
+      def <=>(other)
+        return -1 if prefer_for_regexp_match? && !other.prefer_for_regexp_match?
+        return 1  if other.prefer_for_regexp_match? && !prefer_for_regexp_match?
+        name <=> other.name
       end
 
       private

data/lib/cucumber/cucumber_expressions/parameter_type_matcher.rb

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

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -1,82 +1,62 @@
 require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/errors'
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
 
 module Cucumber
   module CucumberExpressions
     class ParameterTypeRegistry
       INTEGER_REGEXPS = [/-?\d+/, /\d+/]
       FLOAT_REGEXP = /-?\d*\.?\d+/
+      WORD_REGEXP = /\w+/
+      STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/
 
       def initialize
-        @parameter_types_by_name = {}
-        @parameter_types_by_regexp = {}
-        @parameter_types_by_class = {}
+        @parameter_type_by_name = {}
+        @parameter_types_by_regexp = Hash.new {|hash, regexp| hash[regexp] = []}
 
-        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 }))
+        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))
       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
+      def lookup_by_type_name(name)
+        @parameter_type_by_name[name]
       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
+      def lookup_by_regexp(parameter_type_regexp, expression_regexp, text)
+        parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
+        return nil if parameter_types.nil?
+        if parameter_types.length > 1 && !parameter_types[0].prefer_for_regexp_match?
+          # We don't do this check on insertion because we only want to restrict
+          # ambiguity when we look up by Regexp. Users of CucumberExpression should
+          # not be restricted.
+          generated_expressions = CucumberExpressionGenerator.new(self).generate_expressions(text)
+          raise AmbiguousParameterTypeError.new(parameter_type_regexp, expression_regexp, parameter_types, generated_expressions)
         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)
+        parameter_types.first
       end
 
       def parameter_types
-        @parameter_types_by_name.values
+        @parameter_type_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)
+        if @parameter_type_by_name.has_key?(parameter_type.name)
+          raise CucumberExpressionError.new("There is already a parameter with name #{parameter_type.name}")
         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)
+        @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]
+          if parameter_types.any? && parameter_types[0].prefer_for_regexp_match? && parameter_type.prefer_for_regexp_match?
+            raise CucumberExpressionError.new("There can only be one prefer_for_regexp_match parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two prefer_for_regexp_match parameter types, {#{parameter_types[0].name}} and {#{parameter_type.name}}")
+          end
+          parameter_types.push(parameter_type)
+          parameter_types.sort!
         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

@@ -1,48 +1,48 @@
-require 'cucumber/cucumber_expressions/argument_builder'
+require 'cucumber/cucumber_expressions/argument'
+require 'cucumber/cucumber_expressions/parameter_type'
 
 module Cucumber
   module CucumberExpressions
     class RegularExpression
-      CAPTURE_GROUP_PATTERN = /\(([^(]+)\)/
+      CAPTURE_GROUP_PATTERN = /\((?!\?:)([^(]+)\)/
 
-      def initialize(regexp, types, parameter_type_registry)
-        @regexp = regexp
-        @parameter_types = []
+      def initialize(expression_regexp, parameter_type_registry)
+        @expression_regexp = expression_regexp
+        @parameter_type_registry = parameter_type_registry
+      end
+
+      def match(text)
+        parameter_types = []
 
-        type_index = 0
-        match = nil
         match_offset = 0
 
         loop do
-          match = CAPTURE_GROUP_PATTERN.match(regexp.source, match_offset)
+          match = CAPTURE_GROUP_PATTERN.match(@expression_regexp.source, match_offset)
           break if match.nil?
+          match_offset = match.offset(0)[1]
 
-          capture_group_pattern = match[1]
-          type = types.length <= type_index ? nil : types[type_index]
-          type_index += 1
-
-          parameter_type = nil
-          if (type)
-            parameter_type = parameter_type_registry.lookup_by_type(type)
-          end
-          if (parameter_type.nil?)
-            parameter_type = parameter_type_registry.lookup_by_regexp(capture_group_pattern)
-          end
-          if (parameter_type.nil?)
-            parameter_type = parameter_type_registry.create_anonymous_lookup(lambda {|s| s})
+          parameter_type_regexp = match[1]
+
+          parameter_type = @parameter_type_registry.lookup_by_regexp(parameter_type_regexp, @expression_regexp, text)
+          if parameter_type.nil?
+            parameter_type = ParameterType.new(
+                '*',
+                parameter_type_regexp,
+                String,
+                lambda {|s| s},
+                false,
+                false
+            )
           end
 
-          @parameter_types.push(parameter_type)
-          match_offset = match.offset(0)[1]
+          parameter_types.push(parameter_type)
         end
-      end
 
-      def match(text)
-        ArgumentBuilder.build_arguments(@regexp, text, @parameter_types)
+        Argument.build(@expression_regexp, text, parameter_types)
       end
 
       def source
-        @regexp
+        @expression_regexp
       end
     end
   end

data/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb

@@ -0,0 +1,43 @@
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/combinatorial_generated_expression_factory'
+
+module Cucumber
+  module CucumberExpressions
+
+    class Color; end
+    class CssColor; end
+    class Date; end
+    class DateTime; end
+    class Timestamp; end
+
+    describe CombinatorialGeneratedExpressionFactory do
+      it 'generates multiple expressions' do
+        parameter_type_combinations = [
+          [
+            ParameterType.new('color', /red|blue|yellow/, Color, lambda {|s| Color.new}, true, false),
+            ParameterType.new('csscolor', /red|blue|yellow/, CssColor, lambda {|s| CssColor.new}, true, false)
+          ],
+          [
+            ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, Date, lambda {|s| Date.new}, true, false),
+            ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, DateTime, lambda {|s| DateTime.new}, true, false),
+            ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, Timestamp, lambda {|s| Timestamp.new}, true, false)
+          ]
+        ]
+
+        factory = CombinatorialGeneratedExpressionFactory.new(
+          'I bought a {%s} ball on {%s}',
+          parameter_type_combinations
+        )
+        expressions = factory.generate_expressions.map {|ge| ge.source}
+        expect(expressions).to eq([
+            'I bought a {color} ball on {date}',
+            'I bought a {color} ball on {datetime}',
+            'I bought a {color} ball on {timestamp}',
+            'I bought a {csscolor} ball on {date}',
+            'I bought a {csscolor} ball on {datetime}',
+            'I bought a {csscolor} ball on {timestamp}',
+        ])
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -34,6 +34,12 @@ module Cucumber
           "I have 2 cukes and 1.5 euro")
       end
 
+      it "generates expression for strings" do
+        assert_expression(
+            "I like {string} and {string}", ["string", "string2"],
+            'I like "bangers" and \'mash\'')
+      end
+
       it "generates expression for just int" do
         assert_expression(
           "{int}", ["int"],
@@ -49,9 +55,11 @@ module Cucumber
       it "numbers only second argument when type is not reserved keyword" do
         @parameter_type_registry.define_parameter_type(ParameterType.new(
           'currency',
-          Currency,
           '[A-Z]{3}',
-          nil
+          Currency,
+          lambda {|s| Currency.new(s)},
+          true,
+          true
         ))
 
         assert_expression(

data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb

@@ -6,7 +6,7 @@ module Cucumber
     describe CucumberExpression do
       context "Regexp translation" do
         def assert_regexp(expression, regexp)
-          cucumber_expression = CucumberExpression.new(expression, [], ParameterTypeRegistry.new)
+          cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
           expect(regexp).to eq(cucumber_expression.instance_variable_get('@regexp'))
         end
 
@@ -24,17 +24,10 @@ module Cucumber
           )
         end
 
-        it "translates two untyped arguments" do
+        it "translates parameters" do
           assert_regexp(
-            "I have {n} cukes in my {bodypart} now",
-            /^I have (.+) cukes in my (.+) now$/
-          )
-        end
-
-        it "translates three typed arguments" do
-          assert_regexp(
-            "I have {float} cukes in my {bodypart} at {int} o'clock",
-            /^I have (-?\d*\.?\d+) cukes in my (.+) at ((?:-?\d+)|(?:\d+)) o'clock$/
+            "I have {float} cukes at {int} o'clock",
+            /^I have (-?\d*\.?\d+) cukes at ((?:-?\d+)|(?:\d+)) o'clock$/
           )
         end
 

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -8,84 +8,83 @@ module Cucumber
         parameter_registry = ParameterTypeRegistry.new
 
         ### [capture-match-arguments]
-        expr = "I have {n} cuke(s) in my {bodypart} now"
-        types = ['int', nil]
-        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")
+        expr = "I have {int} cuke(s)"
+        expression = CucumberExpression.new(expr, parameter_registry)
+        args = expression.match("I have 7 cukes")
+        expect(args[0].value).to eq(7)
         ### [capture-match-arguments]
       end
 
-      it "does no transform by default" do
-        expect( match("{what}", "22") ).to eq(["22"])
+      it "matches word" do
+        expect(match("three {word} mice", "three blind mice")).to eq(['blind'])
       end
 
-      it "transforms to int by parameter type" do
-        expect( match("{int}", "22") ).to eq([22])
+      it('matches double quoted string') do
+        expect(match('three {string} mice', 'three "blind" mice')).to eq(['blind'])
       end
 
-      it "transforms to int by explicit type" do
-        expect( match("{what}", "22", ['int']) ).to eq([22])
+      it('matches single quoted string') do
+        expect(match('three {string} mice', "three 'blind' mice")).to eq(['blind'])
       end
 
-      # Ruby-specific
-      it "parameters to Integer by explicit type" do
-        expect( match("{what}", "22", [Integer]) ).to eq([22])
+      it('does not match misquoted string') do
+        expect(match('three {string} mice', 'three "blind\' mice')).to eq(nil)
       end
 
-      it "doesn't match a float with an int parameter" do
-        expect( match("{int}", "1.22") ).to be_nil
+      it('matches single quoted string with double quotes') do
+        expect(match('three {string} mice', 'three \'"blind"\' mice')).to eq(['"blind"'])
       end
 
-      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])
+      it('matches double quoted string with single quotes') do
+        expect(match('three {string} mice', 'three "\'blind\'" mice')).to eq(["'blind'"])
       end
 
-      it "transforms to float by explicit type" do
-        expect( match("{what}", "0.22", ['float']) ).to eq([0.22])
-        expect( match("{what}",  ".22", ['float']) ).to eq([0.22])
+      it('matches double quoted string with escaped double quote') do
+        expect(match('three {string} mice', 'three "bl\\"nd" mice')).to eq(['bl"nd'])
       end
 
-      it "leaves unknown type untransformed" do
-        expect( match("{unknown}", "something") ).to eq(["something"])
+      it('matches single quoted string with escaped single quote') do
+        expect(match('three {string} mice', "three 'bl\\'nd' mice")).to eq(["bl'nd"])
       end
 
-      it "supports deprecated {name:type} syntax for now" do
-        expect( match("{param:unknown}", "something") ).to eq(["something"])
+      it "matches int" do
+        expect(match("{int}", "22")).to eq([22])
       end
 
-      it "exposes source" do
-        expr = "I have {int} cuke(s) in my {bodypart} now"
-        expect(CucumberExpression.new(expr, [], ParameterTypeRegistry.new).source).to eq(expr)
+      it "doesn't match float as int" do
+        expect(match("{int}", "1.22")).to be_nil
+      end
+
+      it "matches float" do
+        expect(match("{float}", "0.22")).to eq([0.22])
+        expect(match("{float}", ".22")).to eq([0.22])
       end
 
-      it "exposes offset and value" do
-        expr = "I have {int} cuke(s) in my {bodypart} now"
-        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")
+      it "throws unknown parameter type" do
+        expect {match("{unknown}", "something")}.to raise_error('Undefined parameter type {unknown}')
+      end
+
+      it "exposes source" do
+        expr = "I have {int} cuke(s)"
+        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
       end
 
-      describe "RegExp special characters" do
+      describe "escapes special characters" do
         %w(\\ [ ] ^ $ . | ? * +).each do |character|
           it "escapes #{character}" do
             expr = "I have {int} cuke(s) and #{character}"
-            expression = CucumberExpression.new(expr, [], ParameterTypeRegistry.new)
+            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")
+            expect(arg1.value).to eq(800)
           end
         end
       end
 
-      def match(expression, text, types = [])
-        cucumber_expression = CucumberExpression.new(expression, types, ParameterTypeRegistry.new)
+      def match(expression, text)
+        cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
         args = cucumber_expression.match(text)
         return nil if args.nil?
-        args.map { |arg| arg.transformed_value }
+        args.map {|arg| arg.value}
       end
     end
   end