readwritesettings 3.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+*.log
+*.sqlite3
+pkg/*
+coverage/*
+doc/*
+benchmarks/*
+.bundle
+vendor/bundle
+.rvmrc

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+script: bundle exec rake
+rvm:
+  - ruby-1.9.3
+  - rbx-19mode
+  - ruby-2.0.0
+notifications:
+  email:
+    recipients:
+      - drnicwilliams@gmail.com
+    on_success: change
+    on_failure: always

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    settingslogic (2.0.9)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rspec
+  settingslogic!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ben Johnson of Binary Logic (binarylogic.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,196 @@
+# ReadWriteSettings
+
+ReadWriteSettings is a simple configuration / settings solution that uses an ERB enabled YAML file. It has been great for
+our apps, maybe you will enjoy it too.  ReadWriteSettings works with Rails, Sinatra, or any Ruby project.
+
+It is a fork of {ReadWriteSettings}[http://github.com/binarylogic/settingslogic] to support modifications and additional getting/setter methods. Hopefully can merge this fork back into ReadWriteSettings in future and have a single project again.
+
+## Helpful links
+
+* <b>Issues:</b> http://github.com/drnic/readwritesettings/issues
+* <b>Source:</b> http://github.com/drnic/readwritesettings
+* [![Build Status](https://travis-ci.org/drnic/readwritesettings.png?branch=master)](https://travis-ci.org/drnic/readwritesettings)
+* [![Code Climate](https://codeclimate.com/github/drnic/readwritesettings.png)](https://codeclimate.com/github/drnic/readwritesettings)
+
+## Installation
+
+Add the following to your Gemfile:
+
+``` ruby
+gem "readwritesettings"
+```
+
+## Usage
+
+### 1. Define your class
+
+Instead of defining a Settings constant for you, that task is left to you. Simply create a class in your application
+that looks like:
+
+``` ruby
+class Settings < ReadWriteSettings
+  source "#{Rails.root}/config/application.yml"
+  namespace Rails.env
+end
+```
+
+Name it Settings, name it Config, name it whatever you want. Add as many or as few as you like. A good place to put
+this file in a rails app is app/models/settings.rb
+
+I felt adding a settings file in your app was more straightforward, less tricky, and more flexible.
+
+Alternately, you can pass a Hash into the constructor.
+
+``` ruby
+Settings = ReadWriteSettings.new({"key" => "value"})
+```
+
+### 2. Create your settings
+
+Notice above we specified an absolute path to our settings file called "application.yml". This is just a typical YAML file.
+Also notice above that we specified a namespace for our environment.  A namespace is just an optional string that corresponds
+to a key in the YAML file.
+
+Using a namespace allows us to change our configuration depending on our environment:
+
+``` yaml
+# config/application.yml
+defaults: &defaults
+  cool:
+    saweet: nested settings
+  neat_setting: 24
+  awesome_setting: <%= "Did you know 5 + 5 = #{5 + 5}?" %>
+
+development:
+  <<: *defaults
+  neat_setting: 800
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults
+```
+
+_Note_: Certain Ruby/Bundler versions include a version of the Psych YAML parser which incorrectly handles merges (the `<<` in the example above.)
+If your default settings seem to be overwriting your environment-specific settings, including the following lines in your config/boot.rb file may solve the problem:
+
+``` ruby
+require 'yaml'
+YAML::ENGINE.yamler= 'syck'
+```
+
+### 3. Access your settings
+
+``` ruby
+>> Rails.env
+=> "development"
+
+>> Settings.cool
+=> "#<ReadWriteSettings::Settings ... >"
+
+>> Settings.cool.saweet
+=> "nested settings"
+
+>> Settings.neat_setting
+=> 800
+
+>> Settings.awesome_setting
+=> "Did you know 5 + 5 = 10?"
+```
+
+You can use these settings anywhere, for example in a model:
+
+``` ruby
+class Post < ActiveRecord::Base
+  self.per_page = Settings.pagination.posts_per_page
+end
+```
+
+### 4. Optional / dynamic settings
+
+Often, you will want to handle defaults in your application logic itself, to reduce the number of settings
+you need to put in your YAML file.  You can access an optional setting by using Hash notation:
+
+``` ruby
+>> Settings.messaging.queue_name
+=> Exception: Missing setting 'queue_name' in 'message' section in 'application.yml'
+
+>> Settings.messaging['queue_name']
+=> nil
+
+>> Settings.messaging['queue_name'] ||= 'user_mail'
+=> "user_mail"
+
+>> Settings.messaging.queue_name
+=> "user_mail"
+```
+
+Modifying our model example:
+
+``` ruby
+class Post < ActiveRecord::Base
+  self.per_page = Settings.posts['per_page'] || Settings.pagination.per_page
+end
+```
+
+This would allow you to specify a custom value for per_page just for posts, or
+to fall back to your default value if not specified.
+
+### 5. Suppressing Exceptions Conditionally
+
+Raising exceptions for missing settings helps highlight configuration problems.  However, in a
+Rails app it may make sense to suppress this in production and return nil for missing settings.
+While it's useful to stop and highlight an error in development or test environments, this is
+often not the right answer for production.
+
+``` ruby
+class Settings < ReadWriteSettings
+  source "#{Rails.root}/config/application.yml"
+  namespace Rails.env
+  suppress_errors Rails.env.production?
+end
+
+>> Settings.non_existent_key
+=> nil
+```
+
+## Note on Sinatra / Capistrano / Vlad
+
+Each of these frameworks uses a +set+ convention for settings, which actually defines methods
+in the global Object namespace:
+
+``` ruby
+set :application, "myapp"  # does "def application" globally
+```
+
+This can cause collisions with ReadWriteSettings, since those methods are global. Luckily, the
+solution is to just add a call to load! in your class:
+
+``` ruby
+class Settings < ReadWriteSettings
+  source "#{Rails.root}/config/application.yml"
+  namespace Rails.env
+  load!
+end
+```
+
+It's probably always safest to add load! to your class, since this guarantees settings will be
+loaded at that time, rather than lazily later via method_missing.
+
+Finally, you can reload all your settings later as well:
+
+``` ruby
+Settings.reload!
+```
+
+This is useful if you want to support changing your settings YAML without restarting your app.
+
+## History
+
+This project was originally created by Ben Johnson and called ReadWriteSettings. A renamed fork was created so that new gem versions could be released with new functionality, by Dr Nic Williams. The latter is not entirely thrilled about this situation; but at least he now has a versioned gem with the new shiny stuff in it.
+
+Copyright (c) 2008-2010 {Ben Johnson}[http://github.com/binarylogic] of {Binary Logic}[http://www.binarylogic.com],
+released under the MIT license.  Support for optional settings and reloading by {Nate Wiger}[http://nate.wiger.org].
+
+Copyright (c) 2013 {Dr Nic Williams}[http://github.com/drnic]

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/readwritesettings.rb

@@ -0,0 +1,246 @@
+require "yaml"
+require "erb"
+require 'open-uri'
+
+# A simple settings solution using a YAML file. See README for more information.
+class ReadWriteSettings < Hash
+  class MissingSetting < StandardError; end
+
+  class << self
+    def name # :nodoc:
+      self.superclass != Hash && instance.key?("name") ? instance.name : super
+    end
+        
+    # Enables Settings.get('nested.key.name') for dynamic access
+    def get(key)
+      parts = key.split('.')
+      curs = self
+      while p = parts.shift
+        curs = curs.send(p)
+      end
+      curs
+    end
+
+    def source(value = nil)
+      @source ||= value
+    end
+
+    def namespace(value = nil)
+      @namespace ||= value
+    end
+
+    def suppress_errors(value = nil)
+      @suppress_errors ||= value
+    end
+
+    def [](key)
+      instance.fetch(key.to_s, nil)
+    end
+
+    def []=(key, val)
+      # Setting[:key][:key2] = 'value' for dynamic settings
+      val = new(val, source) if val.is_a? Hash
+      instance.store(key.to_s, val)
+      instance.create_accessor_for(key, val)
+    end
+
+    def load!
+      instance
+      true
+    end
+
+    def reload!
+      @instance = nil
+      load!
+    end
+
+    private
+      def instance
+        return @instance if @instance
+        @instance = new
+        create_accessors!
+        @instance
+      end
+
+      def method_missing(name, *args, &block)
+        instance.send(name, *args, &block)
+      end
+
+      # It would be great to DRY this up somehow, someday, but it's difficult because
+      # of the singleton pattern.  Basically this proxies Setting.foo to Setting.instance.foo
+      def create_accessors!
+        instance.each do |key,val|
+          create_accessor_for(key)
+        end
+      end
+
+      def create_accessor_for(key)
+        return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+        instance_eval "def #{key}; instance.send(:#{key}); end"
+      end
+
+  end
+
+  # Initializes a new settings object. You can initialize an object in any of the following ways:
+  #
+  #   Settings.new(:application) # will look for config/application.yml
+  #   Settings.new("application.yaml") # will look for application.yaml
+  #   Settings.new("/var/configs/application.yml") # will look for /var/configs/application.yml
+  #   Settings.new(:config1 => 1, :config2 => 2)
+  #
+  # Basically if you pass a symbol it will look for that file in the configs directory of your rails app,
+  # if you are using this in rails. If you pass a string it should be an absolute path to your settings file.
+  # Then you can pass a hash, and it just allows you to access the hash via methods.
+  def initialize(hash_or_file = self.class.source, section = nil)
+    #puts "new! #{hash_or_file}"
+    case hash_or_file
+    when nil
+      raise Errno::ENOENT, "No file specified as ReadWriteSettings source"
+    when Hash
+      self.replace hash_or_file
+    else
+      file_contents = open(hash_or_file).read
+      hash = file_contents.empty? ? {} : YAML.load(ERB.new(file_contents).result).to_hash
+      if self.class.namespace
+        hash = hash[self.class.namespace] or return missing_key("Missing setting '#{self.class.namespace}' in #{hash_or_file}")
+      end
+      self.replace hash
+    end
+    @section = section || self.class.source  # so end of error says "in application.yml"
+    create_accessors!
+  end
+
+  # Called for dynamically-defined keys, and also the first key deferenced at the top-level, if load! is not used.
+  # Otherwise, create_accessors! (called by new) will have created actual methods for each key.
+  def method_missing(name, *args, &block)
+    key = name.to_s
+    return missing_key("Missing setting '#{key}' in #{@section}") unless has_key? key
+    value = fetch(key)
+    create_accessor_for(key)
+    value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
+  end
+
+  def [](key)
+    fetch(key.to_s, nil)
+  end
+
+  def []=(key,val)
+    # Setting[:key][:key2] = 'value' for dynamic settings
+    val = self.class.new(val, @section) if val.is_a? Hash
+    store(key.to_s, val)
+    create_accessor_for(key, val)
+  end
+
+  # Create a nested structure and set value.
+  # For example: set("foo.bar.tar", 123)
+  # Resulting ReadWriteSettings/Hash:
+  # { "foo" => { "bar" => { "tar" => 123 }}}
+  def set(nested_key, val)
+    target_settings_field = self
+    settings_key_portions = nested_key.to_s.split(".")
+    parent_key_portions, final_key = settings_key_portions[0..-2], settings_key_portions[-1]
+    parent_key_portions.each do |key_portion|
+      target_settings_field[key_portion] ||= ReadWriteSettings.new({})
+      target_settings_field = target_settings_field[key_portion]
+    end
+    target_settings_field[final_key] = val
+    create_accessors!
+  end
+
+  # Like #set, but only sets the value if the key is not already set
+  # Returns the existing value or the newly-set default value
+  def set_default(nested_key, val)
+    target_settings_field = self
+    settings_key_portions = nested_key.to_s.split(".")
+    parent_key_portions, final_key = settings_key_portions[0..-2], settings_key_portions[-1]
+    parent_key_portions.each do |key_portion|
+      target_settings_field[key_portion] ||= ReadWriteSettings.new({})
+      target_settings_field = target_settings_field[key_portion]
+    end
+    target_settings_field[final_key] ||= val
+    target_settings_field[final_key]
+  end
+
+  def nested_value(nested_key)
+    target_settings_field = self
+    settings_key_portions = nested_key.to_s.split(".")
+    parent_key_portions, final_key = settings_key_portions[0..-2], settings_key_portions[-1]
+    parent_key_portions.each do |key_portion|
+      target_settings_field[key_portion] ||= ReadWriteSettings.new({})
+      target_settings_field = target_settings_field[key_portion]
+    end
+    target_settings_field[final_key]
+  end
+  alias :exists? :nested_value
+
+  # Returns an instance of a Hash object
+  def to_hash
+    Hash[self]
+  end
+
+  # Convert all nested ReadWriteSettings objects to Hash objects
+  def to_nested_hash
+    inject({}) do |hash, key_value|
+      key, value = key_value
+      hash[key]  = value.respond_to?(:to_nested_hash) ? value.to_nested_hash : value
+      hash
+    end
+  end
+
+  def save(path)
+    File.open(path, "w") { |f| f << to_nested_hash.to_yaml }
+  end
+
+  # This handles naming collisions with Sinatra/Vlad/Capistrano. Since these use a set()
+  # helper that defines methods in Object, ANY method_missing ANYWHERE picks up the Vlad/Sinatra
+  # settings!  So settings.deploy_to title actually calls Object.deploy_to (from set :deploy_to, "host"),
+  # rather than the app_yml['deploy_to'] hash.  Jeezus.
+  def create_accessors!
+    self.each do |key,val|
+      create_accessor_for(key)
+    end
+  end
+
+  # Use instance_eval/class_eval because they're actually more efficient than define_method{}
+  # http://stackoverflow.com/questions/185947/ruby-definemethod-vs-def
+  # http://bmorearty.wordpress.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/
+  def create_accessor_for(key, val=nil)
+    return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+    instance_variable_set("@#{key}", val)
+    self.class.class_eval <<-EndEval
+      def #{key}
+        return @#{key} if @#{key}
+        return missing_key("Missing setting '#{key}' in #{@section}") unless has_key? '#{key}'
+        value = fetch('#{key}')
+        @#{key} = if value.is_a?(Hash)
+          self.class.new(value, "'#{key}' section in #{@section}")
+        elsif value.is_a?(Array) && value.all?{|v| v.is_a? Hash}
+          value.map{|v| self.class.new(v)}
+        else
+          value
+        end
+      end
+    EndEval
+  end
+  
+  def symbolize_keys
+    
+    inject({}) do |memo, tuple|
+      
+      k = (tuple.first.to_sym rescue tuple.first) || tuple.first
+            
+      v = k.is_a?(Symbol) ? send(k) : tuple.last # make sure the value is accessed the same way Settings.foo.bar works
+      
+      memo[k] = v && v.respond_to?(:symbolize_keys) ? v.symbolize_keys : v #recurse for nested hashes
+      
+      memo
+    end
+    
+  end
+  
+  def missing_key(msg)
+    return nil if self.class.suppress_errors
+
+    raise MissingSetting, msg
+  end
+end

data/readwritesettings.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "readwritesettings"
+  s.version     = "3.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dr Nic Williams", "Ben Johnson"]
+  s.email       = ["drnicwilliams@gmail.com", "bjohnson@binarylogic.com"]
+  s.homepage    = "http://github.com/drnic/readwritesettings"
+  s.summary     = %q{A simple settings solution that uses an ERB enabled YAML file and a singleton design pattern.}
+  s.description = %q{A simple settings solution that uses an ERB enabled YAML file and a singleton design pattern.}
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+
+  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"]
+end

data/spec/readwritesettings_spec.rb

@@ -0,0 +1,284 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe "ReadWriteSettings" do
+  it "should access settings" do
+    Settings.setting2.should == 5
+  end
+  
+  it "should access nested settings" do
+    Settings.setting1.setting1_child.should == "saweet"
+  end
+  
+  it "should access settings in nested arrays" do
+    Settings.array.first.name.should == "first"
+  end
+
+  it "should access deep nested settings" do
+    Settings.setting1.deep.another.should == "my value"
+  end
+
+  it "should access extra deep nested settings" do
+    Settings.setting1.deep.child.value.should == 2
+  end
+
+  it "should enable erb" do
+    Settings.setting3.should == 25
+  end
+
+  it "should namespace settings" do
+    Settings2.setting1_child.should == "saweet"
+    Settings2.deep.another.should == "my value"
+  end
+
+  it "should return the namespace" do
+    Settings.namespace.should be_nil
+    Settings2.namespace.should == 'setting1'
+  end
+
+  it "should distinguish nested keys" do
+    Settings.language.haskell.paradigm.should == 'functional'
+    Settings.language.smalltalk.paradigm.should == 'object oriented'
+  end
+  
+  it "should not collide with global methods" do
+    Settings3.nested.collides.does.should == 'not either'
+    Settings3[:nested] = 'fooey'
+    Settings3[:nested].should == 'fooey'
+    Settings3.nested.should == 'fooey'
+    Settings3.collides.does.should == 'not'
+  end
+
+  it "should raise a helpful error message" do
+    e = nil
+    begin
+      Settings.missing
+    rescue => e
+      e.should be_kind_of ReadWriteSettings::MissingSetting
+    end
+    e.should_not be_nil
+    e.message.should =~ /Missing setting 'missing' in/
+
+    e = nil
+    begin
+      Settings.language.missing
+    rescue => e
+      e.should be_kind_of ReadWriteSettings::MissingSetting
+    end
+    e.should_not be_nil
+    e.message.should =~ /Missing setting 'missing' in 'language' section/
+  end
+
+  it "should handle optional / dynamic settings" do
+    e = nil
+    begin
+      Settings.language.erlang
+    rescue => e
+      e.should be_kind_of ReadWriteSettings::MissingSetting
+    end
+    e.should_not be_nil
+    e.message.should =~ /Missing setting 'erlang' in 'language' section/
+    
+    Settings.language['erlang'].should be_nil
+    Settings.language['erlang'] = 5
+    Settings.language['erlang'].should == 5
+
+    Settings.language['erlang'] = {'paradigm' => 'functional'}
+    Settings.language.erlang.paradigm.should == 'functional'
+    Settings.respond_to?('erlang').should be_false
+
+    Settings.reload!
+    Settings.language['erlang'].should be_nil
+
+    Settings.language[:erlang] ||= 5
+    Settings.language[:erlang].should == 5
+
+    Settings.language[:erlang] = {}
+    Settings.language[:erlang][:paradigm] = 'functional'
+    Settings.language.erlang.paradigm.should == 'functional'
+
+    Settings[:toplevel] = '42'
+    Settings.toplevel.should == '42'
+  end
+
+  it "should raise an error on a nil source argument" do
+    class NoSource < ReadWriteSettings; end
+    e = nil
+    begin
+      NoSource.foo.bar
+    rescue => e
+      e.should be_kind_of Errno::ENOENT
+    end
+    e.should_not be_nil
+  end
+
+  it "should allow suppressing errors" do
+    Settings4.non_existent_key.should be_nil
+  end
+
+  # This one edge case currently does not pass, because it requires very
+  # esoteric code in order to make it pass.  It was judged not worth fixing,
+  # as it introduces significant complexity for minor gain.
+  # it "should handle reloading top-level settings"
+  #   Settings[:inspect] = 'yeah baby'
+  #   Settings.inspect.should == 'yeah baby'
+  #   Settings.reload!
+  #   Settings.inspect.should == 'Settings'
+  # end
+
+  it "should handle oddly-named settings" do
+    Settings.language['some-dash-setting#'] = 'dashtastic'
+    Settings.language['some-dash-setting#'].should == 'dashtastic'
+  end
+
+  it "should handle settings with nil value" do
+    Settings["flag"] = true
+    Settings["flag"] = nil
+    Settings.flag.should == nil
+  end
+
+  it "should handle settings with false value" do
+    Settings["flag"] = true
+    Settings["flag"] = false
+    Settings.flag.should == false
+  end
+
+  it "should support instance usage as well" do
+    settings = SettingsInst.new(Settings.source)
+    settings.setting1.setting1_child.should == "saweet"
+  end
+
+  it "should be able to get() a key with dot.notation" do
+    Settings.get('setting1.setting1_child').should == "saweet"
+    Settings.get('setting1.deep.another').should == "my value"
+    Settings.get('setting1.deep.child.value').should == 2
+  end
+
+  # If .name is not a property, delegate to superclass
+  it "should respond with Module.name" do
+    Settings2.name.should == "Settings2"
+  end
+
+  # If .name is called on ReadWriteSettings itself, handle appropriately
+  # by delegating to Hash
+  it "should have the parent class always respond with Module.name" do
+    ReadWriteSettings.name.should == 'ReadWriteSettings'
+  end
+
+  # If .name is a property, respond with that instead of delegating to superclass
+  it "should allow a name setting to be overriden" do
+    Settings.name.should == 'test'
+  end
+  
+  it "should allow symbolize_keys" do
+    Settings.reload!
+    result = Settings.language.haskell.symbolize_keys 
+    result.class.should == Hash
+    result.should == {:paradigm => "functional"} 
+  end
+  
+  it "should allow symbolize_keys on nested hashes" do
+    Settings.reload!
+    result = Settings.language.symbolize_keys
+    result.class.should == Hash
+    result.should == {
+      :haskell => {:paradigm => "functional"},
+      :smalltalk => {:paradigm => "object oriented"}
+    }
+  end
+
+  it "should handle empty file" do
+    SettingsEmpty.keys.should eql([])
+  end
+
+  # Put this test last or else call to .instance will load @instance,
+  # masking bugs.
+  it "should be a hash" do
+    Settings.send(:instance).should be_is_a(Hash)
+  end
+
+  describe "#to_hash" do
+    it "should return a new instance of a Hash object" do
+      Settings.to_hash.should be_kind_of(Hash)
+      Settings.to_hash.class.name.should == "Hash"
+      Settings.to_hash.object_id.should_not == Settings.object_id
+    end
+  end
+
+  describe "#to_nested_hash" do
+    it "should convert all nested ReadWriteSettings objects to Hash objects" do
+      hash = Settings.to_nested_hash
+      hash.class.should == Hash
+      hash["language"].class.should == Hash
+      hash["language"]["haskell"].class.should == Hash
+      hash["language"]["haskell"]["paradigm"].class.should == String
+    end
+  end
+
+  describe "#save(file)" do
+    it "should save ReadWriteSettings object such that it can be reloaded later" do
+      Settings.reload!
+      Settings["extra"] = {}
+      Settings["extra"]["value"] = 123
+      Settings.extra.value.should == 123
+      Settings.save("/tmp/settings.yml")
+
+      later_on = ReadWriteSettings.new("/tmp/settings.yml")
+      later_on.extra.value.should == 123
+    end
+  end
+
+  describe "#set('nested.key', value)" do
+    it "works like []= for non-dotted keys" do
+      Settings.set("simple", "value")
+      Settings.simple.should == "value"
+    end
+
+    it "creates new nested structures" do
+      Settings.set("nested.key", "value")
+      Settings.nested.key.should == "value"
+    end
+
+    it "reuses existing structures" do
+      Settings.set("language.ruby.paradigm", "scripting")
+      Settings.language.haskell.paradigm.should == "functional"
+      Settings.language.ruby.paradigm.should == "scripting"
+    end
+  end
+
+  describe "#set_default('nested.key', value)" do
+    it "works like #set if key 'nested.key' missing" do
+      Settings.set("nested", {})
+      Settings.set_default("nested.key", "default").should == "default"
+      Settings.nested.key.should == "default"
+    end
+
+    it "works like #set if key 'nested' missing" do
+      Settings.set_default("nested.key", "default").should == "default"
+      Settings.nested.key.should == "default"
+    end
+
+    it "does nothing if nested.key is set" do
+      Settings.set("nested.key", "value")
+      Settings.set_default("nested.key", "default").should == "value"
+      Settings.nested.key.should == "value"
+    end
+  end
+
+  describe "#exists?('nested.key') && #value('nested.key')" do
+    before { Settings.reload! }
+    it "returns truthy if nested.key is set" do
+      Settings.set("nested.key", "value")
+      Settings.nested_value("nested.key").should == "value"
+    end
+
+    it "returns falsy if nested is not set" do
+      Settings.nested_value("nested.key").should be_nil
+    end
+
+    it "returns falsy if nested.key is not set" do
+      Settings.set("nested", {})
+      Settings.exists?("nested.key").should be_nil
+    end
+  end
+
+end

data/spec/settings.rb

@@ -0,0 +1,6 @@
+class Settings < ReadWriteSettings
+  source "#{File.dirname(__FILE__)}/settings.yml"
+end
+
+class SettingsInst < ReadWriteSettings
+end

data/spec/settings.yml

@@ -0,0 +1,28 @@
+setting1:
+  setting1_child: saweet
+  deep:
+    another: my value
+    child:
+      value: 2
+
+setting2: 5
+setting3: <%= 5 * 5 %>
+name: test
+
+language:
+  haskell:
+    paradigm: functional
+  smalltalk:
+    paradigm: object oriented 
+
+collides:
+  does: not
+nested:
+  collides:
+    does: not either
+
+array:
+  -
+    name: first
+  -
+    name: second

data/spec/settings2.rb

@@ -0,0 +1,4 @@
+class Settings2 < ReadWriteSettings
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  namespace "setting1"
+end

data/spec/settings3.rb

@@ -0,0 +1,4 @@
+class Settings3 < ReadWriteSettings
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  load!  # test of load
+end

data/spec/settings4.rb

@@ -0,0 +1,4 @@
+class Settings4 < ReadWriteSettings
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  suppress_errors true
+end

data/spec/settings_empty.rb

@@ -0,0 +1,3 @@
+class SettingsEmpty < ReadWriteSettings
+  source "#{File.dirname(__FILE__)}/settings_empty.yml"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+require 'readwritesettings'
+require 'settings'
+require 'settings2'
+require 'settings3'
+require 'settings4'
+require 'settings_empty'
+
+# Needed to test Settings3
+Object.send :define_method, 'collides' do
+  'collision'
+end
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: readwritesettings
+version: !ruby/object:Gem::Version
+  version: 3.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dr Nic Williams
+- Ben Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple settings solution that uses an ERB enabled YAML file and a singleton
+  design pattern.
+email:
+- drnicwilliams@gmail.com
+- bjohnson@binarylogic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/readwritesettings.rb
+- readwritesettings.gemspec
+- spec/readwritesettings_spec.rb
+- spec/settings.rb
+- spec/settings.yml
+- spec/settings2.rb
+- spec/settings3.rb
+- spec/settings4.rb
+- spec/settings_empty.rb
+- spec/settings_empty.yml
+- spec/spec_helper.rb
+homepage: http://github.com/drnic/readwritesettings
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.8.25
+signing_key: 
+specification_version: 3
+summary: A simple settings solution that uses an ERB enabled YAML file and a singleton
+  design pattern.
+test_files:
+- spec/readwritesettings_spec.rb
+- spec/settings.rb
+- spec/settings.yml
+- spec/settings2.rb
+- spec/settings3.rb
+- spec/settings4.rb
+- spec/settings_empty.rb
+- spec/settings_empty.yml
+- spec/spec_helper.rb