cucumber-cucumber-expressions 8.3.1 → 19.0.0

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,212 +0,0 @@
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpression do
-      it "documents match arguments" do
-        parameter_registry = ParameterTypeRegistry.new
-
-        ### [capture-match-arguments]
-        expr = "I have {int} cuke(s)"
-        expression = CucumberExpression.new(expr, parameter_registry)
-        args = expression.match("I have 7 cukes")
-        expect(args[0].value(nil)).to eq(7)
-        ### [capture-match-arguments]
-      end
-
-      it "matches word" do
-        expect(match("three {word} mice", "three blind mice")).to eq(['blind'])
-      end
-
-      it('matches double quoted string') do
-        expect(match('three {string} mice', 'three "blind" mice')).to eq(['blind'])
-      end
-
-      it('matches multiple double quoted strings') do
-        expect(match('three {string} and {string} mice', 'three "blind" and "crippled" mice')).to eq(['blind', 'crippled'])
-      end
-
-      it('matches single quoted string') do
-        expect(match('three {string} mice', "three 'blind' mice")).to eq(['blind'])
-      end
-
-      it('matches multiple single quoted strings') do
-        expect(match('three {string} and {string} mice', "three 'blind' and 'crippled' mice")).to eq(['blind', 'crippled'])
-      end
-
-      it('does not match misquoted string') do
-        expect(match('three {string} mice', 'three "blind\' mice')).to eq(nil)
-      end
-
-      it('matches single quoted string with double quotes') do
-        expect(match('three {string} mice', 'three \'"blind"\' mice')).to eq(['"blind"'])
-      end
-
-      it('matches double quoted string with single quotes') do
-        expect(match('three {string} mice', 'three "\'blind\'" mice')).to eq(["'blind'"])
-      end
-
-      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('matches single quoted string with escaped single quote') do
-        expect(match('three {string} mice', "three 'bl\\'nd' mice")).to eq(["bl'nd"])
-      end
-
-      it('matches single quoted empty string as empty string') do
-        expect(match('three {string} mice', "three '' mice")).to eq([''])
-      end
-
-      it('matches double quoted empty string as empty string') do
-        expect(match('three {string} mice', 'three "" mice')).to eq([''])
-      end
-
-      it('matches single quoted empty string as empty string, along with other strings') do
-        expect(match('three {string} and {string} mice', "three '' and 'handsome' mice")).to eq(['', 'handsome'])
-      end
-
-      it('matches double quoted empty string as empty string, along with other strings') do
-        expect(match('three {string} and {string} mice', 'three "" and "handsome" mice')).to eq(['', 'handsome'])
-      end
-
-      it 'matches escaped parentheses' do
-        expect(match('three \\(exceptionally) {string} mice', 'three (exceptionally) "blind" mice')).to eq(['blind'])
-      end
-
-      it "matches escaped slash" do
-        expect(match("12\\/2020", "12/2020")).to eq([])
-      end
-
-      it "matches int" do
-        expect(match("{int}", "22")).to eq([22])
-      end
-
-      it "doesn't match float as int" do
-        expect(match("{int}", "1.22")).to be_nil
-      end
-
-      it "matches int as float" do
-        expect(match("{float}", "0")).to eq([0.0])
-      end
-
-      it "matches float" do
-        expect(match("{float}", "")).to eq(nil)
-        expect(match("{float}", ".")).to eq(nil)
-        expect(match("{float}", ",")).to eq(nil)
-        expect(match("{float}", "-")).to eq(nil)
-        expect(match("{float}", "E")).to eq(nil)
-        expect(match("{float}", "1,")).to eq(nil)
-        expect(match("{float}", ",1")).to eq(nil)
-        expect(match("{float}", "1.")).to eq(nil)
-
-        expect(match("{float}", "1")).to eq([1])
-        expect(match("{float}", "-1")).to eq([-1])
-        expect(match("{float}", "1.1")).to eq([1.1])
-        expect(match("{float}", "1,000")).to eq(nil)
-        expect(match("{float}", "1,000,0")).to eq(nil)
-        expect(match("{float}", "1,000.1")).to eq(nil)
-        expect(match("{float}", "1,000,10")).to eq(nil)
-        expect(match("{float}", "1,0.1")).to eq(nil)
-        expect(match("{float}", "1,000,000.1")).to eq(nil)
-        expect(match("{float}", "-1.1")).to eq([-1.1])
-
-        expect(match("{float}", ".1")).to eq([0.1])
-        expect(match("{float}", "-.1")).to eq([-0.1])
-        expect(match("{float}", "-.1000001")).to eq([-0.1000001])
-        expect(match("{float}", "1E1")).to eq([10.0])
-        expect(match("{float}", ".1E1")).to eq([1])
-        expect(match("{float}", "E1")).to eq(nil)
-        expect(match("{float}", "-.1E-1")).to eq([-0.01])
-        expect(match("{float}", "-.1E-2")).to eq([-0.001])
-        expect(match("{float}", "-.1E+1")).to eq([-1])
-        expect(match("{float}", "-.1E+2")).to eq([-10])
-        expect(match("{float}", "-.1E1")).to eq([-1])
-        expect(match("{float}", "-.1E2")).to eq([-10])
-      end
-
-      it "matches anonymous" do
-        expect(match("{}", "0.22")).to eq(["0.22"])
-      end
-
-      '[]()$.|?*+'.split('').each do |char|
-        it "does not allow parameter type with #{char}" do
-          expect {match("{#{char}string}", "something")}.to raise_error("Illegal character '#{char}' in parameter name {#{char}string}")
-        end
-      end
-
-      it "throws unknown parameter type" do
-        expect {match("{unknown}", "something")}.to raise_error('Undefined parameter type {unknown}')
-      end
-
-      it "does not allow optional parameter types" do
-        expect {match("({int})", "3")}.to raise_error('Parameter types cannot be optional: ({int})')
-      end
-
-      it "does allow escaped optional parameter types" do
-        expect(match("\\({int})", "(3)")).to eq([3])
-      end
-
-      it "does not allow text/parameter type alternation" do
-        expect {match("x/{int}", "3")}.to raise_error('Parameter types cannot be alternative: x/{int}')
-      end
-
-      it "does not allow parameter type/text alternation" do
-        expect {match("{int}/x", "3")}.to raise_error('Parameter types cannot be alternative: {int}/x')
-      end
-
-      it "exposes source" do
-        expr = "I have {int} cuke(s)"
-        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
-      end
-
-      it "delegates transform to custom object" do
-        parameter_type_registry = ParameterTypeRegistry.new
-        parameter_type_registry.define_parameter_type(
-          ParameterType.new(
-                  'widget',
-                  /\w+/,
-                  Object,
-                  -> (s) {
-                    self.create_widget(s)
-                  },
-                  false,
-                  true
-              )
-        )
-        expression = CucumberExpression.new(
-          'I have a {widget}',
-          parameter_type_registry
-        )
-
-        class World
-          def create_widget(s)
-            "widget:#{s}"
-          end
-        end
-
-        args = expression.match("I have a bolt")
-        expect(args[0].value(World.new)).to eq('widget:bolt')
-      end
-
-      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)
-            arg1 = expression.match("I have 800 cukes and #{character}")[0]
-            expect(arg1.value(nil)).to eq(800)
-          end
-        end
-      end
-
-      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.value(nil)}
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -1,202 +0,0 @@
-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
-
-    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 type" do
-      before do
-        parameter_type_registry = ParameterTypeRegistry.new
-        ### [add-color-parameter-type]
-        parameter_type_registry.define_parameter_type(ParameterType.new(
-            'color',                   # name
-            /red|blue|yellow/,         # regexp
-            Color,                     # type
-            lambda {|s| Color.new(s)}, # transform
-            true,                      # use_for_snippets
-            false                      # prefer_for_regexp_match
-        ))
-        ### [add-color-parameter-type]
-        @parameter_type_registry = parameter_type_registry
-      end
-
-      it "throws exception for illegal character in parameter name" do
-        expect do
-          ParameterType.new(
-              '[string]',
-              /.*/,
-              String,
-              lambda {|s| s},
-              true,
-              false
-          )
-        end.to raise_error("Illegal character '[' in parameter name {[string]}")
-      end
-
-      describe CucumberExpression do
-        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].value(nil)
-          expect(transformed_argument_value).to eq(Color.new('red'))
-        end
-
-        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(
-              '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')
-
-          thick = args[0].value(nil)
-          expect(thick).to eq(5)
-
-          from = args[1].value(nil)
-          expect(from).to eq(Coordinate.new(10, 20, 30))
-
-          to = args[2].value(nil)
-          expect(to).to eq(Coordinate.new(40, 50, 60))
-        end
-
-        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(nil)
-          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',
-              /bad/,
-              CssColor,
-              lambda {|s| raise "Can't transform [#{s}]"},
-              true,
-              false
-          ))
-          expression = CucumberExpression.new("I have a {throwing} parameter", @parameter_type_registry)
-          args = expression.match("I have a bad parameter")
-          expect {args[0].value(nil)}.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',
-                  /.*/,
-                  CssColor,
-                  lambda {|s| CssColor.new(s)},
-                  true,
-                  false
-              ))
-            }.to raise_error("There is already a parameter with name color")
-          end
-
-          it "is not detected for type" do
-            @parameter_type_registry.define_parameter_type(ParameterType.new(
-                'whatever',
-                /.*/,
-                Color,
-                lambda {|s| Color.new(s)},
-                false,
-                false
-            ))
-          end
-
-          it "is not detected for regexp" do
-            @parameter_type_registry.define_parameter_type(ParameterType.new(
-                '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(nil)
-            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(nil)
-            expect(color_value).to eq(Color.new("blue"))
-          end
-        end
-      end
-
-      describe RegularExpression do
-        it "matches arguments with custom parameter type without name" do
-          parameter_type_registry = ParameterTypeRegistry.new
-          parameter_type_registry.define_parameter_type(ParameterType.new(
-              nil,
-              /red|blue|yellow/,
-              Color,
-              lambda {|s| Color.new(s)},
-              true,
-              false
-          ))
-
-          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
-          value = expression.match("I have a red ball")[0].value(nil)
-          expect(value).to eq(Color.new('red'))
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb

@@ -1,30 +0,0 @@
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-require 'json'
-
-module Cucumber
-  module CucumberExpressions
-    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)
-
-        arguments = expression.match(text)
-        return nil if arguments.nil?
-        arguments.map { |arg| arg.value(nil) }
-      end
-
-      File.open(File.expand_path("../../../../examples.txt", __FILE__), "r:utf-8") do |io|
-        chunks = io.read.split(/^---/m)
-        chunks.each do |chunk|
-          expression_text, text, expected_args = *chunk.strip.split(/\n/m)
-          it "Works with: #{expression_text}" do
-            expect( match(expression_text, text).to_json ).to eq(expected_args)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -1,86 +0,0 @@
-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 preferential parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two preferential 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 preferential and continue to use a Regular Expression.\n" +
-                       "\n"
-               )
-      end
-    end
-  end
-end
-

data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb

@@ -1,15 +0,0 @@
-require 'cucumber/cucumber_expressions/parameter_type'
-
-module Cucumber
-  module CucumberExpressions
-    describe ParameterType do
-      it 'does not allow ignore flag on regexp' do
-        expect do
-          ParameterType.new("case-insensitive", /[a-z]+/i, String, lambda {|s| s}, true, true)
-        end.to raise_error(
-          CucumberExpressionError,
-          "ParameterType Regexps can't use option Regexp::IGNORECASE")
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,80 +0,0 @@
-require 'cucumber/cucumber_expressions/regular_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe RegularExpression do
-      it "documents match arguments" do
-        parameter_type_registry = ParameterTypeRegistry.new
-
-        ### [capture-match-arguments]
-        expr = /I have (\d+) cukes? in my (\w*) now/
-        expression = RegularExpression.new(expr, parameter_type_registry)
-        args = expression.match("I have 7 cukes in my belly now")
-        expect( args[0].value(nil) ).to eq(7)
-        expect( args[1].value(nil) ).to eq("belly")
-        ### [capture-match-arguments]
-      end
-
-      it "does no transform by default" do
-        expect( match(/(\d\d)/, "22") ).to eq(["22"])
-      end
-
-      it "does not transform anonymous" do
-        expect( match(/(.*)/, "22") ).to eq(["22"])
-      end
-
-      it "transforms negative int" do
-        expect( match(/(-?\d+)/, "-22") ).to eq([-22])
-      end
-
-      it "transforms positive int" do
-        expect( match(/(\d+)/, "22") ).to eq([22])
-      end
-
-      it "returns nil when there is no match" do
-        expect( match(/hello/, "world") ).to be_nil
-      end
-
-      it "matches nested capture group without match" do
-        expect( match(/^a user( named "([^"]*)")?$/, 'a user') ).to eq([nil])
-      end
-
-      it "matches nested capture group with match" do
-        expect( match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"') ).to eq(['Charlie'])
-      end
-
-      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 "matches capture group nested in optional one" do
-        regexp = /^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
-        expect( match(regexp, 'a purchase') ).to eq([nil, nil])
-        expect( match(regexp, 'a purchase for $33') ).to eq([nil, 33])
-        expect( match(regexp, 'a pre buyer fee model purchase') ).to eq(['pre buyer fee model ', nil])
-      end
-
-      it "works with escaped parenthesis" do
-        expect( match(/Across the line\(s\)/, 'Across the line(s)') ).to eq([])
-      end
-
-      it "exposes source and regexp" do
-        regexp = /I have (\d+) cukes? in my (\+) now/
-        expression = RegularExpression.new(regexp, ParameterTypeRegistry.new)
-        expect(expression.regexp).to eq(regexp)
-        expect(expression.source).to eq(regexp.source)
-      end
-
-      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.value(nil) }
-      end
-    end
-  end
-end