cucumber-cucumber-expressions 8.3.1 → 19.0.0

data/lib/cucumber/cucumber_expressions/cucumber_expression_parser.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/ast'
+require 'cucumber/cucumber_expressions/errors'
+require 'cucumber/cucumber_expressions/cucumber_expression_tokenizer'
+
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpressionParser
+      def parse(expression)
+        # text := whitespace | ')' | '}' | .
+        parse_text = lambda do |_, tokens, current|
+          token = tokens[current]
+          case token.type
+          when TokenType::WHITE_SPACE, TokenType::TEXT, TokenType::END_PARAMETER, TokenType::END_OPTIONAL
+            return [1, [Node.new(NodeType::TEXT, nil, token.text, token.start, token.end)]]
+          when TokenType::ALTERNATION
+            raise AlternationNotAllowedInOptional.new(expression, token)
+          when TokenType::BEGIN_PARAMETER, TokenType::START_OF_LINE, TokenType::END_OF_LINE, TokenType::BEGIN_OPTIONAL
+          else
+            # If configured correctly this will never happen
+            return [0, nil]
+          end
+          # If configured correctly this will never happen
+          return [0, nil]
+        end
+
+        # name := whitespace | .
+        parse_name = lambda do |_, tokens, current|
+          token = tokens[current]
+          case token.type
+          when TokenType::WHITE_SPACE, TokenType::TEXT
+            return [1, [Node.new(NodeType::TEXT, nil, token.text, token.start, token.end)]]
+          when TokenType::BEGIN_PARAMETER, TokenType::END_PARAMETER, TokenType::BEGIN_OPTIONAL, TokenType::END_OPTIONAL, TokenType::ALTERNATION
+            raise InvalidParameterTypeNameInNode.new(expression, token)
+          when TokenType::START_OF_LINE, TokenType::END_OF_LINE
+            # If configured correctly this will never happen
+            return [0, nil]
+          else
+            # If configured correctly this will never happen
+            return [0, nil]
+          end
+        end
+
+        # parameter := '{' + name* + '}'
+        parse_parameter = parse_between(NodeType::PARAMETER, TokenType::BEGIN_PARAMETER, TokenType::END_PARAMETER, [parse_name])
+
+        # optional := '(' + option* + ')'
+        # option := optional | parameter | text
+        optional_sub_parsers = []
+        parse_optional = parse_between(NodeType::OPTIONAL, TokenType::BEGIN_OPTIONAL, TokenType::END_OPTIONAL, optional_sub_parsers)
+        optional_sub_parsers << parse_optional << parse_parameter << parse_text
+
+        # alternation := alternative* + ( '/' + alternative* )+
+        parse_alternative_separator = lambda do |_, tokens, current|
+          return [0, nil] unless looking_at(tokens, current, TokenType::ALTERNATION)
+
+          token = tokens[current]
+          return [1, [Node.new(NodeType::ALTERNATIVE, nil, token.text, token.start, token.end)]]
+        end
+
+        alternative_parsers = [
+          parse_alternative_separator,
+          parse_optional,
+          parse_parameter,
+          parse_text,
+        ]
+
+        # alternation := (?<=left-boundary) + alternative* + ( '/' + alternative* )+ + (?=right-boundary)
+        # left-boundary := whitespace | } | ^
+        # right-boundary := whitespace | { | $
+        # alternative: = optional | parameter | text
+        parse_alternation = lambda do |expr, tokens, current|
+          previous = current - 1
+          return [0, nil] unless looking_at_any(tokens, previous, [TokenType::START_OF_LINE, TokenType::WHITE_SPACE, TokenType::END_PARAMETER])
+
+          consumed, ast = parse_tokens_until(expr, alternative_parsers, tokens, current, [TokenType::WHITE_SPACE, TokenType::END_OF_LINE, TokenType::BEGIN_PARAMETER])
+          sub_current = current + consumed
+          return [0, nil] unless ast.map { |ast_node| ast_node.type }.include? NodeType::ALTERNATIVE
+
+          start = tokens[current].start
+          _end = tokens[sub_current].start
+          # Does not consume right hand boundary token
+          return [consumed, [Node.new(NodeType::ALTERNATION, split_alternatives(start, _end, ast), nil, start, _end)]]
+        end
+
+        #
+        # cucumber-expression :=  ( alternation | optional | parameter | text )*
+        #
+        parse_cucumber_expression = parse_between(
+          NodeType::EXPRESSION,
+          TokenType::START_OF_LINE,
+          TokenType::END_OF_LINE,
+          [parse_alternation, parse_optional, parse_parameter, parse_text]
+        )
+
+        tokenizer = CucumberExpressionTokenizer.new
+        tokens = tokenizer.tokenize(expression)
+        _, ast = parse_cucumber_expression.call(expression, tokens, 0)
+        ast[0]
+      end
+
+      private
+
+      def parse_between(type, begin_token, end_token, parsers)
+        lambda do |expression, tokens, current|
+          return [0, nil] unless looking_at(tokens, current, begin_token)
+
+          sub_current = current + 1
+          consumed, ast = parse_tokens_until(expression, parsers, tokens, sub_current, [end_token, TokenType::END_OF_LINE])
+          sub_current += consumed
+
+          # endToken not found
+          raise MissingEndToken.new(expression, begin_token, end_token, tokens[current]) unless looking_at(tokens, sub_current, end_token)
+
+          # consumes endToken
+          start = tokens[current].start
+          _end = tokens[sub_current].end
+          consumed = sub_current + 1 - current
+          ast = [Node.new(type, ast, nil, start, _end)]
+          return [consumed, ast]
+        end
+      end
+
+      def parse_token(expression, parsers, tokens, start_at)
+        parsers.each do |parser|
+          consumed, ast = parser.call(expression, tokens, start_at)
+          return [consumed, ast] unless consumed == 0
+        end
+        # If configured correctly this will never happen
+        raise 'No eligible parsers for ' + tokens
+      end
+
+      def parse_tokens_until(expression, parsers, tokens, start_at, end_tokens)
+        current = start_at
+        size = tokens.length
+        ast = []
+        while current < size do
+          break if looking_at_any(tokens, current, end_tokens)
+
+          consumed, sub_ast = parse_token(expression, parsers, tokens, current)
+          if consumed == 0
+            # If configured correctly this will never happen
+            # Keep to avoid infinite loops
+            raise 'No eligible parsers for ' + tokens
+          end
+
+          current += consumed
+          ast += sub_ast
+        end
+        [current - start_at, ast]
+      end
+
+      def looking_at_any(tokens, at, token_types)
+        token_types.detect { |token_type| looking_at(tokens, at, token_type) }
+      end
+
+      def looking_at(tokens, at, token)
+        if at < 0
+          # If configured correctly this will never happen
+          # Keep for completeness
+          return token == TokenType::START_OF_LINE
+        end
+        return token == TokenType::END_OF_LINE if at >= tokens.length
+
+        tokens[at].type == token
+      end
+
+      def split_alternatives(start, _end, alternation)
+        separators = []
+        alternatives = []
+        alternative = []
+        alternation.each do |n|
+          if NodeType::ALTERNATIVE == n.type
+            separators.push(n)
+            alternatives.push(alternative)
+            alternative = []
+          else
+            alternative.push(n)
+          end
+        end
+        alternatives.push(alternative)
+        create_alternative_nodes(start, _end, separators, alternatives)
+      end
+
+      def create_alternative_nodes(start, _end, separators, alternatives)
+        alternatives.each_with_index.map do |n, i|
+          if i == 0
+            right_separator = separators[i]
+            Node.new(NodeType::ALTERNATIVE, n, nil, start, right_separator.start)
+          elsif i == alternatives.length - 1
+            left_separator = separators[i - 1]
+            Node.new(NodeType::ALTERNATIVE, n, nil, left_separator.end, _end)
+          else
+            left_separator = separators[i - 1]
+            right_separator = separators[i]
+            Node.new(NodeType::ALTERNATIVE, n, nil, left_separator.end, right_separator.start)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/cucumber_expression_tokenizer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/ast'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpressionTokenizer
+      def tokenize(expression)
+        @expression = expression
+        tokens = []
+        @buffer = []
+        previous_token_type = TokenType::START_OF_LINE
+        treat_as_text = false
+        @escaped = 0
+        @buffer_start_index = 0
+
+        codepoints = expression.codepoints
+
+        tokens.push(Token.new(TokenType::START_OF_LINE, '', 0, 0)) if codepoints.empty?
+
+        codepoints.each do |codepoint|
+          if !treat_as_text && Token.is_escape_character(codepoint)
+            @escaped += 1
+            treat_as_text = true
+            next
+          end
+          current_token_type = token_type_of(codepoint, treat_as_text)
+          treat_as_text = false
+
+          if should_create_new_token?(previous_token_type, current_token_type)
+            token = convert_buffer_to_token(previous_token_type)
+            previous_token_type = current_token_type
+            @buffer.push(codepoint)
+            tokens.push(token)
+          else
+            previous_token_type = current_token_type
+            @buffer.push(codepoint)
+          end
+        end
+
+        if @buffer.length > 0
+          token = convert_buffer_to_token(previous_token_type)
+          tokens.push(token)
+        end
+
+        raise TheEndOfLineCannotBeEscaped.new(expression) if treat_as_text
+
+        tokens.push(Token.new(TokenType::END_OF_LINE, '', codepoints.length, codepoints.length))
+        tokens
+      end
+
+      private
+
+      # TODO: Make these lambdas
+
+      def convert_buffer_to_token(token_type)
+        escape_tokens = 0
+        if token_type == TokenType::TEXT
+          escape_tokens = @escaped
+          @escaped = 0
+        end
+
+        consumed_index = @buffer_start_index + @buffer.length + escape_tokens
+        t = Token.new(
+          token_type,
+          @buffer.map { |codepoint| codepoint.chr(Encoding::UTF_8) }.join(''),
+          @buffer_start_index,
+          consumed_index
+        )
+        @buffer = []
+        @buffer_start_index = consumed_index
+        t
+      end
+
+      def token_type_of(codepoint, treat_as_text)
+        return Token.type_of(codepoint) unless treat_as_text
+
+        return TokenType::TEXT if Token.can_escape(codepoint)
+
+        raise CantEscape.new(@expression, @buffer_start_index + @buffer.length + @escaped)
+      end
+
+      def should_create_new_token?(previous_token_type, current_token_type)
+        current_token_type != previous_token_type ||
+          (current_token_type != TokenType::WHITE_SPACE && current_token_type != TokenType::TEXT)
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/errors.rb

@@ -1,39 +1,231 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/ast'
+
 module Cucumber
   module CucumberExpressions
     class CucumberExpressionError < StandardError
+      def build_message(index, expression, pointer, problem, solution)
+        m = <<~ERROR
+          This Cucumber Expression has a problem at column #{index + 1}:
+
+          #{expression}
+          #{pointer}
+          #{problem}.
+          #{solution}
+        ERROR
+        m.strip
+      end
+
+      def point_at(index)
+        ' ' * index + '^'
+      end
+
+      def point_at_located(node)
+        pointer = [point_at(node.start)]
+        if node.start + 1 < node.end
+          for _ in node.start + 1...node.end - 1
+            pointer.push('-')
+          end
+          pointer.push('^')
+        end
+        pointer.join('')
+      end
     end
 
-    class UndefinedParameterTypeError < CucumberExpressionError
+    class AlternativeMayNotExclusivelyContainOptionals < CucumberExpressionError
+      def initialize(node, expression)
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An alternative may not exclusively contain optionals',
+            "If you did not mean to use an optional you can use '\\(' to escape the '('"
+          )
+        )
+      end
+    end
+
+    class AlternativeMayNotBeEmpty < CucumberExpressionError
+      def initialize(node, expression)
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'Alternative may not be empty',
+            "If you did not mean to use an alternative you can use '\\/' to escape the '/'"
+          )
+        )
+      end
+    end
+
+    class CantEscape < CucumberExpressionError
+      def initialize(expression, index)
+        super(
+          build_message(
+            index,
+            expression,
+            point_at(index),
+            "Only the characters '{', '}', '(', ')', '\\', '/' and whitespace can be escaped",
+            "If you did mean to use an '\\' you can use '\\\\' to escape it"
+          )
+        )
+      end
+    end
+
+    class OptionalMayNotBeEmpty < CucumberExpressionError
+      def initialize(node, expression)
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An optional must contain some text',
+            "If you did not mean to use an optional you can use '\\(' to escape the '('"
+          )
+        )
+      end
+    end
+
+    class ParameterIsNotAllowedInOptional < CucumberExpressionError
+      def initialize(node, expression)
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An optional may not contain a parameter type',
+            "If you did not mean to use an parameter type you can use '\\{' to escape the '{'"
+          )
+        )
+      end
+    end
+
+    class OptionalIsNotAllowedInOptional < CucumberExpressionError
+      def initialize(node, expression)
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An optional may not contain an other optional',
+            "If you did not mean to use an optional type you can use '\\(' to escape the '('. For more complicated expressions consider using a regular expression instead."
+          )
+        )
+      end
+    end
+
+    class TheEndOfLineCannotBeEscaped < CucumberExpressionError
+      def initialize(expression)
+        index = expression.codepoints.length - 1
+        super(
+          build_message(
+            index,
+            expression,
+            point_at(index),
+            'The end of line can not be escaped',
+            "You can use '\\\\' to escape the '\\'"
+          )
+        )
+      end
+    end
+
+    class MissingEndToken < CucumberExpressionError
+      def initialize(expression, begin_token, end_token, current)
+        begin_symbol = Token::symbol_of(begin_token)
+        end_symbol = Token::symbol_of(end_token)
+        purpose = Token::purpose_of(begin_token)
+
+        super(
+          build_message(
+            current.start,
+            expression,
+            point_at_located(current),
+            "The '#{begin_symbol}' does not have a matching '#{end_symbol}'",
+            "If you did not intend to use #{purpose} you can use '\\#{begin_symbol}' to escape the #{purpose}"
+          )
+        )
+      end
+    end
+
+    class AlternationNotAllowedInOptional < CucumberExpressionError
+      def initialize(expression, current)
+        super(
+          build_message(
+            current.start,
+            expression,
+            point_at_located(current),
+            'An alternation can not be used inside an optional',
+            "If you did not mean to use an alternation you can use '\\/' to escape the '/'. Otherwise rephrase your expression or consider using a regular expression instead."
+          )
+        )
+      end
+    end
+
+    class InvalidParameterTypeName < CucumberExpressionError
       def initialize(type_name)
-        super("Undefined parameter type {#{type_name}}")
+        super("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '{', '}', '(', ')', '\\' or '/'")
+      end
+    end
+
+    class InvalidParameterTypeNameInNode < CucumberExpressionError
+      def initialize(expression, token)
+        super(
+          build_message(
+            token.start,
+            expression,
+            point_at_located(token),
+            "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'",
+            'Did you mean to use a regular expression?'
+          )
+        )
+      end
+    end
+
+    class UndefinedParameterTypeError < CucumberExpressionError
+      attr_reader :undefined_parameter_type_name
+
+      def initialize(node, expression, undefined_parameter_type_name)
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            "Undefined parameter type '#{undefined_parameter_type_name}'",
+            "Please register a ParameterType for '#{undefined_parameter_type_name}'"
+          )
+        )
+        @undefined_parameter_type_name = undefined_parameter_type_name
       end
     end
 
     class AmbiguousParameterTypeError < CucumberExpressionError
       def initialize(parameter_type_regexp, expression_regexp, parameter_types, generated_expressions)
-        super(<<-EOM)
-Your Regular Expression /#{expression_regexp.source}/
-matches multiple parameter types with regexp /#{parameter_type_regexp}/:
-   #{parameter_type_names(parameter_types)}
+        super(<<~ERROR)
+          Your Regular Expression /#{expression_regexp.source}/
+          matches multiple parameter types with regexp /#{parameter_type_regexp}/:
+             #{parameter_type_names(parameter_types)}
 
-I couldn't decide which one to use. You have two options:
+          I couldn't decide which one to use. You have two options:
 
-1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:
-   #{expressions(generated_expressions)}
+          1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:
+             #{expressions(generated_expressions)}
 
-2) Make one of the parameter types preferential and continue to use a Regular Expression.
+          2) Make one of the parameter types preferential and continue to use a Regular Expression.
 
-        EOM
+        ERROR
       end
 
       private
 
       def parameter_type_names(parameter_types)
-        parameter_types.map{|p| "{#{p.name}}"}.join("\n   ")
+        parameter_types.map { |p| "{#{p.name}}" }.join("\n   ")
       end
 
       def expressions(generated_expressions)
-        generated_expressions.map{|ge| ge.source}.join("\n   ")
+        generated_expressions.map { |ge| ge.source }.join("\n   ")
       end
     end
   end

data/lib/cucumber/cucumber_expressions/expression_factory.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/errors'
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+
+module Cucumber
+  module CucumberExpressions
+    class ExpressionFactory
+      def initialize(parameter_type_registry)
+        @parameter_type_registry = parameter_type_registry
+      end
+
+      def create_expression(string_or_regexp)
+        case string_or_regexp
+        when String then CucumberExpression.new(string_or_regexp, @parameter_type_registry)
+        when Regexp then RegularExpression.new(string_or_regexp, @parameter_type_registry)
+        else
+          raise CucumberExpressionError.new("Can't create an expression from #{string_or_regexp.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/generated_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module CucumberExpressions
     class GeneratedExpression

data/lib/cucumber/cucumber_expressions/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module CucumberExpressions
     class Group
@@ -11,7 +13,11 @@ module Cucumber
       end
 
       def values
-        (children.empty? ? [self] : children).map(&:value).compact
+        if children.nil?
+          [self.value]
+        else
+          children.map(&:value)
+        end
       end
     end
   end

data/lib/cucumber/cucumber_expressions/group_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/group'
 
 module Cucumber
@@ -16,8 +18,13 @@ module Cucumber
 
       def build(match, group_indices)
         group_index = group_indices.next
-        children = @group_builders.map {|gb| gb.build(match, group_indices)}
-        Group.new(match[group_index], match.offset(group_index)[0], match.offset(group_index)[1], children)
+        children = @group_builders.map { |gb| gb.build(match, group_indices) }
+        Group.new(
+            match[group_index], 
+            match.offset(group_index)[0], 
+            match.offset(group_index)[1], 
+            children.empty? ? nil : children
+        )
       end
 
       def set_non_capturing!

data/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -1,28 +1,22 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/errors'
 
 module Cucumber
   module CucumberExpressions
     class ParameterType
-      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/
-      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/
+      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/.freeze
+      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/.freeze
 
-      attr_reader :name, :type, :regexps
+      attr_reader :name, :type, :transformer, :use_for_snippets, :prefer_for_regexp_match, :regexps
 
       def self.check_parameter_type_name(type_name)
-        unescaped_type_name = type_name.gsub(UNESCAPE_PATTERN) do
-          $2
-        end
-        if ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name
-          raise CucumberExpressionError.new("Illegal character '#{$1}' in parameter name {#{unescaped_type_name}}")
-        end
+        raise CucumberExpressionError.new("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '[]()$.|?*+'") unless is_valid_parameter_type_name(type_name)
       end
 
-      def prefer_for_regexp_match?
-        @prefer_for_regexp_match
-      end
-
-      def use_for_snippets?
-        @use_for_snippets
+      def self.is_valid_parameter_type_name(type_name)
+        unescaped_type_name = type_name.gsub(UNESCAPE_PATTERN) { Regexp.last_match(2) }
+        !(ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name)
       end
 
       # Create a new Parameter
@@ -51,8 +45,9 @@ module Cucumber
       end
 
       def <=>(other)
-        return -1 if prefer_for_regexp_match? && !other.prefer_for_regexp_match?
-        return 1 if other.prefer_for_regexp_match? && !prefer_for_regexp_match?
+        return -1 if prefer_for_regexp_match && !other.prefer_for_regexp_match
+        return 1 if other.prefer_for_regexp_match && !prefer_for_regexp_match
+
         return name <=> other.name
       end
 
@@ -60,7 +55,7 @@ module Cucumber
 
       def string_array(regexps)
         array = regexps.is_a?(Array) ? regexps : [regexps]
-        array.map {|regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp)}
+        array.map { |regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp) }
       end
 
       def regexp_source(regexp)
@@ -70,9 +65,7 @@ module Cucumber
           'MULTILINE'
         ].each do |option_name|
           option = Regexp.const_get(option_name)
-          if regexp.options & option != 0
-            raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}")
-          end
+          raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}") if regexp.options & option != 0
         end
         regexp.source
       end