cucumber-cucumber-expressions 10.3.0 → 11.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 705a1aa48bf85408fc0db737e50091584f930c7e73e6ffe485f5c8cdf0c8a9f4
-  data.tar.gz: 3d40ff2d7b847cb5b44aa547ab6e46791e769abccf7beaf14e5de9f0440710e3
+  metadata.gz: 2d322bd3d9bfcf753132e6f053b408e261a65622719d46f821c3ccece9ecbb83
+  data.tar.gz: 34ad192b82c6786750f71b85038eee3fd95a56d583ce197ebdaf53aeeccd95ce
 SHA512:
-  metadata.gz: e9407c5108c578c553831398255986de2bee9393500adb35f3528b359e05ae0cc3df966b163da15052623b0dfe01efb2b64e624a1976030dc0c9d355e279cf89
-  data.tar.gz: 51ce8f4c93b3948dbb36c34cd221f48aa29c2eb812fb4d7a582b2644b4118d1e6373d1de644c5d78470525bc80a9ab4dae6f414eec27ef55e3c6a76fedce2ee1
+  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

@@ -1 +1 @@
-10.3.0
+11.0.0

data/cucumber-cucumber-expressions.gemspec

@@ -23,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/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]
 ---
@@ -37,3 +37,7 @@ a purchase for $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

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -59,9 +59,7 @@ module Cucumber
             break
           end
 
-          if pos >= text.length
-            break
-          end
+          break if pos >= text.length
         end
 
         expression_template += escape(text.slice(pos..-1))
@@ -85,19 +83,17 @@ module Cucumber
       end
 
       def create_parameter_type_matchers2(parameter_type, text)
-        result = []
         regexps = parameter_type.regexps
-        regexps.each do |regexp|
+        regexps.map do |regexp|
           regexp = Regexp.new("(#{regexp})")
-          result.push(ParameterTypeMatcher.new(parameter_type, regexp, text, 0))
+          ParameterTypeMatcher.new(parameter_type, regexp, text, 0)
         end
-        result
       end
 
       def escape(s)
         s.gsub(/%/, '%%')
         .gsub(/\(/, '\\(')
-        .gsub(/\{/, '\\{')
+        .gsub(/{/, '\\{')
         .gsub(/\//, '\\/')
       end
     end