activeconfig 0.5.5

data/lib/active_config/hash_config.rb

@@ -0,0 +1,213 @@
+
+class ActiveConfig
+  class HashConfig < Hash
+  def initialize(constructor = {})
+    super()
+    update(constructor)
+  end
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # Updates the instantized hash with values from the second:
+  # 
+  #   hash_1 = HashWithIndifferentAccess.new
+  #   hash_1[:key] = "value"
+  # 
+  #   hash_2 = HashWithIndifferentAccess.new
+  #   hash_2[:key] = "New Value!"
+  # 
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  # 
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    self.class.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+
+    # HashWithIndifferentAccess#dup always returns HashWithIndifferentAccess!
+    # -- kurt 2007/10/18
+    def dup
+      self.class.new(self)
+    end
+
+    def self._make_indifferent_and_freeze(x)
+      _make_indifferent(x,:freeze => true)
+    end
+    def freeze!
+      return false if self.frozen?
+      self.each_pair do | k, v |
+        self[self.class.recursive_freeze(k)] = self.class.recursive_freeze(v) 
+      end
+      self.freeze
+      self 
+    end
+    def self.recursive_freeze x
+      return x if x.frozen?
+      case x
+      when HashConfig,Hash
+          x.each_pair do | k, v |
+            x[recursive_freeze(k)] = recursive_freeze(v) 
+          end
+      when Array
+        x.collect! {|v|freeze(v)}
+      end
+      x.freeze 
+    end
+    def self._make_indifferent(x,opts={})
+      return x if  opts[:freeze] and x.frozen?
+      case x
+      when HashConfig
+          x.each_pair do | k, v |
+            x[k.freeze] = _make_indifferent(v,opts)
+          end
+      when Hash
+        x = HashConfig.new.merge(x)
+        x.each_pair do | k, v |
+          x[k.freeze] = _make_indifferent(v,opts)
+        end
+        # STDERR.puts "x = #{x.inspect}:#{x.class}"
+      when Array
+        x.collect!  do | v |
+          _make_indifferent(v,opts)
+        end
+      end
+
+      x.freeze if opts[:freeze]
+      x
+    end
+
+    # dotted notation can now be used with arguments (useful for creating mock objects)
+    # in the YAML file the method name is a key (just like usual), argument(s)
+    # form a nested key, and the value will get returned.
+    #
+    # For example loading to variable foo a yaml file that looks like:
+    # customer:
+    #   id: 12345678
+    #   verified:
+    #     phone: verified
+    #     :address: info_not_available
+    #     ? [name, employer]
+    #     : not_verified
+    # 
+    # Allows the following calls:
+    # foo.customer.id   --> 12345678
+    # foo.customer.verified.phone  --> verified
+    # foo.customer.verified("phone")  --> verified
+    # foo.customer.verified("name", "employer")  --> not_verified
+    # foo.customer.verified(:address) --> info_not_available
+    #
+    # Note that :address is specified as a symbol, where phone is just a string.
+    # Depending on what kind of parameter the method being mocked out is going 
+    # to be called with, define in the YAML file either a string or a symbol.  
+    # This also works inside the composite array keys.
+    def method_missing(method, *args)
+      method = method.to_s
+      if args.size==1 and method.to_s=~/=$/
+        return  self[method.to_s.sub(/=$/,'')]=args[0]
+      end
+      args.inject(self[method]){|s,e|s and s[e]}
+    end
+    
+    ## 
+    # Why the &*#^@*^&$ isn't HashWithIndifferentAccess actually doing this?
+    #
+    def [](key)
+      key = key.to_s if key.kind_of?(Symbol)
+      super(key)
+    end
+
+    # HashWithIndifferentAccess#default is broken!
+    define_method(:default_Hash, Hash.instance_method(:default))
+
+    ##
+    # Allow hash.default => hash['default']
+    # without breaking Hash's usage of default(key)
+    #
+    @@no_key = [ :no_key ] # magically unique value.
+    def default(key = @@no_key)
+      key = key.to_s if key.is_a?(Symbol)
+      key == @@no_key ? self['default'] : default_Hash(key == @@no_key ? nil : key)
+    end
+    
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      return value
+    end
+
+  end
+end

data/lib/active_config/hash_weave.rb

@@ -0,0 +1,72 @@
+unless Hash.instance_methods.include? 'weave'
+class Hash
+  # source: http://rubyforge.org/projects/facets/
+  # version: 1.7.46
+  # license: Ruby License
+  # NOTE: remove this method if the Facets gem is installed.
+  # BUG: weave is destructive to values in the source hash that are arrays!
+  #      (this is acceptable for our use as the basis for weave!)
+  # -------------------------------------------------------------
+  # Weaves two hashes producing a new hash. The two hashes need
+  # to be compatible according to the following rules for each node:
+  #
+  #   <tt>
+  #   hash, hash => hash (recursive +)
+  #   hash, array => error
+  #   hash, value => error
+  #   array, hash => error
+  #   array, array => array + array
+  #   array, value => array << value
+  #   value, hash => error
+  #   value, array => array.unshift(valueB)
+  #   valueA, valueB => valueB
+  #   </tt>
+  #
+  # Example:
+  #
+  #   # to do
+  #
+  def weave(h, dont_clobber=true)
+    return self unless h
+    raise ArgumentError, "Hash expected" unless h.kind_of?(Hash)
+    s = self.dup # self.clone does not remove freeze!
+    h.each { |k,node|
+      node_is_hash = node.kind_of?(Hash)
+      node_is_array = node.kind_of?(Array)
+      if s.has_key?(k)
+        self_node_is_hash = s[k].kind_of?(Hash)
+        self_node_is_array = s[k].kind_of?(Array)
+        if self_node_is_hash
+          if node_is_hash
+            s[k] = s[k].weave(node, dont_clobber)
+          elsif node_is_array
+            dont_clobber ? raise(ArgumentError, "{} <= [] is a tad meaningless") : s[k] = node
+          else
+            s[k] = node
+          end
+        elsif self_node_is_array
+          if node_is_hash
+            dont_clobber ? s[k] = s[k] << node : s[k] = node
+          elsif node_is_array
+            dont_clobber ? s[k] += node : s[k] = node
+          else
+            dont_clobber ? s[k] = s[k] << node : s[k] = node
+          end
+        else
+          if node_is_hash
+            s[k] = node
+          elsif node_is_array
+            dont_clobber ? s[k].unshift( node ) : s[k] = node
+          else
+            s[k] = node
+          end
+        end
+      else
+        s[k] = node
+      end
+    }
+    s
+  end
+  def weave!(h, dont_clobber = true) self.merge! self.weave(h, dont_clobber) end
+end
+end

data/lib/active_config/suffixes.rb

@@ -0,0 +1,86 @@
+class ActiveConfig
+  class HashWithHooks < HashConfig 
+    attr_accessor :write_hooks
+    alias_method :regular_writer_hwh, :regular_writer unless method_defined?(:regular_writer_hwh)
+    def write_hooks
+      @write_hooks||=[]
+    end
+    def regular_writer *args 
+      write_hooks.each{|p|p.call}
+      regular_writer_hwh(*args)
+    end
+    def add_write_hook func=nil,&block
+      self.write_hooks||=[]
+      self.write_hooks << func if Proc===func
+      self.write_hooks << block if Kernel.block_given?
+    end
+  end
+  class Suffixes
+    attr_writer :priority
+    attr_accessor :ac_instance
+    attr :symbols
+
+    def overlay= new_overlay
+      ac_instance._flush_cache
+      @symbols[:overlay]=(new_overlay.respond_to?(:upcase) ? new_overlay.upcase : new_overlay)
+    end
+    def initialize(*args)
+      ac_instance=args.shift
+      @symbols=HashWithHooks.new
+      @symbols[:hostname]=proc {|sym_table| ENV['ACTIVE_CONFIG_HOSTNAME'] ||
+       Socket.gethostname
+      } 
+      @symbols[:hostname_short]=proc {|sym_table| sym_table[:hostname].call(sym_table).sub(/\..*$/, '').freeze}
+      @symbols[:rails_env]=proc { |sym_table| (RAILS_ENV if defined?(RAILS_ENV))||ENV['RAILS_ENV']}
+      @symbols[:overlay]=proc { |sym_table| ENV['ACTIVE_CONFIG_OVERLAY']}
+      @symbols.add_write_hook do
+        ac_instance.flush_cache
+      end
+      @priority=[
+       nil,
+       :rails_env,
+       [:rails_env,:local],
+       :overlay,
+       [:overlay,:local],
+       [:hostname_short],
+       [:hostname_short, :local],
+       :hostname,
+       [:hostname, :local],
+       :local,
+      ]
+    end
+    def method_missing method, val=nil 
+      super if method.to_s=~/^_/
+      if method.to_s=~/^(.*)=$/
+        ac_instance._flush_cache
+        return @symbols[$1]=val
+      end      
+      ret=@symbols[method]
+      if ret 
+        return ret.call(@symbols) if ret.respond_to?(:call)
+        return ret
+      end
+      super
+    end
+    def for file
+      suffixes.map { |this_suffix| [file,*this_suffix].compact.join('_')}.compact.uniq
+    end
+    def suffixes ary=@priority
+      ary.map{|e|
+        if Array===e
+          t=self.suffixes(e).compact
+          t.size > 0 ? t.join('_') : nil
+        elsif @symbols[e]
+          method_missing(e)
+        else
+          e && e.to_s
+        end
+      }
+    end
+    def file fname
+      suffixes.map{|m|m="#{m}" if m
+"#{fname}#{m}.yml"
+}
+    end
+  end
+end

data/test/active_config_collision_test.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path("../../lib",__FILE__)
+ENV['ACTIVE_CONFIG_PATH']=[File.expand_path("../active_config_test_collision/patha",__FILE__),File.expand_path("../active_config_test_collision/pathb",__FILE__)].join(':')
+
+
+# even if a gem is installed, load cnu_config and active_config locally
+dir = File.dirname __FILE__
+$LOAD_PATH.unshift File.join(dir, "..", "lib")
+
+# Configure ActiveConfig to use our test config files.
+RAILS_ENV = 'development'
+ENV.delete('ACTIVE_CONFIG_OVERLAY') # Avoid gb magic.
+
+# Test environment.
+require 'rubygems'
+
+# Test target
+require 'active_config'
+
+# Test dependencies
+require 'test/unit'
+
+
+
+
+
+class ActiveConfig::TestMulti < Test::Unit::TestCase
+
+
+  def teardown
+    super
+  end
+
+  def test_collision
+    assert_raise ActiveConfig::DuplicateConfig do
+     ActiveConfig.new
+    end
+  end  
+
+end

data/test/active_config_multi_test.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path("../../lib",__FILE__)
+ENV['ACTIVE_CONFIG_PATH']=[File.expand_path("../active_config_test_multi/patha",__FILE__),File.expand_path("../active_config_test_multi/pathb",__FILE__)].join(':')
+
+# TEST_CONFIG_BEGIN
+# enabled: true
+# TEST_CONFIG_END
+
+# Test target dependencies
+
+# even if a gem is installed, load cnu_config and active_config locally
+dir = File.dirname __FILE__
+$LOAD_PATH.unshift File.join(dir, "..", "lib")
+
+# Configure ActiveConfig to use our test config files.
+RAILS_ENV = 'development'
+ENV.delete('ACTIVE_CONFIG_OVERLAY') # Avoid gb magic.
+
+# Test environment.
+require 'rubygems'
+
+# Test target
+require 'active_config'
+
+# Test dependencies
+require 'test/unit'
+require 'fileutils' # FileUtils.touch
+require 'benchmark'
+
+
+
+
+
+class ActiveConfig::TestMulti < Test::Unit::TestCase
+  def active_config
+    @active_config||=ActiveConfig.new
+  end
+  def setup
+    super
+    begin
+      active_config._flush_cache
+      active_config._verbose = nil # default
+      active_config.reload(true)
+      active_config._reload_disabled = nil # default
+      active_config._reload_delay = nil # default
+    rescue => err
+      # NOTHING
+    end
+  end
+
+
+  def teardown
+    super
+  end
+
+  def test_multi
+      assert_equal  "WIN",  active_config.test.default
+  end  
+
+end