jlawler-activeconfig 0.1.4 → 0.2.0

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = 'activeconfig'
+    s.author = 'Jeremy Lawler'
+    s.email = 'jlawler@cashnetusa.com'
+    s.homepage = 'http://jlawler.github.com/activeconfig/'
+    s.summary = 'An extremely flexible configuration system'
+    s.authors = ["Jeremy Lawler"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :default => :test
+active_config_multi_paths=[File.expand_path(File.dirname(__FILE__) + "/test/active_config_test_multi/patha"),':',File.expand_path(File.dirname(__FILE__) + "/test/active_config_test_multi/pathb")]
+
+task :rdoc do
+  sh "rm -rf #{File.dirname(__FILE__)}/doc"
+  sh "cd lib && rdoc -o ../doc " 
+end
+task :test do
+  sh "ruby -I lib test/active_config_test.rb"
+  puts "\n\n"
+  exception1,exception2,exception3=nil,nil,nil
+  begin 
+    ENV['ACTIVE_CONFIG_PATH'] =  active_config_multi_paths.join('') 
+    sh "ruby -I lib test/active_config_test_multi.rb"
+  rescue Object => exception1
+  end
+  puts "\n\n"
+  begin 
+    ENV['ACTIVE_CONFIG_PATH'] =  active_config_multi_paths.reverse.join('') 
+    sh "ruby -I lib test/active_config_test_multi.rb"
+    sh "ruby -I lib test/env_test.rb"
+    rescue Object => exception2
+  end
+  x=exception1 ||exception2 
+  raise x if x
+end
+task :cnu_config_test do 
+  sh "ruby -I lib test/cnu_config_test.rb"
+  puts "\n\n"
+  begin
+    ENV['CNU_CONFIG_PATH'] =  cnu_config_multi_paths.join('')
+    sh "ruby -I lib test/cnu_config_test.rb"
+  rescue Object => exception3
+  end
+end
+
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 2

data/bin/active_config

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+=begin rdoc
+
+# Prints info from  to STDOUT.
+#
+# Example:
+#
+#  > active_config httpd.httpd.domain.portal.primary httpd.httpd.domain.frontend.primary
+# portal.cashnetusa.com
+# www.cashnetusa.com
+#
+#  > ACTIVE_CONFIG_OVERLAY=gb active_config httpd.httpd.domain.portal.primary httpd.httpd.domain.frontend.primary
+# portaluk.cashnetusa.com
+# www.quickquid.co.uk
+#
+#  > ACTIVE_CONFIG_OVERLAY=gb RAILS_ENV=production active_config --PRODDB 'database[RAILS_ENV].database'
+# PRODDB=activeapp_dev_uk
+#  > ACTIVE_CONFIG_OVERLAY=us RAILS_ENV=production active_config --PRODDB 'database[RAILS_ENV].database'
+# PRODDB=activeapp_dev
+
+=end
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/lib/ruby')
+
+# Need to remove active_config's dependency on activesupport.
+require 'rubygems'
+gem 'activesupport'
+
+# Yuck!
+RAILS_ENV = ENV['RAILS_ENV'] || 'development'
+
+require 'active_config'
+
+name = ''
+
+ARGV.each do | x |
+  if x =~ /^--(.+)/
+    name = "#{$1}="
+  else 
+    puts(name + (eval(".#{x}").to_s))
+  end
+end
+
+exit 0
+

data/lib/active_config/hash_config.rb

@@ -0,0 +1,110 @@
+class ActiveConfig
+  class HashConfig < HashWithIndifferentAccess
+    # HashWithIndifferentAccess#dup always returns HashWithIndifferentAccess!
+    # -- kurt 2007/10/18
+    def dup
+      self.class.new(self)
+    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
+      # STDERR.puts "CHF#method_missing(#{method.inspect}, #{args.inspect}) on #{self.inspect}:#{self.class}" if method == 'dup'
+      value = self[method]
+      case args.size
+        when 0:
+          # e.g.: ActiveConfig.global.method
+          ;
+        when 1:
+          # e.g.: ActiveConfig.global.method(one_arg)
+          value = value.send(args[0])
+        else
+          # e.g.: ActiveConfig.global.method(arg_one, args_two, ...)
+          value = value[args]
+      end
+      # value =  convert_value(value)
+      value
+    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
+    
+    ## 
+    # HashWithIndifferentAccess#update is broken!
+    # This took way too long to figure this out:
+    #
+    # Hash#update returns self,
+    # BUT,
+    # HashWithIndifferentAccess#update does not!
+    #
+    #   { :a => 1 }.update({ :b => 2, :c => 3 }) 
+    #   => { :a => 1, :b => 2, :c => 3 }
+    #
+    #   HashWithIndifferentAccess.new({ :a => 1 }).update({ :b => 2, :c => 3 })
+    #   => { :b => 2, :c => 3 } # WTF?
+    #
+    # Subclasses should *never* override methods and break their protocols!!!!
+    # -- kurt 2007/03/28
+    #
+    def update(hash)
+      super(hash)
+      self
+    end
+
+    ## 
+    # Override WithIndifferentAccess#convert_value
+    # return instances of this class for Hash values.
+    #
+    def convert_value(value)
+      # STDERR.puts "convert_value(#{value.inspect}:#{value.class})"
+      if value.class == Hash
+        value = self.class.new(value)
+        value.freeze if self.frozen?
+      end
+      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,85 @@
+class ActiveConfig
+  class HashWithHooks < HashWithIndifferentAccess
+    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|return (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, :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