cucumber-cucumber-expressions 10.1.0 → 11.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed8966625e5c34e68e12635a42b5abcb4cb02767825e12d5dc6605175ccddfe8
-  data.tar.gz: 280642a65a2aab021bd9402455617fdd1560a506ae3dc241e90b46a489ddef26
+  metadata.gz: 2d322bd3d9bfcf753132e6f053b408e261a65622719d46f821c3ccece9ecbb83
+  data.tar.gz: 34ad192b82c6786750f71b85038eee3fd95a56d583ce197ebdaf53aeeccd95ce
 SHA512:
-  metadata.gz: bfa789a7499f47745bf427803456e98d0583a601c83e2af8b9d3e9563cd09ae00ad014f1238be00e6a607c946cf058654f0ff54284bac5748241f9e36d27dcc3
-  data.tar.gz: 31b396476b60e5d6b49397fd49f1b36d926abcaeabef1998baa24482a15938b6e61801c415b00688f925ddf5caa8a13bd68124b4a92eb82be42f2c4bdef33a5f
+  metadata.gz: bc1ed4bbfe1d4da2974619df9f47ec450c26f1b4881bc3041483f923854361aee757e459c2dc66a563aecb130f722a933778d68bfcdb6a177e6abadfaff5b851
+  data.tar.gz: b0384445624c1344f8830f4da5dafcc8de9deb63d21169b272518562a169ed40e1f2bbcb99e6a0d6ec66cbcca926f7dc379428bdfaa13ef4426945ddf522d268

data/.rsync

@@ -2,3 +2,4 @@
 ../../.templates/github/ .github/
 ../../.templates/ruby/ .
 ../examples.txt examples.txt
+../testdata .

data/VERSION

@@ -0,0 +1 @@
+11.0.0

data/cucumber-cucumber-expressions.gemspec

@@ -1,7 +1,10 @@
 # -*- encoding: utf-8 -*-
+
+version = File.read(File.expand_path("VERSION", __dir__)).strip
+
 Gem::Specification.new do |s|
   s.name        = 'cucumber-cucumber-expressions'
-  s.version     = '10.1.0'
+  s.version     = version
   s.authors     = ["Aslak Hellesøy"]
   s.description = 'Cucumber Expressions - a simpler alternative to Regular Expressions'
   s.summary     = "cucumber-expressions-#{s.version}"
@@ -20,7 +23,7 @@ Gem::Specification.new do |s|
                   }
 
   s.add_development_dependency 'rake', '~> 13.0', '>= 13.0.1'
-  s.add_development_dependency 'rspec', '~> 3.9', '>= 3.9.0'
+  s.add_development_dependency 'rspec', '~> 3.10', '>= 3.10.0'
 
   s.rubygems_version = ">= 1.6.1"
   s.files            = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }

data/default.mk

@@ -3,6 +3,10 @@ RUBY_SOURCE_FILES = $(shell find . -name "*.rb")
 GEMSPEC = $(shell find . -name "*.gemspec")
 LIBNAME := $(shell basename $$(dirname $$(pwd)))
 GEM := cucumber-$(LIBNAME)-$(NEW_VERSION).gem
+IS_TESTDATA = $(findstring -testdata,${CURDIR})
+
+# https://stackoverflow.com/questions/2483182/recursive-wildcards-in-gnu-make
+rwildcard=$(foreach d,$(wildcard $(1:=/*)),$(call rwildcard,$d,$2) $(filter $(subst *,%,$2),$d))
 
 default: .tested
 .PHONY: default
@@ -45,22 +49,25 @@ pre-release: remove-local-dependencies update-version update-dependencies gem
 .PHONY: pre-release
 
 update-version:
+ifeq ($(IS_TESTDATA),-testdata)
+	# no-op
+else
 ifdef NEW_VERSION
-ifneq (,$(GEMSPEC))
-	sed -i "s/\(s\.version *= *'\)[0-9]*\.[0-9]*\.[0-9]*\('\)/\1$(NEW_VERSION)\2/" $(GEMSPEC)
+	@echo "$(NEW_VERSION)" > VERSION
 endif
-else
-	@echo -e "\033[0;31mNEW_VERSION is not defined. Can't update version :-(\033[0m"
-	exit 1
 endif
 .PHONY: update-version
 
 publish: gem
+ifeq ($(IS_TESTDATA),-testdata)
+	# no-op
+else
 ifneq (,$(GEMSPEC))
 	gem push $(GEM)
 else
 	@echo "Not publishing because there is no gemspec"
 endif
+endif
 .PHONY: publish
 
 post-release:
@@ -72,5 +79,5 @@ clean: clean-ruby
 .PHONY: clean
 
 clean-ruby:
-	rm -f .deps .linked .tested* Gemfile.lock *.gem
+	rm -rf .deps .linked .tested* Gemfile.lock *.gem acceptance
 .PHONY: clean-ruby

data/examples.txt

@@ -2,7 +2,7 @@ I have {int} cuke(s)
 I have 22 cukes
 [22]
 ---
-I have {int} cuke(s) and some \[]^$.|?*+
+I have {int} cuke(s) and some \\[]^$.|?*+
 I have 1 cuke and some \[]^$.|?*+
 [1]
 ---
@@ -29,3 +29,15 @@ I have 22 cukes in my belly now
 I have {} cuke(s) in my {} now
 I have 22 cukes in my belly now
 ["22","belly"]
+---
+/^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
+a purchase for $33
+[null,33]
+---
+Some ${float} of cukes at {int}° Celsius
+Some $3.50 of cukes at 42° Celsius
+[3.5,42]
+---
+I select the {int}st/nd/rd/th Cucumber
+I select the 3rd Cucumber
+[3]

data/lib/cucumber/cucumber_expressions/ast.rb

@@ -0,0 +1,201 @@
+module Cucumber
+  module CucumberExpressions
+    ESCAPE_CHARACTER = '\\'
+    ALTERNATION_CHARACTER = '/'
+    BEGIN_PARAMETER_CHARACTER = '{'
+    END_PARAMETER_CHARACTER = '}'
+    BEGIN_OPTIONAL_CHARACTER = '('
+    END_OPTIONAL_CHARACTER = ')'
+
+    class Node
+      def initialize(type, nodes, token, start, _end)
+        if nodes.nil? && token.nil?
+          raise 'Either nodes or token must be defined'
+        end
+        @type = type
+        @nodes = nodes
+        @token = token
+        @start = start
+        @end = _end
+      end
+
+      def type
+        @type
+      end
+
+      def nodes
+        @nodes
+      end
+
+      def token
+        @token
+      end
+
+      def start
+        @start
+      end
+
+      def end
+        @end
+      end
+
+      def text
+        if @token.nil?
+          return @nodes.map { |value| value.text }.join('')
+        end
+        @token
+      end
+
+      def to_hash
+        hash = Hash.new
+        hash["type"] = @type
+        unless @nodes.nil?
+          hash["nodes"] = @nodes.map { |node| node.to_hash }
+        end
+        unless @token.nil?
+          hash["token"] = @token
+        end
+        hash["start"] = @start
+        hash["end"] = @end
+        hash
+      end
+    end
+
+    module NodeType
+      TEXT = 'TEXT_NODE'
+      OPTIONAL = 'OPTIONAL_NODE'
+      ALTERNATION = 'ALTERNATION_NODE'
+      ALTERNATIVE = 'ALTERNATIVE_NODE'
+      PARAMETER = 'PARAMETER_NODE'
+      EXPRESSION = 'EXPRESSION_NODE'
+    end
+
+
+    class Token
+      def initialize(type, text, start, _end)
+        @type, @text, @start, @end = type, text, start, _end
+      end
+
+      def type
+        @type
+      end
+
+      def text
+        @text
+      end
+
+      def start
+        @start
+      end
+
+      def end
+        @end
+      end
+
+      def self.is_escape_character(codepoint)
+        codepoint.chr(Encoding::UTF_8) == ESCAPE_CHARACTER
+      end
+
+      def self.can_escape(codepoint)
+        c = codepoint.chr(Encoding::UTF_8)
+        if c == ' '
+          # TODO: Unicode whitespace?
+          return true
+        end
+        case c
+        when ESCAPE_CHARACTER
+          true
+        when ALTERNATION_CHARACTER
+          true
+        when BEGIN_PARAMETER_CHARACTER
+          true
+        when END_PARAMETER_CHARACTER
+          true
+        when BEGIN_OPTIONAL_CHARACTER
+          true
+        when END_OPTIONAL_CHARACTER
+          true
+        else
+          false
+        end
+      end
+
+      def self.type_of(codepoint)
+        c = codepoint.chr(Encoding::UTF_8)
+        if c == ' '
+          # TODO: Unicode whitespace?
+          return TokenType::WHITE_SPACE
+        end
+        case c
+        when ALTERNATION_CHARACTER
+          TokenType::ALTERNATION
+        when BEGIN_PARAMETER_CHARACTER
+          TokenType::BEGIN_PARAMETER
+        when END_PARAMETER_CHARACTER
+          TokenType::END_PARAMETER
+        when BEGIN_OPTIONAL_CHARACTER
+          TokenType::BEGIN_OPTIONAL
+        when END_OPTIONAL_CHARACTER
+          TokenType::END_OPTIONAL
+        else
+          TokenType::TEXT
+        end
+      end
+
+      def self.symbol_of(token)
+        case token
+        when TokenType::BEGIN_OPTIONAL
+          return BEGIN_OPTIONAL_CHARACTER
+        when TokenType::END_OPTIONAL
+          return END_OPTIONAL_CHARACTER
+        when TokenType::BEGIN_PARAMETER
+          return BEGIN_PARAMETER_CHARACTER
+        when TokenType::END_PARAMETER
+          return END_PARAMETER_CHARACTER
+        when TokenType::ALTERNATION
+          return ALTERNATION_CHARACTER
+        else
+          return ''
+        end
+      end
+
+      def self.purpose_of(token)
+        case token
+        when TokenType::BEGIN_OPTIONAL
+          return 'optional text'
+        when TokenType::END_OPTIONAL
+          return 'optional text'
+        when TokenType::BEGIN_PARAMETER
+          return 'a parameter'
+        when TokenType::END_PARAMETER
+          return 'a parameter'
+        when TokenType::ALTERNATION
+          return 'alternation'
+        else
+          return ''
+        end
+      end
+
+      def to_hash
+        {
+            "type" => @type,
+            "text" => @text,
+            "start" => @start,
+            "end" => @end
+        }
+      end
+    end
+
+    module TokenType
+      START_OF_LINE = 'START_OF_LINE'
+      END_OF_LINE = 'END_OF_LINE'
+      WHITE_SPACE = 'WHITE_SPACE'
+      BEGIN_OPTIONAL = 'BEGIN_OPTIONAL'
+      END_OPTIONAL = 'END_OPTIONAL'
+      BEGIN_PARAMETER = 'BEGIN_PARAMETER'
+      END_PARAMETER = 'END_PARAMETER'
+      ALTERNATION = 'ALTERNATION'
+      TEXT = 'TEXT'
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -1,38 +1,32 @@
 require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/tree_regexp'
 require 'cucumber/cucumber_expressions/errors'
+require 'cucumber/cucumber_expressions/cucumber_expression_parser'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpression
-      # Does not include (){} characters because they have special meaning
-      ESCAPE_REGEXP = /([\\^\[$.|?*+\]])/
-      PARAMETER_REGEXP = /(\\\\)?{([^}]*)}/
-      OPTIONAL_REGEXP = /(\\\\)?\(([^)]+)\)/
-      ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP = /([^\s^\/]+)((\/[^\s^\/]+)+)/
-      DOUBLE_ESCAPE = '\\\\'
-      PARAMETER_TYPES_CANNOT_BE_ALTERNATIVE = 'Parameter types cannot be alternative: '
-      PARAMETER_TYPES_CANNOT_BE_OPTIONAL = 'Parameter types cannot be optional: '
 
-      attr_reader :source
+      ESCAPE_PATTERN = /([\\^\[({$.|?*+})\]])/
 
       def initialize(expression, parameter_type_registry)
-        @source = expression
+        @expression = expression
+        @parameter_type_registry = parameter_type_registry
         @parameter_types = []
-
-        expression = process_escapes(expression)
-        expression = process_optional(expression)
-        expression = process_alternation(expression)
-        expression = process_parameters(expression, parameter_type_registry)
-        expression = "^#{expression}$"
-
-        @tree_regexp = TreeRegexp.new(expression)
+        parser = CucumberExpressionParser.new
+        ast = parser.parse(expression)
+        pattern = rewrite_to_regex(ast)
+        @tree_regexp = TreeRegexp.new(pattern)
       end
 
       def match(text)
         Argument.build(@tree_regexp, text, @parameter_types)
       end
 
+      def source
+        @expression
+      end
+
       def regexp
         @tree_regexp.regexp
       end
@@ -43,76 +37,86 @@ module Cucumber
 
       private
 
-      def process_escapes(expression)
-        expression.gsub(ESCAPE_REGEXP, '\\\\\1')
+      def rewrite_to_regex(node)
+        case node.type
+        when NodeType::TEXT
+          return escape_regex(node.text)
+        when NodeType::OPTIONAL
+          return rewrite_optional(node)
+        when NodeType::ALTERNATION
+          return rewrite_alternation(node)
+        when NodeType::ALTERNATIVE
+          return rewrite_alternative(node)
+        when NodeType::PARAMETER
+          return rewrite_parameter(node)
+        when NodeType::EXPRESSION
+          return rewrite_expression(node)
+        else
+          # Can't happen as long as the switch case is exhaustive
+          raise "#{node.type}"
+        end
       end
 
-      def process_optional(expression)
-        # Create non-capturing, optional capture groups from parenthesis
-        expression.gsub(OPTIONAL_REGEXP) do
-          g2 = $2
-          # When using Parameter Types, the () characters are used to represent an optional
-          # item such as (a ) which would be equivalent to (?:a )? in regex
-          #
-          # You cannot have optional Parameter Types i.e. ({int}) as this causes
-          # problems during the conversion phase to regex. So we check for that here
-          #
-          # One exclusion to this rule is if you actually want the brackets i.e. you
-          # want to capture (3) then we still permit this as an individual rule
-          # See: https://github.com/cucumber/cucumber-ruby/issues/1337 for more info
-          # look for double-escaped parentheses
-          if $1 == DOUBLE_ESCAPE
-            "\\(#{g2}\\)"
-          else
-            check_no_parameter_type(g2, PARAMETER_TYPES_CANNOT_BE_OPTIONAL)
-            "(?:#{g2})?"
-          end
-        end
+      def escape_regex(expression)
+        expression.gsub(ESCAPE_PATTERN, '\\\\\1')
       end
 
-      def process_alternation(expression)
-        expression.gsub(ALTERNATIVE_NON_WHITESPACE_TEXT_REGEXP) do
-          # replace \/ with /
-          # replace / with |
-          replacement = $&.tr('/', '|').gsub(/\\\|/, '/')
-          if replacement.include?('|')
-            replacement.split(/\|/).each do |part|
-              check_no_parameter_type(part, PARAMETER_TYPES_CANNOT_BE_ALTERNATIVE)
-            end
-            "(?:#{replacement})"
-          else
-            replacement
-          end
-        end
+      def rewrite_optional(node)
+        assert_no_parameters(node) { |astNode| raise ParameterIsNotAllowedInOptional.new(astNode, @expression) }
+        assert_no_optionals(node) { |astNode| raise OptionalIsNotAllowedInOptional.new(astNode, @expression) }
+        assert_not_empty(node) { |astNode| raise OptionalMayNotBeEmpty.new(astNode, @expression) }
+        regex = node.nodes.map { |n| rewrite_to_regex(n) }.join('')
+        "(?:#{regex})?"
       end
 
-      def process_parameters(expression, parameter_type_registry)
-        # Create non-capturing, optional capture groups from parenthesis
-        expression.gsub(PARAMETER_REGEXP) do
-          if ($1 == DOUBLE_ESCAPE)
-            "\\{#{$2}\\}"
-          else
-            type_name = $2
-            ParameterType.check_parameter_type_name(type_name)
-            parameter_type = parameter_type_registry.lookup_by_type_name(type_name)
-            raise UndefinedParameterTypeError.new(type_name) if parameter_type.nil?
-            @parameter_types.push(parameter_type)
-
-            build_capture_regexp(parameter_type.regexps)
+      def rewrite_alternation(node)
+        # Make sure the alternative parts aren't empty and don't contain parameter types
+        node.nodes.each { |alternative|
+          if alternative.nodes.length == 0
+            raise AlternativeMayNotBeEmpty.new(alternative, @expression)
           end
-        end
+          assert_not_empty(alternative) { |astNode| raise AlternativeMayNotExclusivelyContainOptionals.new(astNode, @expression) }
+        }
+        regex = node.nodes.map { |n| rewrite_to_regex(n) }.join('|')
+        "(?:#{regex})"
       end
 
-      def build_capture_regexp(regexps)
-        return "(#{regexps[0]})" if regexps.size == 1
-        capture_groups = regexps.map { |group| "(?:#{group})" }
-        "(#{capture_groups.join('|')})"
+      def rewrite_alternative(node)
+        node.nodes.map { |lastNode| rewrite_to_regex(lastNode) }.join('')
       end
 
-      def check_no_parameter_type(s, message)
-        if PARAMETER_REGEXP =~ s
-          raise CucumberExpressionError.new("#{message}#{source}")
+      def rewrite_parameter(node)
+        name = node.text
+        parameter_type = @parameter_type_registry.lookup_by_type_name(name)
+        if parameter_type.nil?
+          raise UndefinedParameterTypeError.new(node, @expression, name)
         end
+        @parameter_types.push(parameter_type)
+        regexps = parameter_type.regexps
+        if regexps.length == 1
+          return "(#{regexps[0]})"
+        end
+        "((?:#{regexps.join(')|(?:')}))"
+      end
+
+      def rewrite_expression(node)
+        regex = node.nodes.map { |n| rewrite_to_regex(n) }.join('')
+        "^#{regex}$"
+      end
+
+      def assert_not_empty(node, &raise_error)
+        text_nodes = node.nodes.filter { |astNode| NodeType::TEXT == astNode.type }
+        raise_error.call(node) if text_nodes.length == 0
+      end
+
+      def assert_no_parameters(node, &raise_error)
+        nodes = node.nodes.filter { |astNode| NodeType::PARAMETER == astNode.type }
+        raise_error.call(nodes[0]) if nodes.length > 0
+      end
+
+      def assert_no_optionals(node, &raise_error)
+        nodes = node.nodes.filter { |astNode| NodeType::OPTIONAL == astNode.type }
+        raise_error.call(nodes[0]) if nodes.length > 0
       end
     end
   end