chamber 1.0.3 → 2.0.0

data/lib/chamber/rails/railtie.rb

@@ -1,4 +1,4 @@
-class   Chamber
+module  Chamber
 module  Rails
 class   Railtie < ::Rails::Railtie
   initializer 'chamber.load', before: :load_environment_config do

data/lib/chamber/settings.rb

@@ -1,18 +1,34 @@
 require 'hashie/mash'
 require 'chamber/system_environment'
 require 'chamber/namespace_set'
+require 'chamber/filters/namespace_filter'
+require 'chamber/filters/encryption_filter'
+require 'chamber/filters/decryption_filter'
+require 'chamber/filters/environment_filter'
+require 'chamber/filters/boolean_conversion_filter'
+require 'chamber/filters/secure_filter'
 
 ###
 # Internal: Represents the base settings storage needed for Chamber.
 #
-class   Chamber
+module  Chamber
 class   Settings
 
   attr_reader :namespaces
 
   def initialize(options = {})
-    self.namespaces = options.fetch(:namespaces,  NamespaceSet.new)
-    self.data       = options.fetch(:settings,    Hashie::Mash.new)
+    self.namespaces       = options[:namespaces]      ||  []
+    self.raw_data         = options[:settings]        ||  {}
+    self.decryption_key   = options[:decryption_key]
+    self.encryption_key   = options[:encryption_key]
+    self.pre_filters      = options[:pre_filters]     ||  [
+                                                            Filters::NamespaceFilter,
+                                                          ]
+    self.post_filters     = options[:post_filters]    ||  [
+                                                            Filters::DecryptionFilter,
+                                                            Filters::EnvironmentFilter,
+                                                            Filters::BooleanConversionFilter,
+                                                          ]
   end
 
   ###
@@ -68,14 +84,14 @@ class   Settings
   # Internal: Merges a Settings object with another Settings object or
   # a hash-like object.
   #
-  # Also, if merging Settings, it will merge the namespaces as well.
+  # Also, if merging Settings, it will merge all other Settings data as well.
   #
   # Example:
   #
   #   settings        = Settings.new settings: { my_setting:        'my value' }
   #   other_settings  = Settings.new settings: { my_other_setting:  'my other value' }
   #
-  #   settings.merge! other_settings
+  #   settings.merge other_settings
   #
   #   settings
   #   # => {
@@ -83,70 +99,115 @@ class   Settings
   #     'my_other_setting'  => 'my other value',
   #   }
   #
+  # Returns a new Settings object
+  #
+  def merge(other)
+    other_settings = if other.is_a? Settings
+                       other
+                     elsif other.is_a? Hash
+                       Settings.new(settings: other)
+                     end
+
+    Settings.new(
+      encryption_key: encryption_key || other_settings.encryption_key,
+      decryption_key: decryption_key || other_settings.decryption_key,
+      namespaces:     (namespaces + other_settings.namespaces),
+      settings:       raw_data.merge(other_settings.raw_data))
+  end
+
+  ###
+  # Internal: Returns the Settings data as a Hash for easy manipulation.
+  # Changes made to the hash will *not* be reflected in the original Settings
+  # object.
+  #
   # Returns a Hash
   #
-  def merge!(other)
-    self.data       = data.merge(other.to_hash)
-    self.namespaces = (namespaces + other.namespaces) if other.respond_to? :namespaces
+  def to_hash
+    data.to_hash
+  end
+
+  ###
+  # Internal: Determines whether a Settings is equal to another hash-like
+  # object.
+  #
+  # Returns a Boolean
+  #
+  def ==(other)
+    self.to_hash == other.to_hash
   end
 
+  ###
+  # Internal: Determines whether a Settings is equal to another Settings.
+  #
+  # Returns a Boolean
+  #
   def eql?(other)
     other.is_a?(        Chamber::Settings)  &&
     self.data        == other.data          &&
     self.namespaces  == other.namespaces
   end
 
-  def to_hash
-    data
+  def secured
+    Settings.new( metadata.merge(
+                    settings:     raw_data,
+                    pre_filters:  [Filters::SecureFilter]))
   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)
+  def secure
+    Settings.new( metadata.merge(
+                    settings:     @raw_data,
+                    pre_filters:  [Filters::EncryptionFilter],
+                    post_filters: [] ))
   end
 
   protected
 
-  attr_reader :raw_data
-  attr_writer :namespaces
+  attr_accessor :pre_filters,
+                :post_filters,
+                :encryption_key,
+                :decryption_key,
+                :raw_data
 
-  def data
-    @data ||= Hashie::Mash.new
+  def raw_data=(new_raw_data)
+    @raw_data   = Hashie::Mash.new(new_raw_data)
   end
 
-  def data=(raw_data)
-    @raw_data = Hashie::Mash.new(raw_data)
-
-    namespace_checked_data =  if data_is_namespaced?
-                                namespace_filtered_data
-                              else
-                                self.raw_data
-                              end
+  def namespaces=(raw_namespaces)
+    @namespaces = NamespaceSet.new(raw_namespaces)
+  end
 
-    @data = SystemEnvironment.inject_into(namespace_checked_data)
+  def raw_data
+    @filtered_raw_data  ||= pre_filters.reduce(@raw_data) do |filtered_data, filter|
+                              filter.execute({data: filtered_data}.
+                                              merge(metadata))
+                            end
   end
 
-  private
+  def data
+    @data               ||= post_filters.reduce(raw_data) do |filtered_data, filter|
+                              filter.execute({data: filtered_data}.
+                                              merge(metadata))
+                            end
+  end
 
-  def data_is_namespaced?
-    @data_is_namespaced ||= raw_data.keys.any? { |key| namespaces.include? key }
+  def metadata
+    {
+      namespaces:     self.namespaces,
+      decryption_key: self.decryption_key,
+      encryption_key: self.encryption_key,
+    }
   end
 
-  def namespace_filtered_data
-    @namespace_filtered_data ||= -> do
-      data = Hashie::Mash.new
+  public
+
+  def method_missing(name, *args)
+    return data.public_send(name, *args) if data.respond_to?(name)
 
-      namespaces.each do |namespace|
-        data.merge!(raw_data[namespace]) if raw_data[namespace]
-      end
+    super
+  end
 
-      data
-    end.call
+  def respond_to_missing?(name, include_private = false)
+    data.respond_to?(name, include_private)
   end
 end
 end

data/lib/chamber/system_environment.rb

@@ -1,65 +1,12 @@
-require 'hashie/mash'
+require 'chamber/environmentable'
 
 ###
 # Internal: Gives access to the existing environment for importing/exporting
 # values.
 #
-class   Chamber
+module  Chamber
 module  SystemEnvironment
-
-  ###
-  # 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'
-  #
-  #   SystemEnvironment.inject_into(
-  #     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'
-  #
-  #   SystemEnvironment.inject_into({
-  #                                   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.inject_into(settings = {}, parent_keys = [])
-    with_environment(settings, parent_keys,
-      ->(key, value, environment_keys) do
-        { key => inject_into(value, environment_keys) }
-      end,
-      ->(key, value, environment_key) do
-        { key => convert_value(ENV[environment_key] || value) }
-      end)
-  end
+  extend Environmentable
 
   ###
   # Internal: Allows the environment variable-compatible variables to be
@@ -104,42 +51,5 @@ module  SystemEnvironment
         { environment_key => value.to_s }
       end)
   end
-
-  private
-
-  def self.with_environment(settings, parent_keys, hash_block, value_block)
-    environment_hash = Hashie::Mash.new
-
-    settings.each_pair do |key, value|
-      environment_keys = parent_keys.dup.push(key)
-
-      if value.respond_to? :each_pair
-        environment_hash.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))
-      end
-    end
-
-    environment_hash
-  end
-
-  def self.convert_value(value)
-    return nil if value.nil?
-
-    if value.is_a? String
-      case value
-      when 'false', 'f', 'no'
-        false
-      when 'true', 't', 'yes'
-        true
-      else
-        value
-      end
-    else
-      value
-    end
-  end
 end
 end

data/lib/chamber/version.rb

@@ -1,3 +1,3 @@
-class  Chamber
-  VERSION = '1.0.3'
+module Chamber
+  VERSION = '2.0.0'
 end

data/spec/fixtures/settings.yml

@@ -0,0 +1,27 @@
+---
+development:
+  my_setting: my_dev_value
+  my_boolean: 'false'
+  my_dynamic_setting: 3
+  another_level:
+    setting_one: 1
+    setting_two: 4
+    level_three:
+      an_array:
+      - item 8
+      - item 2
+      - item 0
+      a_scalar: hello
+test:
+  my_setting: my_value
+  my_boolean: 'false'
+  my_dynamic_setting: 2
+  another_level:
+    setting_one: 1
+    setting_two: 2
+    level_three:
+      an_array:
+      - item 1
+      - item 2
+      - item 3
+      a_scalar: hello

data/spec/lib/chamber/commands/context_resolver_spec.rb

@@ -0,0 +1,106 @@
+require 'rspectacular'
+require 'chamber/commands/context_resolver'
+
+module    Chamber
+module    Commands
+describe  ContextResolver do
+  let(:rails_2_path) { ::File.expand_path('../../../../rails-2-test', __FILE__) }
+  let(:rails_3_path) { ::File.expand_path('../../../../rails-3-test', __FILE__) }
+  let(:rails_4_path) { ::File.expand_path('../../../../rails-4-test', __FILE__) }
+
+  it 'does not attempt to do any resolution if all valid options are passed in' do
+    options = ContextResolver.resolve(basepath:       'my_path',
+                                      namespaces:     'ns')
+
+    expect(options[:basepath]).to       eql 'my_path'
+    expect(options[:files]).to          be_nil
+    expect(options[:namespaces]).to     eql 'ns'
+  end
+
+  it 'does not attempt to do any resolution if files are passed in in place of a basepath' do
+    options = ContextResolver.resolve(files:          'my_files',
+                                      namespaces:     'ns')
+
+    expect(options[:files]).to          eql 'my_files'
+    expect(options[:namespaces]).to     eql 'ns'
+  end
+
+  it 'defaults the basepath to the rootpath if none is explicitly set' do
+    options = ContextResolver.resolve(rootpath:       './app',
+                                      namespaces:     'ns')
+
+    expect(options[:basepath].to_s).to  eql './app'
+  end
+
+  it 'sets the rootpath to the current working directory if none is passed in' do
+    allow(Pathname).to  receive(:pwd).
+                        and_return('my_dir')
+
+    options = ContextResolver.resolve
+
+    expect(options[:rootpath].to_s).to  eql 'my_dir'
+  end
+
+  it 'sets the encryption key to the default if not passed in' do
+    options = ContextResolver.resolve(rootpath: rails_3_path)
+
+    expect(options[:encryption_key].to_s).to  include 'rails-3-test/.chamber.pub.pem'
+  end
+
+  it 'sets the decryption key to the default if not passed in' do
+    options = ContextResolver.resolve(rootpath: rails_3_path)
+
+    expect(options[:decryption_key].to_s).to  include 'rails-3-test/.chamber.pem'
+  end
+
+  it 'does not set the encryption key if the keyfile does not exist' do
+    options = ContextResolver.resolve(rootpath: './app')
+
+    expect(options[:encryption_key]).to be_nil
+  end
+
+  it 'does not set the decryption key if the keyfile does not exist' do
+    options = ContextResolver.resolve(rootpath: './app')
+
+    expect(options[:decryption_key]).to be_nil
+  end
+
+  it 'sets the information to a Rails preset even if it is not pointing to a Rails app' do
+    options = ContextResolver.resolve(rootpath: './app',
+                                      preset:   'rails')
+
+    expect(options[:basepath].to_s).to  include './app/config'
+    expect(options[:namespaces]).to     eql     []
+  end
+
+  it 'sets the information to a Rails preset when the rootpath is a Rails app' do
+    options = ContextResolver.resolve(rootpath: rails_3_path,
+                                      preset:   'rails')
+
+    expect(options[:basepath].to_s).to  include 'rails-3-test/config'
+    expect(options[:namespaces]).to     eql     ['development']
+  end
+
+  it 'sets the basepath if inside a Rails 2 project' do
+    options = ContextResolver.resolve(rootpath: rails_2_path)
+
+    expect(options[:basepath].to_s).to  include 'rails-2-test/config'
+    expect(options[:namespaces]).to     eql     ['development']
+  end
+
+  it 'sets the basepath if inside a Rails 3 project' do
+    options = ContextResolver.resolve(rootpath: rails_3_path)
+
+    expect(options[:basepath].to_s).to  include 'rails-3-test/config'
+    expect(options[:namespaces]).to     eql     ['development']
+  end
+
+  it 'sets the basepath if inside a Rails 4 project' do
+    options = ContextResolver.resolve(rootpath: rails_4_path)
+
+    expect(options[:basepath].to_s).to  include 'rails-4-test/config'
+    expect(options[:namespaces]).to     eql     ['development']
+  end
+end
+end
+end