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}/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/tree_regexp'
 
 module Cucumber
   module CucumberExpressions
     describe TreeRegexp do
-      it 'exposes group source' do
+      it 'exposes the group source' do
         tr = TreeRegexp.new(/(a(?:b)?)(c)/)
-        expect(tr.group_builder.children.map{|gb| gb.source}).to eq(['a(?:b)?', 'c'])
+        expect(tr.group_builder.children.map { |gb| gb.source }).to eq(['a(?:b)?', 'c'])
       end
 
-      it 'builds tree' do
+      it 'builds a tree' do
         tr = TreeRegexp.new(/(a(?:b)?)(c)/)
         group = tr.match('ac')
         expect(group.value).to eq('ac')
@@ -78,7 +80,7 @@ module Cucumber
         }.to raise_error(/Named capture groups are not supported/)
       end
 
-      it 'matches optional group' do
+      it 'matches an optional group' do
         tr = TreeRegexp.new(/^Something( with an optional argument)?/)
         group = tr.match('Something')
         expect(group.children[0].value).to eq(nil)
@@ -99,45 +101,45 @@ module Cucumber
         expect(group.children[2].children[2].value).to eq('60')
       end
 
-      it 'detects multiple non capturing groups' do
+      it 'detects multiple non-capturing groups' do
         tr = TreeRegexp.new(/(?:a)(:b)(\?c)(d)/)
-        group = tr.match("a:b?cd")
+        group = tr.match('a:b?cd')
         expect(group.children.length).to eq(3)
       end
 
-      it 'works with escaped backslash' do
+      it 'works with escaped backslashes' do
         tr = TreeRegexp.new(/foo\\(bar|baz)/)
-        group = tr.match("foo\\bar")
+        group = tr.match('foo\\bar')
         expect(group.children.length).to eq(1)
       end
 
-      it 'works with escaped slash' do
+      it 'works with escaped slashes' do
         tr = TreeRegexp.new(/^I go to '\/(.+)'$/)
         group = tr.match("I go to '/hello'")
         expect(group.children.length).to eq(1)
       end
 
-      it 'works with digit and word' do
+      it 'works with digit and word regexp metacharacters' do
         tr = TreeRegexp.new(/^(\d) (\w+)$/)
-        group = tr.match("2 you")
+        group = tr.match('2 you')
         expect(group.children.length).to eq(2)
       end
 
-      it 'captures non capturing groups with capturing groups inside' do
+      it 'captures non-capturing groups with capturing groups inside' do
         tr = TreeRegexp.new(/the stdout(?: from "(.*?)")?/)
-        group = tr.match("the stdout")
-        expect(group.value).to eq("the stdout")
+        group = tr.match('the stdout')
+        expect(group.value).to eq('the stdout')
         expect(group.children[0].value).to eq(nil)
         expect(group.children.length).to eq(1)
       end
 
       it 'works with flags' do
         tr = TreeRegexp.new(/HELLO/i)
-        group = tr.match("hello")
-        expect(group.value).to eq("hello")
+        group = tr.match('hello')
+        expect(group.value).to eq('hello')
       end
 
-      it('does not consider parenthesis in character class as group') do
+      it('does not consider parentheses in regexp character classes as a group') do
         tr = TreeRegexp.new(/^drawings: ([A-Z_, ()]+)$/)
         group = tr.match('drawings: ONE, TWO(ABC)')
         expect(group.value).to eq('drawings: ONE, TWO(ABC)')
@@ -152,14 +154,14 @@ module Cucumber
         expect(group.children.length).to eq 0
       end
 
-      it 'works with non capturing inline flags' do
+      it 'works with non-capturing inline flags' do
         tr = TreeRegexp.new(/(?i:HELLO)/)
         group = tr.match('hello')
         expect(group.value).to eq('hello')
         expect(group.children.length).to eq 0
       end
 
-      it 'works with empty capturing group' do
+      it 'works with empty capturing groups' do
         tr = TreeRegexp.new(/()/)
         group = tr.match('')
         expect(group.value).to eq('')
@@ -167,20 +169,19 @@ module Cucumber
         expect(group.children.length).to eq 1
       end
 
-      it 'works with empty non-capturing group' do
+      it 'works with empty non-capturing groups' do
         tr = TreeRegexp.new(/(?:)/)
         group = tr.match('')
         expect(group.value).to eq('')
         expect(group.children.length).to eq 0
       end
 
-      it 'works with empty non-look ahead' do
+      it 'works with empty non-look ahead groups' do
         tr = TreeRegexp.new(/(?<=)/)
         group = tr.match('')
         expect(group.value).to eq('')
         expect(group.children.length).to eq 0
       end
-
     end
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-messages-21.0.1 → cucumber-messages-22.0.0}/lib/cucumber/messages.deserializers.rb

@@ -594,6 +594,7 @@ module Cucumber
           prefer_for_regular_expression_match: hash[:preferForRegularExpressionMatch],
           use_for_snippets: hash[:useForSnippets],
           id: hash[:id],
+          source_reference: SourceReference.from_h(hash[:sourceReference]),
         )
       end
     end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-messages-21.0.1 → cucumber-messages-22.0.0}/lib/cucumber/messages.dtos.rb

@@ -1050,18 +1050,22 @@ module Cucumber
 
       attr_reader :id
 
+      attr_reader :source_reference
+
       def initialize(
         name: '',
         regular_expressions: [],
         prefer_for_regular_expression_match: false,
         use_for_snippets: false,
-        id: ''
+        id: '',
+        source_reference: nil
       )
         @name = name
         @regular_expressions = regular_expressions
         @prefer_for_regular_expression_match = prefer_for_regular_expression_match
         @use_for_snippets = use_for_snippets
         @id = id
+        @source_reference = source_reference
       end
     end
 

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-tag-expressions-4.1.0 → cucumber-tag-expressions-5.0.6}/lib/cucumber/tag_expressions/expressions.rb

@@ -11,7 +11,11 @@ module Cucumber
       end
 
       def to_s
-        @value.gsub(/\\/, "\\\\\\\\").gsub(/\(/, "\\(").gsub(/\)/, "\\)")
+        @value
+          .gsub(/\\/, "\\\\\\\\")
+          .gsub(/\(/, "\\(")
+          .gsub(/\)/, "\\)")
+          .gsub(/\s/, "\\ ")
       end
     end
 
@@ -26,7 +30,12 @@ module Cucumber
       end
 
       def to_s
-        "not ( #{@expression} )"
+        if @expression.is_a?(And)|| @expression.is_a?(Or)
+          # -- HINT: Binary operatos provides already "( ... )"
+          "not #{@expression}"
+        else
+          "not ( #{@expression} )"
+        end
       end
     end
 
@@ -61,5 +70,15 @@ module Cucumber
         "( #{@left} and #{@right} )"
       end
     end
+
+    class True
+      def evaluate(variables)
+        true
+      end
+
+      def to_s
+        "true"
+      end
+    end
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-tag-expressions-4.1.0 → cucumber-tag-expressions-5.0.6}/lib/cucumber/tag_expressions/parser.rb

@@ -18,9 +18,21 @@ module Cucumber
       end
 
       def parse(infix_expression)
-        process_tokens!(infix_expression)
+        expected_token_type = :operand
+
+        tokens = tokenize(infix_expression)
+        return True.new if tokens.empty?
+
+        tokens.each do |token|
+          if @operator_types[token]
+            expected_token_type = send("handle_#{@operator_types[token][:type]}", infix_expression, token, expected_token_type)
+          else
+            expected_token_type = handle_literal(infix_expression, token, expected_token_type)
+          end
+        end
+
         while @operators.any?
-          raise 'Syntax error. Unmatched (' if @operators.last == '('
+          raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched (.} if @operators.last == '('
           push_expression(pop(@operators))
         end
         expression = pop(@expressions)
@@ -52,48 +64,36 @@ module Cucumber
         @operator_types[token][:precedence]
       end
 
-      def tokens(infix_expression)
+      def tokenize(infix_expression)
+        tokens = []
         escaped = false
         token = ""
-        result = []
         infix_expression.chars.each do | ch |
-          if ch == '\\' && !escaped
-            escaped = true
-          else
-            if ch.match(/\s/)
-              if token.length > 0
-                result.push(token)
-                token = ""
-              end
+          if escaped
+            if ch == '(' || ch == ')' || ch == '\\' || ch.match(/\s/)
+              token += ch
+              escaped = false
             else
-              if (ch == '(' || ch == ')') && !escaped
-                if token.length > 0
-                  result.push(token)
-                  token = ""
-                end
-                result.push(ch)
-              else
-                token = token + ch
-              end
+              raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Illegal escape before "#{ch}".}
             end
-            escaped = false
+          elsif ch == '\\'
+            escaped = true
+          elsif ch == '(' || ch == ')' || ch.match(/\s/)
+            if token.length > 0
+              tokens.push(token)
+              token = ""
+            end
+            if !ch.match(/\s/)
+              tokens.push(ch)
+            end
+          else
+            token += ch
           end
         end
         if token.length > 0
-          result.push(token)
-        end
-        result
-      end
-
-      def process_tokens!(infix_expression)
-        expected_token_type = :operand
-        tokens(infix_expression).each do |token|
-          if @operator_types[token]
-            expected_token_type = send("handle_#{@operator_types[token][:type]}", token, expected_token_type)
-          else
-            expected_token_type = handle_literal(token, expected_token_type)
-          end
+          tokens.push(token)
         end
+        tokens
       end
 
       def push_expression(token)
@@ -112,14 +112,14 @@ module Cucumber
       ############################################################################
       # Handlers
       #
-      def handle_unary_operator(token, expected_token_type)
-        check(expected_token_type, :operand)
+      def handle_unary_operator(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operand)
         @operators.push(token)
         :operand
       end
 
-      def handle_binary_operator(token, expected_token_type)
-        check(expected_token_type, :operator)
+      def handle_binary_operator(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operator)
         while @operators.any? && operator?(@operators.last) &&
               lower_precedence?(token)
           push_expression(pop(@operators))
@@ -128,31 +128,31 @@ module Cucumber
         :operand
       end
 
-      def handle_open_paren(token, expected_token_type)
-        check(expected_token_type, :operand)
+      def handle_open_paren(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operand)
         @operators.push(token)
         :operand
       end
 
-      def handle_close_paren(_token, expected_token_type)
-        check(expected_token_type, :operator)
+      def handle_close_paren(infix_expression, _token, expected_token_type)
+        check(infix_expression, expected_token_type, :operator)
         while @operators.any? && @operators.last != '('
           push_expression(pop(@operators))
         end
-        raise 'Syntax error. Unmatched )' if @operators.empty?
+        raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched ).} if @operators.empty?
         pop(@operators) if @operators.last == '('
         :operator
       end
 
-      def handle_literal(token, expected_token_type)
-        check(expected_token_type, :operand)
+      def handle_literal(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operand)
         push_expression(token)
         :operator
       end
 
-      def check(expected_token_type, token_type)
+      def check(infix_expression, expected_token_type, token_type)
         if expected_token_type != token_type
-          raise "Syntax error. Expected #{expected_token_type}"
+          raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Expected #{expected_token_type}.}
         end
       end
 

data/vendor/bundle/ruby/3.2.0/gems/cucumber-tag-expressions-5.0.6/spec/errors_spec.rb

@@ -0,0 +1,13 @@
+require 'cucumber/tag_expressions/parser'
+require 'yaml'
+
+tests = YAML.load_file('../testdata/errors.yml')
+
+describe 'Errors' do
+  tests.each do |test|
+    it %Q{fails to parse "#{test['expression']}" with "#{test['error']}"} do
+      parser = Cucumber::TagExpressions::Parser.new
+      expect { parser.parse(test['expression']) }.to raise_error(test['error'])
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-tag-expressions-5.0.6/spec/evaluations_spec.rb

@@ -0,0 +1,17 @@
+require 'cucumber/tag_expressions/parser'
+require 'yaml'
+
+evaluations = YAML.load_file('../testdata/evaluations.yml')
+
+describe 'Evaluations' do
+  evaluations.each do |evaluation|
+    context evaluation['expression'] do
+      evaluation['tests'].each do |test|
+        it "evaluates [#{test['variables'].join(', ')}] to #{test['result']}" do
+          parser = Cucumber::TagExpressions::Parser.new
+          expect(parser.parse(evaluation['expression']).evaluate(test['variables'])).to eq(test['result'])
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-tag-expressions-5.0.6/spec/parsing_spec.rb

@@ -0,0 +1,14 @@
+require 'cucumber/tag_expressions/parser'
+require 'yaml'
+
+tests = YAML.load_file('../testdata/parsing.yml')
+
+describe 'Parsing' do
+  tests.each do |test|
+    it %Q{parses "#{test['expression']}" into "#{test['formatted']}"} do
+      parser = Cucumber::TagExpressions::Parser.new
+      expression = parser.parse(test['expression'])
+      expect(expression.to_s).to eq(test['formatted'])
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/date_rolling_log_file.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 require "date"
 

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/log_file.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 require "fileutils"
 

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/multi.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/null.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/rolling_log_file.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/size_rolling_log_file.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device/writer.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/device.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   # This is an abstract class for logging devices. Subclasses must implement the +write+ method and

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/date_time_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/exception_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter
@@ -16,7 +16,7 @@ module Lumberjack
       end
 
       def call(exception)
-        message = "#{exception.class.name}: #{exception.message}"
+        message = +"#{exception.class.name}: #{exception.message}"
         trace = exception.backtrace
         if trace
           trace = clean_backtrace(trace)

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/id_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/inspect_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/object_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/pretty_print_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 require "pp"
 require "stringio"

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/string_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/strip_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/structured_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 require "set"
 

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter/truncate_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   # This class controls the conversion of log entry messages into a loggable format. This allows you

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/log_entry.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   # An entry in a log is a data structure that captures the log message as well as
@@ -66,7 +66,7 @@ module Lumberjack
     private
 
     def tags_to_s
-      tags_string = ""
+      tags_string = +""
       tags&.each { |name, value| tags_string << " #{name}:#{value.inspect}" }
       tags_string
     end

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/logger.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   # Logger is a thread safe logging object. It has a compatible API with the Ruby
@@ -118,15 +118,19 @@ module Lumberjack
     # @param [Integer, Symbol, String] value The severity level.
     # @return [void]
     def level=(value)
-      @level = if value.is_a?(Integer)
-        value
-      else
-        Severity.label_to_level(value)
-      end
+      @level = Severity.coerce(value)
     end
 
     alias_method :sev_threshold=, :level=
 
+    # Adjust the log level during the block execution for the current Fiber only.
+    #
+    # @param [Integer, Symbol, String] severity The severity level.
+    # @return [Object] The result of the block.
+    def with_level(severity, &block)
+      push_thread_local_value(:lumberjack_logger_level, Severity.coerce(severity), &block)
+    end
+
     # Set the Lumberjack::Formatter used to format objects for logging as messages.
     #
     # @param [Lumberjack::Formatter, Object] value The formatter to use.

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/rack/context.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   module Rack

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/rack/request_id.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   module Rack

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/rack/unit_of_work.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   module Rack

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/rack.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   module Rack

data/vendor/bundle/ruby/3.2.0/gems/{lumberjack-1.2.9 → lumberjack-1.2.10}/lib/lumberjack/severity.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   # The standard severity levels for logging messages.
@@ -29,6 +29,18 @@ module Lumberjack
       def label_to_level(label)
         SEVERITY_LABELS.index(label.to_s.upcase) || UNKNOWN
       end
+
+      # Coerce a value to a severity level.
+      #
+      # @param [Integer, String, Symbol] value The value to coerce.
+      # @return [Integer] The severity level.
+      def coerce(value)
+        if value.is_a?(Integer)
+          value
+        else
+          label_to_level(value)
+        end
+      end
     end
   end
 end