simpleconfig 1.0.2

data/README.textile

@@ -0,0 +1,158 @@
+Simple Config is a plugin designed to make application-wide configuration settings easy to set and access in an object-oriented fashion.
+
+Rails already provides a way of configuring the framework on a per-environment basis but other than global variables/constants set in each environment file or environment.rb, there isn't a built-in way of providing application-specific settings.
+
+One simple solution is to simply put all of your app configuration into a YAML file and load this somewhere in your environment, but here at Reevoo we wanted something a little bit more flexible that we could use across all of our applications and Simple Config is what we came up with.
+
+h2. Getting started
+
+The plugin comes with a rake task to get you up and running quickly, so start by running that.
+
+  $ rake simple_config:setup
+
+This will create a config/settings folder and a blank settings file for each of the main Rails environments. It will also create a copy of the SimpleConfig initializer  in config/initializers/configuration.rb[1].
+
+Now, if you open up the configuration.rb initializer, you will see something like this:
+
+<pre><code class="ruby">
+SimpleConfig.for :application do
+
+  # your app configuration here
+  
+  load File.join(RAILS_ROOT, 'config', "settings", "#{RAILS_ENV}.rb"), :if_exists? => true
+  load File.join(RAILS_ROOT, 'config', "settings", "local.rb"),        :if_exists? => true
+  
+end
+</code></pre>
+
+This is where you can set any configuration variables that are required across all Rails environments. The <code>load</code> method works just like Ruby's built-in load method, except the contents of the file it loads are evaluated within the context of the <code>SimpleConfig.for</code> block. The <code>:if_exists?</code> flag, when set to true, means that the file will only be loaded if it exists, otherwise it will simply be ignored.
+
+Variables can be overwritten, and are defined in the order that they are loaded, so you can set up default values in the above file and override them in the environment files.
+
+As well as loading a settings file for your current Rails environment, a file called "local.rb" is loaded which is designed as a place for you to override variables specific to your own development environment -- you can just keep a copy of this locally without having to check it into your version control system[2].
+
+h2. Variables
+
+h3. Setting Variables
+
+Setting variables is simple and will be familiar to anybody who has used Capistrano. Whether in your main <code>SimpleConfig.for</code> block in configuration.rb, or one of your external settings files, use the <code>set</code> method:
+
+<pre><code class="ruby">
+SimpleConfig.for :application do
+  set :my_variable, 'hello world'
+end
+</code></pre>
+
+SimpleConfig also supports a form of namespacing that allows you to group logical sets of variables together:
+
+<pre><code class="ruby">
+SimpleConfig.for :application do
+  group :awesome_stuff do
+    set :my_variable, 'hello world'
+  end
+end
+</code></pre>
+
+Both the <code>set</code> and <code>load</code> methods are available within <code>group</code> blocks and files loaded inside groups will be evaluated in the context of that group.
+
+Whilst I'd recommend not nesting your groups more than one-level, there is no limit on how deep they can be nested.
+
+h3. Unsetting variables
+
+Sometimes you might want to completely delete a variable from the collection. Simply setting its value to nil doesn't work because <code>nil</code> might be a valid value.
+You can delete a variable using the <code>unset</code> method.
+
+<pre><code class="ruby">
+SimpleConfig.for :application do
+  set :my_variable, 'hello world'
+  
+  ...
+  
+  unset :my_variable
+end
+</code></pre>
+
+For instance, this is useful to remove global settings at environment level instead of overwriting the default value with a nonsense-one.
+<code>unset</code> returns the value of the variable just in case you need to use it elsewhere.
+
+h3. Does a specific variable exist?
+
+I don't know but you can check it yourself using <code>exists?</code> method.
+
+<pre><code class="ruby">
+config = SimpleConfig.for :application do
+  set :my_variable, 'hello world'
+end
+
+# write some nice code 
+config.exists? :my_variable     # => true
+config.exists? :your_variable   # => false
+</code></pre>
+
+h2. Accessing your configuration
+
+SimpleConfig allows you set as many separate configurations as you like using the <code>SimpleConfig.for</code> method, which takes a symbol representing the configuration name, although most people will just create a single "application" config as above. To access this config from anywhere in your application, you can also use <code>SimpleConfig.for</code> method without a block, which always returns the named configuration object.
+
+It is worth pointing out that <code>SimpleConfig.for</code> provides an almost singleton-style access to a particular named config. Calling <code>SimpleConfig.for</code> with a block a second time for a particular named configuration will simply extend the existing configuration, not overwrite it.
+
+Once you have a reference to your configuration object, you can access variables using method access. Given the above example, <code>:my_variable</code> would be accessed in the following way:
+
+<pre><code class="ruby">
+config = SimpleConfig.for(:application)
+config.my_variable # => "hello world"
+</code></pre>
+
+Accessing grouped variables works as you would expect:
+
+<pre><code class="ruby">
+config = SimpleConfig.for(:application)
+config.awesome_stuff.my_variable # => "hello world"
+</code></pre>
+
+h2. Using your configuration in your Rails app
+
+The plugin provides a convenient mixin for your <code>ApplicationController</code> to make configuration access as simple as possible. Assuming a configuration called "application" (as in the above examples), it defines a <code>config</code> method which can be used in any of your controllers. It also defines this as a method as a view helper using the Rails <code>helper_method</code> macro so you can access configuration data in your views. 
+
+Note - there is no direct way of accessing your configuration variables in your models other than making a direct call to <code>SimpleConfig.for</code>. I'd recommend designing your models in such a way that configuration data can be passed into them at runtime as method arguments by your controller to avoid coupling your model to SimpleConfig.
+
+To use the mixin, simply include it in your <code>ApplicationController</code>:
+
+<pre><code class="ruby">
+class ApplicationController < ActionController::Base
+  include SimpleConfig::ControllerMixin
+end
+</code></pre>
+
+Then in your controllers:
+
+<pre><code class="ruby">
+class MyController < ApplicationController
+  def index
+    render :text => config.my_config_variable
+  end
+end
+</code></pre>
+
+The mixin provides also a class-level <code>config</code> method to access the configuration when you don't have a controller instance available.
+
+<pre><code class="ruby">
+class MyController < ApplicationController
+  protect_from_forgery :secret => config.secret_token
+
+  def index
+    render :text => config.my_config_variable
+  end
+end
+</code></pre>
+
+
+fn1(footnote). SimpleConfig was designed with Rails 2.0 in mind but it has been tested with Rails 1.2. To use the Rails-style initializers that SimpleConfig takes advantage of in Rails 1.2, simply add this to the bottom of your environment.rb file:
+
+<pre><code class="ruby">
+# backported Rails 2.x initializer folder functionality
+Dir[File.join(RAILS_ROOT, 'config', 'initializers', '*.rb')].each do |initializer|
+  load initializer
+end
+</code></pre>
+
+fn2(footnote). In fact, I recommend you make sure your version control system ignores this file otherwise you risk checking in a file that will override values in production! If you are using Subversion, simply add local.rb to the svn:ignore property for the config/settings folder.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the simpleconfig plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the simpleconfig plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Simpleconfig'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/rails_compatibility.rb

@@ -0,0 +1,7 @@
+unless Rails.respond_to?(:env)
+  Rails.instance_eval do
+    def env
+      RAILS_ENV
+    end
+  end
+end

data/lib/simple_config.rb

@@ -0,0 +1,157 @@
+require 'yaml'
+
+unless defined?(Rails)
+  class Object
+    def returning(object, &block)
+      yield object if block_given?
+      object
+    end
+  end
+end
+
+module SimpleConfig
+  
+  class << self
+    def for(config_name, &block)
+      default_manager.for(config_name, &block)
+    end
+    
+    def default_manager
+      @default_manager ||= Manager.new
+    end
+  end
+  
+  class Manager
+    def initialize
+      @configs = {}
+    end
+    
+    def for(config_name, &block)
+      returning @configs[config_name] ||= Config.new do |config|
+        config.configure(&block) if block_given?
+      end
+    end
+  end
+  
+  class Config
+    def initialize
+      @groups = {}
+      @settings = {}
+    end
+    
+    def configure(&block)
+      instance_eval(&block)
+    end
+    
+    def group(name, &block)
+      returning @groups[name] ||= Config.new do |group|
+        group.configure(&block) if block_given?
+      end
+    end
+    
+    def set(key, value)
+      @settings[key] = value
+    end
+    
+    def get(key)
+      @settings[key]
+    end
+    
+    # 
+    # Unsets any variable with given +key+ 
+    # and returns variable value if it exists, nil otherwise.
+    # Any successive call to exists? :key will return false.
+    # 
+    #   exists? :bar      # => false
+    # 
+    #   set :bar, 'foo'
+    #   exists? :bar      # => true
+    # 
+    #   unset :bar        # => 'foo'
+    #   exists? :bar      # => false
+    # 
+    def unset(key)
+      @settings.delete(key)
+    end
+    
+    # 
+    # Returns whether a variable with given +key+ is set.
+    # 
+    # Please note that this method doesn't care about variable value.
+    # A nil variable is considered as set.
+    # 
+    #   exists? :bar      # => false
+    # 
+    #   set :bar, 'foo'
+    #   exists? :bar      # => true
+    # 
+    #   set :bar, nil
+    #   exists? :bar      # => true
+    # 
+    # Use unset to completely remove a variable from the collection.
+    # 
+    #   set :bar, 'foo'
+    #   exists? :bar      # => true
+    # 
+    #   unset :bar
+    #   exists? :bar      # => false
+    # 
+    def exists?(key)
+      @settings.key?(key)
+    end
+    
+    def load(external_config_file, options={})
+      options = {:if_exists? => false}.merge(options)
+      
+      if options[:if_exists?]
+        return unless File.exist?(external_config_file)
+      end
+      
+      case File.extname(external_config_file)
+      when /rb/
+        instance_eval(File.read(external_config_file))
+      when /yml|yaml/
+        YAMLParser.parse_contents_of_file(external_config_file).parse_into(self)
+      end
+    end
+    
+    private
+      def method_missing(method_name, *args)
+        case true
+        when @groups.key?(method_name)
+          return @groups[method_name]
+        when @settings.key?(method_name)
+          return get(method_name)
+        else
+          super(method_name, *args)
+        end
+      end
+  end
+  
+  class YAMLParser
+    def initialize(raw_yaml_data)
+      @data = YAML.load(raw_yaml_data)
+    end
+    
+    def self.parse_contents_of_file(yaml_file)
+      new(File.read(yaml_file))
+    end
+    
+    def parse_into(config)
+      @data.each do |key, value|
+        parse(key, value, config)
+      end
+    end
+    
+    private
+      def parse(key, value, config)
+        if value.is_a?(Hash)
+          group = config.group(key.to_sym)
+          value.each { |key, value| parse(key, value, group) }
+        else
+          config.set(key.to_sym, value)
+        end
+      end
+  end
+  
+end

data/lib/simple_config/controller_mixin.rb

@@ -0,0 +1,31 @@
+module SimpleConfig
+  module ControllerMixin
+    
+    def self.included(base)
+      base.extend     ClassMethods
+      base.class_eval do
+        include       InstanceMethods
+        helper_method :config
+      end
+    end
+    
+    module ClassMethods
+      
+      # Returns the application config.
+      def config
+        SimpleConfig.for(:application)
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      # Instance-level proxy to class-level +config+ method.
+      def config
+        self.class.config
+      end
+      
+    end
+    
+  end
+end

data/lib/simple_config/utilities.rb

@@ -0,0 +1,40 @@
+require 'uri'
+
+module SimpleConfig
+  module Utilities
+    class NetworkHost
+      attr_reader :name, :port
+
+      def initialize(name, port = nil, secure = false)
+        @name, @port = name, port
+        @secure = secure
+      end
+      
+      def secure?
+        @secure
+      end
+
+      def self.from_string(host_string)
+        host, port = host_string.split(':')
+        new(host, port.to_i)
+      end
+
+      def to_uri(uri_options = {})
+        [:host, :port].each { |opt| uri_options.delete(opt) }
+        URI::Generic.build({:host => name, :port => port, :scheme => default_uri_scheme}.merge(uri_options))
+      end
+
+      def url_for_path(path)
+        to_uri(:path => path).to_s
+      end
+
+      def to_s
+        [name, port].compact.join(':')
+      end
+      
+      def default_uri_scheme
+        secure? ? 'https' : 'http'
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'rails_compatibility' 
+require 'simple_config'
+require 'simple_config/controller_mixin'

data/tasks/simple_config.rake

@@ -0,0 +1,21 @@
+require 'fileutils'
+
+namespace :simple_config do
+  include FileUtils
+  
+  task :setup do
+    raise "This task should be run from within a Rails application." unless File.exist?('config')
+    raise "Already found config/settings. Have you already run this task?." if File.exist?('config/settings')
+    
+    mkdir('config/settings')
+    mkdir("config/initializers") unless File.exist?("config/initializers")
+    
+    environments =  Dir["config/environments/*.rb"].map { |f| File.basename(f, ".rb") }
+    environments << 'application'
+    environments.each { |env| touch("config/settings/#{env}.rb") }
+    
+    cp(File.join(File.dirname(__FILE__), *%w[.. templates configuration.rb]), 
+        "config/initializers/configuration.rb")
+  end  
+  
+end

data/templates/configuration.rb

@@ -0,0 +1,18 @@
+SimpleConfig.for :application do
+  
+  # Set here your global configuration.
+  # All settings can be overwritten later per-environment.
+  load File.join(RAILS_ROOT, 'config', "settings", "application.rb"),   :if_exists? => true
+  
+  # Per Environment settings.
+  # At startup only the file matching current environment will be loaded.
+  # Settings stored here will overwrite settings with the same name stored in application.rb
+  load File.join(RAILS_ROOT, 'config', "settings", "#{RAILS_ENV}.rb"),  :if_exists? => true
+  
+  # Local settings. It is designed as a place for you to override variables 
+  # specific to your own development environment.
+  # Make sure your version control system ignores this file otherwise 
+  # you risk checking in a file that will override values in production
+  load File.join(RAILS_ROOT, 'config', "settings", "local.rb"),         :if_exists? => true
+  
+end

data/test/controller_mixin_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+require 'simple_config/controller_mixin'
+
+class RailsController
+  class << self
+    attr_reader :helper_methods
+    def helper_method(name)
+      (@helper_methods ||= []) << name
+    end
+  end
+end
+
+class ControllerMixinTest < Test::Unit::TestCase
+
+  def setup
+    @app_config = SimpleConfig.for(:application) do
+    end
+    
+    @controller_klass = Class.new(RailsController)
+  end
+  
+  def test_should_define_a_config_class_method_that_returns_the_application_config_when_included
+    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
+    assert_equal @app_config, @controller_klass.config
+  end
+  
+  def test_should_define_a_config_instance_method_that_returns_the_application_config_when_included
+    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
+    assert_equal @app_config, @controller_klass.new.config
+  end
+  
+  def test_should_define_the_config_method_as_helper_method_to_make_it_available_to_views_when_included
+    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
+    assert_equal [:config], @controller_klass.helper_methods
+  end
+end

data/test/network_host_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config/utilities'
+
+class NetworkHostTest < Test::Unit::TestCase
+  include SimpleConfig::Utilities
+    
+  def test_should_default_to_no_port
+    host = NetworkHost.new('www.example.com')
+    assert_nil host.port
+  end
+  
+  def test_should_build_a_uri_object_with_the_specified_hostname_and_port_and_a_http_scheme
+    uri = NetworkHost.new('www.example.com', 9000).to_uri
+    assert_instance_of URI::Generic, uri
+    assert_equal 'http', uri.scheme
+  end
+  
+  def test_should_build_a_uri_object_with_an_https_scheme_if_secure
+    uri = NetworkHost.new('www.example.com', 443, secure = true).to_uri
+    assert_equal 'https', uri.scheme
+  end
+  
+  def test_should_return_a_url_for_a_given_path
+    host = NetworkHost.new('www.example.com')
+    assert_equal 'http://www.example.com/foo/bar', host.url_for_path('/foo/bar')
+  end
+  
+  def test_should_return_a_string_representation
+    assert_equal 'www.example.com:9000', NetworkHost.new('www.example.com', 9000).to_s
+  end
+  
+  def test_should_be_constructed_from_a_string_representation
+    host = NetworkHost.from_string('www.example.com:9000')
+    assert_equal 'www.example.com', host.name
+    assert_equal 9000, host.port
+  end
+end

data/test/simple_config_functional_test.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+
+class SimpleConfigFunctionalTest < Test::Unit::TestCase
+  
+  def test_simple_config_with_top_level_settings
+    config = SimpleConfig.for(:my_test) do
+      set :var_one, 'foo'
+      set :var_two, 'bar'
+    end
+    
+    assert_equal 'foo', config.var_one
+    assert_equal 'bar', config.var_two
+  end
+  
+  def test_config_with_groups
+    config = SimpleConfig.for(:my_test) do
+      group :test_group do
+        set :var_one, 'foo'
+      end
+    end
+    
+    assert_equal 'foo', config.test_group.var_one
+  end
+  
+  def test_config_with_top_level_settings_and_groups
+    config = SimpleConfig.for(:my_test) do
+      group :test_group do
+        set :var_one, 'foo'
+      end
+      
+      set :var_two, 'bar'
+    end
+    
+    assert_equal 'foo', config.test_group.var_one
+    assert_equal 'bar', config.var_two
+  end
+  
+  def test_config_with_nested_groups
+    config = SimpleConfig.for(:my_test) do
+      group :test_group do
+        group :inner_group do
+          set :var_one, 'foo'
+        end
+      end
+    end
+    
+    assert_equal 'foo', config.test_group.inner_group.var_one
+  end
+  
+  def test_config_with_externally_loaded_ruby_config
+    sample_file = File.join(File.dirname(__FILE__), *%w[example.rb])
+    File.open(sample_file, "w") do |io|
+      io << %(
+        set :foo, 'bar'
+      )
+    end
+    
+    config = SimpleConfig.for(:my_test) do
+      load sample_file
+    end
+    
+    assert_equal 'bar', config.foo
+    
+    FileUtils.rm_f(sample_file)
+  end
+  
+  def test_config_with_externally_loaded_yaml_config
+    sample_file = File.join(File.dirname(__FILE__), *%w[example.yml])
+    File.open(sample_file, "w") do |io|
+      io << %(
+      example:
+        foo: bar
+        baz: qux
+      
+      test: foo
+      )
+    end
+    
+    config = SimpleConfig.for(:my_test) do
+      load sample_file
+    end
+    
+    assert_equal 'foo', config.test
+    assert_equal 'bar', config.example.foo
+    assert_equal 'qux', config.example.baz
+    
+    FileUtils.rm_f(sample_file)
+  end
+  
+  def test_config_with_optional_external_config
+    assert_nothing_raised do
+      SimpleConfig.for(:my_test) do
+        load "non_existent_file", :if_exists? => true
+      end
+    end
+  end
+  
+end

data/test/simple_config_test.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+
+class SimpleConfigConfigTest < Test::Unit::TestCase
+  
+  def setup
+    @config = SimpleConfig::Config.new
+  end
+  
+  def test_should_be_able_to_set_config_values
+    @config.set(:var_one, 'hello world')
+    assert_equal 'hello world', @config.get(:var_one)
+  end
+  
+  def test_should_be_able_to_access_settings_using_method_access
+    @config.set(:foo, 'bar')
+    assert_equal 'bar', @config.foo
+  end
+  
+  def test_should_raise_NoMethodError_if_setting_does_not_exist_when_using_method_access
+    assert_raises(NoMethodError) { @config.some_non_existent_variable }
+  end
+  
+  def test_should_return_nil_if_setting_does_not_exist_when_using_get
+    assert_nil @config.get(:some_non_existent_variable)
+  end
+  
+  def test_unset_should_delete_config_values
+    @config.set(:foo, 'bar')
+    assert_equal('bar', @config.foo)
+    @config.unset(:foo)
+    assert_raises(NoMethodError) { @config.foo }
+  end
+  
+  def test_unset_should_return_deleted_value
+    @config.set(:foo, 'bar')
+    assert_equal('bar', @config.unset(:foo))
+  end
+  
+  def test_exists_should_return_whether_variable_isset
+    assert(!@config.exists?(:foo))
+    @config.set(:foo, 'bar')
+    assert(@config.exists?(:foo))
+    @config.unset(:foo)
+    assert(!@config.exists?(:foo))
+  end
+  
+  def test_exists_should_consider_empty_values_as_set
+    [nil, 0, ''].each do |empty_value|
+      @config.set(:foo, empty_value)
+      assert_equal(empty_value, @config.get(:foo))
+      assert(@config.exists?(:foo))
+    end
+  end
+  
+  def test_should_return_a_new_group_as_a_separate_config
+    group = @config.group(:test)
+    assert_instance_of(SimpleConfig::Config, group)
+    assert_not_equal @config, group
+  end
+  
+  def test_should_return_an_existing_group
+    group = @config.group(:test)
+    assert_equal group, @config.group(:test)
+  end
+  
+  def test_should_configure_group_with_supplied_block_when_given
+    group = @config.group(:test) do
+      set :group_var, 'value'
+    end
+    assert_equal 'value', group.group_var
+  end
+  
+  def test_should_load_and_parse_external_config_as_ruby_in_context_of_config_instance
+    File.stubs(:read).with('external_config.rb').returns(ruby_code = stub('ruby'))
+    @config.expects(:instance_eval).with(ruby_code)
+    @config.load('external_config.rb')
+  end
+  
+  def test_should_laod_and_parse_external_config_as_yaml_in_context_of_config_instance
+    parser = stub('YAMLParser')
+    SimpleConfig::YAMLParser.stubs(:parse_contents_of_file).with('external_config.yml').returns(parser)
+    parser.expects(:parse_into).with(@config)
+    @config.load('external_config.yml')
+  end
+  
+  def test_should_load_and_parse_external_config_as_yaml_if_config_file_has_full_yaml_extension
+    parser = stub('YAMLParser')
+    SimpleConfig::YAMLParser.expects(:parse_contents_of_file).with('external_config.yaml').returns(parser)
+    parser.stubs(:parse_into)
+    @config.load('external_config.yaml')
+  end
+  
+  def test_should_load_and_parse_external_config_if_file_exists_when_if_exists_is_true
+    File.stubs(:read).with('external_config.rb').returns(ruby_code = stub('ruby'))
+    @config.expects(:instance_eval).with(ruby_code)
+    File.stubs(:exist?).with('external_config.rb').returns(true)
+    @config.load('external_config.rb', :if_exists? => true)
+  end
+  
+  def test_should_not_load_and_parse_external_config_if_file_does_not_exist_when_if_exists_is_true
+    @config.expects(:instance_eval).never
+    File.stubs(:exist?).with('external_config.rb').returns(false)
+    @config.load('external_config.rb', :if_exists? => true)
+  end
+    
+end

data/test/yaml_parser_test.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+
+class YAMLParserTest < Test::Unit::TestCase
+  include SimpleConfig
+  
+  def setup
+    @config = Config.new
+  end
+  
+  def test_parsing_of_a_single_variable
+    parser = YAMLParser.new({'foo' => 'bar'}.to_yaml)
+    parser.parse_into(@config)
+
+    assert_equal 'bar', @config.foo
+  end
+  
+  def test_parsing_of_multiple_variables
+    parser = YAMLParser.new({'foo' => 'bar', 'baz' => 'qux'}.to_yaml)
+    parser.parse_into(@config)
+
+    assert_equal 'bar', @config.foo
+    assert_equal 'qux', @config.baz
+  end
+  
+  def test_parsing_of_a_group_with_one_variable
+    parser = YAMLParser.new({'group1' => {'foo' => 'bar'}}.to_yaml)
+    parser.parse_into(@config)
+    
+    assert_equal 'bar', @config.group1.foo
+  end
+  
+  def test_parsing_of_a_group_with_two_variables
+    parser = YAMLParser.new({'group1' => {'foo' => 'bar', 'baz' => 'qux'}}.to_yaml)
+    parser.parse_into(@config)
+    
+    assert_equal 'bar', @config.group1.foo
+    assert_equal 'qux', @config.group1.baz
+  end
+  
+  def test_parsing_of_a_nested_group
+    parser = YAMLParser.new({'group1' => {'group2' => {'foo' => 'bar'}}}.to_yaml)
+    parser.parse_into(@config)
+    
+    assert_equal 'bar', @config.group1.group2.foo
+  end
+end
+
+class YAMLParserFromContentsOfFile < Test::Unit::TestCase
+  include SimpleConfig
+  
+  def test_should_initialize_new_parser_from_contents_of_given_file
+    File.stubs(:read).with('config.yml').returns(yaml_data = stub('yaml data'))
+    YAMLParser.expects(:new).with(yaml_data).returns(parser = stub('YAMLParser'))
+    assert_equal parser, YAMLParser.parse_contents_of_file('config.yml')
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: simpleconfig
+version: !ruby/object:Gem::Version 
+  version: 1.0.2
+platform: ruby
+authors: 
+- Luke Redpath
+autorequire: simple_config
+bindir: bin
+cert_chain: []
+
+date: 2009-02-05 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Simple Config is a plugin designed to make application-wide configuration settings (e.g. in a Rails app) easy to set and access in an object-oriented fashion.
+email: luke@lukeredpath.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/simple_config.rb
+- lib/simple_config/controller_mixin.rb
+- lib/simple_config/utilities.rb
+- lib/rails_compatibility.rb
+- rails/init.rb
+- Rakefile
+- README.textile
+- tasks/simple_config.rake
+- templates/configuration.rb
+has_rdoc: true
+homepage: http://github.com/lukeredpath/simpleconfig
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple object-oriented application settings
+test_files: 
+- test/controller_mixin_test.rb
+- test/network_host_test.rb
+- test/simple_config_functional_test.rb
+- test/simple_config_test.rb
+- test/yaml_parser_test.rb