chamber 2.13.0 → 3.0.0rc1

data/lib/chamber/key_pair.rb

@@ -9,10 +9,10 @@ class  KeyPair
                 :namespace,
                 :passphrase
 
-  def initialize(options = {})
-    self.namespace     = options[:namespace]
-    self.passphrase    = options.fetch(:passphrase, SecureRandom.uuid)
-    self.key_file_path = Pathname.new(options.fetch(:key_file_path))
+  def initialize(key_file_path:, namespace: nil, passphrase: ::SecureRandom.uuid)
+    self.namespace     = namespace
+    self.passphrase    = passphrase
+    self.key_file_path = Pathname.new(key_file_path)
   end
 
   def encrypted_private_key_passphrase_filepath
@@ -78,9 +78,9 @@ class  KeyPair
     @base_key_filename ||= [
                              '.chamber',
                              namespace ? namespace.tr('-.', '') : nil,
-                           ].
-                             compact.
-                             join('.')
+                           ]
+                             .compact
+                             .join('.')
   end
 end
 end

data/lib/chamber/keys/base.rb

@@ -3,18 +3,18 @@
 module  Chamber
 module  Keys
 class   Base
-  def self.resolve(*args)
-    new(*args).resolve
+  def self.resolve(**args)
+    new(**args).resolve
   end
 
   attr_accessor :rootpath
   attr_reader   :filenames,
                 :namespaces
 
-  def initialize(options = {})
-    self.rootpath   = Pathname.new(options.fetch(:rootpath))
-    self.namespaces = options.fetch(:namespaces)
-    self.filenames  = options[:filenames]
+  def initialize(rootpath:, namespaces:, filenames: nil)
+    self.rootpath   = Pathname.new(rootpath)
+    self.namespaces = namespaces
+    self.filenames  = filenames
   end
 
   def resolve
@@ -41,9 +41,9 @@ class   Base
 
   # rubocop:disable Performance/ChainArrayAllocation
   def filenames=(other)
-    @filenames = Array(other).
-                   map { |o| Pathname.new(o) }.
-                   compact
+    @filenames = Array(other)
+                   .map { |o| Pathname.new(o) }
+                   .compact
   end
   # rubocop:enable Performance/ChainArrayAllocation
 
@@ -52,10 +52,10 @@ class   Base
   end
 
   def namespace_from_path(path)
-    path.
-      basename.
-      to_s.
-      match(self.class::NAMESPACE_PATTERN) { |m| m[1].upcase }
+    path
+      .basename
+      .to_s
+      .match(self.class::NAMESPACE_PATTERN) { |m| m[1].upcase }
   end
 
   def namespace_to_key_path(namespace)

data/lib/chamber/keys/decryption.rb

@@ -22,9 +22,9 @@ class   Decryption < Chamber::Keys::Base
       'CHAMBER',
       namespace_from_path(path),
       'KEY',
-    ].
-      compact.
-      join('_')
+    ]
+      .compact
+      .join('_')
   end
 
   def key_filename_extension

data/lib/chamber/keys/encryption.rb

@@ -22,9 +22,9 @@ class   Encryption < Chamber::Keys::Base
       'CHAMBER',
       namespace_from_path(path),
       'PUBLIC_KEY',
-    ].
-      compact.
-      join('_')
+    ]
+      .compact
+      .join('_')
   end
 
   def key_filename_extension

data/lib/chamber/namespace_set.rb

@@ -71,10 +71,8 @@ class   NamespaceSet
   # Internal: Iterates over each namespace value and allows it to be used in
   # a block.
   #
-  def each
-    namespaces.each do |namespace|
-      yield namespace
-    end
+  def each(&block)
+    namespaces.each(&block)
   end
 
   ###

data/lib/chamber/refinements/array.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rspectacular'
+require 'chamber/refinements/enumerable'
+
+module Chamber
+module Refinements
+module Array
+refine ::Array do
+  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
+end
+end
+end
+end

data/lib/chamber/refinements/deep_dup.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+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
+  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
+  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
+        end
+      end
+    end
+  end
+end
+end
+end
+end

data/lib/chamber/refinements/enumerable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Chamber
+module Refinements
+class  Enumerable
+  def self.deep_transform_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
+
+  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)
+      end
+    when ::Array
+      yield(
+        key,
+        value.map { |v| deep_transform_values(nil, v, &block) }
+      )
+    else
+      yield(key, value)
+    end
+  end
+end
+end
+end

data/lib/chamber/refinements/hash.rb

@@ -0,0 +1,51 @@
+# 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
+  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
+      end
+    end
+  end
+end
+end
+end
+end

data/lib/chamber/settings.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'hashie/mash'
 require 'chamber/namespace_set'
 require 'chamber/filters/namespace_filter'
 require 'chamber/filters/encryption_filter'
@@ -10,35 +9,52 @@ require 'chamber/filters/secure_filter'
 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/hash'
 
 ###
 # Internal: Represents the base settings storage needed for Chamber.
 #
 module  Chamber
 class   Settings
-  attr_accessor :pre_filters,
-                :post_filters,
+  using ::Chamber::Refinements::Hash
+  using ::Chamber::Refinements::DeepDup
+
+  attr_accessor :decryption_keys,
                 :encryption_keys,
-                :decryption_keys
+                :post_filters,
+                :pre_filters,
+                :secure_key_prefix
   attr_reader   :namespaces
-
-  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/LineLength
-  def initialize(options = {})
-    self.namespaces      = options[:namespaces]      || []
-    self.raw_data        = options[:settings]        || {}
-    self.decryption_keys = options[:decryption_keys] || {}
-    self.encryption_keys = options[:encryption_keys] || {}
-    self.pre_filters     = options[:pre_filters]     || [
-                                                          Filters::NamespaceFilter,
-                                                        ]
-    self.post_filters    = options[:post_filters]    || [
-                                                          Filters::DecryptionFilter,
-                                                          Filters::EnvironmentFilter,
-                                                          Filters::FailedDecryptionFilter,
-                                                          Filters::TranslateSecureKeysFilter,
-                                                        ]
+  attr_writer   :raw_data
+
+  # rubocop:disable Metrics/ParameterLists
+  def initialize(
+                  decryption_keys:   {},
+                  encryption_keys:   {},
+                  namespaces:        [],
+                  pre_filters:       [
+                                       Filters::NamespaceFilter,
+                                     ],
+                  post_filters:      [
+                                       Filters::DecryptionFilter,
+                                       Filters::EnvironmentFilter,
+                                       Filters::FailedDecryptionFilter,
+                                       Filters::TranslateSecureKeysFilter,
+                                     ],
+                  secure_key_prefix: '_secure_',
+                  settings:          {},
+                  **_args
+                )
+    self.decryption_keys   = decryption_keys
+    self.encryption_keys   = encryption_keys
+    self.namespaces        = namespaces
+    self.post_filters      = post_filters
+    self.pre_filters       = pre_filters
+    self.raw_data          = settings.deep_dup
+    self.secure_key_prefix = secure_key_prefix
   end
-  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/LineLength
+  # rubocop:enable Metrics/ParameterLists
 
   ###
   # Internal: Converts a Settings object into a hash that is compatible as an
@@ -79,15 +95,11 @@ class   Settings
   #                 } ).to_s
   #   # => 'MY_KEY="my value" MY_OTHER_KEY="my other value"'
   #
-  def to_s(options = {})
-    hierarchical_separator = options[:hierarchical_separator] || '_'
-    pair_separator         = options[:pair_separator]         || ' '
-    value_surrounder       = options[:value_surrounder]       || '"'
-    name_value_separator   = options[:name_value_separator]   || '='
-
-    concatenated_name_hash = to_concatenated_name_hash(hierarchical_separator)
-
-    pairs = concatenated_name_hash.to_a.map do |key, value|
+  def to_s(hierarchical_separator: '_',
+           pair_separator:         ' ',
+           value_surrounder:       '"',
+           name_value_separator:   '=')
+    pairs = to_concatenated_name_hash(hierarchical_separator).to_a.map do |key, value|
       "#{key.upcase}#{name_value_separator}#{value_surrounder}#{value}#{value_surrounder}"
     end
 
@@ -102,7 +114,7 @@ class   Settings
   # Returns a Hash
   #
   def to_hash
-    data.to_hash
+    data.dup
   end
 
   ###
@@ -135,11 +147,11 @@ class   Settings
     flattened_name_hash = {}
 
     hash.each_pair do |key, value|
-      flattened_name_components = parent_keys.dup.push(key)
+      flattened_name_components = parent_keys.deep_dup.push(key)
 
       if value.respond_to?(:each_pair)
-        flattened_name_hash.merge! to_flattened_name_hash(value,
-                                                          flattened_name_components)
+        flattened_name_hash
+          .deep_merge!(to_flattened_name_hash(value, flattened_name_components))
       else
         flattened_name_hash[flattened_name_components] = value
       end
@@ -182,20 +194,21 @@ class   Settings
   # Returns a new Settings object
   #
   def merge(other)
-    other_settings = if other.is_a? Settings
+    other_settings = case other
+                     when Settings
                        other
-                     elsif other.is_a? Hash
+                     when ::Hash
                        Settings.new(settings: other)
                      end
 
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     Settings.new(
       encryption_keys: encryption_keys.any? ? encryption_keys : other_settings.encryption_keys,
       decryption_keys: decryption_keys.any? ? decryption_keys : other_settings.decryption_keys,
       namespaces:      (namespaces + other_settings.namespaces),
-      settings:        raw_data.merge(other_settings.raw_data),
+      settings:        raw_data.deep_merge(other_settings.raw_data),
     )
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
   end
 
   ###
@@ -219,15 +232,36 @@ class   Settings
     namespaces  == other.namespaces
   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
+
+    data.fetch(key)
+  end
+
+  def dig!(*args)
+    args.inject(data) do |data_value, bracket_value|
+      key = bracket_value.is_a?(::Symbol) ? bracket_value.to_s : bracket_value
+
+      data_value.fetch(key)
+    end
+  end
+
+  def dig(*args)
+    dig!(*args)
+  rescue ::KeyError, ::IndexError # rubocop:disable Lint/ShadowedException
+    nil
+  end
+
   def securable
-    Settings.new(metadata.merge(
+    Settings.new(**metadata.deep_merge(
                    settings:    raw_data,
                    pre_filters: [Filters::SecureFilter],
                  ))
   end
 
   def secure
-    Settings.new(metadata.merge(
+    Settings.new(**metadata.deep_merge(
                    settings:     raw_data,
                    pre_filters:  [Filters::EncryptionFilter],
                    post_filters: [Filters::TranslateSecureKeysFilter],
@@ -235,29 +269,15 @@ class   Settings
   end
 
   def insecure
-    Settings.new(metadata.merge(
+    Settings.new(**metadata.deep_merge(
                    settings:     raw_data,
                    pre_filters:  [Filters::InsecureFilter],
                    post_filters: [Filters::TranslateSecureKeysFilter],
                  ))
   end
 
-  def method_missing(name, *args)
-    return data.public_send(name, *args) if data.respond_to?(name)
-
-    super
-  end
-
-  def respond_to_missing?(name, include_private = false)
-    data.respond_to?(name, include_private)
-  end
-
   protected
 
-  def raw_data=(new_raw_data)
-    @raw_data   = Hashie::Mash.new(new_raw_data)
-  end
-
   def namespaces=(raw_namespaces)
     @namespaces = NamespaceSet.new(raw_namespaces)
   end
@@ -265,21 +285,16 @@ class   Settings
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def raw_data
     @filtered_raw_data ||= pre_filters.inject(@raw_data) do |filtered_data, filter|
-      filter.execute({ data: filtered_data }.
-                     merge(metadata))
+      filter.execute(**{ data: filtered_data }.deep_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 }.
-                     merge(metadata))
-    end
-  end
-
-  def secure_key_prefix
-    '_secure_'
+    @data ||= post_filters
+                .inject(raw_data) do |filtered_data, filter|
+                  filter.execute(**{ data: filtered_data }.deep_merge(metadata))
+                end
   end
 
   def metadata