RubyGems - options_hash - Versions diffs - 0.0.1 - Mend

options_hash 0.0.1

Files changed (17) hide show

checksums.yaml +7 -0
data/.gitignore +17 -0
data/.rspec +2 -0
data/.travis.yml +12 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +172 -0
data/Rakefile +1 -0
data/lib/options_hash.rb +204 -0
data/lib/options_hash/version.rb +3 -0
data/options_hash.gemspec +25 -0
data/spec/options_hash_spec.rb +295 -0
data/spec/spec_helper.rb +24 -0
data/spec/support/empty_options.rb +3 -0
data/spec/support/person.rb +9 -0
data/spec/support/person_options.rb +10 -0
metadata +120 -0

checksums.yaml ADDED

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 080f15a9148fb2d6250e85f0779d4bf84813e34d
+  data.tar.gz: 7d41b4bc07b434c3c52df25b73c1d6dc2f38bbfc
+SHA512:
+  metadata.gz: b7f4cbdfbb969bdee95b86fb23c61b2c31f858f6d3f62e245894691feb91746bef5617c25474971eec0c7b8336f0d6a48c1ce65ad06ecc7d4ddd4f64101e1850
+  data.tar.gz: 8c14f9cd0777ac19bd8a43e33ef562b109a0af748ecb648a9e8a18b2cdc39bb5036d37d2889a0fd93055f0504478d4a0bde4a55b8cfed1bf24f70f27966fd597

data/.gitignore ADDED

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec ADDED

	@@ -0,0 +1,2 @@
1	+ --color
2	+ --format progress

data/.travis.yml ADDED

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-2.1.1
+  - ruby-head
+  - jruby-head
+  - 1.8.7
+  - ree

data/Gemfile ADDED

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

data/LICENSE.txt ADDED

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jared Grippe
+MIT License
+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 ADDED

@@ -0,0 +1,172 @@
+# OptionsHash
+An OptionsHash is a definition of required and optional keys in an options hash
+## Installation
+Add this line to your application's Gemfile:
+    gem 'options_hash'
+And then execute:
+    $ bundle
+Or install it yourself as:
+    $ gem install options_hash
+## Usage
+A simple use case goes something like this:
+```ruby
+require 'net/http'
+def http_get options
+  options = OptionsHash.parse(options) do
+    required :host, :path
+    optional :port, default: 80
+  end
+  Net::HTTP.get(options.host, options.path, options.port)
+end
+http_get
+# => ArgumentError: wrong number of arguments (0 for 1)
+http_get({})
+# => ArgumentError: required options: :host, :path
+http_get(host: 'google.com')
+# => ArgumentError: required options: :path
+http_get(host: 'google.com', path: '/')
+# => "<HTML><HEAD><meta ht..."
+http_get(host: 'google.com', path: '/', port: 81)
+# => Net::HTTPRequestTimeOut
+```
+A possibly more common use case:
+```ruby
+class Person
+  class Options < OptionsHash
+    required :name
+    optional :age, default: 31
+  end
+  def initialize options
+    @options = Options.parse(options)
+  end
+  attr_reader :options
+end
+me = Person.new({}) # => ArgumentError: required options: :name
+me = Person.new(name: 'Jared Grippe')
+me.options.name    # => "Jared Grippe"
+me.options.age     # => 31
+me.options.to_hash # => {:name=>"Jared Grippe", :age=>31}
+me = Person.new(name: 'Jared Grippe', age: 25)
+me.options.name    # => "Jared Grippe"
+me.options.age     # => 25
+```
+Advanced usage:
+```ruby
+class PersonOptions < OptionsHash
+  required :name
+  optional :favorite_color
+  optional :species, default: :human
+end
+PersonOptions.options # => {
+  # :name=>required without default,
+  # :favorite_color=>optional without default,
+  # :species=>optional with default}
+PersonOptions[:name]                   # => required without default
+PersonOptions[:name].required?         # => true
+PersonOptions[:name].has_default?      # => false
+PersonOptions[:name].has_default_proc? # => false
+PersonOptions[:name].default           # => nil
+PersonOptions.parse({}) # ArgumentError: required options: :name
+PersonOptions.parse(name: 'Steve')
+# => #<PersonOptions {:name=>"Steve", :favorite_color=>nil, :species=>:human}>
+PersonOptions.parse(name: 'Steve', favorite_color: 'blue')
+# => #<PersonOptions {:name=>"Steve", :favorite_color=>"blue", :species=>:human}>
+PersonOptions.parse(name: 'Steve', species: :robot)
+# => #<PersonOptions {:name=>"Steve", :favorite_color=>"blue", :species=>:robot}>
+options = PersonOptions.parse(name: 'Steve', species: :robot)
+options.name           # => "Steve"
+options.favorite_color # => nil
+options.species        # => :robot
+options.given? :name           # => true
+options.given? :favorite_color # => false
+options.given? :species        # => true
+options.to_hash # => {:name=>"Steve", :favorite_color=>nil, :species=>:robot}
+```
+All options can take a block to determine their default value:
+```ruby
+class PersonOptions < OptionsHash
+  required(:first_name, :last_name) { |name| name.to_sym }
+  optional :full_name, default: ->{ "#{first_name} #{last_name}" }
+end
+PersonOptions
+# => PersonOptions(required: [:first_name, :last_name], optional: [:full_name])
+options = PersonOptions.parse(first_name: 'Jared', last_name: 'Grippe')
+# => #<PersonOptions {:first_name=>:Jared, :last_name=>:Grippe, :full_name=>"Jared Grippe"}>
+options.given_options
+# => {:first_name=>"Jared", :last_name=>"Grippe"}
+options[:first_name] # => :Jared
+options[:last_name]  # => :Grippe
+options[:full_name]  # => "Jared Grippe"
+```
+Option hashes can inherit from other option hashes
+```ruby
+class AnimalOptions < OptionsHash
+  required :species
+  optional :alive, default: true
+end
+class DogOptions < AnimalOptions
+  required :name, :breed
+end
+AnimalOptions
+# => AnimalOptions(required: [:species], optional: [:alive])
+DogOptions
+# => DogOptions(required: [:breed, :name, :species], optional: [:alive])
+DogOptions[:alive].default # => true
+```
+## Contributing
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile ADDED

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/lib/options_hash.rb ADDED

@@ -0,0 +1,204 @@
+require "options_hash/version"
+class OptionsHash
+  class Option
+    def initialize required, default=nil
+      @required, @default = !!required, default
+    end
+    def required?; @required; end
+    attr_reader :default
+    def has_default?
+      !!default
+    end
+    def has_default_proc?
+      default.is_a? Proc
+    end
+    def inspect
+      %(#{required? ? 'required' : 'optional'} #{default ? 'with' : 'without'} default)
+    end
+    alias_method :to_s, :inspect
+  end
+  def self.inherited(subclass)
+    subclass.send :extend,  ClassMethods
+    subclass.send :include, InstanceMethods
+    subclass
+  end
+  class << self
+    alias_method :_new, :new
+    undef_method :new
+    private :_new
+    def parse options, &block
+      block_given? or raise ArgumentError, 'block required', caller(2)
+      Class.new(self, &block).parse(options)
+    rescue ArgumentError => error
+      raise ArgumentError, error.message, caller(2)
+    end
+  end
+  module ClassMethods
+    def parse options
+      _new options
+    rescue ArgumentError => error
+      raise ArgumentError, error.message, caller(2)
+    end
+    def options
+      @options ||= {}
+      (superclass.respond_to?(:options) ? superclass.options : {}).merge @options
+    end
+    def option? key
+      keys.include? key
+    end
+    def [] key
+      option? key or raise KeyError, "#{key} is not an option", caller(1)
+      options[key]
+    end
+    def keys
+      options.keys.to_set
+    end
+    def required_keys
+      options.select{|key, option| option.required? }.keys.to_set
+    end
+    def optional_keys
+      options.reject{|key, option| option.required? }.keys.to_set
+    end
+    def required *options, &block
+      default = extract_default options, &block
+      set_options Option.new(true, default), *options
+    end
+    def optional *options, &block
+      default = extract_default options, &block
+      set_options Option.new(false, default), *options
+    end
+    def define_attr_readers object, instance_variable_name=:@options
+      self.freeze
+      instance_variable_name = "@#{instance_variable_name.to_s.sub(/@/,'')}"
+      keys.each do |key|
+        object.send(:define_method, "#{key}" ) do
+          instance_variable_get(instance_variable_name)[key]
+        end
+      end
+    end
+    alias_method :_inspect, :inspect
+    private :_inspect
+    def class_name
+      name || "OptionsHash:#{_inspect[/^#<Class:(\w+)/,1]}"
+    end
+    def inspect
+      inspect = super
+      required_keys = self.required_keys.to_a.sort
+      optional_keys = self.optional_keys.to_a.sort
+      "#{class_name}(required: #{required_keys.inspect}, optional: #{optional_keys.inspect})"
+    end
+    alias_method :to_s, :inspect
+    private
+    def extract_default options, &block
+      return block if block_given?
+      (options.last.is_a?(Hash) ? options.pop : {})[:default]
+    end
+    def set_options definition, *options
+      @options ||= {}
+      options.each do |key|
+        key = key.to_sym
+        @options[key] = definition.dup
+        define_method("#{key}" ){ fetch key }
+        define_method("#{key}?"){ given? key }
+      end
+    end
+  end
+  module InstanceMethods
+    def initialize given_options
+      @keys          = self.class.keys.freeze
+      @options       = self.class.options.freeze
+      @given_options = (given_options || {}).freeze
+      unknown_options = @given_options.keys - keys.to_a
+      unknown_options.empty? or raise ArgumentError, "unknown options: #{unknown_options.sort.map(&:inspect).join(', ')}"
+      missing_required_options = required_keys.to_a - @given_options.keys
+      missing_required_options.empty? or raise ArgumentError, "required options: #{missing_required_options.sort.map(&:inspect).join(', ')}"
+      @values        = {}
+      keys.to_a.sort.each{|key| send(key) }
+    end
+    attr_reader :keys, :options, :given_options
+    def required_keys
+      @options.select do |key, option|
+        option.required?
+      end.keys.to_set
+    end
+    def given? key
+      @given_options.key? key
+    end
+    def fetch key
+      key = key.to_sym
+      keys.include?(key) or raise KeyError, "#{key} is not an option", caller(1)
+      return @values[key] if @values.key? key
+      option = @options[key]
+      default_proc = option.default if option.default && option.default.is_a?(Proc)
+      if option.required?
+        value = @given_options[key]
+        value = instance_exec(value, &default_proc) if option.required? && default_proc
+        return @values[key] = value
+      end
+      return @values[key] = @given_options[key] if @given_options.key? key
+      return @values[key] = default_proc ? instance_exec(&default_proc) : option.default
+    end
+    alias_method :[], :fetch
+    def to_hash
+      keys.each_with_object Hash.new do |key, hash|
+        hash[key] = send(key)
+      end
+    end
+    def inspect
+      %(#<#{self.class.class_name} #{to_hash.inspect}>)
+    end
+    alias_method :to_s, :inspect
+  end
+end
+# class Foo
+#   def whatever options={}
+#     OptionsHash.parse(options) do
+#       required :name
+#       optional :size, default: 42
+#     end
+#   end
+# end

data/lib/options_hash/version.rb ADDED

@@ -0,0 +1,3 @@
+class OptionsHash
+  VERSION = "0.0.1"
+end

data/options_hash.gemspec ADDED

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'options_hash/version'
+Gem::Specification.new do |spec|
+  spec.name          = "options_hash"
+  spec.version       = OptionsHash::VERSION
+  spec.authors       = ["Jared Grippe"]
+  spec.email         = ["jared@deadlyicon.com"]
+  spec.description   = %q{A configurable options hash definition}
+  spec.summary       = %q{A configurable options hash definition}
+  spec.homepage      = "https://github.com/deadlyicon/options_hash"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-debugger"
+end

data/spec/options_hash_spec.rb ADDED

@@ -0,0 +1,295 @@
+require 'spec_helper'
+describe OptionsHash do
+  subject{ described_class }
+  it { should_not respond_to :new           }
+  it { should_not respond_to :options       }
+  it { should_not respond_to :keys          }
+  it { should_not respond_to :required_keys }
+  it { should_not respond_to :optional_keys }
+  it { should_not respond_to :required      }
+  it { should_not respond_to :optional      }
+  its(:name   ){ should == 'OptionsHash' }
+  its(:inspect){ should == 'OptionsHash' }
+  its(:to_s   ){ should == 'OptionsHash' }
+  shared_examples 'an options hash' do
+    it { should_not respond_to :new       }
+    it { should respond_to :options       }
+    it { should respond_to :keys          }
+    it { should respond_to :required_keys }
+    it { should respond_to :optional_keys }
+    it { should respond_to :required      }
+    it { should respond_to :optional      }
+  end
+  shared_examples 'an options hash instance' do
+    its(:inspect){ should =~ %r[#<#{subject.class.class_name} #{subject.to_hash.inspect}>] }
+    its(:to_s   ){ should =~ %r[#<#{subject.class.class_name} #{subject.to_hash.inspect}>] }
+    it 'should respond to each key' do
+      subject.keys.each do |key|
+        expect(subject).to respond_to "#{key}"
+        expect(subject).to respond_to "#{key}?"
+      end
+    end
+  end
+  describe '.parse' do
+    context 'when given no arguments' do
+      subject{ ->{ OptionsHash.parse } }
+      it { should raise_error ArgumentError, 'wrong number of arguments (0 for 1)' }
+    end
+    context 'when given no block' do
+      subject{ ->{ OptionsHash.parse({}) } }
+      it { should raise_error ArgumentError, 'block required' }
+    end
+    context 'when given insufficient options' do
+      subject{ ->{ OptionsHash.parse({}){ required :name } } }
+      it { should raise_error ArgumentError, 'required options: :name' }
+    end
+    context 'when given unknown options' do
+      subject{ ->{ OptionsHash.parse(foo:1){ } } }
+      it { should raise_error ArgumentError, 'unknown options: :foo' }
+    end
+    context 'when given valid options' do
+      subject do
+        OptionsHash.parse(name: 'steve') do
+          required :name
+          optional :size, default: 42
+        end
+      end
+      it_behaves_like 'an options hash instance'
+      its(:name){ should eq 'steve' }
+      its(:size){ should eq 42 }
+      its(:to_hash){ should eq(:name=>"steve", :size=>42) }
+    end
+  end
+  describe 'OptionsHash(required: [:a, :b], optional: [:c, :d])' do
+    let :options_hash do
+      Class.new(OptionsHash) do
+        required :a
+        required :b do |b|
+          b.inspect
+        end
+        optional :c
+        optional :d, default: ->{ 42 }
+      end
+    end
+    describe '.parse' do
+      context '(nil)' do
+        subject{ ->{ options_hash.parse(nil) } }
+        it{ should raise_error ArgumentError, 'required options: :a, :b' }
+      end
+      context '({})' do
+        subject{ ->{ options_hash.parse({}) } }
+        it{ should raise_error ArgumentError, 'required options: :a, :b' }
+      end
+      context '(a:1)' do
+        subject{ ->{ options_hash.parse(a:1) } }
+        it{ should raise_error ArgumentError, 'required options: :b' }
+      end
+      context '(b:1)' do
+        subject{ ->{ options_hash.parse(b:1) } }
+        it{ should raise_error ArgumentError, 'required options: :a' }
+      end
+      context '(a:1, b:2)' do
+        subject{ options_hash.parse(a:1, b:2) }
+        its(:a){ should eq 1 }
+        its(:b){ should eq '2' }
+        its(:c){ should be_nil }
+        its(:d){ should eq 42 }
+      end
+      context '(a:1, b:2, c:3)' do
+        subject{ options_hash.parse(a:1, b:2, c:3) }
+        its(:a){ should eq 1 }
+        its(:b){ should eq '2' }
+        its(:c){ should eq 3 }
+        its(:d){ should eq 42 }
+      end
+      context '(a:1, b:2, c:3, d:4)' do
+        subject{ options_hash.parse(a:1, b:2, c:3, d:4) }
+        its(:a){ should eq 1 }
+        its(:b){ should eq '2' }
+        its(:c){ should eq 3 }
+        its(:d){ should eq 4 }
+      end
+      context '(a: nil, b: nil, c: nil, d: nil)' do
+        subject{ options_hash.parse(a: nil, b: nil, c: nil, d: nil) }
+        its(:a){ should be_nil }
+        its(:b){ should eq 'nil' }
+        its(:c){ should be_nil }
+        its(:d){ should be_nil }
+      end
+    end
+    describe '#define_attr_readers' do
+      it 'should freeze the options hash' do
+        expect(options_hash).to_not be_frozen
+        options_hash.define_attr_readers(Class.new)
+        expect(options_hash).to be_frozen
+      end
+      it "should define attr readers for each option" do
+        options_hash = self.options_hash
+        _class = Class.new
+        _class.send(:define_method, :initialize) do |options|
+          @options = options_hash.parse(options)
+        end
+        options_hash.define_attr_readers(_class)
+        expect(_class.new(a:1,b:2,c:3,d:4).a).to eq 1
+        expect(_class.new(a:1,b:2,c:3,d:4).b).to eq '2'
+        expect(_class.new(a:1,b:2,c:3,d:4).c).to eq 3
+        expect(_class.new(a:1,b:2,c:3,d:4).d).to eq 4
+        options_hash = self.options_hash
+        _class = Class.new
+        _class.send(:define_method, :initialize) do |options|
+          @swordfish = options_hash.parse(options)
+        end
+        options_hash.define_attr_readers(_class, :@swordfish)
+        expect(_class.new(a:1,b:2,c:3,d:4).a).to eq 1
+        expect(_class.new(a:1,b:2,c:3,d:4).b).to eq '2'
+        expect(_class.new(a:1,b:2,c:3,d:4).c).to eq 3
+        expect(_class.new(a:1,b:2,c:3,d:4).d).to eq 4
+      end
+    end
+  end
+  describe 'Class.new(OptionsHash)' do
+    subject{ Class.new(OptionsHash) }
+    it_behaves_like 'an options hash'
+    its(:name   ){ should be_nil }
+    its(:inspect){ should =~ %r{OptionsHash:(\w+)\(required: \[\], optional: \[\]\)} }
+    its(:to_s   ){ should =~ %r{OptionsHash:(\w+)\(required: \[\], optional: \[\]\)} }
+    describe '.parse({})' do
+      subject{ Class.new(OptionsHash).parse({}) }
+      it_behaves_like 'an options hash instance'
+    end
+    describe '.parse(nil)' do
+      subject{ Class.new(OptionsHash).parse(nil) }
+      it_behaves_like 'an options hash instance'
+    end
+  end
+  describe EmptyOptions do
+    subject{ EmptyOptions }
+    it_behaves_like 'an options hash'
+    its(:name   ){ should == 'EmptyOptions' }
+    its(:inspect){ should == %{EmptyOptions(required: [], optional: [])} }
+    its(:to_s   ){ should == %{EmptyOptions(required: [], optional: [])} }
+  end
+  describe PersonOptions do
+    subject{ PersonOptions }
+    it_behaves_like 'an options hash'
+    its(:keys){ should eq Set[:name, :level_of_schooling, :height, :weight, :size, :iq, :intelegence] }
+    describe %(PersonOptions.parse(name: 'jared', level_of_schooling: 100, iq: 240, intelegence: 2)) do
+      subject{ PersonOptions.parse(name: 'jared', level_of_schooling: 100, iq: 240, intelegence: 2) }
+      it_behaves_like 'an options hash instance'
+      its(:name?               ){ should be_true   }
+      its(:level_of_schooling? ){ should be_true   }
+      its(:height?             ){ should be_false  }
+      its(:weight?             ){ should be_false  }
+      its(:size?               ){ should be_false  }
+      its(:iq?                 ){ should be_true   }
+      its(:intelegence?        ){ should be_true   }
+      its(:name                ){ should eq 'jared'}
+      its(:level_of_schooling  ){ should eq 100    }
+      its(:height              ){ should eq 2      }
+      its(:weight              ){ should eq 2      }
+      its(:size                ){ should eq 400    }
+      its(:iq                  ){ should eq 120.0  }
+      its(:intelegence         ){ should eq 1.0    }
+      its(:keys){ should eq Set[:name, :level_of_schooling, :height, :weight, :size, :iq, :intelegence] }
+      its(:to_hash){ should eq(:name=>"jared", :level_of_schooling=>100, :height=>2, :weight=>2, :size=>400, :iq=>120.0, :intelegence=>1.0) }
+    end
+    describe 'argument errors' do
+      it "should be raised" do
+        expect{ subject.parse                                                        }.to raise_error ArgumentError, 'wrong number of arguments (0 for 1)'
+        expect{ subject.parse({})                                                    }.to raise_error ArgumentError, 'required options: :intelegence, :iq, :level_of_schooling, :name'
+        expect{ subject.parse(intelegence: 1)                                        }.to raise_error ArgumentError, 'required options: :iq, :level_of_schooling, :name'
+        expect{ subject.parse(intelegence: 1, iq: 1)                                 }.to raise_error ArgumentError, 'required options: :level_of_schooling, :name'
+        expect{ subject.parse(intelegence: 1, iq: 1, level_of_schooling: 1)          }.to raise_error ArgumentError, 'required options: :name'
+        expect{ subject.parse(intelegence: 1, iq: 1, level_of_schooling: 1, name: 1) }.to_not raise_error
+        expect{ subject.parse(b:1, a:2, name:'steve')                                }.to raise_error ArgumentError, 'unknown options: :a, :b'
+      end
+    end
+  end
+  describe 'Person.new' do
+    let(:proc){ ->{ Person.new } }
+    subject{ proc }
+    it { should raise_error ArgumentError, 'required options: :intelegence, :iq, :level_of_schooling, :name' }
+    describe 'ArgumentError' do
+      let(:error){ begin; proc.call; rescue => error; error end }
+      subject{ error }
+      describe 'backtrace[0]' do
+        subject{ error.backtrace[0] }
+        it { should eq "#{Bundler.root+'spec/support/person.rb'}:6:in `initialize'" }
+      end
+    end
+  end
+  describe 'Person.new(father:1)' do
+    let(:proc){ ->{ Person.new(father:1) } }
+    subject{ proc }
+    it { should raise_error ArgumentError, 'unknown options: :father' }
+    describe 'ArgumentError' do
+      let(:error){ begin; proc.call; rescue => error; error end }
+      subject{ error }
+      describe 'backtrace[0]' do
+        subject{ error.backtrace[0] }
+        it { should eq "#{Bundler.root+'spec/support/person.rb'}:6:in `initialize'" }
+      end
+    end
+  end
+  describe %[Person.new(name: 'jared', level_of_schooling: 100, iq: 240, intelegence: 2)] do
+    subject{ Person.new(name: 'jared', level_of_schooling: 100, iq: 240, intelegence: 2) }
+    it{ should respond_to :name               }
+    it{ should respond_to :level_of_schooling }
+    it{ should respond_to :height             }
+    it{ should respond_to :weight             }
+    it{ should respond_to :size               }
+    it{ should respond_to :iq                 }
+    it{ should respond_to :intelegence        }
+    its(:name                ){ should eq 'jared'}
+    its(:level_of_schooling  ){ should eq 100    }
+    its(:height              ){ should eq 2      }
+    its(:weight              ){ should eq 2      }
+    its(:size                ){ should eq 400    }
+    its(:iq                  ){ should eq 120.0  }
+    its(:intelegence         ){ should eq 1.0    }
+  end
+end

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,24 @@
+require 'options_hash'
+require 'pry-debugger'
+require Bundler.root + 'spec/support/empty_options.rb'
+require Bundler.root + 'spec/support/person_options.rb'
+require Bundler.root + 'spec/support/person.rb'
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/empty_options.rb ADDED

@@ -0,0 +1,3 @@
+class EmptyOptions < OptionsHash
+end

data/spec/support/person.rb ADDED

@@ -0,0 +1,9 @@
+class Person
+  PersonOptions.define_attr_readers(self)
+  def initialize options=nil
+    @options = PersonOptions.parse(options)
+  end
+end

data/spec/support/person_options.rb ADDED

@@ -0,0 +1,10 @@
+class PersonOptions < OptionsHash
+  required :name, :level_of_schooling
+  optional :height, :weight, default: ->{ 2 }
+  optional :size,            &->{ (weight * height) * 100 }
+  required :iq, :intelegence do |given_value|
+    given_value.to_f * 0.50
+  end
+end

metadata ADDED

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: options_hash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jared Grippe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A configurable options hash definition
+email:
+- jared@deadlyicon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/options_hash.rb
+- lib/options_hash/version.rb
+- options_hash.gemspec
+- spec/options_hash_spec.rb
+- spec/spec_helper.rb
+- spec/support/empty_options.rb
+- spec/support/person.rb
+- spec/support/person_options.rb
+homepage: https://github.com/deadlyicon/options_hash
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: A configurable options hash definition
+test_files:
+- spec/options_hash_spec.rb
+- spec/spec_helper.rb
+- spec/support/empty_options.rb
+- spec/support/person.rb
+- spec/support/person_options.rb