confstruct 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.yardoc
+coverage
+rdoc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in confstruct.gemspec
+gemspec

data/README.md

@@ -0,0 +1,164 @@
+# confstruct
+
+<b>Confstruct</b> is yet another configuration gem. Definable and configurable by 
+hash, struct, or block, confstruct aims to provide the flexibility to do things your
+way, while keeping things simple and intuitive.
+
+[![Build Status](https://secure.travis-ci.org/mbklein/confstruct.png)](http://travis-ci.org/mbklein/confstruct])
+
+## Usage
+
+First, either create an empty `ConfStruct::Configuration` object:
+
+    config = Confstruct::Configuration.new
+    
+Or with some default values:
+
+    config = Confstruct::Configuration.new({ 
+      :project => 'confstruct', 
+      :github => { 
+        :url => 'http://www.github.com/mbklein/confstruct',
+        :branch => 'master'
+      }
+    })
+
+The above can also be done in block form:
+
+    config = Confstruct::Configuration.new do 
+      project 'confstruct'
+      github do
+        url 'http://www.github.com/mbklein/confstruct'
+        branch 'master'
+      end
+    end
+    
+There are many ways to access and configure the resulting `config` object...
+
+As a struct...
+
+    config.project = 'other-project'
+    config.github.url = 'http://www.github.com/somefork/other-project'
+    config.github.branch = 'pre-1.0'
+  
+As a block...
+
+    config.configure do
+      project 'other-project'
+      github.url 'http://www.github.com/somefork/other-project'
+      github.branch 'pre-1.0'
+    end
+
+As a hash...
+
+    config[:github][:url] = 'http://www.github.com/somefork/other-project'
+    
+Or even as a crazy struct/hash hybrid...
+
+    config.github[:url] = 'http://www.github.com/somefork/other-project'
+    config[:github].branch = 'pre-1.0'
+    
+Each sub-hash/struct is a configuration object in its own right, and can be
+treated as such. (Note the ability to leave the `configure` method
+off the inner call.)
+
+    config.configure do
+      project 'other-project'
+      github do
+        url 'http://www.github.com/somefork/other-project'
+        branch 'pre-1.0'
+      end
+    end
+
+You can even
+
+    config.project = 'other-project'
+    config.github = { :url => 'http://www.github.com/somefork/other-project', :branch => 'pre-1.0' }
+
+The configure method will even a deep merge for you if you pass it a hash or hash-like object
+(anything that responds to `each_pair`)
+
+    config.configure({:project => 'other-project', :github => {:url => 'http://www.github.com/somefork/other-project', :branch => 'pre-1.0'}})
+
+Because it's "hashes all the way down," you can store your defaults and/or configurations
+in YAML files, or in Ruby scripts if you need to evaluate expressions at config-time.
+
+However you do it, the resulting configuration object can be accessed either as a
+hash or a struct:
+
+    config.project
+     => "other-project" 
+    config[:project]
+     => "other-project" 
+    config.github
+     => {:url=>"http://www.github.com/somefork/other-project", :branch=>"pre-1.0"}
+    config.github.url
+     => "http://www.github.com/somefork/other-project" 
+    config.github[:url]
+     => "http://www.github.com/somefork/other-project" 
+    config[:github]
+     => {:url=>"http://www.github.com/somefork/other-project", :branch=>"pre-1.0"}
+
+### Advanced Tips & Tricks
+
+Any configuration value of class `Confstruct::Deferred` will be evaluated on access, allowing you to
+define read-only, dynamic configuration attributes
+
+    config[:github][:client] = Confstruct::Deferred.new { |c| RestClient::Resource.new(c.url) }
+     => #<Proc:0x00000001035eb240>
+    config.github.client 
+     => #<RestClient::Resource:0x1035e3b30 @options={}, @url="http://www.github.com/mbklein/confstruct", @block=nil> 
+    config.github.url = 'http://www.github.com/somefork/other-project'
+     => "http://www.github.com/somefork/other-project" 
+    config.github.client 
+     => #<RestClient::Resource:0x1035d5bc0 @options={}, @url="http://www.github.com/somefork/other-project", @block=nil>
+     
+As a convenience, `Confstruct.deferred(&block)` and `Confstruct::HashWithStructAccess#deferred!(&block)`
+act like `lambda`, making the following two assignments equivalent to the above:
+
+    config.github.client = Confstruct.deferred { |c| RestClient::Resource.new(c.url) }
+    config.github do
+      client deferred! { |c| RestClient::Resource.new(c.url) }
+    end
+
+`push!` and `pop!` methods allow you to temporarily override some or all of your configuration values. This can be
+useful in spec tests where you need to change values but don't want to worry about messing up tests that depend
+on the same global configuration object.
+
+    config.github.url
+     => "http://www.github.com/mbklein/confstruct"
+    config.push! { github.url 'http://www.github.com/somefork/other-project' }
+     => {:project=>"confstruct", :github=>{:branch=>"master", :url=>"http://www.github.com/somefork/other-project"}} 
+    config.github.url
+     => "http://www.github.com/somefork/other-project"
+    config.pop!
+     => {:project=>"confstruct", :github=>{:branch=>"master", :url=>"http://www.github.com/mbklein/confstruct"}} 
+    config.github.url
+     => "http://www.github.com/mbklein/confstruct"
+
+### Notes
+
+* Confstruct will attempt to use ordered hashes internally when available.
+  * In Ruby 1.9 and above, this is automatic.
+  * In Rubies earlier than 1.9, Confstruct will try to require and use ActiveSupport::OrderedHash, 
+    falling back to a regular Hash if necessary. The class/instance method `ordered?` can be used 
+    to determine if the hash is ordered or not.
+* In order to support struct access, all hash keys are converted to symbols, and are accessible
+  both as strings and symbols (like a `HashWithIndifferentAccess`). In other words, config['foo'] 
+  and config[:foo] refer to the same value.
+  
+## Release History
+
+## Contributing to confstruct
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Michael B. Klein. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+Dir.glob('lib/tasks/*.rake').each { |r| import r }

data/confstruct.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "confstruct"
+
+Gem::Specification.new do |s|
+  s.name        = "confstruct"
+  s.version     = Confstruct::VERSION
+  s.authors     = ["Michael Klein"]
+  s.email       = ["mbklein@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A simple, hash/struct-based configuration object}
+  s.description = %q{A simple, hash/struct-based configuration object}
+
+  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 "rake", ">=0.8.7"
+  s.add_development_dependency "rcov"
+  s.add_development_dependency "rdiscount"
+  s.add_development_dependency "rdoc"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "yard"
+  
+end

data/lib/confstruct.rb

@@ -0,0 +1,3 @@
+module Confstruct  
+  VERSION = '0.1.0'
+end

data/lib/confstruct/configuration.rb

@@ -0,0 +1,53 @@
+require "confstruct/hash_with_struct_access"
+
+module Confstruct
+  
+  class Configuration < HashWithStructAccess
+  
+    def initialize hash=@@hash_class.new, &block
+      super({})
+      @default_values = hash.is_a?(HashWithStructAccess) ? hash : HashWithStructAccess.new(hash)
+      eval_or_yield @default_values, &block
+      reset_defaults!
+    end
+    
+    def after_config! obj
+    end
+    
+    def configure *args, &block
+      if args[0].respond_to?(:each_pair)
+        self.deep_merge!(args[0])
+      end
+      eval_or_yield self, &block
+      after_config! self
+      self
+    end
+
+    def push! *args, &block
+      _stash.push(self.deep_copy)
+      configure *args, &block if args.length > 0 or block_given?
+      self
+    end
+    
+    def pop!
+      if _stash.empty?
+        raise IndexError, "Stash is empty"
+      else
+        obj = _stash.pop
+        self.clear
+        self.merge! obj
+        after_config! self
+      end
+      self
+    end
+    
+    def reset_defaults!
+      self.replace(default_values.deep_copy)
+    end
+
+    protected
+    def _stash
+      @stash ||= []
+    end
+  end
+end

data/lib/confstruct/hash_with_struct_access.rb

@@ -0,0 +1,214 @@
+require 'delegate'
+require 'confstruct/utils'
+
+module Confstruct
+  class Deferred < Proc; end
+  def self.deferred &block; Deferred.new(&block); end
+
+  if ::RUBY_VERSION < '1.9'
+    begin
+      require 'active_support/ordered_hash'
+      class HashWithStructAccess < DelegateClass(ActiveSupport::OrderedHash); @@ordered = true; @@hash_class = ActiveSupport::OrderedHash; end
+    rescue LoadError, NameError
+      class HashWithStructAccess < DelegateClass(Hash); @@ordered = false; @@hash_class = Hash; end
+    end
+  else
+    class HashWithStructAccess < DelegateClass(Hash); @@ordered = true; @@hash_class = Hash; end
+  end
+  
+  class HashWithStructAccess
+    attr_accessor :default_values
+    @default_values = {}
+    
+    class << self
+      def from_hash hash
+        symbolized_hash = symbolize_hash hash
+        self.new(symbolized_hash)
+      end
+
+      def ordered?
+        @@ordered
+      end
+      
+      def structurize hash
+        result = hash
+        if result.is_a?(Hash) and not result.is_a?(HashWithStructAccess)
+          result = HashWithStructAccess.new(result)
+        end
+        result
+      end
+      
+      def symbolize_hash hash
+        hash.inject(@@hash_class.new) do |h,(k,v)| 
+          h[symbolize k] = v.is_a?(Hash) ? symbolize_hash(v) : v
+          h
+        end
+      end
+      
+      def symbolize key
+        (key.to_s.gsub(/\s+/,'_').to_sym rescue key.to_sym) || key
+      end
+    end
+    
+    def initialize hash = @@hash_class.new
+      super(hash)
+    end
+
+    def [] key
+      result = structurize! super(symbolize!(key))
+      if result.is_a?(Deferred)
+        result = eval_or_yield self, &result
+      end
+      result
+    end
+    
+    def []= key,value
+      k = symbolize!(key)
+      v = structurize! value
+      if v.is_a?(Hash) and self[k].is_a?(Hash)
+        self[k].replace(v)
+      else
+        super(k, v)
+      end
+    end
+
+    def deep_copy
+      result = self.class.new(@@hash_class.new)
+      self.each_pair do |k,v|
+        if v.respond_to?(:deep_copy)
+          result[k] = v.deep_copy
+        else
+          result[k] = Marshal.load(Marshal.dump(v)) rescue v.dup
+        end
+      end
+      result
+    end
+    alias_method :inheritable_copy, :deep_copy
+
+    def deep_merge hash
+      do_deep_merge! hash, self.deep_copy
+    end
+
+    def deep_merge! hash
+      do_deep_merge! hash, self
+    end
+
+    def deferred! &block
+      Deferred.new(&block)
+    end
+    
+    def has? key_path
+      val = self
+      keys = key_path.split(/\./)
+      keys.each do |key|
+        return false if val.nil?
+        if val.respond_to?(:has_key?) and val.has_key?(key.to_sym)
+          val = val[key.to_sym]
+        else
+          return false
+        end
+      end
+      return true
+    end
+    
+    def inspect
+      r = self.keys.collect { |k| "#{k.inspect}=>#{self[k].inspect}" }
+      "{#{r.compact.join(', ')}}"
+    end
+    
+    def is_a? klazz
+      klazz == @@hash_class or super
+    end
+    
+    def lookup! key_path
+      val = self
+      keys = key_path.split(/\./)
+      keys.each do |key|
+        return nil if val.nil?
+        if val.respond_to?(:has_key?) and val.has_key?(key.to_sym)
+          val = val[key.to_sym]
+        else
+          return nil
+        end
+      end
+      return val
+    end
+    
+    def method_missing sym, *args, &block
+      name = sym.to_s.chomp('=').to_sym
+      result = nil
+      
+      if name.to_s =~ /^add_(.+)!$/
+        name = $1.to_sym
+        self[name] = [] unless self.has_key?(name)
+        unless self[name].is_a?(Array)
+          raise TypeError, "Cannot #add! to a #{self[name].class}"
+        end
+        if args.length > 0
+          local_args = args.collect { |a| structurize! a }
+          result = self[name].push *local_args
+        elsif block_given?
+          result = HashWithStructAccess.new(@@hash_class.new)
+          self[name].push result
+        end
+      elsif args.length == 1
+        result = self[name] = args[0]
+      elsif args.length > 1
+        super(sym,*args,&block)
+      else
+        result = self[name]
+        if result.nil? and block_given?
+          result = self[name] = HashWithStructAccess.new(@@hash_class.new)
+        end
+      end
+      if block_given?
+        eval_or_yield result, &block
+      end
+      result
+    end
+    
+    def methods
+      key_methods = keys.collect do |k|
+        self[k].is_a?(Deferred) ? k.to_s : [k.to_s, "#{k}="]
+      end
+      super + key_methods.compact.flatten
+    end
+    
+    def ordered?
+      self.class.ordered?
+    end
+    
+    def respond_to? arg
+      super(arg) || keys.include?(symbolize!(arg.to_s.sub(/=$/,'')))
+    end
+
+    def structurize! hash
+      self.class.structurize(hash)
+    end
+    
+    def symbolize! key
+      self.class.symbolize(key)
+    end
+       
+    def values
+     keys.collect { |k| self[k] }
+    end
+
+    protected 
+    def do_deep_merge! source, target
+      source.each_pair do |k,v|
+        if target.has_key?(k)
+          if v.respond_to?(:each_pair) and target[k].respond_to?(:merge)
+            do_deep_merge! v, target[k]
+          elsif v != target[k]
+            target[k] = v
+          end
+        else
+          target[k] = v
+        end
+      end
+      target
+    end
+
+  end
+end

data/lib/confstruct/utils.rb

@@ -0,0 +1,13 @@
+module Kernel
+  def eval_or_yield obj, &block
+    if block_given?
+      if block.arity < 1
+        obj.instance_eval(&block)
+      else
+        block.call(obj)
+      end
+    else
+      obj
+    end
+  end
+end

data/lib/tasks/rdoc.rake

@@ -0,0 +1,32 @@
+desc "Generate RDoc"
+task :doc => ['doc:generate']
+
+namespace :doc do
+  project_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  doc_destination = File.join(project_root, 'rdoc')
+
+  begin
+    require 'yard'
+    require 'yard/rake/yardoc_task'
+
+    YARD::Rake::YardocTask.new(:generate) do |yt|
+      yt.files   =  Dir.glob(File.join(project_root, 'lib', '*.rb')) + 
+                    Dir.glob(File.join(project_root, 'lib', '**', '*.rb')) +
+                   [ File.join(project_root, 'README.rdoc') ] +
+                   [ File.join(project_root, 'LICENSE') ]
+                   
+      yt.options = ['--output-dir', doc_destination, '--readme', 'README.rdoc']
+    end
+  rescue LoadError
+    desc "Generate YARD Documentation"
+    task :generate do
+      abort "Please install the YARD gem to generate rdoc."
+    end
+  end
+
+  desc "Remove generated documenation"
+  task :clean do
+    rm_r doc_destination if File.exists?(doc_destination)
+  end
+
+end

data/lib/tasks/rspec.rake

@@ -0,0 +1,17 @@
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', '/gems/,/Library/,/usr/,spec,lib/tasks']
+end

data/spec/confstruct/configuration_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'confstruct/configuration'
+
+describe Confstruct::Configuration do
+
+  it "should initialize empty" do
+    conf = Confstruct::Configuration.new
+    conf.is_a?(Hash).should be_true
+    conf.is_a?(Confstruct::Configuration).should be_true
+    conf.should == {}
+  end
+
+  context "default values" do
+    before :all do
+      @defaults = { 
+        :project => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          :branch => 'master'
+        }
+      }
+    end
+    
+    before :each do
+      @config = Confstruct::Configuration.new(@defaults)
+    end
+    
+    it "should have the correct defaults" do
+      @config.default_values.should == @defaults
+      @config.should == @defaults
+    end
+    
+    it "can be defined in block mode" do
+      config = Confstruct::Configuration.new do
+        project 'confstruct'
+        github do
+          url 'http://www.github.com/mbklein/confstruct'
+          branch 'master'
+        end
+      end
+      config.default_values.should == @defaults
+      config.should == @defaults
+    end
+  end
+  
+  context "configuration" do
+    before :all do
+      @defaults = { 
+        :project => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          :branch => 'master'
+        }
+      }
+      
+      @configured = { 
+        :project => 'other-project', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/other-project',
+          :branch => 'master'
+        }
+      }
+    end
+
+    before :each do
+      @config = Confstruct::Configuration.new(@defaults)
+    end
+    
+    it "should deep merge a hash" do
+      @config.configure({ :project => 'other-project', :github => { :url => 'http://www.github.com/mbklein/other-project' } })
+      @config.should == @configured
+    end
+
+    it "should configure as a struct" do
+      @config.project = 'other-project'
+      @config.github.url = 'http://www.github.com/mbklein/other-project'
+      @config.should == @configured
+    end
+    
+    it "should configure as a block" do
+      @config.configure do
+        project 'other-project'
+        github do
+          url 'http://www.github.com/mbklein/other-project'
+        end
+      end
+      @config.should == @configured
+    end
+    
+    it "should save and restore state via #push! and #pop!" do
+      @config.push!({ :project => 'other-project', :github => { :url => 'http://www.github.com/mbklein/other-project' } })
+      @configured.each_pair { |k,v| @config[k].should == v }
+      @config.pop!
+      @defaults.each_pair { |k,v| @config[k].should == v }
+    end
+    
+    it "should raise an exception when popping an empty stash" do
+      lambda { @config.pop! }.should raise_error(IndexError)
+    end
+
+    it "should #reset_defaults!" do
+      @config.project = 'other-project'
+      @config.github.url = 'http://www.github.com/mbklein/other-project'
+      @config.should == @configured
+      @config.reset_defaults!
+      @config.should == @defaults
+    end
+    
+    it "should call #after_config! when configuration is complete" do
+      postconfigurator = RSpec::Mocks::Mock.new('after_config!')
+      postconfigurator.should_receive(:configured!).once.with(@config)
+      def @config.after_config! obj
+        obj.project.should == 'other-project'
+        obj.mock.configured!(obj)
+      end
+      @config.configure do
+        project 'other-project'
+        mock postconfigurator
+      end
+    end
+  end
+
+end

data/spec/confstruct/hash_with_struct_access_spec.rb

@@ -0,0 +1,226 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'confstruct/hash_with_struct_access'
+
+describe Confstruct::HashWithStructAccess do
+  
+  it "should initialize empty" do
+    hwsa = Confstruct::HashWithStructAccess.new
+    hwsa.is_a?(Hash).should be_true
+    hwsa.is_a?(Confstruct::HashWithStructAccess).should be_true
+    hwsa.should == {}
+  end
+  
+  it "should respond to #ordered?" do
+    hwsa = Confstruct::HashWithStructAccess.new
+    [true,false].should include(hwsa.ordered?)
+  end
+  
+  context "data manipulation" do
+    before :all do
+      @hash = { 
+        :project => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          :default_branch => 'master'
+        }
+      }
+    end
+  
+    before :each do
+      @hwsa = Confstruct::HashWithStructAccess.from_hash(@hash)
+    end
+    
+    it "should initialize from a hash" do
+      hwsa = Confstruct::HashWithStructAccess.from_hash({ 
+        'project' => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          'default branch' => 'master'
+        }
+      })
+
+      hwsa.should == @hwsa
+      hwsa.should == @hash
+    end
+    
+    it "should provide hash access" do
+      @hwsa[:project].should == @hash[:project]
+      @hwsa['project'].should == @hash[:project]
+      @hwsa[:github].should == @hash[:github]
+      @hwsa[:github][:url].should == @hash[:github][:url]
+    end
+    
+    it "should provide struct access" do
+      @hwsa.project.should == @hash[:project]
+      @hwsa.github.should == @hash[:github]
+      @hwsa.github.url.should == @hash[:github][:url]
+    end
+    
+    it "should provide block access" do
+      u = @hash[:github][:url]
+      @hwsa.github do
+        url.should == u
+      end
+      
+      @hwsa.github do |g|
+        g.url.should == @hash[:github][:url]
+      end
+    end
+    
+    it "should properly respond to #has?" do
+      @hwsa.has?('github.url').should be_true
+      @hwsa.has?('github.foo.bar.baz').should be_false
+    end
+    
+    it "should properly respond to #lookup!" do
+      @hwsa.lookup!('github.url').should == @hash[:github][:url]
+      @hwsa.lookup!('github.foo.bar.baz').should be_nil
+    end
+    
+    it "should provide introspection" do
+      @hwsa.should_respond_to(:project)
+      @hash.keys.each do |m| 
+        @hwsa.methods.should include("#{m}")
+        @hwsa.methods.should include("#{m}=")
+      end
+    end
+    
+    it "should #deep_merge" do
+      hwsa = @hwsa.deep_merge({ :new_foo => 'bar', :github => { :default_branch => 'develop' } })
+      @hwsa.should == @hash
+      hwsa.should_not == @hwsa
+      hwsa.should_not == @hash
+      hwsa.should == { 
+        :new_foo => 'bar',
+        :project => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          :default_branch => 'develop'
+        }
+      }
+    end
+
+    it "should #deep_merge!" do
+      @hwsa.deep_merge!({ :github => { :default_branch => 'develop' } })
+      @hwsa.should_not == @hash
+      @hwsa.should == { 
+        :project => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          :default_branch => 'develop'
+        }
+      }
+    end
+    
+    it "should create values on demand" do
+      @hwsa.github.foo = 'bar'
+      @hwsa.github.should == { 
+        :foo => 'bar',
+        :url => 'http://www.github.com/mbklein/confstruct',
+        :default_branch => 'master'
+      }
+
+      @hwsa.baz do
+        quux 'default_for_quux'
+      end
+      @hwsa[:baz].should == { :quux => 'default_for_quux' }
+    end
+
+    it "should replace an existing hash" do
+      @hwsa.github = { :url => 'http://www.github.com/somefork/other-project', :branch => 'pre-1.0' }
+      @hwsa.github.has_key?(:default_branch).should == false
+      @hwsa.github.should == { :url => 'http://www.github.com/somefork/other-project', :branch => 'pre-1.0' }
+    end
+    
+    it "should eval_or_yield all types" do
+      @hwsa.github do
+        items([]) do
+          self.should == []
+          push 1
+          push 'two'
+          push :III
+          self.should == [1,'two',:III]
+        end
+      end
+      @hwsa.github.items.should == [1,'two',:III]
+    end
+    
+    it "should fail on other method signatures" do
+      lambda { @hwsa.error(1, 2, 3) }.should raise_error(NoMethodError)
+    end
+  end
+
+  context "Proc values as virtual methods" do
+    before :all do
+      @hash = { 
+        :project => 'confstruct', 
+        :github => { 
+          :url => 'http://www.github.com/mbklein/confstruct',
+          :default_branch => 'master',
+          :regular_proc => lambda { |a,b,c| puts "#{a}: #{b} #{c}" },
+          :reverse_url => Confstruct.deferred { self.url.reverse },
+          :upcase_url => Confstruct.deferred { |c| c.url.upcase }
+        }
+      }
+    end
+  
+    before :each do
+      @hwsa = Confstruct::HashWithStructAccess.from_hash(@hash)
+    end
+    
+    it "should only evaluate Confstruct::Deferred procs" do
+      @hwsa.github.regular_proc.is_a?(Proc).should be_true
+      @hwsa.github.upcase_url.is_a?(Proc).should be_false
+      @hwsa.github.reverse_url.is_a?(Proc).should be_false
+    end
+    
+    it "should instance_eval the proc with no params" do
+      @hwsa.github.reverse_url.should == @hash[:github][:url].reverse
+    end
+
+    it "should call the proc with params" do
+      @hwsa.github.upcase_url.should == @hash[:github][:url].upcase
+    end
+        
+    it "should evaluate deferreds when enumerating values" do
+      @hash[:github].values.should_not include(@hash[:github][:url].reverse)
+      @hwsa.github.values.should include(@hash[:github][:url].reverse)
+    end
+
+    it "should evaluate deferreds when inspecting" do
+      s = @hwsa.inspect
+      s.should =~ %r[:reverse_url=>"tcurtsfnoc/nielkbm/moc.buhtig.www//:ptth"]
+      s.should =~ %r[:regular_proc=>#<Proc:]
+    end
+    
+    it "should allow definition of deferreds in block mode" do
+      @hwsa.github do
+        defproc deferred! { reverse_url + upcase_url }
+        regproc lambda { reverse_url + upcase_url }
+      end
+      @hwsa.github.defproc.is_a?(Proc).should be_false
+      @hwsa.github.defproc.should == @hwsa.github.reverse_url + @hwsa.github.upcase_url
+      @hwsa.github.regproc.is_a?(Proc).should be_true
+    end
+    
+    it "should create arrays on the fly" do
+      @hwsa.github do
+        add_roles!({:jeeves => :valet}, {:wooster => :dolt})
+        add_roles! do
+          psmith :chum
+        end
+      end
+      @hwsa.github.roles.should == [{:jeeves => :valet}, {:wooster => :dolt}, {:psmith => :chum}]
+      @hwsa.github.roles.first.jeeves.should == :valet
+    end
+    
+    it "should not allow #add!ing to non-Array types" do
+      lambda { 
+        @hwsa.github do
+          add_url! 'https://github.com/mbklein/busted'
+        end
+      }.should raise_error(TypeError)
+    end
+    
+  end
+end

data/spec/confstruct/utils_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'confstruct/utils'
+
+describe "Kernel.eval_or_yield" do
+  before :all do
+    @obj = RSpec::Mocks::Mock.new('obj')
+  end
+  
+  it "should instance_eval when the block takes no params" do
+    @obj.should_receive(:test).and_return('OK')
+    eval_or_yield(@obj) { 
+      self.should_not == @obj
+      self.test.should == 'OK'
+    }
+  end
+  
+  it "should yield when the block takes a param" do
+    @obj.should_receive(:test).and_return('OK')
+    eval_or_yield(@obj) { |o|
+      self.should_not == @obj
+      o.should == @obj
+      lambda { self.test }.should raise_error(NoMethodError)
+      o.test.should == 'OK'
+    }
+  end
+  
+  it "should return the object when no block is given" do
+    eval_or_yield(@obj).should == @obj
+  end
+  
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'bundler/setup'
+require 'rspec'
+require 'rspec/autorun'
+
+require 'rubygems'
+require 'confstruct'
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification 
+name: confstruct
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Klein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: A simple, hash/struct-based configuration object
+email: 
+- mbklein@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- confstruct.gemspec
+- lib/confstruct.rb
+- lib/confstruct/configuration.rb
+- lib/confstruct/hash_with_struct_access.rb
+- lib/confstruct/utils.rb
+- lib/tasks/rdoc.rake
+- lib/tasks/rspec.rake
+- spec/confstruct/configuration_spec.rb
+- spec/confstruct/hash_with_struct_access_spec.rb
+- spec/confstruct/utils_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A simple, hash/struct-based configuration object
+test_files: 
+- spec/confstruct/configuration_spec.rb
+- spec/confstruct/hash_with_struct_access_spec.rb
+- spec/confstruct/utils_spec.rb
+- spec/spec_helper.rb
+has_rdoc: