honeybadger 5.0.2 → 5.1.0

data/lib/honeybadger/config/env.rb

@@ -1,42 +1,42 @@
-require 'set'
-
-module Honeybadger
-  class Config
-    module Env
-      CONFIG_KEY = /\AHONEYBADGER_(.+)\Z/.freeze
-      CONFIG_MAPPING = Hash[DEFAULTS.keys.map {|k| [k.to_s.upcase.gsub(KEY_REPLACEMENT, '_'), k] }].freeze
-      ARRAY_VALUES = Regexp.new('\s*,\s*').freeze
-      IGNORED_TYPES = Set[Hash]
-
-      def self.new(env = ENV)
-        hash = {}
-
-        env.each_pair do |k,v|
-          next unless k.match(CONFIG_KEY)
-          next unless config_key = CONFIG_MAPPING[$1]
-          type = OPTIONS[config_key][:type]
-          next if IGNORED_TYPES.include?(type)
-          hash[config_key] = cast_value(v, type)
-        end
-
-        hash
-      end
-
-      def self.cast_value(value, type = String)
-        v = value.to_s
-
-        if type == Boolean
-          !!(v =~ /\A(true|t|1)\z/i)
-        elsif type == Array
-          v.split(ARRAY_VALUES).map(&method(:cast_value))
-        elsif type == Integer
-          v.to_i
-        elsif type == Float
-          v.to_f
-        else
-          v
-        end
-      end
-    end
-  end
-end
+require 'set'
+
+module Honeybadger
+  class Config
+    module Env
+      CONFIG_KEY = /\AHONEYBADGER_(.+)\Z/.freeze
+      CONFIG_MAPPING = Hash[DEFAULTS.keys.map {|k| [k.to_s.upcase.gsub(KEY_REPLACEMENT, '_'), k] }].freeze
+      ARRAY_VALUES = Regexp.new('\s*,\s*').freeze
+      IGNORED_TYPES = Set[Hash]
+
+      def self.new(env = ENV)
+        hash = {}
+
+        env.each_pair do |k,v|
+          next unless k.match(CONFIG_KEY)
+          next unless config_key = CONFIG_MAPPING[$1]
+          type = OPTIONS[config_key][:type]
+          next if IGNORED_TYPES.include?(type)
+          hash[config_key] = cast_value(v, type)
+        end
+
+        hash
+      end
+
+      def self.cast_value(value, type = String)
+        v = value.to_s
+
+        if type == Boolean
+          !!(v =~ /\A(true|t|1)\z/i)
+        elsif type == Array
+          v.split(ARRAY_VALUES).map(&method(:cast_value))
+        elsif type == Integer
+          v.to_i
+        elsif type == Float
+          v.to_f
+        else
+          v
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/config/ruby.rb

@@ -1,146 +1,146 @@
-module Honeybadger
-  class Config
-    class Mash
-      KEYS = DEFAULTS.keys.map(&:to_s).freeze
-
-      def initialize(config, prefix: nil, hash: {})
-        @config = config
-        @prefix = prefix
-        @hash = hash
-      end
-
-      def to_hash
-        hash.to_hash
-      end
-      alias to_h to_hash
-
-      private
-
-      attr_reader :config, :prefix, :hash
-
-      def method_missing(method_name, *args, &block)
-        m = method_name.to_s
-        if mash?(m)
-          return Mash.new(config, prefix: key(m), hash: hash)
-        elsif setter?(m)
-          return hash.send(:[]=, key(m).to_sym, args[0])
-        elsif getter?(m)
-          return get(key(m))
-        end
-
-        super
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        true
-      end
-
-      def mash?(method)
-        key = [prefix, method.to_s + '.'].compact.join('.')
-        KEYS.any? {|k| k.start_with?(key) }
-      end
-
-      def setter?(method_name)
-        return false unless method_name.to_s =~ /=\z/
-        key = key(method_name)
-        KEYS.any? {|k| k == key }
-      end
-
-      def getter?(method_name)
-        key = key(method_name)
-        KEYS.any? {|k| k == key }
-      end
-
-      def key(method_name)
-        parts = [prefix, method_name.to_s.chomp('=')]
-        parts.compact!
-        parts.join('.')
-      end
-
-      def get(key)
-        k = key.to_sym
-        return hash[k] if hash.has_key?(k)
-        config.get(k)
-      end
-    end
-
-    class Ruby < Mash
-      def logger=(logger)
-        hash[:logger] = logger
-      end
-
-      def logger
-        get(:logger) || config.logger
-      end
-
-      def backend=(backend)
-        hash[:backend] = backend
-      end
-
-      def backend
-        get(:backend) || config.backend
-      end
-
-      def before_notify(action = nil, &block)
-        hooks = Array(get(:before_notify)).dup
-
-        if action && validate_before_action(action)
-          hooks << action
-        elsif block_given? && validate_before_action(block)
-          hooks << block
-        end
-
-        hash[:before_notify] = hooks
-      end
-
-      def backtrace_filter(&block)
-        if block_given?
-          logger.warn('DEPRECATED: backtrace_filter is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#backtrace_filter')
-          hash[:backtrace_filter] = block if block_given?
-        end
-
-        get(:backtrace_filter)
-      end
-
-      def exception_filter(&block)
-        if block_given?
-          logger.warn('DEPRECATED: exception_filter is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#exception_filter')
-          hash[:exception_filter] = block
-        end
-
-        get(:exception_filter)
-      end
-
-      def exception_fingerprint(&block)
-        if block_given?
-          logger.warn('DEPRECATED: exception_fingerprint is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#exception_fingerprint')
-          hash[:exception_fingerprint] = block
-        end
-
-        get(:exception_fingerprint)
-      end
-
-      private
-
-      def validate_before_action(action)
-        if !action.respond_to?(:call)
-          logger.warn(
-            'You attempted to add a before notify hook that does not respond ' \
-            'to #call. We are discarding this hook so your intended behavior ' \
-            'will not occur.'
-          )
-          false
-        elsif action.arity != 1
-          logger.warn(
-            'You attempted to add a before notify hook that has an arity ' \
-            'other than one. We are discarding this hook so your intended ' \
-            'behavior will not occur.'
-          )
-          false
-        else
-          true
-        end
-      end
-    end
-  end
-end
+module Honeybadger
+  class Config
+    class Mash
+      KEYS = DEFAULTS.keys.map(&:to_s).freeze
+
+      def initialize(config, prefix: nil, hash: {})
+        @config = config
+        @prefix = prefix
+        @hash = hash
+      end
+
+      def to_hash
+        hash.to_hash
+      end
+      alias to_h to_hash
+
+      private
+
+      attr_reader :config, :prefix, :hash
+
+      def method_missing(method_name, *args, &block)
+        m = method_name.to_s
+        if mash?(m)
+          return Mash.new(config, prefix: key(m), hash: hash)
+        elsif setter?(m)
+          return hash.send(:[]=, key(m).to_sym, args[0])
+        elsif getter?(m)
+          return get(key(m))
+        end
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+
+      def mash?(method)
+        key = [prefix, method.to_s + '.'].compact.join('.')
+        KEYS.any? {|k| k.start_with?(key) }
+      end
+
+      def setter?(method_name)
+        return false unless method_name.to_s =~ /=\z/
+        key = key(method_name)
+        KEYS.any? {|k| k == key }
+      end
+
+      def getter?(method_name)
+        key = key(method_name)
+        KEYS.any? {|k| k == key }
+      end
+
+      def key(method_name)
+        parts = [prefix, method_name.to_s.chomp('=')]
+        parts.compact!
+        parts.join('.')
+      end
+
+      def get(key)
+        k = key.to_sym
+        return hash[k] if hash.has_key?(k)
+        config.get(k)
+      end
+    end
+
+    class Ruby < Mash
+      def logger=(logger)
+        hash[:logger] = logger
+      end
+
+      def logger
+        get(:logger) || config.logger
+      end
+
+      def backend=(backend)
+        hash[:backend] = backend
+      end
+
+      def backend
+        get(:backend) || config.backend
+      end
+
+      def before_notify(action = nil, &block)
+        hooks = Array(get(:before_notify)).dup
+
+        if action && validate_before_action(action)
+          hooks << action
+        elsif block_given? && validate_before_action(block)
+          hooks << block
+        end
+
+        hash[:before_notify] = hooks
+      end
+
+      def backtrace_filter(&block)
+        if block_given?
+          logger.warn('DEPRECATED: backtrace_filter is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#backtrace_filter')
+          hash[:backtrace_filter] = block if block_given?
+        end
+
+        get(:backtrace_filter)
+      end
+
+      def exception_filter(&block)
+        if block_given?
+          logger.warn('DEPRECATED: exception_filter is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#exception_filter')
+          hash[:exception_filter] = block
+        end
+
+        get(:exception_filter)
+      end
+
+      def exception_fingerprint(&block)
+        if block_given?
+          logger.warn('DEPRECATED: exception_fingerprint is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#exception_fingerprint')
+          hash[:exception_fingerprint] = block
+        end
+
+        get(:exception_fingerprint)
+      end
+
+      private
+
+      def validate_before_action(action)
+        if !action.respond_to?(:call)
+          logger.warn(
+            'You attempted to add a before notify hook that does not respond ' \
+            'to #call. We are discarding this hook so your intended behavior ' \
+            'will not occur.'
+          )
+          false
+        elsif action.arity != 1
+          logger.warn(
+            'You attempted to add a before notify hook that has an arity ' \
+            'other than one. We are discarding this hook so your intended ' \
+            'behavior will not occur.'
+          )
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/config/yaml.rb

@@ -1,76 +1,76 @@
-require 'pathname'
-require 'yaml'
-require 'erb'
-
-module Honeybadger
-  class Config
-    module Yaml
-      DISALLOWED_KEYS = [:'config.path'].freeze
-
-      def self.new(path, env = 'production')
-        path = path.kind_of?(Pathname) ? path : Pathname.new(path)
-
-        if !path.exist?
-          raise ConfigError, "The configuration file #{path} was not found."
-        elsif !path.file?
-          raise ConfigError, "The configuration file #{path} is not a file."
-        elsif !path.readable?
-          raise ConfigError, "The configuration file #{path} is not readable."
-        end
-
-        yaml = load_yaml(path)
-        yaml.merge!(yaml[env]) if yaml[env].kind_of?(Hash)
-
-        dotify_keys(yaml)
-      end
-
-      def self.load_yaml(path)
-        begin
-          # This uses `YAML.unsafe_load` to support loading arbitrary Ruby
-          # classes, such as !ruby/regexp. This was the default behavior prior
-          # to Psych 4. https://bugs.ruby-lang.org/issues/17866
-          method = YAML.respond_to?(:unsafe_load) ? :unsafe_load : :load
-          yaml = YAML.send(method, ERB.new(path.read).result)
-        rescue => e
-          config_error = ConfigError.new(e.to_s)
-
-          if e.backtrace
-            backtrace = e.backtrace.map do |line|
-              if line.start_with?('(erb)'.freeze)
-                line.gsub('(erb)'.freeze, path.to_s)
-              else
-                line
-              end
-            end
-            config_error.set_backtrace(backtrace)
-          end
-
-          raise config_error
-        end
-
-        case yaml
-        when Hash
-          yaml
-        when NilClass, FalseClass
-          {}
-        else
-          raise ConfigError, "The configuration file #{path} is invalid."
-        end
-      end
-
-      def self.dotify_keys(hash, key_prefix = nil)
-        {}.tap do |new_hash|
-          hash.each_pair do |k,v|
-            k = [key_prefix, k].compact.join('.')
-            if v.kind_of?(Hash)
-              new_hash.update(dotify_keys(v, k))
-            else
-              next if DISALLOWED_KEYS.include?(k.to_sym)
-              new_hash[k.to_sym] = v
-            end
-          end
-        end
-      end
-    end
-  end
-end
+require 'pathname'
+require 'yaml'
+require 'erb'
+
+module Honeybadger
+  class Config
+    module Yaml
+      DISALLOWED_KEYS = [:'config.path'].freeze
+
+      def self.new(path, env = 'production')
+        path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+
+        if !path.exist?
+          raise ConfigError, "The configuration file #{path} was not found."
+        elsif !path.file?
+          raise ConfigError, "The configuration file #{path} is not a file."
+        elsif !path.readable?
+          raise ConfigError, "The configuration file #{path} is not readable."
+        end
+
+        yaml = load_yaml(path)
+        yaml.merge!(yaml[env]) if yaml[env].kind_of?(Hash)
+
+        dotify_keys(yaml)
+      end
+
+      def self.load_yaml(path)
+        begin
+          # This uses `YAML.unsafe_load` to support loading arbitrary Ruby
+          # classes, such as !ruby/regexp. This was the default behavior prior
+          # to Psych 4. https://bugs.ruby-lang.org/issues/17866
+          method = YAML.respond_to?(:unsafe_load) ? :unsafe_load : :load
+          yaml = YAML.send(method, ERB.new(path.read).result)
+        rescue => e
+          config_error = ConfigError.new(e.to_s)
+
+          if e.backtrace
+            backtrace = e.backtrace.map do |line|
+              if line.start_with?('(erb)'.freeze)
+                line.gsub('(erb)'.freeze, path.to_s)
+              else
+                line
+              end
+            end
+            config_error.set_backtrace(backtrace)
+          end
+
+          raise config_error
+        end
+
+        case yaml
+        when Hash
+          yaml
+        when NilClass, FalseClass
+          {}
+        else
+          raise ConfigError, "The configuration file #{path} is invalid."
+        end
+      end
+
+      def self.dotify_keys(hash, key_prefix = nil)
+        {}.tap do |new_hash|
+          hash.each_pair do |k,v|
+            k = [key_prefix, k].compact.join('.')
+            if v.kind_of?(Hash)
+              new_hash.update(dotify_keys(v, k))
+            else
+              next if DISALLOWED_KEYS.include?(k.to_sym)
+              new_hash[k.to_sym] = v
+            end
+          end
+        end
+      end
+    end
+  end
+end