config_logic 0.1.0

data/README.rdoc

@@ -0,0 +1,159 @@
+= Config Logic
+
+Config Logic is a configuration management tool for Ruby/Rails applications. It
+wraps any set of config files in a managed access layer which supports
+
+* caching
+* multi argument, hash style, or dot style access
+* ordered overlays
+* dynamic or static multiplexing
+
+
+== Requirements
+
+The following gems will be installed along with config_logic
+
+* activesupport (2.2.2+)
+* buffered_logger (0.1.2+)
+
+
+== Installation
+
+  gem install config_logic
+
+
+== Usage
+
+Imagine that your application has a config directory with the following layout,
+
+  config/config_prod.yml -->
+
+      :key1: 1 
+      :key2: 2
+      :key3: 3
+
+  config/config_dev.yml -->
+
+      :key1: 11 
+      :key2: 12 
+      :key3: 13
+
+  config/dir1/config_prod.yml -->
+      
+      :key1: 11 
+      :key2: 12 
+      :key3: 13
+
+  config/dir2/config_dev.yml -->
+
+      :key4: 1
+      :key5: 2
+      :key6: 3
+
+
+=== Initialization
+
+  c = ConfigLogic.new('path/to/config/dir')
+  c = ConfigLogic.new(['path1', 'path2'])
+
+
+=== Data Access
+
+  c.config.key1        => 1
+  c[:config][:key1]    => 1
+  c['config']['key1']  => 1
+  c(:config, :key1)    => 1
+  c('config', 'key1')  => 1
+  c.unknown            => nil
+  c.config.unknown     => nil
+
+
+=== Rebuilding the Config Cache
+
+  c.reload!
+
+
+=== Applying Overlays
+
+An Overlay allows multiple config values to be merged in a specified order. The
+merge order is determined by the order of the key names in the :inputs parameter.
+
+==== Global
+
+  c = ConfigLogic.new('path/to/config/dir', :overlays => [ { :name => 'config',
+                                                             :inputs => [:config_prod, :config_dev] } ] )
+  c.config.key1 => 11
+  c.config.key2 => 12
+  c.config.key3 => 13
+  c.config.dir1.key1 => 11
+  c.config.dir1.key2 => 12
+  c.config.dir1.key3 => 13
+  c.config.dir1.key4 => 1
+  c.config.dir1.key5 => 2
+  c.config.dir1.key6 => 3
+
+==== Local
+
+  c.config.insert_overlay( { :name => 'config',
+                             :inputs => [:config_prod, :config_dev] } )
+  c.config.key1 => 11
+  c.config.key2 => 12
+  c.config.key3 => 13
+  c.config.dir1.key1 => 1
+  c.config.dir1.key2 => 2
+  c.config.dir1.key3 => 3
+  c.config.dir1.key4 => nil
+
+
+=== Applying Multiplexers
+
+A multiplexer groups multiple config values and uses the result of a supplied code
+block to choose the appropriate one. Multiplexers can be static or dynamic. A
+static multiplexer is evaluated when it is created and its result replaces the
+key group specified. A dynamic multiplexer is evaluated every time it's called.
+Multiplexers are static by default.
+ 
+
+==== Global
+
+  c = ConfigLogic.new('path/to/config/dir', :multiplexers => [ { :name => 'key',
+                                                                 :selector => Proc.new {1 + 1 },
+                                                                 :inputs => {1 => :key1, 2 => :key2, 3 => :key3} } ] )
+  c.config.key => 2
+  c.config.key1 => nil
+  c.config.key2 => nil
+  c.config.key3 => nil
+  c.config.dir1.key => 2
+  c.config.dir1.key1 => nil
+  c.config.dir1.key2 => nil
+  c.config.dir1.key3 => nil
+
+==== Local
+
+  c.config.insert_multiplexer({ :name => 'key',
+                                :selector => Proc.new {1 + 1 },
+                                :inputs => {1 => :key1, 2 => :key2, 3 => :key3} })
+  c.config.key => 2
+  c.config.key1 => nil
+  c.config.key2 => nil
+  c.config.key3 => nil
+  c.config.dir1.key => nil
+  c.config.dir1.key1 => 1
+  c.config.dir1.key2 => 2
+  c.config.dir1.key3 => 3
+
+==== Static vs Dynamic
+
+  A dynamic multiplexer will re-evaluate the selecor proc every time it's called
+
+  c.config.insert_multiplexer({ :name => 'key',
+                                :static => false,
+                                :selector => Proc.new { rand(3) + 1 },
+                                :inputs => {1 => :key1, 2 => :key2, 3 => :key3} })
+  c.config.key => 2 # time = 0
+  c.config.key => 1 # time = 0 + n
+  
+
+== Credits
+
+Inspired by RConfig (Rahmal Conda) / activeconfig (Enova Financial)

data/lib/config_logic/cache.rb

@@ -0,0 +1,22 @@
+class ConfigLogic::Cache < SimpleDelegator
+  include ConfigLogic::Logger
+  include Enumerable
+
+  def initialize(load_paths, params = {})
+    @load_paths = [load_paths].flatten
+    reload!(params)
+    super(@cache)
+  end
+
+  def reload!(params = {})
+    __setobj__(@cache)
+    self
+  end
+
+  def each
+    @cache.each do |node|
+      yield node
+    end
+  end
+
+end

data/lib/config_logic/config_logic.rb

@@ -0,0 +1,54 @@
+class ConfigLogic < SimpleDelegator
+  extend Forwardable
+
+  def_delegators :@cache, :reload!
+  def_delegators :@data, :inspect
+
+  def initialize(load_paths, params = {})
+    @cache = TreeCache.new(load_paths, params)
+    @path = params[:path] || []
+    @data = @cache[*@path]
+    super(@data)
+  end
+
+  def [](*keys)
+    new_path = @path + keys
+    val = @cache[*new_path] 
+
+    case val
+    when Hash
+      self.clone_with_new_path(new_path)
+    when ConfigLogic::LogicElement
+      val.output
+    else val
+    end
+  end
+
+protected
+
+  def clone_with_new_path(path)
+    clone = self.dup
+    clone.instance_variable_set('@path', path)
+    new_delegate = \
+      clone.instance_variable_set('@data', @cache[*path])
+    clone.__setobj__(new_delegate)
+    clone
+  end
+
+private
+  
+  def method_missing(method_symbol, *args)
+    method_name = method_symbol.to_s
+    element_matcher = ConfigLogic::LogicElement.available_elements.join('|')
+
+    if (val = self[method_symbol])
+      val
+    elsif /^insert_(#{element_matcher})$/ === method_name
+      type = ConfigLogic::LogicElement.name_to_type($1)
+      @cache.insert_logic_element(type.new(args.first), @data) if type
+    else
+      super
+    end
+  end
+
+end

data/lib/config_logic/core_ext/array.rb

@@ -0,0 +1,15 @@
+class Array
+
+  def stringify_symbols
+    self.map { |val| val.is_a?(Symbol) ? val.to_s : val }
+  end
+
+  def symbolize_strings
+    self.map { |val| val.is_a?(Symbol) ? val.to_s : val }
+  end
+
+  def to_hash
+    self.inject({}) { |h, (key, val)| h[key] = val; h }
+  end
+
+end

data/lib/config_logic/core_ext/class.rb

@@ -0,0 +1,7 @@
+class Class
+
+  def simple_name
+    name.split('::').last
+  end
+
+end

data/lib/config_logic/file_cache.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+require 'find'
+
+class ConfigLogic::FileCache < ConfigLogic::Cache
+
+  PARSER_MAP = {
+    ['.yaml', '.yml'] => lambda do |path| YAML::load_file(path) end, 
+    ['.txt']          => lambda do |path| File.read(path) end, 
+    ['.json']         => lambda do |path| end }.freeze
+
+  VALID_EXTENSIONS = PARSER_MAP.map { |(extensions, parser_proc)| extensions }.flatten!.freeze
+
+  def reload!(params = {})
+    @cache = rebuild_primary_cache(params)
+    super
+  end
+
+private
+
+  def rebuild_primary_cache(params)
+    file_cache = []
+    load_file = Proc.new do |path|
+    end
+
+    valid_files = @load_paths.inject([]) do |valid, path| 
+      valid << find_valid_files(path)
+    end.flatten
+
+    valid_files.each do |path|
+      content = parse(path)
+      file_cache << [path, content] if content
+      log.debug "found file #{BLUE} #{path}"
+    end 
+
+    file_cache.inject({}) do 
+      |h, (path, content)| h[path] = content; h
+    end
+  end
+  
+  def find_valid_files(path)
+    valid_files = []
+    Find.find(path) do |file| 
+      valid_files << file if valid_file_ext?(file)
+    end
+    valid_files
+  end
+
+# parsing helpers
+
+  def parse(path)
+    parser = find_parser(path)
+    return unless parser
+
+    begin
+      parser.call(path)
+    rescue => e
+      log.warn "#{RED} #{path} #{RESET} is not a valid config file"
+    end
+  end
+
+  def find_parser(path)
+    parser = PARSER_MAP.detect { |(extensions, parse_proc)| extensions.include?(File.extname(path)) }
+    parser ? parser.last : nil
+  end
+
+# path helpers
+
+  def load_path_exists?(path)
+    unless File.exists?(path)
+      log.warn "#{RED} #{path} #{RESET} does not exist"; false
+    else true end
+  end
+
+  def valid_file_ext?(path)
+    VALID_EXTENSIONS.include?(File.extname(path))
+  end
+
+end

data/lib/config_logic/logger.rb

@@ -0,0 +1,40 @@
+require 'buffered_logger'
+
+class ConfigLogic::Log
+  private_class_method :new
+  LOG_LEVEL = 6
+
+  def self.init_log(log_level, color)
+    @log = BufferedLogger.new(STDOUT, log_level || LOG_LEVEL, default_format)
+    log.disable_color unless color
+  end
+
+  def self.log
+    @log ||=  BufferedLogger.new(STDOUT, LOG_LEVEL, default_format) 
+  end
+
+private
+  
+  def self.default_format
+    { :debug => "$negative DEBUG: $reset %s",
+      :warn  => "$yellow WARNING: $reset %s",
+      :error => "$red ERROR: $reset %s" }
+  end
+
+end
+
+
+module ConfigLogic::Logger
+  module Colors
+    RED   = '$red'
+    BLUE  = '$blue'
+    GREEN = '$green'
+    YELLOW = '$yellow'
+    RESET = '$reset'
+  end
+  include Colors
+
+  def log
+    ConfigLogic::Log.log
+  end
+end

data/lib/config_logic/logic_element.rb

@@ -0,0 +1,62 @@
+require 'set'
+
+class ConfigLogic::LogicElement
+  include ConfigLogic::Logger
+
+  MIN_INPUTS = 2
+  NAME = 'logic_element'
+  STATIC = true
+
+  attr_reader :name, :inputs
+  cattr_reader :min_inputs, :types
+  @@types = Set.new
+  @@min_inputs = MIN_INPUTS
+
+  def initialize(params)
+    @name = params[:name] || NAME
+    @static = params[:static].nil? ? STATIC : params[:static]
+    @inputs = HashWithIndifferentAccess.new
+  end
+
+  def set_input(input_name, value)
+    @inputs[input_name] = value
+  end
+
+  def input_names
+    @inputs.keys
+  end
+
+  def static?
+    @static
+  end
+
+class << self
+
+  def inherited(child)
+    @@types << child
+  end
+
+  def available_elements
+    @@types.map { |t| t.simple_name.downcase }
+  end
+
+  def name_to_type(name)
+    if available_elements.include?(name)
+      ('ConfigLogic::' + name.classify).constantize
+    end
+  end
+
+end
+
+private
+
+  def inputs_valid?
+    input_count = @inputs.values.compact.size
+    if input_count < min_inputs 
+      log.error("number of inputs (#{input_count}) is less than minimum (#{@@min_inputs})") 
+      false
+    else true
+    end
+  end
+
+end

data/lib/config_logic/multiplexer.rb

@@ -0,0 +1,22 @@
+class ConfigLogic::Multiplexer < ConfigLogic::LogicElement
+
+  attr_reader :selector
+
+  def initialize(params)
+    super
+    @multiplexer = params[:inputs]
+    @inputs = HashWithIndifferentAccess.new(@multiplexer.values.to_hash)
+    @selector = params[:selector]
+  end
+
+  def output
+    return unless inputs_valid?
+    case @selector
+    when Proc
+      @inputs[@multiplexer[@selector.call]]
+    else
+      @inputs[@multiplexer[@selector]]
+    end
+  end
+
+end

data/lib/config_logic/overlay.rb

@@ -0,0 +1,24 @@
+class ConfigLogic::Overlay < ConfigLogic::LogicElement
+  
+  attr_reader :order
+
+  def initialize(params)
+    super
+    @order = params[:inputs]
+    @inputs = HashWithIndifferentAccess.new(@order.to_hash)
+  end
+
+  # merge if possible, return highest priority data if not
+  #
+  def output
+    return unless inputs_valid?
+    if @inputs.values.all? { |d| d.is_a? Hash }
+      @order.inject({}) do |output, input_name|
+        output.deep_merge!(@inputs[input_name])
+      end
+    else
+      @inputs[@order.last]
+    end
+  end
+
+end

data/lib/config_logic/tree_cache.rb

@@ -0,0 +1,132 @@
+class ConfigLogic::TreeCache < ConfigLogic::Cache
+
+  def initialize(load_paths, params = {})
+    @global_logic = params.inject([]) do |a, (type_name, elements)|
+      type_name = type_name.to_s.singularize
+      type = ConfigLogic::LogicElement.name_to_type(type_name)
+      type ? a << elements.map { |settings| type.new(settings) } : a
+    end.flatten
+    super
+  end
+
+  def [](*key_path)
+    return @cache if key_path.blank?
+    key_path.inject(@cache) do |val, key|
+      val[key] if val
+    end
+  end
+
+  def reload!(params = {})
+    @cache = rebuild_primary_cache(params)
+    unless @cache.empty?
+      trim_cache! unless params[:no_trim]
+      @flat_cache = flatten_tree_cache
+      apply_global_logic
+    end
+    super
+  end
+
+  def insert_logic_element(element, node)
+    input_names = element.input_names
+    input_names.each do |input_name|
+      element.set_input(input_name, node[input_name])
+    end
+    log.debug "inserted logic element:\n#{element.pretty_inspect}"
+
+    node[element.name] = element.static? ? element.output : element
+    prune!(node, input_names)
+  end
+
+private
+
+  def rebuild_primary_cache(params)
+    file_cache = ConfigLogic::FileCache.new(@load_paths)
+    return {} unless valid_file_cache?(file_cache)
+
+    tree_cache = HashWithIndifferentAccess.new
+    file_cache.each do |path, content|
+      tree_cache = tree_cache.deep_merge(hashify_path(path, content))
+    end
+    tree_cache
+  end
+
+  def hashify_path(path, content)
+    path_keys = split_file_path(path)
+    content = HashWithIndifferentAccess.new({ path_keys.pop => content })
+    path_keys.reverse.inject(content) do |content, key| 
+      HashWithIndifferentAccess.new({ key => content })
+    end
+  end
+
+  def trim_cache!
+    return if @cache.size > 1
+
+    until @cache.size > 1 do
+      @cache = @cache[@cache.keys.first]
+    end
+  end
+
+# node cache helpers
+
+  def flatten_tree_cache
+    flatten = Proc.new do |tree_cache|
+      tree_cache.inject([]) do |hashes, (k,v)|
+        if v.is_a? Hash
+          hashes << v << flatten.call(v)
+        else hashes end
+      end.flatten
+    end
+    flatten.call(@cache) << @cache
+  end
+
+  def nodes_with_keys(keys, min_matches = 1)
+    self.select do |node|
+      node_keys = node.keys
+      node_keys.size - (node_keys - keys).size >= min_matches
+    end
+  end
+
+  def prune!(node, keys)
+    node.reject! { |k, v| keys.include?(k) }
+  end
+
+# logic helpers
+
+  def apply_global_logic
+    @global_logic.each do |element|
+      log.debug "applying #{element.class}: #{[element.name, element.input_names].inspect}"
+      insert_global_logic_element(element)
+    end
+  end
+
+  def insert_global_logic_element(element)
+    matching_nodes = nodes_with_keys(element.input_names, element.min_inputs)
+    log.debug "matching nodes:\n#{matching_nodes.pretty_inspect}"
+    matching_nodes.each do |node|
+      insert_logic_element(element, node)
+    end
+  end
+
+# path helpers
+
+  def split_file_path(path)
+    basename = File.basename(path, '.*')
+    dirname = File.dirname(path)
+    dirname.split('/')[1..-1] << basename
+  end
+
+  def valid_file_cache?(file_cache)
+    if file_cache.empty?
+      log.error "file cache is empty"; false
+    else true end
+  end
+
+# enumerable
+
+  def each
+    @flat_cache.each do |node|
+      yield node
+    end
+  end
+
+end

data/lib/config_logic.rb

@@ -0,0 +1,27 @@
+$: << File.dirname(__FILE__)
+
+require 'rubygems'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/inflector'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/deep_merge'
+require 'buffered_logger'
+require 'forwardable'
+require 'delegate'
+
+class ConfigLogic < SimpleDelegator
+  module Logger; end
+  include ConfigLogic::Logger
+end
+
+require 'config_logic/core_ext/class'
+require 'config_logic/core_ext/array'
+require 'config_logic/logger'
+require 'config_logic/cache'
+require 'config_logic/file_cache'
+require 'config_logic/logic_element'
+require 'config_logic/multiplexer'
+require 'config_logic/overlay'
+require 'config_logic/tree_cache'
+require 'config_logic/config_logic'

data/spec/cache_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic::Cache do
+
+  before :each do
+    @c = ConfigLogic::Cache.new(CONFIG_DIR)
+  end
+
+  it 'should initialize' do
+    @c.should be_an_instance_of(ConfigLogic::Cache)
+  end
+
+  it 'should delegate unknown calls to the cache container' do
+    cache = @c.instance_variable_get('@cache')
+    cache.public_methods(false).each do |m|
+      @c.should respond_to(m)
+    end
+  end
+
+  it 'should be enumerable' do
+    @c.should respond_to(:each)
+  end
+
+end

data/spec/config_logic_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic do
+
+  before :each do
+    @c = ConfigLogic.new(CONFIG_DIR)
+  end
+
+  it 'should initialize' do
+    @c.should be_an_instance_of(ConfigLogic)
+  end
+
+  it 'should delegate unknown calls to cache node pointed to by current path' do
+    node = @c.instance_variable_get('@data')
+    node.public_methods(false).each do |m|
+      @c.should respond_to(m)
+    end
+  end
+
+  it 'should delegate :reload! and :inspect calls to cache' do
+    @c.should respond_to(:reload!)
+    @c.should respond_to(:inspect)
+  end
+
+  it 'should be accessible via different access methods' do
+    @c[:dir1, :config1, :key1, :nestedkey1].should == 1
+    @c[:dir1][:config1][:key1][:nestedkey1].should == 1
+    @c['dir1', 'config1', 'key1', 'nestedkey1'].should == 1
+    @c['dir1']['config1']['key1']['nestedkey1'].should == 1
+    @c.dir1.config1.key1.nestedkey1.should == 1
+  end
+
+  it 'should return ConfigLogic hashes for any path that doesnt point to a simple value' do
+    @c.dir1.should be_a_kind_of(ConfigLogic)
+    @c.dir1.config1.should be_a_kind_of(ConfigLogic)
+    @c.dir1.config1.key1.should be_a_kind_of(ConfigLogic)
+  end
+
+  it 'should apply local overlay elements' do
+    @c.dir1.config1.insert_overlay({:name => :over, :inputs => [:key1, :key2, :key3]})
+    overlayed_result = {"nestedkey1" => 1, "nestedkey2" => 2, "nestedkey3" => 3, 
+                        "nestedkey4" => 4, "nestedkey5" => 5, "nestedkey6" => 6, 
+                        "nestedkey7" => 7, "nestedkey8" => 8, "nestedkey9" => 9}
+    @c[:dir1][:config1][:over].to_hash.should == overlayed_result
+    @c[:dir1][:config1].keys.size.should == 1
+    @c[:dir1][:config2].keys.size.should == 3
+  end
+
+  it 'should apply local multiplexer elements' do
+    @c.dir1.insert_multiplexer({:name => :multi, :selector => 1, :inputs => {1 => :config1, 2 => :config2, 3 => :config3}})
+    multiplexed_result = {"key1"=>{"nestedkey1"=>1, "nestedkey2"=>2, "nestedkey3"=>3},
+                          "key2"=>{"nestedkey4"=>4, "nestedkey5"=>5, "nestedkey6"=>6},
+                          "key3"=>{"nestedkey7"=>7, "nestedkey8"=>8, "nestedkey9"=>9}} 
+    @c[:dir1][:multi].to_hash.should == multiplexed_result
+    @c[:dir1].keys.size.should == 1
+    @c.keys.size.should == 5
+  end
+
+end

data/spec/file_cache_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic::FileCache do
+
+  def find_valid_files(path)
+    valid_files = ConfigLogic::FileCache::VALID_EXTENSIONS.inject([]) do |valid, ext|
+      valid << Dir["#{path}/**/*#{ext}"]
+    end.flatten
+    valid_files.reject { |f| f =~ /syntax_error/ }
+  end
+
+  def cache_valid?(path, cache)
+    cache = cache.keys
+    valid_files = find_valid_files(path)
+    cache.empty?.should be_false
+    cache.each do |cached_file|
+      valid_files.include?(cached_file).should be_true
+    end
+  end
+
+  before :each do
+    @c = ConfigLogic::FileCache.new(CONFIG_DIR)
+  end
+
+  it 'should initialize' do
+    @c.should be_an_instance_of(ConfigLogic::FileCache)
+  end
+
+  it 'should build a valid file cache during initialization' do
+    cache_valid?(CONFIG_DIR, @c.instance_variable_get('@cache')) 
+  end
+
+  it 'should rebuild cache during a reload!' do
+    config_dir = "#{CONFIG_DIR}/dir1"
+    @c.instance_variable_set('@load_paths', [config_dir])
+    @c.reload!
+    cache_valid?(config_dir, @c.instance_variable_get('@cache')) 
+  end
+
+end

data/spec/logic_element_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic::LogicElement do
+
+  before :each do
+    settings = {:name => :a_logic_element}
+    @e = ConfigLogic::LogicElement.new(settings)
+  end
+
+  it 'should initialize' do
+    @e.should be_an_instance_of(ConfigLogic::LogicElement)
+    @e.name.should == :a_logic_element
+    @e.static?.should == true
+  end
+
+  it 'should specify the minimum number of inputs' do
+    @e.class.min_inputs.should == 2
+    @e.min_inputs.should == 2
+  end
+
+  it 'should respond with all registered component types' do
+    (@e.class.available_elements - ['multiplexer', 'overlay']).should == []
+  end
+
+  it 'should set input values' do
+    @e.set_input(:a, 1)
+    @e.set_input(:b, 2)
+    @e.set_input(:c, 3)
+    @e.inputs.should == {'a' => 1, 'b' => 2, 'c' => 3}
+  end
+
+  it 'should determine if the input state is valid' do
+    @e.send(:inputs_valid?).should == false
+    @e.instance_variable_set('@inputs', {'a' => 1, 'b' => 2})
+    @e.send(:inputs_valid?).should == true
+  end
+
+  it 'should convert element name to type' do
+    @e.class.name_to_type('multiplexer').should == ConfigLogic::Multiplexer
+    @e.class.name_to_type('overlay').should == ConfigLogic::Overlay
+  end
+
+end

data/spec/multiplexer_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic::Multiplexer do
+
+  before :each do
+    settings = { :name => :a_multiplexer,
+                 :selector => Proc.new { 1 + 1 },
+                 :inputs => {1 => :a, 2 => :b, 3 => :c} }
+    @m = ConfigLogic::Multiplexer.new(settings)
+    @m.set_input(:a, 10)
+    @m.set_input(:b, 11)
+    @m.set_input(:c, 12)
+  end
+
+  it 'should initialize' do
+    @m.should be_an_instance_of(ConfigLogic::Multiplexer)
+    @m.should be_a_kind_of(ConfigLogic::LogicElement)
+    @m.name.should == :a_multiplexer
+    @m.inputs.should == {'a' => 10, 'b' => 11, 'c' => 12}
+  end
+
+  it 'should return selector proc' do
+    @m.should respond_to(:selector)
+  end
+
+  it 'should correctly multiplex outputs based on selector' do
+    @m.output.should == 11
+  end
+
+end

data/spec/overlay_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic::Overlay do
+
+  before :each do
+    settings = { :name => :an_overlay, :inputs => [:input1, :input2, :input3] } 
+    @e = ConfigLogic::Overlay.new(settings)
+    @e.set_input(:input1, {:a => 1})
+    @e.set_input(:input2, {:b => 2})
+    @e.set_input(:input3, {:a => 2, :c => 3})
+  end
+
+  it 'should initialize' do
+    @e.should be_an_instance_of(ConfigLogic::Overlay)
+    @e.should be_a_kind_of(ConfigLogic::LogicElement)
+    @e.name.should == :an_overlay
+    @e.inputs.should == {'input1' => {'a' => 1}, 
+                         'input2' => {'b' => 2}, 
+                         'input3' => {'a' => 2, 'c' => 3}}
+  end
+
+  it 'should output a propper overlay when all inputs are hashes' do
+    @e.output.should == {'a' => 2, 'b' => 2, 'c' => 3}
+  end
+
+  it 'should output a propper overlay when not all inputs are hashes' do
+    settings = { :name => :an_overlay, :inputs => [:input1, :input2, :input3] } 
+    e = ConfigLogic::Overlay.new(settings)
+    e.set_input(:input1, 1)
+    e.set_input(:input2, {:a => 1})
+    e.set_input(:input3, 3)
+    e.output.should == 3
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$: << File.join(File.dirname(__FILE__), "../lib")
+CONFIG_DIR = File.join(File.dirname(__FILE__), 'config')
+
+require 'rspec'
+require 'config_logic'

data/spec/tree_cache_spec.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe ConfigLogic::TreeCache do
+
+  before :each do
+    @c = ConfigLogic::TreeCache.new(CONFIG_DIR)
+  end
+
+  it 'should initialize' do
+    @c.should be_an_instance_of(ConfigLogic::TreeCache)
+  end
+
+  it 'should build a valid tree cache' do
+    @c.to_hash.keys.sort.should == ['config1', 'config2', 'config3', 'dir1', 'dir4']
+  end
+
+  it 'should rebuild cache during a reload!' do
+    config_dir = "#{CONFIG_DIR}/dir1"
+    @c.instance_variable_set('@load_paths', [config_dir])
+    @c.reload!
+    @c.to_hash.keys.sort.should == ['config1', 'config2', 'config3']
+  end
+
+  it 'should apply global overlay elements' do
+    @c = ConfigLogic::TreeCache.new(CONFIG_DIR, :overlays => [{:name => :over, :inputs => [:key1, :key2, :key3]}] )
+    overlayed_result = {"nestedkey1" => 1, "nestedkey2" => 2, "nestedkey3" => 3,
+                        "nestedkey4" => 4, "nestedkey5" => 5, "nestedkey6" => 6,
+                        "nestedkey7" => 7, "nestedkey8" => 8, "nestedkey9" => 9}
+    @c[:dir1][:config1][:over].to_hash.should == overlayed_result
+    @c[:dir1][:config2][:over].to_hash.should == overlayed_result
+    @c[:dir1][:config3][:over].to_hash.should == overlayed_result
+    @c[:dir1][:config3].keys.size.should == 1
+    @c[:config1][:over].to_hash.should == overlayed_result
+    @c[:config2][:over].to_hash.should == overlayed_result
+    @c[:config3][:over].to_hash.should == overlayed_result
+    @c[:config3].keys.size.should == 1
+  end
+
+  it 'should apply global multiplexer elements' do
+    @c = ConfigLogic::TreeCache.new(CONFIG_DIR, :multiplexers => [{:name => :multi, :selector => 1, :inputs => {1 => :config1, 2 => :config2, 3 => :config3}}])
+    multiplexed_result = {"key1"=>{"nestedkey1"=>1, "nestedkey2"=>2, "nestedkey3"=>3},
+                          "key2"=>{"nestedkey4"=>4, "nestedkey5"=>5, "nestedkey6"=>6},
+                          "key3"=>{"nestedkey7"=>7, "nestedkey8"=>8, "nestedkey9"=>9}} 
+    @c[:dir1][:multi].to_hash.should == multiplexed_result
+    @c[:dir1].keys.size.should == 1
+    @c[:multi].to_hash.should == multiplexed_result
+    @c.keys.size.should == 3
+  end
+
+  it 'should return node at any path' do
+    @c[:dir1, :config1, :key1, :nestedkey1].should == 1
+    @c[:dir1].should be_a_kind_of(Hash)
+    @c[:dir1, :config1, :key1].should be_a_kind_of(Hash)
+  end
+
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: config_logic
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alex Skryl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-17 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: buffered_logger
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.2
+  type: :runtime
+  version_requirements: *id002
+description: An intuitive configuration access layer
+email: rut216@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/config_logic.rb
+- lib/config_logic/logger.rb
+- lib/config_logic/config_logic.rb
+- lib/config_logic/logic_element.rb
+- lib/config_logic/cache.rb
+- lib/config_logic/tree_cache.rb
+- lib/config_logic/file_cache.rb
+- lib/config_logic/multiplexer.rb
+- lib/config_logic/core_ext/array.rb
+- lib/config_logic/core_ext/class.rb
+- lib/config_logic/overlay.rb
+- spec/cache_spec.rb
+- spec/file_cache_spec.rb
+- spec/logic_element_spec.rb
+- spec/multiplexer_spec.rb
+- spec/overlay_spec.rb
+- spec/config_logic_spec.rb
+- spec/spec_helper.rb
+- spec/tree_cache_spec.rb
+- README.rdoc
+- TODO
+has_rdoc: true
+homepage: http://github.com/skryl
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A configuration access layer for Ruby/Rails applications
+test_files: []
+