activeconfig 0.5.5

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+end

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+
+require 'rubygems'
+
+#require 'rubygems/package_task'
+require 'jeweler'
+Jeweler::Tasks.new do |s|
+  s.name = 'activeconfig'
+  s.author = 'Jeremy Lawler'
+  s.email = 'jeremylawler@gmail.com'
+  s.homepage = 'http://jlawler.github.com/activeconfig/'
+  s.summary = 'An extremely flexible configuration system'
+  s.description = 'An extremely flexible configuration system.
+s the ability for certain values to be "overridden" when conditions are met.
+r example, you could have your production API keys only get read when the Rails.env == "production"'
+  s.authors = ["Jeremy Lawler"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+
+task :rdoc do
+  sh "rm -rf #{File.dirname(__FILE__)}/doc"
+  sh "cd lib && rdoc -o ../doc " 
+end
+
+task :test do 
+  Dir['*/*_test.rb'].each do |f|
+    puts `ruby -I lib #{f}`
+  end
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,5 @@
+---
+:major: 0
+:minor: 5
+:patch: 5
+:build: 

data/activeconfig.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "activeconfig"
+  s.version = "0.5.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jeremy Lawler"]
+  s.date = "2012-05-30"
+  s.description = "An extremely flexible configuration system.\ns the ability for certain values to be \"overridden\" when conditions are met.\nr example, you could have your production API keys only get read when the Rails.env == \"production\""
+  s.email = "jeremylawler@gmail.com"
+  s.executables = ["active_config"]
+  s.files = [
+    "Gemfile",
+    "Rakefile",
+    "VERSION.yml",
+    "activeconfig.gemspec",
+    "bin/active_config",
+    "lib/active_config.rb",
+    "lib/active_config/hash_config.rb",
+    "lib/active_config/hash_weave.rb",
+    "lib/active_config/suffixes.rb",
+    "pkg/activeconfig-0.1.4.gem",
+    "pkg/activeconfig-0.2.0.gem",
+    "pkg/activeconfig-0.3.0.gem",
+    "pkg/activeconfig-0.4.0.gem",
+    "pkg/activeconfig-0.4.1.gem",
+    "pkg/activeconfig-0.5.0.gem",
+    "pkg/activeconfig-0.5.1.gem",
+    "test/active_config_collision_test.rb",
+    "test/active_config_multi_test.rb",
+    "test/active_config_test.rb",
+    "test/active_config_test/global.yml",
+    "test/active_config_test/test.yml",
+    "test/active_config_test/test_GB.yml",
+    "test/active_config_test/test_US.yml",
+    "test/active_config_test/test_config.yml",
+    "test/active_config_test/test_local.yml",
+    "test/active_config_test/test_production.yml",
+    "test/active_config_test_collision/patha/test.yml",
+    "test/active_config_test_collision/pathb/test.yml",
+    "test/active_config_test_collision/pathb/test_local.yml",
+    "test/active_config_test_multi/patha/test.yml",
+    "test/active_config_test_multi/pathb/test_local.yml",
+    "test/env_test.rb"
+  ]
+  s.homepage = "http://jlawler.github.com/activeconfig/"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "An extremely flexible configuration system"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+    else
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    end
+  else
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+  end
+end
+

data/bin/active_config

@@ -0,0 +1,44 @@
+#!/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')
+
+require 'rubygems'
+
+# 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.rb

@@ -0,0 +1,384 @@
+require 'socket'
+require 'yaml'
+require 'active_config/hash_weave' # Hash#weave
+require 'rubygems'
+require 'active_config/hash_config'
+require 'active_config/suffixes'
+require 'erb'
+
+
+##
+# See LICENSE.txt for details
+#
+#=ActiveConfig
+#
+# * Provides dottable, hash, array, and argument access to YAML 
+#   configuration files
+# * Implements multilevel caching to reduce disk accesses
+# * Overlays multiple configuration files in an intelligent manner
+#
+# Config file access example:
+#  Given a configuration file named test.yaml and test_local.yaml
+#  test.yaml:
+# ...
+# hash_1:
+#   foo: "foo"
+#   bar: "bar"
+#   bok: "bok"
+
+# ...
+# test_local.yaml:
+# ...
+# hash_1:
+#   foo: "foo"
+#   bar: "baz"
+#   zzz: "zzz"
+# ...
+#
+#  irb> ActiveConfig.test
+#  => {"array_1"=>["a", "b", "c", "d"], "perform_caching"=>true,
+#  "default"=>"yo!", "lazy"=>true, "hash_1"=>{"zzz"=>"zzz", "foo"=>"foo",
+#  "bok"=>"bok", "bar"=>"baz"}, "secure_login"=>true, "test_mode"=>true}
+#
+#  --Notice that the hash produced is the result of merging the above
+#  config files in a particular order
+#
+#  The overlay order of the config files is defined by ActiveConfig._get_file_suffixes:
+#  * nil
+#  * _local
+#  * _config
+#  * _local_config
+#  * _{environment} (.i.e _development)
+#  * _{environment}_local (.i.e _development_local)
+#  * _{hostname} (.i.e _whiskey)
+#  * _{hostname}_config_local (.i.e _whiskey_config_local)
+#
+#  ------------------------------------------------------------------
+#  irb> ActiveConfig.test_local
+#  => {"hash_1"=>{"zzz"=>"zzz", "foo"=>"foo", "bar"=>"baz"}, "test_mode"=>true} 
+#
+
+class ActiveConfig
+  class ActiveConfig::DuplicateConfig < Exception; end
+  EMPTY_ARRAY = [ ].freeze unless defined? EMPTY_ARRAY
+  def _suffixes
+    @suffixes_obj
+  end
+  # ActiveConfig.new take options from a hash (or hash like) object.
+  # Valid keys are:
+  #   :path           :  Where it can find the config files, defaults to ENV['ACTIVE_CONFIG_PATH'], or RAILS_ROOT/etc
+  #   :root_file      :  Defines the file that holds "top level" configs. (ie active_config.key).  Defaults to "global"
+  #   :suffixes       :  Either a suffixes object, or an array of suffixes symbols with their priority.  See the ActiveConfig::Suffixes object
+  #   :config_refresh :  How often we should check for update config files
+  #
+  #                 
+  #FIXME TODO
+  def initialize opts={}
+    @config_path=opts[:path] || ENV['ACTIVE_CONFIG_PATH'] || (defined?(RAILS_ROOT) ? File.join(RAILS_ROOT,'etc') : nil)
+    @opts=opts
+    if opts[:one_file]
+      @root_file=@config_path 
+    else
+    @root_file=opts[:root_file] || 'global' 
+      if ActiveConfig::Suffixes===opts[:suffixes]
+        @suffixes_obj = opts[:suffixes] 
+      end
+    end
+    @suffixes_obj ||= Suffixes.new self, opts[:suffixes]
+    @suffixes_obj.ac_instance=self
+    @config_refresh = 
+      (opts.has_key?(:config_refresh) ? opts[:config_refresh].to_i : 300)
+    @on_load = { }
+    self._flush_cache
+    dups_h=Hash.new{|h,e|h[e]=[]}
+    self._config_path.map{|e|
+      if File.exists?(e) and File.directory?(e)
+        Dir[e + '/*'].map{|f|
+          if File.file?(f)
+            dups_h[File.basename(f)] << f
+          end
+        }
+      else
+        STDERR.puts "WARNING:  Active Config Path NOT FOUND #{e}" unless opts[:quiet]
+      end
+    }
+    dups = dups_h.to_a.select{|k,v|v.size>=2}
+    raise ActiveConfig::DuplicateConfig.new(dups.map{|e|"Duplicate file #{e.first} found in \n#{e.last.map{|el|"\t"+el}.join("\n")}"}.join("\n")) if dups.size>0
+  end
+  def _config_path
+    @config_path_ary ||=
+      begin
+        path_sep = (@config_path =~ /;/) ? /;/ : /:/ # Make Wesha happy
+        path = @config_path.split(path_sep).reject{ | x | x.empty? }
+        path.map!{|x| x.freeze }.freeze
+      end
+  end
+
+  # DON'T CALL THIS IN production.
+  def _flush_cache *types
+    if types.size == 0 or types.include? :hash
+      @cache_hash = { }
+      @hash_times = Hash.new(0)
+    end
+    if types.size == 0 or types.include? :file
+      @file_times = Hash.new(0)
+      @file_cache = { }
+    end
+    self
+  end
+
+  def _reload_disabled=(x)
+    @reload_disabled = x.nil? ? false : x
+  end
+
+  def _reload_delay=(x)
+    @config_refresh = x || 300
+  end
+
+  def _verbose=(x)
+    @verbose = x.nil? ? false : x;
+  end
+
+  ##
+  # Get each config file's yaml hash for the given config name, 
+  # to be merged later. Files will only be loaded if they have 
+  # not been loaded before or the files have changed within the 
+  # last five minutes, or force is explicitly set to true.
+  #
+  # If file contains the comment:
+  #
+  #   # ACTIVE_CONFIG:ERB
+  #
+  # It will be run through ERb before YAML parsing
+  # with the following object bound:
+  #
+  #   active_config.config_file => <<the name of the config.yml file>>
+  #   active_config.config_directory => <<the directory of the config.yml>>
+  #   active_config.config_name => <<the config name>>
+  #   active_config.config_files => <<Array of config files to be parsed>>
+  #
+  def _load_config_files(name, force=false)
+    name = name.to_s
+    now = Time.now
+
+    # Get array of all the existing files file the config name.
+    config_files = _config_files(name)
+    
+    #$stderr.puts config_files.inspect
+    # Get all the data from all yaml files into as hashes
+    _fire_on_load(name)
+    hashes = config_files.collect do |f|
+      filename=f
+      val=nil
+      mod_time=nil
+      next unless File.exists?(filename)
+      next(@file_cache[filename]) unless (mod_time=File.stat(filename).mtime) != @file_times[filename]
+      begin
+      File.open( filename ) { | yf |
+        val = yf.read
+      }
+      # If file has a # ACTIVE_CONFIG:ERB comment,
+      # Process it as an ERb first.
+      if /^\s*#\s*ACTIVE_CONFIG\s*:\s*ERB/i.match(val)
+        # Prepare a object visible from ERb to
+        # allow basic substitutions into YAMLs.
+        active_config = HashConfig.new({
+          :config_file => filename,
+          :config_directory => File.dirname(filename),
+          :config_name => name,
+          :config_files => config_files,
+        })
+        val = ERB.new(val).result(binding)
+      end
+      # Read file data as YAML.
+      val = YAML::load(val)
+      # STDERR.puts "ActiveConfig: loaded #{filename.inspect} => #{val.inspect}"
+      (@config_file_loaded ||= { })[name] = config_files
+      rescue Exception => e
+        raise
+      end
+      @file_cache[filename]=val
+      @file_times[filename]=mod_time
+      @file_cache[filename]
+    end
+    hashes.compact
+  end
+
+
+  def get_config_file(name)
+    # STDERR.puts "get_config_file(#{name.inspect})"
+    name = name.to_s # if name.is_a?(Symbol)
+    now = Time.now
+    return @cache_hash[name.to_sym] if 
+      (now.to_i - @hash_times[name.to_sym]  < @config_refresh) 
+    # return cached if we have something cached and no reload_disabled flag
+    return @cache_hash[name.to_sym] if @cache_hash[name.to_sym] and @reload_disabled
+    # $stderr.puts "NOT USING CACHED AND RELOAD DISABLED" if @reload_disabled
+    @cache_hash[name.to_sym]=begin
+      x = _config_hash(name)
+      @hash_times[name.to_sym]=now.to_i
+      x
+    end
+  end
+
+  ## 
+  # Returns a list of all relavant config files as specified
+  # by the suffixes object.
+  def _config_files(name) 
+    return [name] if File.exists?(name) and not File.directory?(name)
+    _suffixes.for(name).inject([]) do | files,name_x |
+      _config_path.reverse.inject(files) do |files, dir |
+        files <<  File.join(dir, name_x.to_s + '.yml')
+      end
+    end
+  end
+
+  def _config_hash(name)
+    unless result = @cache_hash[name]
+      result = @cache_hash[name] = 
+        HashConfig._make_indifferent_and_freeze(
+          _load_config_files(name).inject({ }) { | n, h | n.weave(h, false) })
+    end
+    #$stderr.puts result.inspect
+    result
+  end
+
+
+  ##
+  # Register a callback when a config has been reloaded.
+  #
+  # The config :ANY will register a callback for any config file change.
+  #
+  # Example:
+  #
+  #   class MyClass 
+  #     @my_config = { }
+  #     ActiveConfig.on_load(:global) do 
+  #       @my_config = { } 
+  #     end
+  #     def my_config
+  #       @my_config ||= something_expensive_thing_on_config(ACTIVEConfig.global.foobar)
+  #     end
+  #   end
+  #
+  def on_load(*args, &blk)
+    args << :ANY if args.empty?
+    proc = blk.to_proc
+
+    # Call proc on registration.
+    proc.call()
+
+    # Register callback proc.
+    args.each do | name |
+      name = name.to_s
+      (@on_load[name] ||= [ ]) << proc
+    end
+  end
+
+  # Do reload callbacks.
+  def _fire_on_load(name)
+    callbacks = 
+      (@on_load['ANY'] || EMPTY_ARRAY) + 
+      (@on_load[name] || EMPTY_ARRAY)
+    callbacks.uniq!
+    STDERR.puts "_fire_on_load(#{name.inspect}): callbacks = #{callbacks.inspect}" if @verbose && ! callbacks.empty?
+    callbacks.each do | cb |
+      cb.call()
+    end
+  end
+
+  def _check_config_changed(iname=nil)
+    iname=iname.nil? ?  @cache_hash.keys.dup : [*iname]
+    ret=iname.map{ | name |
+    # STDERR.puts "ActiveConfig: config changed? #{name.inspect} reload_disabled = #{@reload_disabled}" if @verbose
+    if config_changed?(name) && ! @reload_disabled 
+      STDERR.puts "ActiveConfig: config changed #{name.inspect}" if @verbose
+      if @cache_hash[name]
+        @cache_hash[name] = nil
+
+        # force on_load triggers.
+        name
+      end
+    end
+    }.compact
+    return nil if ret.empty?
+    ret
+  end
+
+  def with_file(name, *args)
+    # STDERR.puts "with_file(#{name.inspect}, #{args.inspect})"; result = 
+    args.inject(get_config_file(name)) { | v, i | 
+      # STDERR.puts "v = #{v.inspect}, i = #{i.inspect}"
+      case v
+      when Hash
+        v[i.to_s]
+      when Array
+        i.is_a?(Integer) ? v[i] : nil
+      else
+        nil
+      end
+    }
+    # STDERR.puts "with_file(#{name.inspect}, #{args.inspect}) => #{result.inspect}"; result
+  end
+ 
+  #If you are using this in production code, you fail.
+  def reload(force = false)
+    if force || ! @reload_disabled
+      _flush_cache
+    end
+    nil
+  end
+
+  ## 
+  # Disables any reloading of config,
+  # executes &block, 
+  # calls check_config_changed,
+  # returns result of block
+  #
+  def disable_reload(&block)
+    # This should increment @reload_disabled on entry, decrement on exit.
+    # -- kurt 2007/06/12
+    result = nil
+    reload_disabled_save = @reload_disabled
+    begin
+      @reload_disabled = true
+      result = yield
+    ensure
+      @reload_disabled = reload_disabled_save
+      _check_config_changed unless @reload_disabled
+    end
+    result
+  end
+
+  ##
+  # Gets a value from the global config file
+  #
+  def [](key, file=@root_file)
+    get_config_file(file)[key]
+  end
+
+  ##
+  # Short-hand access to config file by its name.
+  #
+  # Example:
+  #
+  #   ActiveConfig.global(:foo) => ActiveConfig.with_file(:global).foo
+  #   ActiveConfig.global.foo   => ActiveConfig.with_file(:global).foo
+  #
+  def method_missing(method, *args)
+    return self[method.to_sym] if @opts[:one_file] 
+    if method.to_s=~/^_(.*)/
+      _flush_cache 
+      return @suffixes.send($1, *args)
+    else 
+      if @root_file && rf=get_config_file(@root_file)      
+        if rf.has_key?(method.to_sym) || rf.has_key?(method.to_s)
+          return with_file(@root_file).send(method,*args)
+        end
+      end
+      value = with_file(method, *args)
+      value
+    end
+  end
+end
+