chamber 1.0.3 → 2.0.0

data/lib/chamber/filters/decryption_filter.rb

@@ -0,0 +1,69 @@
+require 'openssl'
+require 'base64'
+require 'hashie/mash'
+require 'chamber/errors/undecryptable_value_error'
+
+module  Chamber
+module  Filters
+class   DecryptionFilter
+  SECURE_KEY_TOKEN      = %r{\A_secure_}
+  BASE64_STRING_PATTERN = %r{\A[A-Za-z0-9\+\/]{342}==\z}
+
+  def initialize(options = {})
+    self.decryption_key = options.fetch(:decryption_key, nil)
+    self.data           = options.fetch(:data).dup
+  end
+
+  def self.execute(options = {})
+    self.new(options).send(:execute)
+  end
+
+  protected
+
+  attr_accessor :data
+  attr_reader   :decryption_key
+
+  def execute(raw_data = data)
+    settings = Hashie::Mash.new
+
+    raw_data.each_pair do |key, value|
+      if value.respond_to? :each_pair
+        value = execute(value)
+      elsif value.respond_to? :match
+        if key.match(SECURE_KEY_TOKEN)
+          key   = key.to_s.sub(SECURE_KEY_TOKEN, '')
+          value = if value.match(BASE64_STRING_PATTERN)
+                    raise Errors::UndecryptableValueError.new("#{key} appears to need decrypting but the decryption key is not available.") if decryption_key.nil?
+
+                    decoded_string = Base64.strict_decode64(value)
+                    decryption_key.private_decrypt(decoded_string)
+                  else
+                    warn "WARNING: It appears that you would like to keep your information for #{key} secure, however the value for that setting does not appear to be encrypted.  Make sure you run 'chamber settings secure' before committing."
+
+                    value
+                  end
+        else
+          key = key.to_s
+        end
+      end
+
+      settings[key] = value
+    end
+
+    settings
+  end
+
+  def decryption_key=(keyish)
+    return @decryption_key = nil if keyish.nil?
+
+    key_content     = if ::File.readable?(::File.expand_path(keyish))
+                        ::File.read(::File.expand_path(keyish))
+                      else
+                        keyish
+                      end
+
+    @decryption_key = OpenSSL::PKey::RSA.new(key_content)
+  end
+end
+end
+end

data/lib/chamber/filters/encryption_filter.rb

@@ -0,0 +1,57 @@
+require 'openssl'
+require 'base64'
+require 'hashie/mash'
+
+module    Chamber
+module    Filters
+class     EncryptionFilter
+  SECURE_KEY_TOKEN      = %r{\A_secure_}
+  BASE64_STRING_PATTERN = %r{\A[A-Za-z0-9\+\/]{342}==\z}
+
+  def initialize(options = {})
+    self.encryption_key = options.fetch(:encryption_key, nil)
+    self.data           = options.fetch(:data).dup
+  end
+
+  def self.execute(options = {})
+    self.new(options).send(:execute)
+  end
+
+  protected
+
+  attr_accessor :data
+  attr_reader   :encryption_key
+
+  def execute(raw_data = data)
+    settings = Hashie::Mash.new
+
+    raw_data.each_pair do |key, value|
+      if value.respond_to? :each_pair
+        value = execute(value)
+      elsif value.respond_to? :match
+        if key.match(SECURE_KEY_TOKEN) && !value.match(BASE64_STRING_PATTERN)
+          encrypted_string = encryption_key.public_encrypt(value)
+          value            = Base64.strict_encode64(encrypted_string)
+        end
+      end
+
+      settings[key] = value
+    end
+
+    settings
+  end
+
+  def encryption_key=(keyish)
+    return @encryption_key = nil if keyish.nil?
+
+    key_content     = if ::File.readable?(::File.expand_path(keyish))
+                        ::File.read(::File.expand_path(keyish))
+                      else
+                        keyish
+                      end
+
+    @encryption_key = OpenSSL::PKey::RSA.new(key_content)
+  end
+end
+end
+end

data/lib/chamber/filters/environment_filter.rb

@@ -0,0 +1,75 @@
+require 'chamber/environmentable'
+
+module  Chamber
+module  Filters
+class   EnvironmentFilter
+  include Environmentable
+
+  def initialize(options = {})
+    self.data = options.fetch(:data)
+  end
+
+  ###
+  # 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
+  # returned.
+  #
+  # Examples:
+  #
+  #   ###
+  #   # Injects the current environment variables
+  #   #
+  #   ENV['LEVEL_ONE_1_LEVEL_TWO_1']               = 'env value 1'
+  #   ENV['LEVEL_ONE_1_LEVEL_TWO_2_LEVEL_THREE_1'] = 'env value 2'
+  #
+  #   EnvironmentFilter.execute(
+  #     level_one_1: {
+  #       level_two_1: 'value 1',
+  #       level_two_2: {
+  #         level_three_1: 'value 2' } } )
+  #
+  #   # => {
+  #     'level_one_1' => {
+  #       'level_two_1' => 'env value 1',
+  #       'level_two_2' => {
+  #         'level_three_1' => 'env value 2',
+  #   }
+  #
+  #   ###
+  #   # Can inject environment variables if said variables are prefixed
+  #   #
+  #   ENV['PREFIX_LEVEL_TWO_1'] = 'env value 1'
+  #   ENV['PREFIX_LEVEL_TWO_2'] = 'env value 2'
+  #
+  #   EnvironmentFilter.execute({
+  #                               level_two_1: 'value 1',
+  #                               level_two_2: 'value 2'
+  #                             },
+  #                             ['prefix'])
+  #
+  #   # => {
+  #     'level_two_1' => 'env value 1',
+  #     'level_two_2' => 'env value 2',
+  #   }
+  #
+  #
+  def self.execute(options = {})
+    self.new(options).send(:execute)
+  end
+
+  protected
+
+  attr_accessor :data
+
+  def execute(settings = data, parent_keys = [])
+    with_environment(settings, parent_keys,
+      ->(key, value, environment_keys) do
+        { key => execute(value, environment_keys) }
+      end,
+      ->(key, value, environment_key) do
+        { key => (ENV[environment_key] || value) }
+      end)
+  end
+end
+end
+end

data/lib/chamber/filters/namespace_filter.rb

@@ -0,0 +1,37 @@
+require 'hashie/mash'
+
+module  Chamber
+module  Filters
+class   NamespaceFilter
+  def initialize(options = {})
+    self.data       = Hashie::Mash.new(options.fetch(:data))
+    self.namespaces = options.fetch(:namespaces)
+  end
+
+  def self.execute(options = {})
+    self.new(options).send(:execute)
+  end
+
+  protected
+
+  attr_accessor :data,
+                :namespaces
+
+  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]
+      end
+    else
+      Hashie::Mash.new(data)
+    end
+  end
+
+  private
+
+  def data_is_namespaced?
+    @data_is_namespaced ||= data.keys.any? { |key| namespaces.include? key.to_s }
+  end
+end
+end
+end

data/lib/chamber/filters/secure_filter.rb

@@ -0,0 +1,39 @@
+require 'hashie/mash'
+
+module  Chamber
+module  Filters
+class   SecureFilter
+  SECURE_KEY_TOKEN = %r{\A_secure_}
+
+  def initialize(options = {})
+    self.data = Hashie::Mash.new(options.fetch(:data))
+  end
+
+  def self.execute(options = {})
+    self.new(options).send(:execute)
+  end
+
+  protected
+
+  attr_accessor :data
+
+  def execute(raw_data = data)
+    settings = Hashie::Mash.new
+
+    raw_data.each_pair do |key, value|
+      secure_value  = if value.respond_to? :each_pair
+                        execute(value)
+                      elsif key.respond_to? :match
+                        if key.match(SECURE_KEY_TOKEN)
+                          value
+                        end
+                      end
+
+      settings[key] = secure_value unless secure_value.nil?
+    end
+
+    settings
+  end
+end
+end
+end

data/lib/chamber/instance.rb

@@ -0,0 +1,40 @@
+require 'chamber/configuration'
+require 'chamber/file_set'
+
+module  Chamber
+class   Instance
+  attr_accessor :configuration,
+                :files
+
+  def initialize(options = {})
+    self.configuration = Configuration.new  options
+    self.files         = FileSet.new        configuration.to_hash
+  end
+
+  def settings
+    @settings ||= files.to_settings { |settings| @settings = settings }
+  end
+
+  def filenames
+    files.filenames
+  end
+
+  def secure
+    files.secure
+  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)
+  end
+end
+end

data/lib/chamber/namespace_set.rb

@@ -8,7 +8,7 @@ require 'set'
 # a NamespaceSet from either an array-like or hash-like object and the ability
 # to allow callables to be passed which will then be executed.
 #
-class   Chamber
+module  Chamber
 class   NamespaceSet
   include Enumerable
 
@@ -16,7 +16,21 @@ class   NamespaceSet
   # Internal: Creates a new NamespaceSet from arrays, hashes and sets.
   #
   def initialize(raw_namespaces = {})
-    self.namespaces = raw_namespaces
+    self.raw_namespaces = raw_namespaces
+  end
+
+  ###
+  # Internal: Allows for more compact NamespaceSet creation by giving a list of
+  # namespace values.
+  #
+  # Examples:
+  #
+  #   NamespaceSet['development', -> { ENV['HOST'] }]
+  #
+  # Returns a new NamespaceSet
+  #
+  def self.[](*namespace_values)
+    self.new(namespace_values)
   end
 
   ###
@@ -78,7 +92,7 @@ class   NamespaceSet
   # Returns a Boolean
   #
   def ==(other)
-    self.to_ary.eql? other.to_ary
+    self.to_a.eql? other.to_a
   end
 
   ###
@@ -88,15 +102,13 @@ class   NamespaceSet
   # Returns a Boolean
   #
   def eql?(other)
-    other.is_a?(        Chamber::NamespaceSet)  &&
+    other.is_a?(        NamespaceSet)  &&
     self.namespaces  == other.namespaces
   end
 
   protected
 
-  def namespaces
-    @namespaces ||= Set.new
-  end
+  attr_accessor :raw_namespaces
 
   ###
   # Internal: Sets the namespaces for the set from a variety of objects and
@@ -108,6 +120,7 @@ class   NamespaceSet
   #
   #   # Can be set to an array
   #   namespace_set.namespaces  = %w{namespace_value_1 namespace_value_2}
+  #   namespace_set.namespaces
   #   # => ['namespace_value_1', 'namespace_value_2']
   #
   #   # Can be set to a hash
@@ -116,6 +129,16 @@ class   NamespaceSet
   #   namespace_set.namespaces
   #   # => ['development', 'my host']
   #
+  #   # Can be set to a NamespaceSet
+  #   namespace_set.namespaces  = NamespaceSet.new('development')
+  #   namespace_set.namespaces
+  #   # => ['development']
+  #
+  #   # Can be set to a single value
+  #   namespace_set.namespaces  = 'development'
+  #   namespace_set.namespaces
+  #   # => ['development']
+  #
   #   # Can be set to a callable
   #   namespace_set.namespaces  = { environment:  -> { 'called' } }
   #   namespace_set.namespaces
@@ -126,16 +149,32 @@ class   NamespaceSet
   #   namespace_set.namespaces
   #   # => ['namespace_value']
   #
-  def namespaces=(raw_namespaces)
-    namespace_values =  if raw_namespaces.respond_to? :values
-                          raw_namespaces.values
-                        else
-                          raw_namespaces
-                        end
+  def namespaces
+    @namespaces ||= Set.new namespace_values.map do |value|
+                      (value.respond_to?(:call) ? value.call : value).to_s
+                    end
+  end
+
+  def raw_namespaces=(raw_namespaces)
+    @raw_namespaces = if raw_namespaces.is_a? NamespaceSet
+                        raw_namespaces.to_ary
+                      else
+                        raw_namespaces
+                      end
+  end
 
-    @namespaces = Set.new namespace_values.map do |value|
-                    value.respond_to?(:call) ? value.call : value
-                  end
+  private
+
+  def namespace_values
+    if raw_namespaces.respond_to? :map
+      if raw_namespaces.respond_to? :values
+        raw_namespaces.values
+      else
+        raw_namespaces
+      end
+    else
+      [raw_namespaces]
+    end
   end
 end
 end