option_initializer 1.3.0 → 1.5.0

data/README.md

@@ -15,12 +15,15 @@ require 'option_initializer'
 
 class Person
   include OptionInitializer
-  option_initializer :id, :name, :greetings => :block, :birthday => 1..3
-  option_validator do |k, v|
-    case k
-    when :name
-      raise ArgumentError, "invalid name" if v.empty?
-    end
+
+  option_initializer :id,
+                     :name => String,
+                     :greetings => :&,
+                     :birthday => 1..3,
+                     :sex => Set[:male, :female]
+
+  option_validator :name do |v|
+    raise ArgumentError, "invalid name" if v.empty?
   end
 
   def initialize opts
@@ -39,6 +42,7 @@ john = Person.
          birthday(1990, 1, 1).
          greetings { |name| "Hi, I'm #{name}!" }.
          id(1000).
+         sex(:male).
          new
 
 # becomes equivalent to
@@ -46,6 +50,7 @@ john = Person.new(
          :id => 1000,
          :name => 'John Doe',
          :birthday => [1990, 1, 1],
+         :sex => :male,
          :greetings => proc { |name| "Hi, I'm #{name}!" }
        )
 
@@ -62,3 +67,51 @@ Person.
   say_hello
 ```
 
+## Option definitions and validators
+
+```ruby
+class MyClass
+  include OptionInitializer
+
+  option_initializer :a,                              # Single object of any type
+                     :b => 2,                         # Two objects of any type
+                     :c => 1..3,                      # 1, 2, or 3 objects of any type
+                     :d => :*,                        # Any number of objects of any type
+                     :e => :&,                        # Block
+                     :f => Fixnum,                    # Single Fixnum object
+                     :g => [Fixnum, String, Symbol],  # Fixnum, String, and Symbol
+                     :h => Set[true, false],          # Value must be either true or false
+                     :i => [Fixnum, Set[true, false]] # Fixnum and boolean
+
+  # Validator for :f
+  option_validator :f do |v|
+    raise ArgumentError if v < 0
+  end
+
+  # Generic validator
+  option_validator do |k, v|
+    case k
+    when :a
+      # ...
+    when :b
+      # ...
+    end
+  end
+
+  def initialize arg1, arg2, options
+    validate_options options
+    @options = options
+  end
+end
+
+object = MyClass.a(o).
+                 b(o1, o2).
+                 c(o1, o2, o3).
+                 d(o1, o2).
+                 e { |o| o ** o }.
+                 f(f).
+                 g(f, str, sym).
+                 h(true).
+                 i(100, false).
+                 new(a1, a2)
+```

data/lib/option_initializer.rb

@@ -1,12 +1,11 @@
-require "option_initializer/version"
+require 'option_initializer/version'
+require 'set'
 
 module OptionInitializer
   class OptionInitializingTemplate
     attr_reader :options
     alias to_h options
 
-    const_set :VALIDATORS, []
-
     def initialize base, options, need_validation
       validate options if need_validation
       @base    = base
@@ -42,10 +41,13 @@ module OptionInitializer
     end
 
     def validate hash
-      self.class.const_get(:VALIDATORS).each do |validator|
-        hash.each do |k, v|
-          validator.call k, v
-        end
+      avals, vals = [:ARG_VALIDATORS, :VALIDATORS].map { |s|
+        self.class.const_get(s)
+      }
+      hash.each do |k, v|
+        avals[k]  && avals[k].call(v)
+        vals[k]   && vals[k].call(v)
+        vals[nil] && vals[nil].call(k, v)
       end
     end
   end
@@ -65,19 +67,25 @@ module OptionInitializer
     raise TypeError,
       "wrong argument type #{options.class} (expected Hash)" unless
         options.is_a?(Hash)
-    return if options.respond_to?(:option_validated?)
-    validators = self.class.const_get(:OptionInitializing).const_get(:VALIDATORS)
-    validators.each do |validator|
-      options.each do |k, v|
-        validator.call k, v
-      end
+    return if options.respond_to?(:option_validated?) && options.option_validated?
+    avals, vals = [:ARG_VALIDATORS, :VALIDATORS].map { |s|
+      self.class.const_get(:OptionInitializing).const_get(s)
+    }
+    options.each do |k, v|
+      avals[k]  && avals[k].call(v)
+      vals[k]   && vals[k].call(v)
+      vals[nil] && vals[nil].call(k, v)
     end
     options
   end
 
   def self.included base
     unless base.constants.map(&:to_sym).include?(:OptionInitializing)
-      base.const_set :OptionInitializing, OptionInitializingTemplate.dup
+      base.const_set :OptionInitializing, oi = OptionInitializingTemplate.dup
+      oi.class_eval do
+        const_set :VALIDATORS, {}
+        const_set :ARG_VALIDATORS, {}
+      end
     end
 
     base.class_eval do
@@ -87,11 +95,12 @@ module OptionInitializer
         end
       end
 
-      def base.option_validator &block
+      def base.option_validator sym = nil, &block
         raise ArgumentError, "block must be given" unless block
-        raise ArgumentError, "invalid arity (expected: 2)" unless block.arity == 2
+        a = sym ? 1 : 2
+        raise ArgumentError, "invalid arity (expected: #{a})" unless block.arity == a
         oi = self.const_get(:OptionInitializing)
-        oi.const_get(:VALIDATORS).push block
+        oi.const_get(:VALIDATORS)[sym] = block
       end
 
       def base.option_initializer *syms
@@ -103,16 +112,98 @@ module OptionInitializer
             arr << [sym.to_sym, 1]
           when Hash
             arr.concat sym.map { |k, v|
-              unless (v.is_a?(Fixnum) && v > 0) || (v.is_a?(Range) && v.begin > 0) || v == :block
-                raise ArgumentError, "invalid number of arguments specified for #{k}"
+              case v
+              when Fixnum
+                raise ArgumentError, "invalid number of arguments specified for #{k}" if v <= 0
+              when Range
+                raise ArgumentError, "invalid number of arguments specified for #{k}" if v.begin < 0
+              when Set
+                raise ArgumentError, "empty set of values specified for #{k}" if v.length == 0
+              when Array
+                raise ArgumentError, "invalid option definition: `#{v}'" unless v.all? { |e| e.is_a?(Class) || e.is_a?(Set) }
+              when Class, :*, :&
+                # noop
+              else
+                raise ArgumentError, "invalid option definition: `#{v}'"
               end
               [k.to_sym, v]
             }
           else
-            raise ArgumentError, "invalid option specification"
+            raise ArgumentError, "invalid option definition"
           end
         }
 
+        # Setup validators
+        vals = oi.const_get(:ARG_VALIDATORS)
+        pairs.each do |pair|
+          sym, nargs = pair
+          case nargs
+          when :&
+            vals[sym] = proc { |v|
+              if !v.is_a?(Proc)
+                raise TypeError, "wrong argument type #{v.class} (expected Proc)"
+              end
+            }
+          when 1
+            # good to go
+            vals.delete sym
+          when :*
+            vals[sym] = proc { |v|
+              if !v.is_a?(Array)
+                raise ArgumentError, "wrong number of arguments (1 for #{nargs})"
+              end
+            }
+          when Fixnum
+            vals[sym] = proc { |v|
+              if !v.is_a?(Array)
+                raise ArgumentError, "wrong number of arguments (1 for #{nargs})"
+              elsif nargs != v.length
+                raise ArgumentError, "wrong number of arguments (#{v.length} for #{nargs})"
+              end
+            }
+          when Range
+            vals[sym] = proc { |v|
+              if !v.is_a?(Array)
+                raise ArgumentError, "wrong number of arguments (1 for #{nargs})"
+              elsif !nargs.include?(v.length)
+                raise ArgumentError, "wrong number of arguments (#{v.length} for #{nargs})"
+              end
+            }
+          when Set
+            vals[sym] = proc { |v|
+              if !nargs.include?(v)
+                raise ArgumentError, "invalid option value: `#{v}' (expected one of #{nargs.to_a.inspect})"
+              end
+            }
+          when Array
+            vals[sym] = proc { |v|
+              if !v.is_a?(Array)
+                raise ArgumentError, "wrong number of arguments (1 for #{nargs.length})"
+              elsif nargs.length != v.length
+                raise ArgumentError, "wrong number of arguments (#{v.length} for #{nargs.length})"
+              else
+                v.zip(nargs).each do |ec|
+                  e, c = ec
+                  case c
+                  when Class
+                    raise TypeError, "wrong argument type #{e.class} (expected #{c})" unless e.is_a?(c)
+                  when Set
+                    unless c.include?(e)
+                      raise ArgumentError, "invalid option value: `#{e}' (expected one of #{c.to_a.inspect})"
+                    end
+                  end
+                end
+              end
+            }
+          when Class
+            vals[sym] = proc { |v|
+              if !v.is_a?(nargs)
+                raise TypeError, "wrong argument type #{v.class} (expected #{nargs})"
+              end
+            }
+          end
+        end
+
         # Class methods
         pairs.each do |pair|
           sym = pair.first
@@ -133,38 +224,25 @@ module OptionInitializer
             sym, nargs = pair
             undef_method(sym) if method_defined?(sym)
             define_method(sym) do |*v, &b|
-              case nargs
-              when :block
-                if b
-                  if v.empty?
-                    merge(sym => b)
-                  else
-                    raise ArgumentError, "only block expected"
-                  end
-                else
-                  raise ArgumentError, "block expected but not given"
-                end
-              when 1
-                if b && v.empty?
+              if nargs == :&
+                if v.empty?
                   merge(sym => b)
-                elsif b && !v.empty?
-                  raise ArgumentError, "wrong number of arguments (#{v.length} for 0 when block given)"
-                elsif v.length == 1
-                  merge(sym => v.first)
                 else
-                  raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+                  raise ArgumentError, "wrong number of arguments (#{v.length} for 0)"
                 end
-              when Range, Fixnum
-                if b
-                  raise ArgumentError, "block not expected"
-                elsif (nargs.is_a?(Range) && !nargs.include?(v.length)) ||
-                      (nargs.is_a?(Fixnum) && nargs != v.length)
-                  raise ArgumentError, "wrong number of arguments (#{v.length} for #{nargs})"
+              elsif b
+                raise ArgumentError, "block not expected"
+              else
+                case nargs
+                when 1, Class, Set
+                  if v.length == 1
+                    merge(sym => v.first)
+                  else
+                    raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+                  end
                 else
                   merge(sym => v)
                 end
-              else
-                raise ArgumentError, "invalid option specification"
               end
             end
           end

data/lib/option_initializer/version.rb

@@ -1,3 +1,3 @@
 module OptionInitializer
-  VERSION = "1.3.0"
+  VERSION = "1.5.0"
 end

data/option_initializer.gemspec

@@ -16,4 +16,6 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'simplecov'
 end

data/test/test_option_initializer.rb

@@ -1,14 +1,17 @@
 $VERBOSE = true
 
 require 'rubygems'
+require 'simplecov'
+SimpleCov.start
 require 'minitest/autorun'
 require 'option_initializer'
+require 'set'
 
 class MyClass
   include OptionInitializer
-  option_initializer :aaa, :bbb
-  option_initializer :ccc, :ddd
+  option_initializer :aaa, :bbb => 1
   option_initializer :ccc, :ddd
+  option_initializer :ccc, :ddd => :&
 
   attr_reader :a, :b, :options, :y
 
@@ -38,19 +41,23 @@ class MyClass2
   option_initializer! :aaa
   option_initializer  :bbb, :ccc
   option_validator do |k, v|
-    @@validate_count += 1
+    @@validate_count += 100
     case k
     when :aaa
-      raise ArgumentError if v == 0
+      raise ArgumentError
     end
   end
   option_validator do |k, v|
     @@validate_count += 1
     case k
     when :aaa
-      raise ArgumentError if v < 0
+      raise ArgumentError if v == 0
     end
   end
+  option_validator :aaa do |v|
+    @@validate_count += 1
+    raise ArgumentError if v < 0
+  end
 
   def initialize options
     validate_options options
@@ -79,14 +86,15 @@ class MyClass3
   end
 end
 
-class MyClass4
+class MyClassVarArgs
   attr_reader :options
 
   include OptionInitializer
   option_initializer :two => 2,
                      :two_or_three => 2..3,
                      :yet_two_or_three => 2...4,
-                     :b => :block
+                     :b => :&,
+                     :v => :*
 
   def initialize options
     validate_options @options = options
@@ -97,15 +105,36 @@ class MyClass5
   include OptionInitializer
 end
 
+class MyClassWithTypes
+  include OptionInitializer
+  option_initializer :a => Fixnum,
+                     :b => String,
+                     :c => Numeric,
+                     :d => Array,
+                     :e => [Fixnum, String, Array],
+                     :f => Set[true, false],
+                     :g => [ Set[true, false], Set[1, 2, 3] ]
+
+  attr_reader :options
+  def initialize options
+    validate_options options
+    @options = options
+  end
+end
+
 # Excerpt from README
 class Person
   include OptionInitializer
-  option_initializer! :id, :name, :greetings, :birthday => 1..3
-  option_validator do |k, v|
-    case k
-    when :name
-      raise ArgumentError, "invalid name" if v.empty?
-    end
+
+  option_initializer :id,
+                     :name => String,
+                     :greetings => :&,
+                     :birthday => 1..3,
+                     :sex => Set[:male, :female]
+  option_initializer!
+
+  option_validator :name do |v|
+    raise ArgumentError, "invalid name" if v.empty?
   end
 
   def initialize opts
@@ -119,6 +148,16 @@ class Person
 end
 
 class TestOptionInitializer < MiniTest::Unit::TestCase
+  def assert_raises x, &b
+    begin
+      b.call
+      assert false
+    rescue Exception => e
+      puts "#{e.class}: #{e}"
+      assert e.is_a?(x)
+    end
+  end
+
   def test_oi
     o = MyClass.aaa(1).bbb(2).ddd { 4 }.ccc(3).new(1, 2)
     assert_equal 1, o.options[:aaa]
@@ -129,11 +168,11 @@ class TestOptionInitializer < MiniTest::Unit::TestCase
     assert_equal 2, o.b
     assert_equal nil, o.y
 
-    o = MyClass.aaa(1).bbb(2).ccc(3).aaa(4).new(1, 2, :ddd => 4) { :y }
+    o = MyClass.aaa(1).bbb(2).ccc(3).aaa(4).new(1, 2, :ddd => proc { 4 }) { :y }
     assert_equal 4, o.options[:aaa]
     assert_equal 2, o.options[:bbb]
     assert_equal 3, o.options[:ccc]
-    assert_equal 4, o.options[:ddd]
+    assert_equal 4, o.options[:ddd].call
     assert_equal 1, o.a
     assert_equal 2, o.b
     assert_equal :y, o.y
@@ -146,9 +185,18 @@ class TestOptionInitializer < MiniTest::Unit::TestCase
     assert_raises(ArgumentError) { MyClass.aaa(1).new(1, 2, 3) }
   end
 
+  def test_default_1
+    MyClass.aaa(1)
+    assert_raises(ArgumentError) { MyClass.aaa { } }
+
+    MyClass.bbb(1)
+    assert_raises(ArgumentError) { MyClass.bbb { } }
+  end
+
   def test_method_missing
     assert_equal 2, MyClass2.aaa(1).bbb(2).num_options(true)
     assert_equal 2, MyClass2.aaa(1).bbb(2).echo(1) { |a| a * 2 }
+    assert_raises(NoMethodError) { MyClass2.aaa(1).bbb(2).echo? }
 
     assert_raises(NoMethodError) do
       MyClass3.aaa(1).bbb(2).echo(1) { |a| a * 2 }
@@ -169,37 +217,69 @@ class TestOptionInitializer < MiniTest::Unit::TestCase
 
     MyClass2.reset_count
     MyClass2.aaa(1).bbb(2)
-    assert_equal 2 + 2, MyClass2.count
+    assert_equal 2 + 1, MyClass2.count
 
     MyClass2.reset_count
     MyClass2.aaa(1).bbb(2).new(:aaa => 3)
-    assert_equal 2 + 2 + 2, MyClass2.count
+    assert_equal 2 + 1 + 2, MyClass2.count
 
     MyClass2.reset_count
     MyClass2.aaa(1).bbb(2).new
-    assert_equal 2 + 2, MyClass2.count
+    assert_equal 2 + 1, MyClass2.count
 
     MyClass2.reset_count
     MyClass2.new :aaa => 1, :bbb => 2
-    assert_equal 4, MyClass2.count
+    assert_equal 2 + 1, MyClass2.count
 
     assert_raises(TypeError) { MyClass2.new 'str' }
   end
 
   def test_varargs
-    obj = MyClass4.two(1, 2).two_or_three(2, 3, 4).yet_two_or_three(3, 4, 5).b { :r }.new
+    obj = MyClassVarArgs.two(1, 2).two_or_three(2, 3, 4).yet_two_or_three(3, 4, 5).b { :r }.new
     assert_equal [1, 2], obj.options[:two]
     assert_equal [2, 3, 4], obj.options[:two_or_three]
     assert_equal [3, 4, 5], obj.options[:yet_two_or_three]
     assert_equal :r, obj.options[:b].call
-    assert_raises(ArgumentError) { MyClass4.two(1) }
-    assert_raises(ArgumentError) { MyClass4.two(1, 2) { } }
-    assert_raises(ArgumentError) { MyClass4.two { } }
-    assert_raises(ArgumentError) { MyClass4.two_or_three(1) }
-    assert_raises(ArgumentError) { MyClass4.yet_two_or_three(1, 2, 3, 4) }
-    assert_raises(ArgumentError) { MyClass4.yet_two_or_three {} }
-    assert_raises(ArgumentError) { MyClass4.b(1) }
-    assert_raises(ArgumentError) { MyClass4.b(1) {} }
+    assert_raises(ArgumentError) { MyClassVarArgs.two }
+    assert_raises(ArgumentError) { MyClassVarArgs.two(1) }
+    assert_raises(ArgumentError) { MyClassVarArgs.two(1, 2) { } }
+    assert_raises(ArgumentError) { MyClassVarArgs.two { } }
+    assert_raises(ArgumentError) { MyClassVarArgs.two_or_three(1) }
+    assert_raises(ArgumentError) { MyClassVarArgs.yet_two_or_three(1, 2, 3, 4) }
+    assert_raises(ArgumentError) { MyClassVarArgs.yet_two_or_three {} }
+    assert_raises(ArgumentError) { MyClassVarArgs.b(1) }
+    assert_raises(ArgumentError) { MyClassVarArgs.b(1) {} }
+    assert_raises(ArgumentError) { MyClassVarArgs.b(1) {} }
+    assert_equal [], MyClassVarArgs.v.new.options[:v]
+    assert_equal [1, 2, 3], MyClassVarArgs.v(1, 2, 3).new.options[:v]
+
+    MyClassVarArgs.class_eval do
+      option_initializer :b2 => :&
+    end
+    MyClassVarArgs.b2 {}
+    assert_raises(ArgumentError) { MyClassVarArgs.b2(5) }
+
+    MyClassVarArgs.class_eval do
+      option_initializer :b2
+    end
+    MyClassVarArgs.b2(5)
+    assert_raises(ArgumentError) { MyClassVarArgs.b2 {} }
+  end
+
+  def test_varargs_validate_options
+    assert_raises(TypeError) { MyClassVarArgs.new(:b => 1) }
+    assert_raises(ArgumentError) { MyClassVarArgs.new(:two => 1) }
+    assert_raises(ArgumentError) { MyClassVarArgs.new(:two => [1]) }
+    assert_raises(ArgumentError) { MyClassVarArgs.new(:two_or_three => 1) }
+    assert_raises(ArgumentError) { MyClassVarArgs.new(:two_or_three => [1]) }
+    assert_raises(ArgumentError) { MyClassVarArgs.new(:yet_two_or_three => [1]) }
+    assert_raises(ArgumentError) { MyClassVarArgs.new(:v => 1) }
+
+    opts = MyClassVarArgs.new(:two => [1, 2], :two_or_three => [2, 3, 4], :v => []).options
+
+    assert_equal [1, 2], opts[:two]
+    assert_equal [2, 3, 4], opts[:two_or_three]
+    assert_equal [], opts[:v]
   end
 
   def test_varargs_def
@@ -212,20 +292,102 @@ class TestOptionInitializer < MiniTest::Unit::TestCase
     assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer :b => 0 } }
     assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer :b => 3.14 } }
     assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer :b => [1] } }
-    assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer :b => 0..3 } }
+    assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer :b => -1..3 } }
     assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer 3.14 } }
     assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer 3.14 => nil } }
     assert_raises(ArgumentError) { MyClass5.class_eval { option_initializer :b => :block? } }
   end
 
+  def test_validator_block_arity
+    MyClass5.class_eval { option_validator { |k, v| } }
+    assert_raises(ArgumentError) { MyClass5.class_eval { option_validator { |v| } } }
+    MyClass5.class_eval { option_validator :aaa do |v| end }
+    assert_raises(ArgumentError) { MyClass5.class_eval { option_validator :aaa do |k, v| end } }
+  end
+
+  def test_typed_option
+    MyClassWithTypes.a(3)
+    assert_raises(TypeError) { MyClassWithTypes.a('str') }
+    assert_raises(TypeError) { MyClassWithTypes.b(1) }
+    assert_raises(ArgumentError) { MyClassWithTypes.c(1, 2) }
+    assert_raises(ArgumentError) { MyClassWithTypes.e(1) }
+    assert_raises(ArgumentError) { MyClassWithTypes.e(1, 'str') }
+    assert_raises(TypeError) { MyClassWithTypes.e(1, 'str', :array) }
+
+
+    assert_raises(TypeError) { MyClassWithTypes.new(:a => 'str') }
+    assert_raises(ArgumentError) { MyClassWithTypes.new(:e => :e) }
+    assert_raises(ArgumentError) { MyClassWithTypes.new(:e => []) }
+    assert_raises(TypeError) { MyClassWithTypes.new(:e => [1, 1, 1]) }
+
+    [
+      MyClassWithTypes.a(3).b('str').c(1).c(3.14).d([1, 2, 3]).e(1, 'str', [0, 1, 2]).options,
+      MyClassWithTypes.new(:a => 3, :b => 'str', :c => 3.14, :d => [1, 2, 3], :e => [1, 'str', [0, 1, 2]]).options
+    ].each do |opts|
+      assert_equal 3, opts[:a]
+      assert_equal 'str', opts[:b]
+      assert_equal 3.14, opts[:c]
+      assert_equal [1, 2, 3], opts[:d]
+      assert_equal [1, 'str', [0, 1, 2]], opts[:e]
+
+    end
+  end
+
+  def test_set
+    opts = MyClassWithTypes.f(true).g(false, 2).options
+    assert_equal true, opts[:f]
+    assert_equal [false, 2], opts[:g]
+
+    assert_raises(ArgumentError) { MyClassWithTypes.f(5) }
+    assert_raises(ArgumentError) { MyClassWithTypes.new(:f => 5) }
+    assert_raises(ArgumentError) { MyClassWithTypes.g(false, 10) }
+    assert_raises(ArgumentError) { MyClassWithTypes.g(nil, 2) }
+
+    assert_raises(ArgumentError) { MyClassWithTypes.class_eval { option_initializer :set => Set[] } }
+  end
+
   def test_readme
-    john = Person.name('John Doe').birthday(1990, 1, 1).
+    john = Person.name('John Doe').birthday(1990, 1, 1).sex(:male).
                   greetings { |name| "Hi, I'm #{name}!" }.id(1000).new
     john = Person.new :id => 1000, :name => 'John Doe',
                       :birthday => [1990, 1, 1],
+                      :sex => :male,
                       :greetings => proc { |name| "Hi, I'm #{name}!" }
     Person.name('John Doe').birthday(1990, 1, 1).
            greetings { |name| "Hi, I'm #{name}!" }.id(1000).say_hello
   end
 end
 
+class MyReadmeClass
+  include OptionInitializer
+
+  option_initializer :a,                             # Single object of any type
+                     :b => 2,                        # Two objects of any type
+                     :c => 1..3,                     # 1, 2, or 3 objects of any type
+                     :d => :*,                       # Any number of objects
+                     :e => :&,                       # Block
+                     :f => Fixnum,                   # Single Fixnum object
+                     :g => [Fixnum, String, Symbol]  # Fixnum, String, and Symbol
+
+  # Validator for :f
+  option_validator :f do |v|
+    raise ArgumentError if v < 0
+  end
+
+  # Generic validator
+  option_validator do |k, v|
+    case k
+    when :a
+      # ...
+    when :b
+      # ...
+    else
+    end
+  end
+
+  def initialize options
+    validate_options options
+    @options = options
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: option_initializer
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-16 00:00:00.000000000 Z
-dependencies: []
+date: 2013-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Object construction with method chaining
 email:
 - junegunn.c@gmail.com