honeybadger 5.3.0 → 5.4.0

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/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'
@@ -12,16 +14,14 @@ module Cucumber
       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?
@@ -39,16 +39,14 @@ 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
@@ -66,14 +64,12 @@ 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
@@ -88,9 +84,9 @@ module Cucumber
 
       def escape(s)
         s.gsub(/%/, '%%')
-        .gsub(/\(/, '\\(')
-        .gsub(/{/, '\\{')
-        .gsub(/\//, '\\/')
+         .gsub(/\(/, '\\(')
+         .gsub(/{/, '\\{')
+         .gsub(/\//, '\\/')
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/cucumber_expression_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/ast'
 require 'cucumber/cucumber_expressions/errors'
 require 'cucumber/cucumber_expressions/cucumber_expression_tokenizer'
@@ -11,16 +13,16 @@ module Cucumber
           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)]
+            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
+            return [0, nil]
           end
           # If configured correctly this will never happen
-          return 0, nil
+          return [0, nil]
         end
 
         # name := whitespace | .
@@ -28,51 +30,40 @@ module Cucumber
           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)]
+            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
+            return [0, nil]
           else
             # If configured correctly this will never happen
-            return 0, nil
+            return [0, nil]
           end
         end
 
         # parameter := '{' + name* + '}'
-        parse_parameter = parse_between(
-            NodeType::PARAMETER,
-            TokenType::BEGIN_PARAMETER,
-            TokenType::END_PARAMETER,
-            [parse_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
-        )
+        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|
-          unless looking_at(tokens, current, TokenType::ALTERNATION)
-            return 0, nil
-          end
+          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)]
+          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,
+          parse_alternative_separator,
+          parse_optional,
+          parse_parameter,
+          parse_text,
         ]
 
         # alternation := (?<=left-boundary) + alternative* + ( '/' + alternative* )+ + (?=right-boundary)
@@ -81,30 +72,26 @@ module Cucumber
         # alternative: = optional | parameter | text
         parse_alternation = lambda do |expr, tokens, current|
           previous = current - 1
-          unless looking_at_any(tokens, previous, [TokenType::START_OF_LINE, TokenType::WHITE_SPACE, TokenType::END_PARAMETER])
-            return 0, nil
-          end
+          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
-          unless ast.map { |astNode| astNode.type }.include? NodeType::ALTERNATIVE
-            return 0, nil
-          end
+          return [0, nil] unless ast.map { |astNode| astNode.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)]
+          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]
+          NodeType::EXPRESSION,
+          TokenType::START_OF_LINE,
+          TokenType::END_OF_LINE,
+          [parse_alternation, parse_optional, parse_parameter, parse_text]
         )
 
         tokenizer = CucumberExpressionTokenizer.new
@@ -117,30 +104,28 @@ module Cucumber
 
       def parse_between(type, begin_token, end_token, parsers)
         lambda do |expression, tokens, current|
-          unless looking_at(tokens, current, begin_token)
-            return 0, nil
-          end
+          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
-          unless looking_at(tokens, sub_current, end_token)
-            raise MissingEndToken.new(expression, begin_token, end_token, tokens[current])
-          end
+          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
+          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
+          return [consumed, ast] unless consumed == 0
         end
         # If configured correctly this will never happen
         raise 'No eligible parsers for ' + tokens
@@ -151,15 +136,15 @@ module Cucumber
         size = tokens.length
         ast = []
         while current < size do
-          if looking_at_any(tokens, current, end_tokens)
-            break
-          end
+          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
@@ -176,9 +161,8 @@ module Cucumber
           # Keep for completeness
           return token == TokenType::START_OF_LINE
         end
-        if at >= tokens.length
-          return token == TokenType::END_OF_LINE
-        end
+        return token == TokenType::END_OF_LINE if at >= tokens.length
+
         tokens[at].type == token
       end
 
@@ -186,7 +170,7 @@ module Cucumber
         separators = []
         alternatives = []
         alternative = []
-        alternation.each { |n|
+        alternation.each do |n|
           if NodeType::ALTERNATIVE == n.type
             separators.push(n)
             alternatives.push(alternative)
@@ -194,7 +178,7 @@ module Cucumber
           else
             alternative.push(n)
           end
-        }
+        end
         alternatives.push(alternative)
         create_alternative_nodes(start, _end, separators, alternatives)
       end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/cucumber_expression_tokenizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/ast'
 require 'cucumber/cucumber_expressions/errors'
 
@@ -15,9 +17,7 @@ module Cucumber
 
         codepoints = expression.codepoints
 
-        if codepoints.empty?
-          tokens.push(Token.new(TokenType::START_OF_LINE, '', 0, 0))
-        end
+        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)
@@ -63,10 +63,10 @@ module Cucumber
 
         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
+          token_type,
+          @buffer.map { |codepoint| codepoint.chr(Encoding::UTF_8) }.join(''),
+          @buffer_start_index,
+          consumed_index
         )
         @buffer = []
         @buffer_start_index = consumed_index
@@ -74,21 +74,16 @@ module Cucumber
       end
 
       def token_type_of(codepoint, treat_as_text)
-        unless treat_as_text
-          return Token.type_of(codepoint)
-        end
-        if Token.can_escape(codepoint)
-          return TokenType::TEXT
-        end
-        raise CantEscape.new(
-            @expression,
-            @buffer_start_index + @buffer.length + @escaped
-        )
+        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)
+          (current_token_type != TokenType::WHITE_SPACE && current_token_type != TokenType::TEXT)
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-cucumber-expressions-17.0.1/lib/cucumber/cucumber_expressions/errors.rb

@@ -0,0 +1,232 @@
+# 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 = <<~EOF
+          This Cucumber Expression has a problem at column #{index + 1}:
+
+          #{expression}
+          #{pointer}
+          #{problem}.
+          #{solution}
+        EOF
+        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 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 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 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 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 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 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 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',
+            "You can use '\\/' to escape the the '/'"
+          )
+        )
+      end
+    end
+
+    class InvalidParameterTypeName < CucumberExpressionError
+      def initialize(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)}
+
+          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)}
+
+          2) Make one of the parameter types preferential and continue to use a Regular Expression.
+
+        EOM
+      end
+
+      private
+
+      def parameter_type_names(parameter_types)
+        parameter_types.map { |p| "{#{p.name}}" }.join("\n   ")
+      end
+
+      def expressions(generated_expressions)
+        generated_expressions.map { |ge| ge.source }.join("\n   ")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/expression_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/errors'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/generated_expression.rb

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

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/group.rb

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

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/group_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/group'
 
 module Cucumber
@@ -16,7 +18,7 @@ module Cucumber
 
       def build(match, group_indices)
         group_index = group_indices.next
-        children = @group_builders.map {|gb| gb.build(match, group_indices)}
+        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)
       end