chamber 3.0.0rc1 → 3.0.0

data/lib/chamber/filters/environment_filter.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
 require 'yaml'
+
 require 'chamber/errors/environment_conversion'
-require 'chamber/refinements/hash'
-require 'chamber/refinements/deep_dup'
 
 module  Chamber
 module  Filters
 class   EnvironmentFilter
-  using ::Chamber::Refinements::Hash
-  using ::Chamber::Refinements::DeepDup
+  attr_accessor :data,
+                :secure_key_token
 
   ###
   # Internal: Allows the existing environment to be injected into the passed in
@@ -95,9 +94,6 @@ class   EnvironmentFilter
     new(**args).__send__(:execute)
   end
 
-  attr_accessor :data,
-                :secure_key_token
-
   def initialize(data:, secure_key_prefix:, **_args)
     self.data             = data
     self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
@@ -113,9 +109,11 @@ class   EnvironmentFilter
         { key => execute(value, environment_keys) }
       end,
       lambda do |key, value, environment_key|
-        { key => convert_environment_value(environment_key,
-                                           ENV[environment_key],
-                                           value) }
+        {
+          key => convert_environment_value(environment_key,
+                                           ENV.fetch(environment_key, nil),
+                                           value),
+        }
       end,
     )
   end
@@ -127,14 +125,14 @@ class   EnvironmentFilter
 
     settings.each_pair do |key, value|
       environment_key  = key.to_s.gsub(secure_key_token, '')
-      environment_keys = parent_keys.deep_dup.push(environment_key)
+      environment_keys = parent_keys.dup.push(environment_key)
 
       if value.respond_to? :each_pair
-        environment_hash.deep_merge!(hash_block.call(key, value, environment_keys))
+        environment_hash.merge!(hash_block.call(key, value, environment_keys))
       else
         environment_key = environment_keys.join('_').upcase
 
-        environment_hash.deep_merge!(value_block.call(key, value, environment_key))
+        environment_hash.merge!(value_block.call(key, value, environment_key))
       end
     end
 
@@ -171,13 +169,13 @@ class   EnvironmentFilter
       environment_value
     end
   rescue ArgumentError
-    raise Chamber::Errors::EnvironmentConversion, <<-HEREDOC
-We attempted to convert '#{environment_key}' from '#{environment_value}' to a '#{settings_value.class.name}'.
+    raise Chamber::Errors::EnvironmentConversion, <<~HEREDOC
+      We attempted to convert '#{environment_key}' from '#{environment_value}' to a '#{settings_value.class.name}'.
 
-Unfortunately, this did not go as planned.  Please either verify that your value is convertable
-or change the original YAML value to be something more generic (like a String).
+      Unfortunately, this did not go as planned.  Please either verify that your value is convertable
+      or change the original YAML value to be something more generic (like a String).
 
-For more information, see https://github.com/thekompanee/chamber/wiki/Environment-Variable-Coercions
+      For more information, see https://github.com/thekompanee/chamber/wiki/Environment-Variable-Coercions
     HEREDOC
   end
 end

data/lib/chamber/filters/failed_decryption_filter.rb

@@ -10,13 +10,13 @@ class   FailedDecryptionFilter
 
   BASE64_STRING_PATTERN = %r{\A[A-Za-z0-9+/]{342}==\z}.freeze
 
+  attr_accessor :data,
+                :secure_key_token
+
   def self.execute(**args)
     new(**args).__send__(:execute)
   end
 
-  attr_accessor :data,
-                :secure_key_token
-
   def initialize(data:, secure_key_prefix:, **_args)
     self.data             = data.deep_dup
     self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/

data/lib/chamber/filters/namespace_filter.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require 'chamber/refinements/hash'
 require 'chamber/refinements/deep_dup'
+require 'chamber/refinements/hash'
 
 module  Chamber
 module  Filters
 class   NamespaceFilter
-  using ::Chamber::Refinements::Hash
   using ::Chamber::Refinements::DeepDup
+  using ::Chamber::Refinements::Hash
+
+  attr_accessor :data,
+                :namespaces
 
   def self.execute(**args)
     new(**args).__send__(:execute)
   end
 
-  attr_accessor :data,
-                :namespaces
-
   def initialize(data:, namespaces:, **_args)
     self.data       = data.deep_dup
     self.namespaces = namespaces
@@ -24,19 +24,17 @@ class   NamespaceFilter
   protected
 
   def execute
-    if data_is_namespaced?
-      namespaces.each_with_object({}) do |namespace, filtered_data|
-        filtered_data.deep_merge!(data[namespace]) if data[namespace]
-      end
-    else
-      data
+    return data unless data_is_namespaced?
+
+    namespaces.each_with_object({}) do |namespace, filtered_data|
+      filtered_data.deep_merge!(data[namespace]) if data[namespace]
     end
   end
 
   private
 
   def data_is_namespaced?
-    @data_is_namespaced ||= data.keys.any? { |key| namespaces.include? key.to_s }
+    @data_is_namespaced ||= data.keys.any? { |key| namespaces.include?(key.to_s) }
   end
 end
 end

data/lib/chamber/filters/secure_filter.rb

@@ -7,13 +7,13 @@ module  Filters
 class   SecureFilter
   using ::Chamber::Refinements::DeepDup
 
+  attr_accessor :data,
+                :secure_key_token
+
   def self.execute(**args)
     new(**args).__send__(:execute)
   end
 
-  attr_accessor :data,
-                :secure_key_token
-
   def initialize(data:, secure_key_prefix:, **_args)
     self.data             = data.deep_dup
     self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/

data/lib/chamber/filters/translate_secure_keys_filter.rb

@@ -7,13 +7,13 @@ module  Filters
 class   TranslateSecureKeysFilter
   using ::Chamber::Refinements::DeepDup
 
+  attr_accessor :data,
+                :secure_key_token
+
   def self.execute(**args)
     new(**args).__send__(:execute)
   end
 
-  attr_accessor :data,
-                :secure_key_token
-
   def initialize(data:, secure_key_prefix:, **_args)
     self.data             = data.deep_dup
     self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/

data/lib/chamber/instance.rb

@@ -3,12 +3,9 @@
 require 'chamber/configuration'
 require 'chamber/file_set'
 require 'chamber/settings'
-require 'chamber/refinements/hash'
 
 module  Chamber
 class   Instance
-  using ::Chamber::Refinements::Hash
-
   attr_accessor :configuration,
                 :files
 
@@ -66,11 +63,11 @@ class   Instance
   end
 
   def encrypt(data, **args)
-    config = configuration.to_hash.deep_merge(**args)
+    config = configuration.to_hash.merge(**args)
 
     Settings
       .new(
-        **config.deep_merge(
+        **config.merge(
           settings:     data,
           pre_filters:  [Filters::EncryptionFilter],
           post_filters: [],
@@ -80,11 +77,11 @@ class   Instance
   end
 
   def decrypt(data, **args)
-    config = configuration.to_hash.deep_merge(**args)
+    config = configuration.to_hash.merge(**args)
 
     Settings
       .new(
-        **config.deep_merge(
+        **config.merge(
           settings:     data,
           pre_filters:  [Filters::NamespaceFilter],
           post_filters: [

data/lib/chamber/integrations/sinatra.rb

@@ -7,7 +7,7 @@ module Integrations
 module Sinatra
   def self.registered(app)
     app.configure do |inner_app|
-      env  = inner_app.environment || ENV['RACK_ENV']
+      env  = inner_app.environment || ENV.fetch('RACK_ENV', nil)
       root = inner_app.root
 
       if defined?(Padrino)

data/lib/chamber/keys/base.rb

@@ -3,14 +3,14 @@
 module  Chamber
 module  Keys
 class   Base
-  def self.resolve(**args)
-    new(**args).resolve
-  end
-
   attr_accessor :rootpath
   attr_reader   :filenames,
                 :namespaces
 
+  def self.resolve(**args)
+    new(**args).resolve
+  end
+
   def initialize(rootpath:, namespaces:, filenames: nil)
     self.rootpath   = Pathname.new(rootpath)
     self.namespaces = namespaces
@@ -20,7 +20,11 @@ class   Base
   def resolve
     key_paths.each_with_object({}) do |path, memo|
       namespace = namespace_from_path(path) || '__default'
-      value     = path.readable? ? path.read : ENV[environment_variable_from_path(path)]
+      value     = if path.readable?
+                    path.read
+                  else
+                    ENV.fetch(environment_variable_from_path(path), nil)
+                  end
 
       memo[namespace.downcase.to_sym] = value if value
     end
@@ -39,13 +43,13 @@ class   Base
                  namespaces.map { |n| namespace_to_key_path(n) }
   end
 
-  # rubocop:disable Performance/ChainArrayAllocation
+  # rubocop:disable Performance/MapCompact
   def filenames=(other)
     @filenames = Array(other)
                    .map { |o| Pathname.new(o) }
                    .compact
   end
-  # rubocop:enable Performance/ChainArrayAllocation
+  # rubocop:enable Performance/MapCompact
 
   def namespaces=(other)
     @namespaces = other + %w{signature}

data/lib/chamber/namespace_set.rb

@@ -14,6 +14,8 @@ module  Chamber
 class   NamespaceSet
   include Enumerable
 
+  attr_reader :raw_namespaces
+
   ###
   # Internal: Allows for more compact NamespaceSet creation by giving a list of
   # namespace values.
@@ -28,8 +30,6 @@ class   NamespaceSet
     new(namespace_values)
   end
 
-  attr_reader :raw_namespaces
-
   ###
   # Internal: Creates a new NamespaceSet from arrays, hashes and sets.
   #

data/lib/chamber/rails.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'chamber/integrations/rails' if defined?(::Rails)
+require 'chamber/integrations/rails' if defined?(Rails)

data/lib/chamber/refinements/deep_dup.rb

@@ -4,50 +4,26 @@ module Chamber
 module Refinements
 module DeepDup
 refine ::Array do
-  unless method_defined?(:deep_dup)
-    def deep_dup
-      map do |i|
-        if i.respond_to?(:deep_dup)
-          i.deep_dup
-        else
-          begin
-            i.dup
-          rescue ::TypeError
-            # Hack for < Ruby 2.4 since FalseClass, TrueClass, Fixnum, etc can't be
-            # dupped
-            i
-          end
-        end
-      end
-    end
+  def deep_dup
+    map { |i| i.respond_to?(:deep_dup) ? i.deep_dup : i.dup }
   end
 end
 
 refine ::Object do
-  unless method_defined?(:deep_dup)
-    def deep_dup
-      begin
-        dup
-      rescue ::TypeError
-        # Hack for < Ruby 2.4 since FalseClass, TrueClass, Fixnum, etc can't be
-        # dupped
-        self
-      end
-    end
+  def deep_dup
+    dup
   end
 end
 
 refine ::Hash do
-  unless method_defined?(:deep_dup)
-    def deep_dup
-      dup.tap do |hash|
-        each_pair do |key, value|
-          if key.frozen? && key.is_a?(::String)
-            hash[key] = value.deep_dup
-          else
-            hash.delete(key)
-            hash[key.deep_dup] = value.deep_dup
-          end
+  def deep_dup
+    dup.tap do |hash|
+      each_pair do |key, value|
+        if key.frozen? && key.is_a?(::String)
+          hash[key] = value.deep_dup
+        else
+          hash.delete(key)
+          hash[key.deep_dup] = value.deep_dup
         end
       end
     end

data/lib/chamber/refinements/enumerable.rb

@@ -1,34 +1,22 @@
 # frozen_string_literal: true
 
+require 'chamber/errors/non_conforming_key'
+
 module Chamber
 module Refinements
 class  Enumerable
-  def self.deep_transform_keys(object, &block)
+  def self.deep_validate_keys(object, &block)
     case object
     when ::Hash
-      object.each_with_object({}) do |(key, value), result|
-        result[yield(key)] = deep_transform_keys(value, &block)
-      end
-    when ::Array
-      object.map { |e| deep_transform_keys(e, &block) }
-    else
-      object
-    end
-  end
+      object.each do |(key, value)|
+        fail ::Chamber::Errors::NonConformingKey unless key == yield(key)
 
-  def self.deep_transform_values(key, value, &block)
-    case value
-    when ::Hash
-      value.each_with_object({}) do |(k, v), memo|
-        memo[k] = deep_transform_values(k, v, &block)
+        deep_validate_keys(value, &block)
       end
     when ::Array
-      yield(
-        key,
-        value.map { |v| deep_transform_values(nil, v, &block) }
-      )
+      object.map { |v| deep_validate_keys(v, &block) }
     else
-      yield(key, value)
+      object
     end
   end
 end

data/lib/chamber/refinements/hash.rb

@@ -1,47 +1,21 @@
 # frozen_string_literal: true
 
-require 'rspectacular'
-require 'chamber/refinements/hash'
-require 'chamber/refinements/enumerable'
-
 module Chamber
 module Refinements
 module Hash
 refine ::Hash do
-  def deep_strip!
-    each do |key, value|
-      if value.respond_to?(:strip)
-        self[key] = value.strip
-      elsif value.respond_to?(:deep_strip!)
-        self[key] = value.deep_strip!
-      end
-    end
-  end
-
-  def deep_transform_keys(&block)
-    Refinements::Enumerable.deep_transform_keys(self, &block)
-  end
-
-  def deep_transform_values(&block)
-    Refinements::Enumerable.deep_transform_values(nil, self, &block)
-  end
-
-  unless method_defined?(:deep_merge)
-    def deep_merge(other, &block)
-      dup.deep_merge!(other, &block)
-    end
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
   end
 
-  unless method_defined?(:deep_merge!)
-    def deep_merge!(other, &block)
-      merge!(other) do |key, value_1, value_2|
-        if value_1.is_a?(::Hash) && value_2.is_a?(::Hash)
-          value_1.deep_merge(value_2, &block)
-        elsif block
-          yield(key, value_1, value_2)
-        else
-          value_2
-        end
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(::Hash) && other_val.is_a?(::Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block
+        yield(key, this_val, other_val)
+      else
+        other_val
       end
     end
   end

data/lib/chamber/rubinius_fix.rb

@@ -5,7 +5,7 @@ require 'pathname'
 unless Pathname.instance_methods.include?(:write)
   class Pathname
     def write(*args)
-      IO.write @path, *args
+      IO.write @path, *args # rubocop:disable Security/IoMethods
     end
   end
 end

data/lib/chamber/settings.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'chamber/errors/missing_index'
+require 'chamber/errors/missing_setting'
 require 'chamber/namespace_set'
 require 'chamber/filters/namespace_filter'
 require 'chamber/filters/encryption_filter'
@@ -10,6 +12,7 @@ require 'chamber/filters/translate_secure_keys_filter'
 require 'chamber/filters/insecure_filter'
 require 'chamber/filters/failed_decryption_filter'
 require 'chamber/refinements/deep_dup'
+require 'chamber/refinements/enumerable'
 require 'chamber/refinements/hash'
 
 ###
@@ -26,7 +29,6 @@ class   Settings
                 :pre_filters,
                 :secure_key_prefix
   attr_reader   :namespaces
-  attr_writer   :raw_data
 
   # rubocop:disable Metrics/ParameterLists
   def initialize(
@@ -46,9 +48,12 @@ class   Settings
                   settings:          {},
                   **_args
                 )
-    self.decryption_keys   = decryption_keys
-    self.encryption_keys   = encryption_keys
-    self.namespaces        = namespaces
+
+    ::Chamber::Refinements::Enumerable.deep_validate_keys(settings, &:to_s)
+
+    self.decryption_keys   = (decryption_keys || {}).transform_keys(&:to_s)
+    self.encryption_keys   = (encryption_keys || {}).transform_keys(&:to_s)
+    self.namespaces        = NamespaceSet.new(namespaces)
     self.post_filters      = post_filters
     self.pre_filters       = pre_filters
     self.raw_data          = settings.deep_dup
@@ -114,7 +119,7 @@ class   Settings
   # Returns a Hash
   #
   def to_hash
-    data.dup
+    data.deep_dup
   end
 
   ###
@@ -147,11 +152,11 @@ class   Settings
     flattened_name_hash = {}
 
     hash.each_pair do |key, value|
-      flattened_name_components = parent_keys.deep_dup.push(key)
+      flattened_name_components = parent_keys.dup.push(key)
 
       if value.respond_to?(:each_pair)
-        flattened_name_hash
-          .deep_merge!(to_flattened_name_hash(value, flattened_name_components))
+        flattened_name_hash.merge! to_flattened_name_hash(value,
+                                                          flattened_name_components)
       else
         flattened_name_hash[flattened_name_components] = value
       end
@@ -197,7 +202,7 @@ class   Settings
     other_settings = case other
                      when Settings
                        other
-                     when ::Hash
+                     when Hash
                        Settings.new(settings: other)
                      end
 
@@ -233,10 +238,13 @@ class   Settings
   end
 
   def [](key)
-    warn "WARNING: Bracket access will require strings instead of symbols in Chamber 3.0.  You attempted to access the '#{key}' setting.  See https://github.com/thekompanee/chamber/wiki/Upgrading-To-Chamber-3.0#removal-of-bracket-indifferent-access for full details." if key.is_a?(::Symbol) # rubocop:disable Layout/LineLength
-    warn "WARNING: Accessing a non-existent key ('#{key}') with brackets will fail in Chamber 3.0.  See https://github.com/thekompanee/chamber/wiki/Upgrading-To-Chamber-3.0#bracket-access-now-fails-on-non-existent-keys for full details." unless data.has_key?(key) # rubocop:disable Layout/LineLength
+    fail ::Chamber::Errors::InvalidKeyType, 'Bracket access with anything other than a String is unsupported.' unless key.is_a?(::String)
 
     data.fetch(key)
+  rescue ::KeyError => error
+    missing_setting_name = error.message.gsub(/.*key not found: "([^"]+)".*/, '\1')
+
+    raise ::Chamber::Errors::MissingSetting.new(missing_setting_name, [])
   end
 
   def dig!(*args)
@@ -245,23 +253,33 @@ class   Settings
 
       data_value.fetch(key)
     end
+  rescue ::KeyError => error
+    missing_setting_name = error.message.gsub(/.*key not found: "([^"]+)".*/, '\1')
+
+    raise ::Chamber::Errors::MissingSetting.new(missing_setting_name, args)
+  rescue ::IndexError => error
+    missing_index_number = error.message.gsub(/.*index (\d+) outside.*/, '\1')
+
+    raise ::Chamber::Errors::MissingIndex.new(missing_index_number, args)
   end
 
   def dig(*args)
     dig!(*args)
-  rescue ::KeyError, ::IndexError # rubocop:disable Lint/ShadowedException
+  rescue ::Chamber::Errors::MissingSetting,
+         ::Chamber::Errors::MissingIndex
+
     nil
   end
 
   def securable
-    Settings.new(**metadata.deep_merge(
+    Settings.new(**metadata.merge(
                    settings:    raw_data,
                    pre_filters: [Filters::SecureFilter],
                  ))
   end
 
   def secure
-    Settings.new(**metadata.deep_merge(
+    Settings.new(**metadata.merge(
                    settings:     raw_data,
                    pre_filters:  [Filters::EncryptionFilter],
                    post_filters: [Filters::TranslateSecureKeysFilter],
@@ -269,7 +287,7 @@ class   Settings
   end
 
   def insecure
-    Settings.new(**metadata.deep_merge(
+    Settings.new(**metadata.merge(
                    settings:     raw_data,
                    pre_filters:  [Filters::InsecureFilter],
                    post_filters: [Filters::TranslateSecureKeysFilter],
@@ -278,23 +296,21 @@ class   Settings
 
   protected
 
-  def namespaces=(raw_namespaces)
-    @namespaces = NamespaceSet.new(raw_namespaces)
-  end
+  attr_writer :namespaces,
+              :raw_data
 
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def raw_data
     @filtered_raw_data ||= pre_filters.inject(@raw_data) do |filtered_data, filter|
-      filter.execute(**{ data: filtered_data }.deep_merge(metadata))
+      filter.execute(**{ data: filtered_data }.merge(metadata))
     end
   end
   # rubocop:enable Naming/MemoizedInstanceVariableName
 
   def data
-    @data ||= post_filters
-                .inject(raw_data) do |filtered_data, filter|
-                  filter.execute(**{ data: filtered_data }.deep_merge(metadata))
-                end
+    @data ||= post_filters.inject(raw_data) do |filtered_data, filter|
+      filter.execute(**{ data: filtered_data }.merge(metadata))
+    end
   end
 
   def metadata