chamber 2.13.0 → 3.0.0rc1

data/lib/chamber/filters/decryption_filter.rb

@@ -2,29 +2,31 @@
 
 require 'openssl'
 require 'base64'
-require 'hashie/mash'
 require 'yaml'
 require 'chamber/encryption_methods/public_key'
 require 'chamber/encryption_methods/ssl'
 require 'chamber/encryption_methods/none'
 require 'chamber/errors/decryption_failure'
+require 'chamber/refinements/deep_dup'
 
 module  Chamber
 module  Filters
 class   DecryptionFilter
-  BASE64_STRING_PATTERN     = %r{\A[A-Za-z0-9\+/]{342}==\z}.freeze
+  using ::Chamber::Refinements::DeepDup
+
+  BASE64_STRING_PATTERN     = %r{\A[A-Za-z0-9+/]{342}==\z}.freeze
   LARGE_DATA_STRING_PATTERN = %r{
                                   \A                            # Beginning of String
                                   (
-                                    [A-Za-z0-9\+\/#]*\={0,2}    # Base64 Encoded Key
+                                    [A-Za-z0-9+/#]*={0,2}       # Base64 Encoded Key
                                   )
                                   \#                            # Separator
                                   (
-                                    [A-Za-z0-9\+\/#]*\={0,2}    # Base64 Encoded IV
+                                    [A-Za-z0-9+/#]*={0,2}       # Base64 Encoded IV
                                   )
                                   \#                            # Separator
                                   (
-                                    [A-Za-z0-9\+\/#]*\={0,2}    # Base64 Encoded Data
+                                    [A-Za-z0-9+/#]*={0,2}       # Base64 Encoded Data
                                   )
                                   \z                            # End of String
                                 }x.freeze
@@ -33,20 +35,20 @@ class   DecryptionFilter
                 :secure_key_token
   attr_reader   :decryption_keys
 
-  def initialize(options = {})
-    self.decryption_keys  = options.fetch(:decryption_keys, {}) || {}
-    self.data             = options.fetch(:data).dup
-    self.secure_key_token = /\A#{Regexp.escape(options.fetch(:secure_key_prefix))}/
+  def initialize(data:, secure_key_prefix:, decryption_keys: {}, **_args)
+    self.decryption_keys  = decryption_keys || {}
+    self.data             = data.deep_dup
+    self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
   end
 
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   protected
 
   def execute(raw_data = data)
-    settings = Hashie::Mash.new
+    settings = {}
 
     raw_data.each_pair do |key, value|
       settings[key] = if value.respond_to? :each_pair
@@ -79,9 +81,11 @@ class   DecryptionFilter
     method = decryption_method(value)
 
     decryption_keys.each do |decryption_key|
-      return method.decrypt(key, value, decryption_key)
-    rescue OpenSSL::PKey::RSAError
-      next
+      begin
+        return method.decrypt(key, value, decryption_key)
+      rescue OpenSSL::PKey::RSAError
+        next
+      end
     end
 
     value

data/lib/chamber/filters/encryption_filter.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 require 'openssl'
-require 'hashie/mash'
 require 'yaml'
 require 'chamber/encryption_methods/public_key'
 require 'chamber/encryption_methods/ssl'
 require 'chamber/encryption_methods/none'
+require 'chamber/refinements/deep_dup'
 
 module    Chamber
 module    Filters
 class     EncryptionFilter
-  BASE64_STRING_PATTERN     = %r{\A[A-Za-z0-9\+\/]{342}==\z}.freeze
-  BASE64_SUBSTRING_PATTERN  = %r{[A-Za-z0-9\+\/#]*\={0,2}}.freeze
+  using ::Chamber::Refinements::DeepDup
+
+  BASE64_STRING_PATTERN     = %r{\A[A-Za-z0-9+/]{342}==\z}.freeze
+  BASE64_SUBSTRING_PATTERN  = %r{[A-Za-z0-9+/#]*={0,2}}.freeze
   LARGE_DATA_STRING_PATTERN = /
                                 \A
                                 (#{BASE64_SUBSTRING_PATTERN})
@@ -26,20 +28,20 @@ class     EncryptionFilter
                 :secure_key_token
   attr_reader   :encryption_keys
 
-  def initialize(options = {})
-    self.encryption_keys  = options.fetch(:encryption_keys, {}) || {}
-    self.data             = options.fetch(:data).dup
-    self.secure_key_token = /\A#{Regexp.escape(options.fetch(:secure_key_prefix))}/
+  def initialize(data:, secure_key_prefix:, encryption_keys: {}, **_args)
+    self.encryption_keys  = encryption_keys || {}
+    self.data             = data.deep_dup
+    self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
   end
 
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   protected
 
   def execute(raw_data = data, namespace = nil)
-    raw_data.each_with_object(Hashie::Mash.new) do |(key, value), settings|
+    raw_data.each_with_object({}) do |(key, value), settings|
       settings[key] = if value.respond_to? :each_pair
                         execute(value, namespace || key)
                       elsif key.match(secure_key_token)
@@ -67,7 +69,8 @@ class     EncryptionFilter
 
   def encrypt(namespace, key, value)
     method         = encryption_method(value)
-    encryption_key = encryption_keys[namespace] || encryption_keys[:__default]
+    namespace_key  = namespace ? namespace.to_sym : nil
+    encryption_key = encryption_keys[namespace_key] || encryption_keys[:__default]
 
     return value unless encryption_key
 

data/lib/chamber/filters/environment_filter.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require 'hashie/mash'
-
 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
+
   ###
   # Internal: Allows the existing environment to be injected into the passed in
   # hash.  The hash that is passed in is *not* modified, instead a new hash is
@@ -88,16 +91,16 @@ class   EnvironmentFilter
   #   }
   #
   #
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   attr_accessor :data,
                 :secure_key_token
 
-  def initialize(options = {})
-    self.data             = options.fetch(:data)
-    self.secure_key_token = /\A#{Regexp.escape(options.fetch(:secure_key_prefix))}/
+  def initialize(data:, secure_key_prefix:, **_args)
+    self.data             = data
+    self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
   end
 
   protected
@@ -120,26 +123,25 @@ class   EnvironmentFilter
   private
 
   def with_environment(settings, parent_keys, hash_block, value_block)
-    environment_hash = Hashie::Mash.new
+    environment_hash = {}
 
     settings.each_pair do |key, value|
       environment_key  = key.to_s.gsub(secure_key_token, '')
-      environment_keys = parent_keys.dup.push(environment_key)
+      environment_keys = parent_keys.deep_dup.push(environment_key)
 
       if value.respond_to? :each_pair
-        environment_hash.merge!(hash_block.call(key, value, environment_keys))
+        environment_hash.deep_merge!(hash_block.call(key, value, environment_keys))
       else
         environment_key = environment_keys.join('_').upcase
 
-        environment_hash.merge!(value_block.call(key, value, environment_key))
+        environment_hash.deep_merge!(value_block.call(key, value, environment_key))
       end
     end
 
     environment_hash
   end
 
-  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-  def convert_environment_value(environment_key, environment_value, settings_value)
+  def convert_environment_value(environment_key, environment_value, settings_value) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
     return settings_value unless environment_value
     return                if %w{___nil___ ___null___}.include?(environment_value)
 
@@ -163,22 +165,21 @@ class   EnvironmentFilter
           fail ArgumentError, "Invalid value for Array: #{environment_value}"
         end
       end
-    when 'Integer'
+    when 'Fixnum', 'Integer'
       Integer(environment_value)
     else
       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
-  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 end
 end
 end

data/lib/chamber/filters/failed_decryption_filter.rb

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
 require 'chamber/errors/decryption_failure'
+require 'chamber/refinements/deep_dup'
 
 module  Chamber
 module  Filters
 class   FailedDecryptionFilter
-  BASE64_STRING_PATTERN = %r{\A[A-Za-z0-9\+/]{342}==\z}.freeze
+  using ::Chamber::Refinements::DeepDup
 
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  BASE64_STRING_PATTERN = %r{\A[A-Za-z0-9+/]{342}==\z}.freeze
+
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   attr_accessor :data,
                 :secure_key_token
 
-  def initialize(options = {})
-    self.data             = options.fetch(:data).dup
-    self.secure_key_token = /\A#{Regexp.escape(options.fetch(:secure_key_prefix))}/
+  def initialize(data:, secure_key_prefix:, **_args)
+    self.data             = data.deep_dup
+    self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
   end
 
   protected

data/lib/chamber/filters/insecure_filter.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require 'hashie/mash'
 require 'chamber/filters/secure_filter'
 
 module  Chamber
 module  Filters
 class   InsecureFilter < SecureFilter
-  BASE64_STRING_PATTERN     = %r{\A[A-Za-z0-9\+\/]{342}==\z}.freeze
-  BASE64_SUBSTRING_PATTERN  = %r{[A-Za-z0-9\+\/#]*\={0,2}}.freeze
+  BASE64_STRING_PATTERN     = %r{\A[A-Za-z0-9+/]{342}==\z}.freeze
+  BASE64_SUBSTRING_PATTERN  = %r{[A-Za-z0-9+/#]*={0,2}}.freeze
   LARGE_DATA_STRING_PATTERN = /
                                 \A
                                 (#{BASE64_SUBSTRING_PATTERN})
@@ -20,9 +19,9 @@ class   InsecureFilter < SecureFilter
 
   protected
 
-  def execute(raw_data = data)
+  def execute(raw_data = data) # rubocop:disable Metrics/CyclomaticComplexity
     securable_settings = super
-    settings           = Hashie::Mash.new
+    settings           = {}
 
     securable_settings.each_pair do |key, value|
       value = if value.respond_to? :each_pair

data/lib/chamber/filters/namespace_filter.rb

@@ -1,31 +1,35 @@
 # frozen_string_literal: true
 
-require 'hashie/mash'
+require 'chamber/refinements/hash'
+require 'chamber/refinements/deep_dup'
 
 module  Chamber
 module  Filters
 class   NamespaceFilter
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  using ::Chamber::Refinements::Hash
+  using ::Chamber::Refinements::DeepDup
+
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   attr_accessor :data,
                 :namespaces
 
-  def initialize(options = {})
-    self.data       = Hashie::Mash.new(options.fetch(:data))
-    self.namespaces = options.fetch(:namespaces)
+  def initialize(data:, namespaces:, **_args)
+    self.data       = data.deep_dup
+    self.namespaces = namespaces
   end
 
   protected
 
   def execute
     if data_is_namespaced?
-      namespaces.each_with_object(Hashie::Mash.new) do |namespace, filtered_data|
-        filtered_data.merge!(data[namespace]) if data[namespace]
+      namespaces.each_with_object({}) do |namespace, filtered_data|
+        filtered_data.deep_merge!(data[namespace]) if data[namespace]
       end
     else
-      Hashie::Mash.new(data)
+      data
     end
   end
 

data/lib/chamber/filters/secure_filter.rb

@@ -1,26 +1,28 @@
 # frozen_string_literal: true
 
-require 'hashie/mash'
+require 'chamber/refinements/deep_dup'
 
 module  Chamber
 module  Filters
 class   SecureFilter
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  using ::Chamber::Refinements::DeepDup
+
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   attr_accessor :data,
                 :secure_key_token
 
-  def initialize(options = {})
-    self.data             = Hashie::Mash.new(options.fetch(:data))
-    self.secure_key_token = /\A#{Regexp.escape(options.fetch(:secure_key_prefix))}/
+  def initialize(data:, secure_key_prefix:, **_args)
+    self.data             = data.deep_dup
+    self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
   end
 
   protected
 
   def execute(raw_data = data)
-    settings = Hashie::Mash.new
+    settings = {}
 
     raw_data.each_pair do |key, value|
       secure_value  = if value.respond_to? :each_pair

data/lib/chamber/filters/translate_secure_keys_filter.rb

@@ -1,26 +1,28 @@
 # frozen_string_literal: true
 
-require 'hashie/mash'
+require 'chamber/refinements/deep_dup'
 
 module  Chamber
 module  Filters
 class   TranslateSecureKeysFilter
-  def self.execute(options = {})
-    new(options).__send__(:execute)
+  using ::Chamber::Refinements::DeepDup
+
+  def self.execute(**args)
+    new(**args).__send__(:execute)
   end
 
   attr_accessor :data,
                 :secure_key_token
 
-  def initialize(options = {})
-    self.data             = options.fetch(:data).dup
-    self.secure_key_token = /\A#{Regexp.escape(options.fetch(:secure_key_prefix))}/
+  def initialize(data:, secure_key_prefix:, **_args)
+    self.data             = data.deep_dup
+    self.secure_key_token = /\A#{Regexp.escape(secure_key_prefix)}/
   end
 
   protected
 
   def execute(raw_data = data)
-    settings = Hashie::Mash.new
+    settings = {}
 
     raw_data.each_pair do |key, value|
       value = execute(value) if value.respond_to? :each_pair

data/lib/chamber/instance.rb

@@ -3,21 +3,36 @@
 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
 
-  def initialize(options = {})
-    self.configuration = Configuration.new  options
-    self.files         = FileSet.new        configuration.to_hash
+  def initialize(**args)
+    self.configuration = Configuration.new(**args)
+    self.files         = FileSet.new(**configuration.to_hash)
   end
 
   def settings
     @settings ||= files.to_settings { |settings| @settings = settings }
   end
 
+  def [](key)
+    settings.[](key)
+  end
+
+  def dig!(*args)
+    settings.dig!(*args)
+  end
+
+  def dig(*args)
+    settings.dig(*args)
+  end
+
   def filenames
     files.filenames
   end
@@ -34,26 +49,42 @@ class   Instance
     files.verify
   end
 
-  def encrypt(data, options = {})
-    config = configuration.to_hash.merge(options)
+  def to_environment
+    settings.to_environment
+  end
+
+  def to_s(**args)
+    settings.to_s(**args)
+  end
+
+  def to_hash
+    settings.to_hash
+  end
+
+  def namespaces
+    settings.namespaces
+  end
 
-    Settings.
-      new(
-        config.merge(
+  def encrypt(data, **args)
+    config = configuration.to_hash.deep_merge(**args)
+
+    Settings
+      .new(
+        **config.deep_merge(
           settings:     data,
           pre_filters:  [Filters::EncryptionFilter],
           post_filters: [],
         ),
-      ).
-      to_hash
+      )
+      .to_hash
   end
 
-  def decrypt(data, options = {})
-    config = configuration.to_hash.merge(options)
+  def decrypt(data, **args)
+    config = configuration.to_hash.deep_merge(**args)
 
-    Settings.
-      new(
-        config.merge(
+    Settings
+      .new(
+        **config.deep_merge(
           settings:     data,
           pre_filters:  [Filters::NamespaceFilter],
           post_filters: [
@@ -61,22 +92,8 @@ class   Instance
                           Filters::FailedDecryptionFilter,
                         ],
         ),
-      ).
-      to_hash
-  end
-
-  def to_s(options = {})
-    settings.to_s(options)
-  end
-
-  def method_missing(name, *args)
-    return settings.public_send(name, *args) if settings.respond_to?(name)
-
-    super
-  end
-
-  def respond_to_missing?(name, include_private = false)
-    settings.respond_to?(name, include_private)
+      )
+      .to_hash
   end
 end
 end