cucumber-cucumber-expressions 8.3.1 → 19.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d75b7265f9a2c2142d7733b064bb4e6ec6d317d1f32ba9e4148e42512b90a4df
-  data.tar.gz: c7f8fa3ce1e9eccaf40fcbfd9288ed8302ea1b13b2cb8aa385a64abaf94a2d15
+  metadata.gz: 7399365cce63cde9618bcffe3d2b02832df27da08aac3e498697f509cfcc7b9b
+  data.tar.gz: 44f194f914c855adc3a670c9d3e0298c1ca9b57878672d056c322ddc19b9f149
 SHA512:
-  metadata.gz: a05e6facfd23519c59b261e253a623097c892108a9b66d3fd330128b9651be4923f01b16666cf61c82abc112c6b5fcee987703b0c4198462148b6a174b51ba24
-  data.tar.gz: '09a81cd8ef765626765d0f269063c284266cf2153d3b80c4cdeacb464aeea41b4df9967ba256a3f8a27bd06f89c2f650cffffc903e4d5206504e05ff1daa2e50'
+  metadata.gz: 66465f00c20d167435a1d25c708a972b4389f674412c4789e9d6748c9a207f9c598d1b3258a6d9ca8be6177b0d166ea96f916d1e7e68cb1f61e0437df9121136
+  data.tar.gz: 1e75e3525394a05944c5e23cf4ea6371a97fa4238a805f518e822799ed11631b4c2bfdcbfe1f3088d8580b9ba87ea0bcdab610ca7cb82d8792364ba9f151b978

data/LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) Cucumber Ltd
+Copyright (c) 2016 Cucumber Ltd and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/cucumber/cucumber_expressions/argument.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/group'
 require 'cucumber/cucumber_expressions/errors'
 
@@ -10,11 +12,12 @@ module Cucumber
         group = tree_regexp.match(text)
         return nil if group.nil?
 
-        arg_groups = group.children
+        arg_groups = group.children.nil? ? [] : group.children
 
         if arg_groups.length != parameter_types.length
           raise CucumberExpressionError.new(
-              "Expression #{tree_regexp.regexp.inspect} has #{arg_groups.length} capture groups (#{arg_groups.map(&:value)}), but there were #{parameter_types.length} parameter types (#{parameter_types.map(&:name)})"
+            "Expression #{tree_regexp.regexp.inspect} has #{arg_groups.length} capture groups (#{arg_groups.map(&:value)}), " \
+            "but there were #{parameter_types.length} parameter types (#{parameter_types.map(&:name)})"
           )
         end
 
@@ -27,8 +30,9 @@ module Cucumber
         @group, @parameter_type = group, parameter_type
       end
 
-      def value(self_obj=:nil)
-        raise "No self_obj" if self_obj == :nil
+      def value(self_obj = :nil)
+        raise 'No self_obj' if self_obj == :nil
+
         group_values = @group ? @group.values : nil
         @parameter_type.transform(self_obj, group_values)
       end

data/lib/cucumber/cucumber_expressions/ast.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module CucumberExpressions
+    ESCAPE_CHARACTER = '\\'
+    ALTERNATION_CHARACTER = '/'
+    BEGIN_PARAMETER_CHARACTER = '{'
+    END_PARAMETER_CHARACTER = '}'
+    BEGIN_OPTIONAL_CHARACTER = '('
+    END_OPTIONAL_CHARACTER = ')'
+
+    class Node
+      attr_reader :type, :nodes, :token, :start, :end
+
+      def initialize(type, nodes, token, start, ending)
+        raise 'Either nodes or token must be defined' if nodes.nil? && token.nil?
+
+        @type = type
+        @nodes = nodes
+        @token = token
+        @start = start
+        @end = ending
+      end
+
+      def text
+        return @nodes.map { |value| value.text }.join('') if @token.nil?
+
+        @token
+      end
+
+      def to_hash
+        hash = Hash.new
+        hash['type'] = @type
+        hash['nodes'] = @nodes.map { |node| node.to_hash } unless @nodes.nil?
+        hash['token'] = @token unless @token.nil?
+        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
+      attr_reader :type, :text, :start, :end
+
+      def initialize(type, text, start, ending)
+        @type, @text, @start, @end = type, text, start, ending
+      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/combinatorial_generated_expression_factory.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require('cucumber/cucumber_expressions/generated_expression')
 
 module Cucumber
   module CucumberExpressions
-
     class CombinatorialGeneratedExpressionFactory
       def initialize(expression_template, parameter_type_combinations)
         @expression_template = expression_template
@@ -19,9 +20,7 @@ module Cucumber
       MAX_EXPRESSIONS = 256
 
       def generate_permutations(generated_expressions, depth, current_parameter_types)
-        if generated_expressions.length >= MAX_EXPRESSIONS
-          return
-        end
+        return if generated_expressions.length >= MAX_EXPRESSIONS
 
         if depth == @parameter_type_combinations.length
           generated_expression = GeneratedExpression.new(@expression_template, current_parameter_types)
@@ -31,19 +30,13 @@ module Cucumber
 
         (0...@parameter_type_combinations[depth].length).each do |i|
           # Avoid recursion if no elements can be added.
-          if generated_expressions.length >= MAX_EXPRESSIONS
-            return
-          end
+          break if generated_expressions.length >= MAX_EXPRESSIONS
+
           new_current_parameter_types = current_parameter_types.dup # clone
           new_current_parameter_types.push(@parameter_type_combinations[depth][i])
-          generate_permutations(
-              generated_expressions,
-              depth + 1,
-              new_current_parameter_types
-          )
+          generate_permutations(generated_expressions, depth + 1, new_current_parameter_types)
         end
       end
     end
-
   end
 end

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -1,118 +1,120 @@
+# frozen_string_literal: true
+
 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 = /([\\^\[({$.|?*+})\]])/.freeze
 
       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
 
       def to_s
-        @source.inspect
+        source.inspect
       end
 
       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) { |ast_node| raise ParameterIsNotAllowedInOptional.new(ast_node, @expression) }
+        assert_no_optionals(node) { |ast_node| raise OptionalIsNotAllowedInOptional.new(ast_node, @expression) }
+        assert_not_empty(node) { |ast_node| raise OptionalMayNotBeEmpty.new(ast_node, @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)
-          end
-        end
+      def rewrite_alternation(node)
+        # Make sure the alternative parts aren't empty and don't contain parameter types
+        node.nodes.each { |alternative|
+          raise AlternativeMayNotBeEmpty.new(alternative, @expression) if alternative.nodes.length == 0
+
+          assert_not_empty(alternative) { |ast_node| raise AlternativeMayNotExclusivelyContainOptionals.new(ast_node, @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 { |last_node| rewrite_to_regex(last_node) }.join('')
       end
 
-      def check_no_parameter_type(s, message)
-        if PARAMETER_REGEXP =~ s
-          raise CucumberExpressionError.new("#{message}#{source}")
-        end
+      def rewrite_parameter(node)
+        name = node.text
+        parameter_type = @parameter_type_registry.lookup_by_type_name(name)
+        raise UndefinedParameterTypeError.new(node, @expression, name) if parameter_type.nil?
+
+        @parameter_types.push(parameter_type)
+        regexps = parameter_type.regexps
+        return "(#{regexps[0]})" if regexps.length == 1
+
+        "((?:#{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.select { |ast_node| NodeType::TEXT == ast_node.type }
+        raise_error.call(node) if text_nodes.length == 0
+      end
+
+      def assert_no_parameters(node, &raise_error)
+        nodes = node.nodes.select { |ast_node| NodeType::PARAMETER == ast_node.type }
+        raise_error.call(nodes[0]) if nodes.length > 0
+      end
+
+      def assert_no_optionals(node, &raise_error)
+        nodes = node.nodes.select { |ast_node| NodeType::OPTIONAL == ast_node.type }
+        raise_error.call(nodes[0]) if nodes.length > 0
       end
     end
   end

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type_matcher'
 require 'cucumber/cucumber_expressions/generated_expression'
 require 'cucumber/cucumber_expressions/combinatorial_generated_expression_factory'
@@ -9,23 +11,17 @@ module Cucumber
         @parameter_type_registry = parameter_type_registry
       end
 
-      def generate_expression(text)
-        generate_expressions(text)[0]
-      end
-
       def generate_expressions(text)
         parameter_type_combinations = []
         parameter_type_matchers = create_parameter_type_matchers(text)
-        expression_template = ""
+        expression_template = +''
         pos = 0
 
         loop do
           matching_parameter_type_matchers = []
           parameter_type_matchers.each do |parameter_type_matcher|
             advanced_parameter_type_matcher = parameter_type_matcher.advance_to(pos)
-            if advanced_parameter_type_matcher.find
-              matching_parameter_type_matchers.push(advanced_parameter_type_matcher)
-            end
+            matching_parameter_type_matchers.push(advanced_parameter_type_matcher) if advanced_parameter_type_matcher.find
           end
 
           if matching_parameter_type_matchers.any?
@@ -43,25 +39,21 @@ module Cucumber
             # Users are most likely to want these, so they should be listed at the top.
             parameter_types = []
             best_parameter_type_matchers.each do |parameter_type_matcher|
-              unless parameter_types.include?(parameter_type_matcher.parameter_type)
-                parameter_types.push(parameter_type_matcher.parameter_type)
-              end
+              parameter_types.push(parameter_type_matcher.parameter_type) unless parameter_types.include?(parameter_type_matcher.parameter_type)
             end
             parameter_types.sort!
 
             parameter_type_combinations.push(parameter_types)
 
             expression_template += escape(text.slice(pos...best_parameter_type_matcher.start))
-            expression_template += "{%s}"
+            expression_template += '{%s}'
 
             pos = best_parameter_type_matcher.start + best_parameter_type_matcher.group.length
           else
             break
           end
 
-          if pos >= text.length
-            break
-          end
+          break if pos >= text.length
         end
 
         expression_template += escape(text.slice(pos..-1))
@@ -72,33 +64,29 @@ module Cucumber
         ).generate_expressions
       end
 
-    private
+      private
 
       def create_parameter_type_matchers(text)
         parameter_matchers = []
         @parameter_type_registry.parameter_types.each do |parameter_type|
-          if parameter_type.use_for_snippets?
-            parameter_matchers += create_parameter_type_matchers2(parameter_type, text)
-          end
+          parameter_matchers += create_parameter_type_matchers2(parameter_type, text) if parameter_type.use_for_snippets
         end
         parameter_matchers
       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(/\(/, '\\(')
+         .gsub(/{/, '\\{')
+         .gsub(/\//, '\\/')
       end
     end
   end