sugarfree-config 1.1.0 → 2.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+doc

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    sugarfree-config (2.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ansi (1.3.0)
+    metaclass (0.0.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    turn (0.8.2)
+      ansi (>= 1.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  sugarfree-config!
+  turn

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 [name of plugin creator]
+Copyright (c) 2011 David Barral
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,51 +1,64 @@
-= SugarfreeConfig
+= sugarfree-config
 
 Configuration handling the easy way.
 
-SugarfreeConfig allows easy access to per Rails environment config values
-stored in a YAML file.
-
-SugarfreeConfig only works with Rails! since SugarfreecConfig 1.1.0 works
-with rails 3 and ruby 1.9.1
+sugarfree-config allows easy access to per environment config values
+stored in a YAML file in Rails and non Rails applications.
 
 == Installation
 
-Just install the gem from Gemcutter
-
-  $ gem install sugarfree-config --source http://gemcutter.org
-
-== Notes on rails 3
-
-In rails 2.x gems were required after Rails.root was initialized. Default rails 3.0
-application generator uses Bundler, and auto-requires all gems before application
-initialization. This could be solved forcing the bundler not to require the gem.
-In your Gemfile:
-
-  gem 'problematic-gem', :require => false
+Just install the gem manually from rubygems.org or add it to your bundle.
 
-and adding an initializer with the require line 
-
-  require 'problematic-gem'
+  $ gem install sugarfree-config
 
 == Usage
 
-Config must be stored in "#{RAILS_ROOT}/config/config.yml" and must have
-at least a section for each RAILS_ENV
-
-Configuration can be accessed like this
+Configuration can be accessed using method calls:
 
   SugarfreeConfig.a.b.c #=> 'value'
 
-which will expect a config file like (given development env)
+which will expect a config.yml file like the one below (given development env) 
+stored in the config folder (in Rails apps) or the root folder (in non Rails apps):
 
   development:
     a:
       b:
         c: 'value'
 
-otherwise a ConfigKeyException will be raised
+If asking for akey that does not exists ConfigKeyException will be raised.
+
+A convinience to_hash method is also provided:
+
+  SugarfreeConfig.a.to_hash #=> { 'b' => { 'c' => 'value' } }
+
+== Configuration
 
-Configuration is accessed through a ConfigIterator that (as its name says) is
+sugarfree-config can be used with or without Rails. Default configurations are
+provided for each case. Default configurations can be overriden the explicit use
+of the SugarfreeConfig::init method.
+
+To set the configuration you need to initialize the SugarfreeConfig class:
+
+  SugarfreeConfig.init :env => 'development', :file => 'my_config.yml', :reload => true
+
+  # Default options in Rails apps
+  SugarfreeConfig.init({
+    :env => Rails.env,
+    :file => Rails.root.join('config', 'config.yml'),
+    :reload => Rails.env.development?
+  })
+
+  # Default options in non Rails apps
+  SugarfreeConfig.init({
+    :env => 'development',
+    :file => File.expand_path('config.yml'),
+    :reload => false
+  })
+
+
+== Gotchas
+
+Configuration is accessed through a ConfigIterator class which (as its name says) is
 an iterator and cannot be reused. However there is a workaround to allow the
 repeated use of scoped iterators.
 
@@ -59,25 +72,15 @@ repeated use of scoped iterators.
   a_config.dup.b.c #=> 'value'
   a_config.dup.b.c #=> 'value'
 
-== Further customization
-
-By default Sugarfree-config caches in memory the YAML file. If you want the gem
-to reload this file each time a value is accessed (like in development mode)
-you must force the initialization of the SugarfreeConfig module.
 
-This could be a possible Rails initializer:
+== Compatibility
 
-  SugarfreeConfig.init(Rails.env.development?) # True to force reload each time
-
-  class Object
-    # For people who prefer app_config.a.b.c instead of SugarfreeConfig.a.b.c
-    def app_config
-      SugarfreeConfig
-    end
-  end
+SugarfreeConfig 2.0.0 has been developed and tested against Ruby 1.9.2 and Rails 3.x. 
+Older versions of Ruby and Rails may also work. Just give it a try ;)
 
 == Contact
 
-Please mail bugs, suggestions and patches to
-contact@davidbarral.com[mailto:contact@davidbarral.com]
+Please use GitHub (https://github.com/davidbarral/sugarfree-config) to report bugs,
+make suggestions or send patches.
+
 

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.libs.push "specs"
+  t.test_files = FileList['specs/*_spec.rb']
+  t.verbose = true
+end

data/lib/sugarfree-config/config.rb

@@ -0,0 +1,128 @@
+require 'yaml'
+
+module SugarfreeConfig
+
+  #
+  # Config base object. Caches the configuration in memory an acts as a factory
+  # for the ConfigIterators needed to get config values
+  #
+  class Config
+
+    #
+    # Creates a new config object and load the config file into memory
+    #
+    def initialize(options)
+      options = default_options.merge(options)
+
+      @file   = options[:file]
+      @reload = options[:reload]
+      @env    = options[:env]
+    end
+
+    #
+    # Returns all the config as a big hash
+    #
+    def to_hash
+      values
+    end
+
+    #
+    # Here is the magic. The first request to config returns a new
+    # ConfigIterator that will handle the first +symbol+
+    #
+    def method_missing(symbol, *args)
+      ConfigIterator.new(values, symbol).next
+    end
+
+    protected
+
+      def values
+        @config = fetch_config unless @config && !@reload
+        @config
+      end
+
+      #
+      # Fetch the config from the file
+      #
+      def fetch_config
+        Rails.logger.debug "Loading #{@file}::#{@env}" if Object.const_defined?('Rails')
+        YAML::load_file(@file)[@env.to_s]
+      end
+
+      #
+      # Default configuration options for Rails and non Rails applications
+      #
+      def default_options
+        if Object.const_defined?('Rails')
+          {
+            :file   => Rails.root.join('config', 'config.yml'),
+            :reload => Rails.env.development?,
+            :env    => Rails.env
+          }
+        else
+          {
+            :file   => File.expand_path("config.yml"),
+            :reload => false,
+            :env    => "development"
+          }
+        end
+      end
+  end
+
+  #
+  # Config Iterator. Given a configuration hash it can navigate trough the
+  # values using method calls that will be translated into hash keys and
+  # indexed
+  #
+  class ConfigIterator
+
+    #
+    # Create a new iterator with a given +configuration+ and the first
+    # element of the path to be iterated (+first_path_element+)
+    #
+    def initialize(configuration, first_path_element)
+      @scoped_config = configuration
+      @path_elements = [first_path_element.to_s]
+    end
+
+    #
+    # Returns the current scope as a hash. Usefull to get a Big hash of config
+    # that will be used later.
+    #
+    def to_hash
+      @scoped_config
+    end
+
+    #
+    # Here is the magic. When an unknown symbol is passed this symbol is set
+    # as the last path element of this iteration, and the iterator is then
+    # forced to make that movement
+    #
+    def method_missing(symbol, *args)
+      @path_elements << symbol.to_s
+      self.next
+    end
+
+    #
+    # Iterate to the next element in the path
+    #
+    # Algorithm:
+    # 1. Get the last element of the key path
+    # 2. Try to find it in the scoped config
+    # 3. If not present raise an error
+    # 4. If present and is a hash we are not in a config leaf, so the scoped
+    #    config is reset to this new value and self is returned
+    # 5. If present and is a value then return the value
+    #
+    def next
+      if (value = @scoped_config[@path_elements.last]).nil?
+        raise ConfigKeyException.new(@path_elements)
+      elsif value.is_a?(Hash)
+        @scoped_config = value
+        self
+      else
+        value
+      end
+    end
+  end
+end

data/lib/sugarfree-config/exceptions.rb

@@ -0,0 +1,27 @@
+module SugarfreeConfig
+  #
+  # Exception raised by the module on unexpected behaviors
+  #
+  class ConfigException < Exception
+  end
+
+  #
+  # Exception raised by the Config Iterator when a key is not found
+  #
+  class ConfigKeyException < ConfigException
+
+    #
+    # Config key path (as a key collection) that failed
+    #
+    attr_accessor :key_path_elements
+
+    #
+    # Create a new exception with the not found key paths (+key_path_elements+
+    # Array)
+    #
+    def initialize(key_path_elements)
+      self.key_path_elements = [*key_path_elements].map(&:to_s)
+      super("Cannot find key #{self.key_path_elements.join('.')}")
+    end
+  end
+end

data/lib/sugarfree-config/version.rb

@@ -0,0 +1,3 @@
+module SugarfreeConfig
+  VERSION = "2.0.0"
+end

data/lib/sugarfree-config.rb

@@ -1,155 +1,24 @@
-#
+
+require 'sugarfree-config/exceptions'
+require 'sugarfree-config/config'
+
 # Sugarfree config allows easy access to the config values.
 #
-# See README.textile for usage info
+# See README.rdoc for usage info
 #
 module SugarfreeConfig
 
   class << self
     attr_reader :config
-    def init(force_reload = false)
-      @config = Config.new(force_reload)
-    end
-  end
-
-  def self.method_missing(*args)
-    init unless SugarfreeConfig.config
-    SugarfreeConfig.config.send(*args)
-  end
-
-  #
-  # Exception raised by the module on unexpected behaviors
-  #
-  class ConfigException < Exception
-  end
 
-  #
-  # Exception raised by the Config Iterator when a key is not found
-  #
-  class ConfigKeyException < ConfigException
-
-    #
-    # Config key path (as a key collection) that failed
-    #
-    attr_accessor :key_path_elements
-
-    #
-    # Create a new exception with the not found key paths (+key_path_elements+
-    # Array)
-    #
-    def initialize(key_path_elements)
-      self.key_path_elements = [*key_path_elements].map(&:to_s)
-      super("Cannot find key #{self.key_path_elements.join('.')}")
-    end
-  end
-
-  #
-  # Config base object. Caches the configuration in memory an acts as a factory
-  # for the ConfigIterators needed to get config values
-  #
-  class Config
-
-    #
-    # Conifg file is expected at "#{RAILS_ROOT}/config/config.yml"
-    #
-    DEFAULT_CONFIG_FILE = Rails.root.join('config', 'config.yml')
-
-    def values
-      @values = fetch_config unless @values && !@force_reload
-      @values
+    def init(options = {})
+      @config = Config.new(options)
     end
 
-    #
-    # Creates a new config object and load the config file into memory
-    #
-    def initialize(force_reload = false)
-      @force_reload = force_reload
-    end
-
-    #
-    # Returns all the config as a big hash
-    #
-    def to_hash
-      @values
-    end
-
-    #
-    # Here is the magic. The first request to config returns a new
-    # ConfigIterator that will handle the first +symbol+
-    #
-    def method_missing(symbol, *args)
-      ConfigIterator.new(values, symbol).next
-    end
-
-    protected
-
-      #
-      # Fetch the config from the file
-      #
-      def fetch_config
-       if Object.const_defined?('RAILS_DEFAULT_LOGGER') && RAILS_DEFAULT_LOGGER.debug?
-          RAILS_DEFAULT_LOGGER.debug "Loading #{DEFAULT_CONFIG_FILE}::#{RAILS_ENV}"
-        end
-        HashWithIndifferentAccess.new(YAML::load(File.new(DEFAULT_CONFIG_FILE))[RAILS_ENV])
-      end
-  end
-
-  #
-  # Config Iterator. Given a configuration hash it can navigate trough the
-  # values using method calls that will be translated into hash keys and
-  # indexed
-  #
-  class ConfigIterator
-
-    #
-    # Create a new iterator with a given +configuration+ and the first
-    # element of the path to be iterated (+first_path_element+)
-    #
-    def initialize(configuration, first_path_element)
-      @scoped_config = configuration
-      @path_elements = [first_path_element]
-    end
-
-    #
-    # Returns the current scope as a hash. Usefull to get a Big hash of config
-    # that will be used later.
-    #
-    def to_hash
-      @scoped_config
-    end
-
-    #
-    # Iterate to the next element in the path
-    #
-    # Algorithm:
-    # 1. Get the last element of the key path
-    # 2. Try to find it in the scoped config.
-    # 3. If not present raise an error
-    # 4. If present and is a hash we are not in a config leaf, so the scoped
-    #    config is reset to this new value and self is returned
-    # 5. If present and is a value then return the value
-    #
-    def next
-      if (value = @scoped_config[@path_elements.last]).nil?
-        raise ConfigKeyException.new(@path_elements)
-      elsif value.is_a?(Hash)
-        @scoped_config = value
-        self
-      else
-        value
-      end
-    end
-
-    #
-    # Here is the magic. When an unknown symbol is passed this symbol is set
-    # as the last path element of this iteration, and the iterator is then
-    # forced to make that movement
-    #
-    def method_missing(symbol, *args)
-      @path_elements << symbol
-      self.next
+    def method_missing(*args)
+      init unless SugarfreeConfig.config
+      SugarfreeConfig.config.send(*args)
     end
   end
-
 end
 

data/specs/config_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe "Config" do
+
+  before do
+    @config = {
+     'an_env' => {
+        'l1' => {
+          'l2' => 'a'
+        }
+      }
+    }
+  end
+
+  describe "initialize with no params for non rails apps" do
+    it "should return default values" do
+      Object.stubs(:const_defined?).with('Rails').returns(false)
+      h = mock()
+      h.expects(:'[]').with('development').once().returns({})
+      YAML.expects(:load_file).with(File.expand_path("config.yml")).once().returns(h)
+
+      c = SugarfreeConfig::Config.new({})
+      c.to_hash
+      c.to_hash
+    end
+  end
+
+  describe "initialize with no params for rails apps" do
+
+    #
+    # Yehaaaa! I know it's awful
+    #
+    it "should return default values" do
+      Object.stubs(:const_defined?).with('Rails').returns(true)
+
+      rails_root = mock()
+      rails_root.expects(:join).once().with('config', 'config.yml').returns("/rails_root/config/config.yml")
+
+      rails_logger = mock()
+      rails_logger.expects(:debug).once().with("Loading /rails_root/config/config.yml::production")
+
+      String.any_instance.stubs(:development?).returns(false)
+
+      Rails = mock()
+      Rails.stubs(:root).returns(rails_root)
+      Rails.stubs(:env).returns("production")
+      Rails.stubs(:logger).returns(rails_logger)
+
+      h = mock()
+      h.expects(:'[]').with('production').once().returns({})
+      YAML.expects(:load_file).with("/rails_root/config/config.yml").once.returns(h)
+
+      c = SugarfreeConfig::Config.new({})
+      c.to_hash
+      c.to_hash
+    end
+  end
+
+  describe "reloading" do
+    it "should reload the configuration if set to" do
+      Object.stubs(:const_defined?).with('Rails').returns(false)
+      YAML.expects(:load_file).twice().returns(@config)
+
+      c = SugarfreeConfig::Config.new(:reload => true, :env => 'an_env')
+      c.to_hash
+      c.to_hash
+    end
+
+    it "should not reload the configuration" do
+      Object.stubs(:const_defined?).with('Rails').returns(false)
+      YAML.expects(:load_file).once.returns(@config)
+
+      SugarfreeConfig::Config.new(:reload => false, :env => 'an_env').to_hash
+    end
+  end
+
+  describe "to_hash" do
+    it "should return the base config for a given env" do
+      Object.stubs(:const_defined?).with('Rails').returns(false)
+      YAML.stubs(:load_file).returns(@config)
+
+      c = SugarfreeConfig::Config.new(:env => 'an_env')
+      c.to_hash.must_equal @config['an_env']
+    end
+  end
+
+  describe "method_missing" do
+    it "should return an scoped iterator config" do
+      Object.stubs(:const_defined?).with('Rails').returns(false)
+      YAML.stubs(:load_file).returns(@config)
+
+      c = SugarfreeConfig::Config.new(:env => 'an_env')
+      ci = c.l1
+      ci.must_be_instance_of SugarfreeConfig::ConfigIterator
+      ci.to_hash.must_equal @config['an_env']['l1']
+    end
+  end
+end
+
+
+describe "ConfigIterator" do
+
+  before do
+    @config = {
+      'l1' => {
+        'l2a' => {
+          'l3' => 'a'
+        },
+        'l2b' => 'b'
+      }
+    }
+  end
+
+  def iterator(config,key)
+    SugarfreeConfig::ConfigIterator.new(config, key)
+  end
+
+
+  describe "to_hash" do
+    it "should return the scoped config" do
+       ci = iterator(@config, :l1)
+
+       ci.to_hash.must_equal @config
+       ci.next.to_hash.must_equal @config['l1']
+    end
+  end
+
+  describe "method_missing" do
+    it "should move the iterator" do
+      ci = iterator(@config, :l1)
+      ci.to_hash.wont_equal ci.next.to_hash
+    end
+
+  end
+
+  describe "next" do
+
+    it "should raise an exception when key is not available" do
+      ci = iterator(@config, :unknown_key)
+      lambda { ci.next }.must_raise SugarfreeConfig::ConfigKeyException
+    end
+
+    it "should return a value if iterated node is a leaf" do
+      iterator(@config['l1'], :l2b).next.must_equal 'b'
+    end
+
+    it "should return self and change iterator state if iterated node is not leaf" do
+      ci = iterator(@config, :l1)
+      cii = ci.next
+      cii.must_be_same_as ci
+    end
+
+  end
+end
+

data/specs/exceptions_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "ConfigKeyException" do
+  it "keeps the path elements that caused the exception as a String array" do
+    SugarfreeConfig::ConfigKeyException.new(:el1).key_path_elements.must_equal(["el1"])
+    SugarfreeConfig::ConfigKeyException.new([:el1, :el2]).key_path_elements.must_equal(["el1", "el2"])
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,9 @@
+gem 'turn'
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'mocha'
+require 'mocha/integration'
+require 'turn'
+
+require 'sugarfree-config'

data/specs/sugarfree_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "SugarfreeConfig" do
+
+  describe "config" do
+    it "should create a Config with the given options" do
+      opts = { :o1 => 2, :o2 => 2 }
+      SugarfreeConfig::Config.expects(:new).once().with(opts)
+      SugarfreeConfig.init(opts)
+    end
+  end
+
+  describe "method_missing" do
+    it "should create a Config and delegate" do
+      config = mock()
+      config.expects(:send).with(:test1)
+      config.expects(:send).with(:test2)
+      SugarfreeConfig::Config.expects(:new).once().returns(config)
+
+      SugarfreeConfig.test1
+      SugarfreeConfig.test2
+    end
+  end
+end
+
+
+describe "SugarfreeConfig delegation" do
+
+  before do
+    @config = {
+      'development' => {
+        'simple_config_key' => 1234,
+        'nested_config_keys' => {
+          'nested_key' => "the nested key"
+        }
+      }
+    }
+
+    YAML.stubs(:load_file).returns(@config)
+  end
+
+  describe "to_hash" do
+    it "should return the environment config as a hash" do
+      SugarfreeConfig.to_hash.must_equal(@config['development'])
+    end
+
+    it "should honor the scope" do
+      SugarfreeConfig.nested_config_keys.to_hash.must_equal(@config['development']['nested_config_keys'])
+    end
+  end
+
+  describe "asking for keys" do
+
+    it "should return the configuration values" do
+      SugarfreeConfig.simple_config_key.must_equal 1234
+      SugarfreeConfig.nested_config_keys.nested_key.must_equal 'the nested key'
+    end
+
+    it "should fail when aksing for non existent key" do
+      lambda { SugarfreeConfig.non_existent_key }.must_raise SugarfreeConfig::ConfigKeyException
+    end
+  end
+
+end

data/sugarfree-config.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sugarfree-config/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sugarfree-config"
+  s.version     = SugarfreeConfig::VERSION
+  s.authors     = ["David Barral"]
+  s.email       = ["contact@davidbarral.com"]
+  s.homepage    = "http://github.com/davidbarral/sugarfree-config"
+  s.summary     = "Configuration handling the easy way"
+  s.description = "Access to per Rails environment configuration stored in a YAML file"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('turn')
+end

metadata

@@ -1,65 +1,83 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sugarfree-config
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 1
-  - 0
-  version: 1.1.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - David Barral
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-03-19 00:00:00 +01:00
-default_executable: 
-dependencies: []
-
+date: 2011-10-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &20817940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *20817940
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: &20817520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *20817520
 description: Access to per Rails environment configuration stored in a YAML file
-email: contact@davidbarral.com
+email:
+- contact@davidbarral.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- README.rdoc
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
 - LICENSE
+- README.rdoc
+- Rakefile
 - init.rb
 - lib/sugarfree-config.rb
-has_rdoc: true
+- lib/sugarfree-config/config.rb
+- lib/sugarfree-config/exceptions.rb
+- lib/sugarfree-config/version.rb
+- specs/config_spec.rb
+- specs/exceptions_spec.rb
+- specs/spec_helper.rb
+- specs/sugarfree_spec.rb
+- sugarfree-config.gemspec
 homepage: http://github.com/davidbarral/sugarfree-config
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+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.3.6
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Configuration handling the easy way
 test_files: []
-