cucumber-expressions 3.0.0 → 4.0.0

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -11,6 +11,7 @@ module Cucumber
       def initialize(name)
         @name = name
       end
+
       ### [color-constructor]
 
       def ==(other)
@@ -18,75 +19,106 @@ module Cucumber
       end
     end
 
+    class CssColor
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        other.is_a?(CssColor) && other.name == name
+      end
+    end
+
+    class Coordinate
+      attr_reader :x, :y, :z
+
+      def initialize(x, y, z)
+        @x, @y, @z = x, y, z
+      end
+
+      def ==(other)
+        other.is_a?(Coordinate) && other.x == x && other.y == y && other.z == z
+      end
+    end
+
     describe "Custom parameter" do
       before do
         parameter_registry = ParameterTypeRegistry.new
-        ### [add-color-parameter]
+        ### [add-color-parameter-type]
         parameter_registry.define_parameter_type(ParameterType.new(
-          'color',
-          Color,
-          /red|blue|yellow/,
-          lambda { |s| Color.new(s) }
+            'color',
+            /red|blue|yellow/,
+            Color,
+            lambda {|s| Color.new(s)},
+            true,
+            false
         ))
-        ### [add-color-parameter]
+        ### [add-color-parameter-type]
         @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'))
+          expression = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].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) }
+        it "matches parameters with multiple capture groups" do
+          @parameter_type_registry.define_parameter_type(ParameterType.new(
+              'coordinate',
+              /(\d+),\s*(\d+),\s*(\d+)/,
+              Coordinate,
+              lambda {|x, y, z| Coordinate.new(x.to_i, y.to_i, z.to_i)},
+              true,
+              false
           ))
-          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
+          expression = CucumberExpression.new(
+              'A {int} thick line from {coordinate} to {coordinate}',
+              @parameter_type_registry
+          )
+          args = expression.match('A 5 thick line from 10,20,30 to 40,50,60')
 
-        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'))
+          thick = args[0].value
+          expect(thick).to eq(5)
+
+          from = args[1].value
+          expect(from).to eq(Coordinate.new(10, 20, 30))
+
+          to = args[2].value
+          expect(to).to eq(Coordinate.new(40, 50, 60))
         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'))
+        it "matches parameters with custom parameter type using optional capture group" do
+          parameter_type_registry = ParameterTypeRegistry.new
+          parameter_type_registry.define_parameter_type(ParameterType.new(
+              'color',
+              [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
+              Color,
+              lambda {|s| Color.new(s)},
+              true,
+              false
+          ))
+          expression = CucumberExpression.new("I have a {color} ball", parameter_type_registry)
+          transformed_argument_value = expression.match("I have a dark red ball")[0].value
+          expect(transformed_argument_value).to eq(Color.new('dark 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}]" }
+              CssColor,
+              lambda {|s| raise "Can't transform [#{s}]"},
+              true,
+              false
           ))
-          expression = CucumberExpression.new("I have a {throwing} parameter", [], @parameter_type_registry)
+          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]")
+          expect {args[0].value}.to raise_error("Can't transform [bad]")
         end
 
         describe "conflicting parameter type" do
@@ -94,69 +126,52 @@ module Cucumber
             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) }
+                  CssColor,
+                  lambda {|s| CssColor.new(s)},
+                  true,
+                  false
               ))
-            }.to raise_error("There is already a parameter with type Cucumber::CucumberExpressions::Color")
+            }.to raise_error("There is already a parameter with name 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
+          it "is not detected for type" do
             @parameter_type_registry.define_parameter_type(ParameterType.new(
-                'foo',
-                nil,
-                /foo/,
-                lambda { |s| s }
+                'whatever',
+                /.*/,
+                Color,
+                lambda {|s| Color.new(s)},
+                true,
+                false
             ))
+          end
+
+          it "is not detected for regexp" do
             @parameter_type_registry.define_parameter_type(ParameterType.new(
-                'bar',
-                nil,
-                /bar/,
-                lambda { |s| s }
+                'css-color',
+                /red|blue|yellow/,
+                CssColor,
+                lambda {|s| CssColor.new(s)},
+                true,
+                false
             ))
+
+            css_color = CucumberExpression.new("I have a {css-color} ball", @parameter_type_registry)
+            css_color_value = css_color.match("I have a blue ball")[0].value
+            expect(css_color_value).to eq(CssColor.new("blue"))
+
+            color = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
+            color_value = color.match("I have a blue ball")[0].value
+            expect(color_value).to eq(Color.new("blue"))
           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'))
+        it "matches arguments with custom parameter type" do
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, @parameter_type_registry)
+          value = expression.match("I have a red ball")[0].value
+          expect(value).to eq(Color.new('red'))
         end
       end
     end

data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb

@@ -8,12 +8,12 @@ module Cucumber
     describe 'examples.txt' do
       def match(expression_text, text)
         expression = expression_text =~ /\/(.*)\// ?
-          RegularExpression.new(Regexp.new($1), [], ParameterTypeRegistry.new) :
-          CucumberExpression.new(expression_text, [], ParameterTypeRegistry.new)
+          RegularExpression.new(Regexp.new($1), ParameterTypeRegistry.new) :
+          CucumberExpression.new(expression_text, ParameterTypeRegistry.new)
 
         arguments = expression.match(text)
         return nil if arguments.nil?
-        arguments.map { |arg| arg.transformed_value }
+        arguments.map { |arg| arg.value }
       end
 
       File.open(File.expand_path("../../../../examples.txt", __FILE__), "r:utf-8") do |io|

data/spec/cucumber/cucumber_expressions/group_spec.rb

@@ -0,0 +1,34 @@
+require 'cucumber/cucumber_expressions/group'
+
+module Cucumber
+  module CucumberExpressions
+    describe Group do
+      it 'matches optional group' do
+        regexp = /^Something( with an optional argument)?/
+        string = 'Something'
+        matches = regexp.match(string)
+        group = Group.new(matches, string)
+
+        expect(group.children[0].value).to eq(nil)
+      end
+
+      it 'matches nested groups' do
+        regexp = /^A (\d+) thick line from ((\d+),\s*(\d+),\s*(\d+)) to ((\d+),\s*(\d+),\s*(\d+))?/
+        string = 'A 5 thick line from 10,20,30 to 40,50,60'
+
+        matches = regexp.match(string)
+        group = Group.new(matches, string)
+
+        expect(group.children[0].value).to eq('5')
+        expect(group.children[1].value).to eq('10,20,30')
+        expect(group.children[1].children[0].value).to eq('10')
+        expect(group.children[1].children[1].value).to eq('20')
+        expect(group.children[1].children[2].value).to eq('30')
+        expect(group.children[2].value).to eq('40,50,60')
+        expect(group.children[2].children[0].value).to eq('40')
+        expect(group.children[2].children[1].value).to eq('50')
+        expect(group.children[2].children[2].value).to eq('60')
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -0,0 +1,86 @@
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+
+    CAPITALISED_WORD = /[A-Z]+\w+/
+
+    class Name
+    end
+
+    class Person
+    end
+
+    class Place
+    end
+
+    describe ParameterTypeRegistry do
+      before do
+        @registry = ParameterTypeRegistry.new
+      end
+
+      it 'does not allow more than one prefer_for_regexp_match parameter type for each regexp' do
+        @registry.define_parameter_type(ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, true))
+        @registry.define_parameter_type(ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false))
+        expect do
+          @registry.define_parameter_type(ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, true))
+        end.to raise_error(
+                   CucumberExpressionError,
+                   "There can only be one prefer_for_regexp_match parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two prefer_for_regexp_match parameter types, {name} and {place}"
+               )
+      end
+
+      it 'looks up prefer_for_regexp_match parameter type by regexp' do
+        name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
+        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, true)
+        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+
+        @registry.define_parameter_type(name)
+        @registry.define_parameter_type(person)
+        @registry.define_parameter_type(place)
+
+        expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
+      end
+
+      it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
+        name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
+        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false)
+        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+
+        @registry.define_parameter_type(name)
+        @registry.define_parameter_type(person)
+        @registry.define_parameter_type(place)
+
+        expect do
+          expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
+        end.to raise_error(
+                   CucumberExpressionError,
+                   "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" +
+                       "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n" +
+                       "   {name}\n" +
+                       "   {person}\n" +
+                       "   {place}\n" +
+                       "\n" +
+                       "I couldn't decide which one to use. You have two options:\n" +
+                       "\n" +
+                       "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n" +
+                       "   {name} and {name}\n" +
+                       "   {name} and {person}\n" +
+                       "   {name} and {place}\n" +
+                       "   {person} and {name}\n" +
+                       "   {person} and {person}\n" +
+                       "   {person} and {place}\n" +
+                       "   {place} and {name}\n" +
+                       "   {place} and {person}\n" +
+                       "   {place} and {place}\n" +
+                       "\n" +
+                       "2) Make one of the parameter types prefer_for_regexp_match and continue to use a Regular Expression.\n" +
+                       "\n"
+               )
+      end
+    end
+  end
+end
+

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -9,11 +9,10 @@ module Cucumber
 
         ### [capture-match-arguments]
         expr = /I have (\d+) cukes? in my (\w*) now/
-        types = ['int', nil]
-        expression = RegularExpression.new(expr, types, parameter_type_registry)
+        expression = RegularExpression.new(expr, 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")
+        expect( args[0].value ).to eq(7)
+        expect( args[1].value ).to eq("belly")
         ### [capture-match-arguments]
       end
 
@@ -21,50 +20,43 @@ module Cucumber
         expect( match(/(\d\d)/, "22") ).to eq(["22"])
       end
 
-      it "transforms int to float by explicit type name" do
-        expect( match(/(.*)/, "22", ['float']) ).to eq([22.0])
+      it "transforms negative int" do
+        expect( match(/(-?\d+)/, "-22") ).to eq([-22])
       end
 
-      it "transforms int to float by explicit function" do
-        expect( match(/(.*)/, "22", [Float]) ).to eq([22.0])
-      end
-
-      it "transforms int by parameter pattern" do
-        expect( match(/(-?\d+)/, "22") ).to eq([22])
-      end
-
-      it "transforms int by alternate parameter pattern" do
+      it "transforms positive int" do
         expect( match(/(\d+)/, "22") ).to eq([22])
       end
 
       it "transforms float without integer part" do
-        expect( match(/(.*)/, ".22", ['float']) ).to eq([0.22])
+        expect( match(/(-?\d*\.?\d+)/, ".22") ).to eq([0.22])
       end
 
       it "transforms float with sign" do
-        expect( match(/(.*)/, "-1.22", ['float']) ).to eq([-1.22])
+        expect( match(/(-?\d*\.?\d+)/, "-1.22") ).to eq([-1.22])
       end
 
       it "returns nil when there is no match" do
         expect( match(/hello/, "world") ).to be_nil
       end
 
-      it "fails when type is not type name or class" do
-        expect( lambda { match(/(.*)/, "-1.22", [99]) } ).to raise_error(
-          # Ruby 2.3 and older report Fixnum, 2.4 and newer report Integer
-          /Type must be string or class, but was 99 of type (?:Fixnum)|(?:Integer)/)
+      it "ignores non capturing groups" do
+        expect( match(
+          /(\S+) ?(can|cannot)? (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
+          "I can cancel the 1st slide upload")
+        ).to eq(["I", "can", 1, "slide"])
       end
 
       it "exposes source" do
         expr = /I have (\d+) cukes? in my (\+) now/
-        expect(RegularExpression.new(expr, [], ParameterTypeRegistry.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, ParameterTypeRegistry.new)
+      def match(expression, text)
+        regular_expression = RegularExpression.new(expression, ParameterTypeRegistry.new)
         arguments = regular_expression.match(text)
         return nil if arguments.nil?
-        arguments.map { |arg| arg.transformed_value }
+        arguments.map { |arg| arg.value }
       end
     end
   end