hashmake 0.1.9 → 0.2.0

data/ChangeLog.rdoc

@@ -37,6 +37,15 @@ Add #find_arg_specs and #make_hash methods to HashMakeable.
 
 In HashMakeable.make_hash, only make objects into hashes if the object class matches the arg spec type (and, still, if it is hash makeable).
 
-=== 0.1.7 / 2013-06-21
+=== 0.1.9 / 2013-06-21
+
+Add :allow_nil option to ArgSpec.new. If an arg spec allows nil, it mean that if a hashed arg is nil, no ArgumentError will be raised and the validator won't be called.
+
+=== 0.2.0 / 2013-06-21
 
-Add :allow_nil option to ArgSpec.new. If an arg spec allows nil, it mean that if a hashed arg is nil, no ArgumentError will be raised and the validator won't be called.
+A bit of a major release. mostly to cut back features and modify interfaces a bit.
+  -hash_make does not recursively build objects from hashes, even if the expected object type is hash-makeable
+  -removed allow_nil from arg_spec
+  -add separate classes for container arg specs (array and hash)
+  -remove make_hash
+  -switch order of arguments for hash_make. Hashed args come first now, and arg spec Hash comes next.

data/README.rdoc

@@ -8,11 +8,13 @@
 
 Make hash-based object initialization easy!
 
-Provides hash_make method that can consider parameter name, type, default value, validation, requiredd/not, and container type (none/array/hash) according to the specification provided. The value is assigned to an instance variable matching the arg key.
-
-There is also a make_hash method to turn an object into a representative Hash object. Any hash-makeable sub-objects can be turned into Hash objects as well.
+The hash_make method checks hashed arguments against a set of specifications, then values are assigned to instance variables matching the arg keys.
 
 == Features
+Type checking via Object#is_a?. The default type is Object, allowing anything.
+Mark as required/not. Set to true, by default.
+Default value, for non-required args that aren't given. For default values that are mutable, make the default value a Proc that can be called to generate the mutable value.
+Validation of values via a Proc.
 
 == Examples
 
@@ -24,9 +26,10 @@ There is also a make_hash method to turn an object into a representative Hash ob
     ARG_SPECS = {
       :x => arg_spec(:reqd => true, :type => Float, :validator => ->(a){ a.between?(0.0,1.0) }),
       :y => arg_spec(:reqd => false, :type => Float, :validator => ->(a){ a.between?(0.0,1.0) }, :default => 0.0),
+      :z => arg_spec_array(:reqd => false, :type => String, :validator => ->(a){ a.size > 0 })
     }
     
-    attr_reader :x, :y
+    attr_reader :x, :y, :z
     
     def initialize hashed_args
       hash_make(ARG_SPECS, hashed_args)
@@ -37,7 +40,10 @@ There is also a make_hash method to turn an object into a representative Hash ob
   a = MyClass.new :x => 0.5, :y => 0.2 # a.x => 0.5, a.y => 0.2
   a = MyClass.new # raise ArgumentError because :x is reqd and not given
   a = MyClass.new :y => 0.5 # raise ArgumentError because :x is reqd and not given
-
+  
+  a = MyClass.new :x => 0.5, :z => ["abc", "efg"] # OK
+  a = MyClass.new :x => 0.5, :z => ["abc", ""] # raise ArgumentError, because validator requires str.size > 0
+  
 == Requirements
 
 == Install

data/lib/hashmake.rb

@@ -1,3 +1,5 @@
 require 'hashmake/version'
 require 'hashmake/arg_spec'
+require 'hashmake/array_arg_spec'
+require 'hashmake/hash_arg_spec'
 require 'hashmake/hash_makeable'

data/lib/hashmake/arg_spec.rb

@@ -1,3 +1,6 @@
+require 'set'
+require 'pry'
+
 module Hashmake
 
 # Provides a specification of how a hashed arg is to be processed by the
@@ -7,28 +10,22 @@ module Hashmake
 # 
 class ArgSpec
 
-  # The valid container types. If nil, indicates no container is expected,
-  # just a plain object of type given by :type.
-  CONTAINERS = [ nil, Hash, Array ]
-    
   # Defines default key/value pairs to use in initializing an instance.
   # The :reqd key is set to true by default.
   # The :validator key is set to a Proc that always returns true.
-  # The :container key is set to CONTAINER_NONE.
   DEFAULT_ARGS = {
     :reqd => true,
     :validator => ->(a){true},
-    :container => nil,
     :type => Object,
     :allow_nil => false
   }
   
-  attr_reader :type, :validator, :reqd, :default, :container, :allow_nil
+  attr_reader :type, :validator, :reqd, :default
   
   # A new instance of ArgSpec. 
   # 
   # @param [Hash] hashed_args Hash to use in initializing an instance. Optional keys
-  #                           are :type, :reqd, :validator, :container, and :default.
+  #                           are :type, :reqd, :validator, and :default.
   #                           :type => the type of object expected to be paired
   #                                    with the key.
   #                           :reqd => If true, the arg key must be in the hash
@@ -41,30 +38,42 @@ class ArgSpec
   #                                       expecting it to produce the default.
   #                           :validator => a Proc used to check the validity of
   #                                         whatever value is paired with an arg key.
-  #                           :container => indicates whether the arg key will be paired
-  #                                     with a container (array or hash) which contains
-  #                                     objects of the type specified by :type. Valid values
-  #                                     for this are given by ArgSpec::CONTAINERS.
   def initialize hashed_args
     new_args = DEFAULT_ARGS.merge(hashed_args)
     
     @type = new_args[:type]
-    raise ArgumentError, "args[:type] #{@type} is not a Class" unless @type.is_a?(Class)
+    raise ArgumentError, "#{@type} is not a Class" unless @type.is_a?(Class)
     
     @validator = new_args[:validator]
     @reqd = new_args[:reqd]
     
-    @container = new_args[:container]
-    raise ArgumentError, "CONTAINERS does not include container #{@container}" unless CONTAINERS.include?(@container)
-    
-    @allow_nil = new_args[:allow_nil]
-    
     unless @reqd
       msg = "if hashed arg is not required, a default value or value generator (proc) must be defined via :default key"
       raise ArgumentError, msg unless new_args.has_key?(:default)
       @default = new_args[:default]
     end
   end
-
+    
+  # If the val is not of the right type, but is a Hash, attempt to
+  # make an object of the right type if it is hash-makeable
+  def hash_make_if_needed val
+    if Hashmake.hash_makeable?(@type) and val.is_a?(Hash)
+      val = @type.new val
+    end
+    return val
+  end
+  
+  # Check the given value, and raise ArgumentError it is not valid.
+  def validate_value val
+    raise ArgumentError, "val #{val} is not a #{@type}" unless val.is_a?(@type)
+    raise ArgumentError, "val #{val} is not valid" unless @validator.call(val)
+  end
+  
+  def make_hash_if_possible val
+    if Hashmake::hash_makeable?(val.class) and val.class.is_a?(@type)
+      val = val.make_hash
+    end
+    return val
+  end
 end
 end

data/lib/hashmake/array_arg_spec.rb

@@ -0,0 +1,49 @@
+
+module Hashmake
+
+class ArrayArgSpec
+  
+  attr_reader :arg_spec
+  
+  def initialize hashed_args = {}
+    hashed_args = { :default => ->(){ [] } }.merge hashed_args
+    @arg_spec = ArgSpec.new hashed_args
+  end
+  
+  def type
+    @arg_spec.type
+  end
+  
+  def validator
+    @arg_spec.validator
+  end
+  
+  def reqd
+    @arg_spec.reqd
+  end
+  
+  def default
+    @arg_spec.default
+  end
+  
+  def hash_make_if_needed val
+    val.each_index do |i|
+      item = val[i]
+      val[i] = @arg_spec.hash_make_if_needed item
+    end
+  end
+  
+  def validate_value val
+    val.each do |item|
+      @arg_spec.validate_value item
+    end
+  end
+  
+  def make_hash_if_possible ary
+    ary.each_index do |i|
+      ary[i] = @arg_spec.make_hash_if_possible ary[i]
+    end
+  end
+end
+
+end

data/lib/hashmake/hash_arg_spec.rb

@@ -0,0 +1,49 @@
+
+module Hashmake
+
+class HashArgSpec
+  
+  attr_reader :arg_spec
+  
+  def initialize hashed_args = {}
+    hashed_args = { :default => ->(){ {} } }.merge hashed_args
+    @arg_spec = ArgSpec.new hashed_args
+  end
+  
+  def type
+    @arg_spec.type
+  end
+  
+  def validator
+    @arg_spec.validator
+  end
+  
+  def reqd
+    @arg_spec.reqd
+  end
+  
+  def default
+    @arg_spec.default
+  end
+  
+  def hash_make_if_needed val
+    val.each_key do |item_key|
+      item = val[item_key]
+      val[item_key] = @arg_spec.hash_make_if_needed item
+    end
+  end
+  
+  def validate_value val
+    val.each do |key, item|
+      @arg_spec.validate_value item
+    end
+  end
+  
+  def make_hash_if_possible hash
+    hash.each_key do |key|
+      hash[key] = @arg_spec.make_hash_if_possible hash[key]
+    end
+  end
+end
+
+end

data/lib/hashmake/hash_makeable.rb

@@ -20,47 +20,21 @@ module HashMakeable
   # Process a hash that contains 'hashed args'. Each hashed arg is intended to
   # be used in initializing an object instance. 
   #
-  # @param [Enumerable] arg_specs An enumerable of ArgSpec objects. Each object
-  #                               details an arg key that might be expected in the
-  #                               args hash.
   # @param [Hash] hashed_args A hash that should contain at least all the required
   #                           keys and valid values, according to the arg_specs passed in.
   #                           Nonrequired keys can be given as well, but if they are
   #                           not then a default value is assigned (again, according to
   #                           arg_specs passed in).
-  def hash_make arg_specs, hashed_args, assign_args = true
-    arg_specs.each do |key, arg_spec|
-      raise ArgumentError, "arg_specs item #{arg_spec} is not a ArgSpec" unless arg_spec.is_a?(ArgSpec)
-    end
-    raise ArgumentError, "hashed_args is not a Hash" unless hashed_args.is_a?(Hash)
-
+  # @param [Hash] arg_specs A hash of ArgSpec objects. An ArgSpec object details
+  #                         what to expect from the hashed argument with a
+  #                         matching same key.
+  # @param [true/false] assign_args If true, the hashed args will be assigned to
+  #                                 instance variables. If false, the hashed args
+  #                                 will still be checked, but not assigned.
+  def hash_make hashed_args, arg_specs = find_arg_specs, assign_args = true
     arg_specs.each do |key, arg_spec|
       if hashed_args.has_key?(key)
         val = hashed_args[key]
-
-        if Hashmake::hash_makeable?(arg_spec.type)
-          # If the val is not of the right type, but is a Hash, attempt to
-          # make an object of the right type if it is hash-makeable
-          if arg_spec.container == Array && val.is_a?(Array)
-            val.each_index do |i|
-              item = val[i]
-              if !item.is_a?(arg_spec.type) && item.is_a?(Hash)
-                val[i] = arg_spec.type.new item
-              end
-            end
-          elsif arg_spec.container == Hash && val.is_a?(Hash)
-            val.each_key do |item_key|
-              item = val[item_key]
-              if !item.is_a?(arg_spec.type) && item.is_a?(Hash)
-                val[item_key] = arg_spec.type.new item
-              end
-            end
-          else
-            if !val.is_a?(arg_spec.type) && val.is_a?(Hash)
-              val = arg_spec.type.new val
-            end
-          end
-        end
       else
         if arg_spec.reqd
           raise ArgumentError, "hashed_args does not have required key #{key}"
@@ -73,50 +47,14 @@ module HashMakeable
         end
       end
       
-      validate_arg arg_spec, val
+      arg_spec.validate_value val
+      
       if assign_args
         self.instance_variable_set("@#{key.to_s}".to_sym, val)
-      end        
-    end
-  end
-  
-  # Check the given value, using the given ArgSpec object. An ArgumentError
-  # exception will be raised if the value is not valid.
-  def validate_arg arg_spec, val
-    if arg_spec.container == Array
-      raise ArgumentError, "val #{val} is not an array" unless val.is_a?(Array)
-      val.each do |item|
-        if item.nil?
-          raise ArgumentError, "nil was given" unless arg_spec.allow_nil
-        else
-          raise ArgumentError, "array item #{item} is not a #{arg_spec.type}" unless item.is_a?(arg_spec.type)
-          raise ArgumentError, "array item #{item} is not valid" unless arg_spec.validator.call(item)      
-        end
       end
-    elsif arg_spec.container == Hash
-      raise ArgumentError, "val #{val} is not a hash" unless val.is_a?(Hash)
-      val.values.each do |item|
-        if item.nil?
-          raise ArgumentError, "nil was given" unless arg_spec.allow_nil
-        else
-          raise ArgumentError, "hash item #{item} is not a #{arg_spec.type}" unless item.is_a?(arg_spec.type)
-          raise ArgumentError, "hash item #{item} is not valid" unless arg_spec.validator.call(item)
-        end
-      end
-    elsif arg_spec.container.nil?
-      if val.nil?
-        raise ArgumentError, "nil was given" unless arg_spec.allow_nil
-      else
-        raise ArgumentError, "val #{val} is not a #{arg_spec.type}" unless val.is_a?(arg_spec.type)
-        raise ArgumentError, "val #{val} is not valid" unless arg_spec.validator.call(val)      
-      end
-    else
-      raise ArgumentError, "arg_spec.container #{arg_spec.container} is not valid"
     end
-    
-    return true
   end
-  
+
   # Look in the current class for a constant that is a Hash containing (only)
   # ArgSpec objects. Returns the first constant matching this criteria, or nil
   # if none was found.
@@ -126,7 +64,7 @@ module HashMakeable
       if val.is_a? Hash
         all_arg_specs = true
         val.each do |key,value|
-          unless value.is_a? ArgSpec
+          unless value.is_a? ArgSpec or value.is_a? ArrayArgSpec or value.is_a?(HashArgSpec)
             all_arg_specs = false
             break
           end
@@ -140,76 +78,6 @@ module HashMakeable
     
     return nil
   end
-
-  # Produce a hash that contains 'hashed args'. Each hashed arg is intended to
-  # be used in initializing an object instance. 
-  #
-  # @param [Enumerable] arg_specs An enumerable of ArgSpec objects. Each one
-  #                               details an arg key that might be expected in the
-  #                               args hash. This param is nil by default. If the param
-  #                               is nil, this method will attempt to locate arg specs
-  #                               using find_arg_specs.
-  #                               
-  def make_hash arg_specs = nil
-    if arg_specs.nil?
-      arg_specs = self.find_arg_specs
-      raise "No arg specs given, and no class constant that is a Hash containing only ArgSpec objects was found" if arg_specs.nil?
-    end
-    
-    arg_specs.each do |key, arg_spec|
-      raise ArgumentError, "arg_specs item #{arg_spec} is not a ArgSpec" unless arg_spec.is_a?(ArgSpec)
-    end
-
-    hash = {}
-
-    arg_specs.each do |key, arg_spec|
-      sym = "@#{key}".to_sym
-      raise ArgumentError, "current obj #{self} does not include instance variable #{sym}" if !self.instance_variables.include?(sym)
-      val = self.instance_variable_get(sym)
-      
-      should_assign = false
-
-      if arg_spec.reqd
-        should_assign = true
-      else
-        if arg_spec.default.is_a?(Proc)
-          should_assign = (val != arg_spec.default.call)
-        else
-          should_assign = (val != arg_spec.default)
-        end
-      end
-      
-      if should_assign
-        if val.is_a?(Array) && arg_spec.container == Array
-          ary = val
-          val = []
-          ary.each do |item|
-            if Hashmake::hash_makeable?(item.class) and item.class == arg_spec.type
-              val << item.make_hash
-            else
-              val << item
-            end
-          end
-        elsif val.is_a?(Hash) && arg_spec.container == Hash
-          hsh = val
-          val = {}
-          hsh.each do |hsh_key,item|
-            if Hashmake::hash_makeable? item.class and item.class == arg_spec.type
-              val[hsh_key] = item.make_hash
-            else
-              val[hsh_key] = item
-            end
-          end
-        elsif Hashmake::hash_makeable?(val.class) and val.class == arg_spec.type
-          val = val.make_hash
-        end
-        
-        hash[key] = val
-      end
-    end
-    
-    return hash
-  end
   
   # Contains class methods to be added to a class that includes the
   # HashMakeable module.
@@ -222,17 +90,14 @@ module HashMakeable
     # Helper method to make a ArgSpec object where the container is an Array.
     # Set :default to a Proc that generates an empty array.
     def arg_spec_array args
-      args = { :container => Array, :default => ->(){Array.new} }.merge(args)
-      ArgSpec.new args
+      ArrayArgSpec.new args
     end
 
     # Helper method to make a ArgSpec object where the container is an Hash.
     # Set :default to a Proc that generates an empty hash.
     def arg_spec_hash args
-      args = { :container => Hash, :default => ->(){Hash.new} }.merge(args)
-      ArgSpec.new args
+      HashArgSpec.new args
     end
   end
-
 end
 end

data/lib/hashmake/version.rb

@@ -4,5 +4,5 @@
 #
 module Hashmake
   # hashmake version
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/spec/arg_spec_spec.rb

@@ -16,22 +16,38 @@ describe Hashmake::ArgSpec do
     
     lambda { Hashmake::ArgSpec.new hash }.should_not raise_error(ArgumentError)
   end
-
-  it 'should not raise ArgumentError if valid container is given' do
-    Hashmake::ArgSpec::CONTAINERS.each do |container|
-      hash = {
-        :reqd => true, :key => :stuff, :type => String, :container => container
-      }
+  
+  context '#validate_value' do
+    before :each do
+      @arg_spec = ArgSpec.new(:reqd => true, :type => Fixnum, :validator => ->(a){ a > 0})
+    end
+    
+    context 'value given is correct type' do
+      context 'value given is valid' do
+        it 'should not raise ArgumentError' do
+          lambda { @arg_spec.validate_value 1 }.should_not raise_error
+        end
+      end
       
-      lambda { Hashmake::ArgSpec.new hash }.should_not raise_error(ArgumentError)      
+      context 'value given is not valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value 0 }.should raise_error(ArgumentError)
+        end
+      end
     end
-  end
-  
-  it 'should raise ArgumentError if invalid container is given' do
-    hash = {
-      :reqd => true, :key => :stuff, :type => String, :container => Fixnum
-    }
     
-    lambda { Hashmake::ArgSpec.new hash }.should raise_error(ArgumentError)
+    context 'value given is not correct type' do
+      context 'value given is valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value 1.0 }.should raise_error(ArgumentError)
+        end
+      end
+      
+      context 'value given is not valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value 0.0 }.should raise_error(ArgumentError)
+        end
+      end
+    end
   end
 end

data/spec/array_arg_spec_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Hashmake::ArrayArgSpec do
+  it 'should not raise ArgumentError if :reqd is false and a :default value is given' do
+    hash = {
+      :reqd => false, :key => :some_variable, :type => String, :default => ""
+    }
+    
+    lambda { Hashmake::ArrayArgSpec.new hash }.should_not raise_error(ArgumentError)
+  end
+  
+  context '#validate_value' do
+    before :each do
+      @arg_spec = ArrayArgSpec.new(:reqd => true, :type => Fixnum, :validator => ->(a){ a > 0})
+    end
+    
+    context 'value given is correct type' do
+      context 'value given is valid' do
+        it 'should not raise ArgumentError' do
+          lambda { @arg_spec.validate_value([1, 2]) }.should_not raise_error
+        end
+      end
+      
+      context 'value given is not valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value([0, 2]) }.should raise_error(ArgumentError)
+        end
+      end
+    end
+    
+    context 'value given is not correct type' do
+      context 'value given is valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value([1.0, 2]) }.should raise_error(ArgumentError)
+        end
+      end
+      
+      context 'value given is not valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value([0.0, 2]) }.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/hash_arg_spec_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Hashmake::HashArgSpec do
+  it 'should not raise ArgumentError if :reqd is false and a :default value is given' do
+    hash = {
+      :reqd => false, :key => :some_variable, :type => String, :default => ""
+    }
+    
+    lambda { Hashmake::HashArgSpec.new hash }.should_not raise_error(ArgumentError)
+  end
+  
+  context '#validate_value' do
+    before :each do
+      @arg_spec = HashArgSpec.new(:reqd => true, :type => Fixnum, :validator => ->(a){ a > 0})
+    end
+    
+    context 'value given is correct type' do
+      context 'value given is valid' do
+        it 'should not raise ArgumentError' do
+          lambda { @arg_spec.validate_value(:a => 1, :b => 2) }.should_not raise_error
+        end
+      end
+      
+      context 'value given is not valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value(:a => 0, :b => 2) }.should raise_error(ArgumentError)
+        end
+      end
+    end
+    
+    context 'value given is not correct type' do
+      context 'value given is valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value(:a => 1.0, :b => 2) }.should raise_error(ArgumentError)
+        end
+      end
+      
+      context 'value given is not valid' do
+        it 'should raise ArgumentError' do
+          lambda { @arg_spec.validate_value(:a => 0.0, :b => 2) }.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/hash_makeable_spec.rb

@@ -2,25 +2,6 @@ require 'pry'
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Hashmake::HashMakeable do
-  class AlsoHashMakeable
-    include Comparable
-    include HashMakeable
-    
-    ARG_SPECS = {
-      :a_number => arg_spec(:reqd => false, :type => Numeric, :default => 1.0)
-    }
-    
-    attr_accessor :a_number
-    
-    def initialize args = {}
-      hash_make ARG_SPECS, args
-    end
-    
-    def <=>(other)
-      a_number <=> other.a_number
-    end
-  end
-  
   class MyTestClass
     include HashMakeable
     
@@ -31,29 +12,13 @@ describe Hashmake::HashMakeable do
       :not_reqd_float => arg_spec(:reqd => false, :type => Float, :default => NON_REQD_FLOAT_DEFAULT, :validator => ->(a){ a.between?(0.0,1.0) }),
       :not_reqd_array_of_float => arg_spec_array(:reqd => false, :type => Float,  :validator => ->(a){ a.between?(0.0,1.0) }),
       :not_reqd_hash_of_float => arg_spec_hash(:reqd => false, :type => Float, :validator => ->(a){ a.between?(0.0,1.0) }),
-      :also_hash_makeable => arg_spec(:reqd => false, :type => AlsoHashMakeable, :default => ->(){ AlsoHashMakeable.new }),
-      :ary_of_also_hash_makeables => arg_spec_array(:reqd => false, :type => AlsoHashMakeable)
     }
     
-    attr_accessor :not_reqd_float, :ary_of_also_hash_makeables
-    attr_reader :reqd_string, :not_reqd_array_of_float, :not_reqd_hash_of_float, :also_hash_makeable
+    attr_accessor :not_reqd_float
+    attr_reader :reqd_string, :not_reqd_array_of_float, :not_reqd_hash_of_float
     
     def initialize hashed_args = {}
-      hash_make ARG_SPECS, hashed_args
-    end
-  end
-  
-  class TestAllowNil
-    include HashMakeable
-  
-    ARG_SPECS = {
-      :allows_nil => arg_spec(:reqd => false, :default => ->(){ "123" }, :type => String, :allow_nil => true),
-      :disallows_nil => arg_spec(:reqd => false, :default => ->(){ "123" }, :type => String, :allow_nil => false)
-    }
-    
-    attr_reader :allows_nil, :disallows_nil
-    def initialize args
-      hash_make ARG_SPECS, args
+      hash_make hashed_args, ARG_SPECS
     end
   end
   
@@ -142,72 +107,5 @@ describe Hashmake::HashMakeable do
         end.should raise_error(ArgumentError)
       end
     end
-    
-    context 'hash-makeable arg' do
-      it 'should construct the hash-makeable arg from just a Hash' do
-        a_number = 5
-        a = MyTestClass.new(:reqd_string => "ok", :also_hash_makeable => { :a_number => a_number })
-        a.also_hash_makeable.a_number.should eq(a_number)
-      end
-    end
-    
-    it 'should not raise ArgumentError if nil is given when nil is allowed' do
-      lambda { TestAllowNil.new(:allows_nil => nil) }.should_not raise_error
-    end
-  
-    it 'should raise ArgumentError if nil is given when nil is not allowed' do
-      lambda { TestAllowNil.new(:disallows_nil => nil) }.should raise_error(ArgumentError)
-    end      
-  end
-  
-  describe '#make_hash' do
-    before :each do
-      @reqd_string = "okeydoke"
-      @obj = MyTestClass.new :reqd_string => @reqd_string, :non_reqd_float => MyTestClass::NON_REQD_FLOAT_DEFAULT
-      @hash = @obj.make_hash
-    end
-    
-    it 'should produce a Hash' do
-      @hash.should be_a Hash
-    end
-    
-    it "should always include req'd values" do
-      @hash.should include(:reqd_string)
-      @hash[:reqd_string].should eq(@reqd_string)
-    end
-    
-    it "should never include non-req'd default values" do
-      @hash.should_not include(:non_reqd_float)
-    end
-
-    it "should always include non-req'd non-default values" do
-      @obj.not_reqd_float = 2.0
-      hash = @obj.make_hash
-      hash.should include(:not_reqd_float)
-      hash[:not_reqd_float].should eq(2.0)
-    end
-    
-    it "should turn any hash-makeable objects into Hash objects" do
-      @obj.also_hash_makeable.a_number = 2.0
-      hash = @obj.make_hash
-      hash.should include(:also_hash_makeable)
-      hash[:also_hash_makeable].should be_a Hash
-      hash[:also_hash_makeable].should include(:a_number)
-      hash[:also_hash_makeable][:a_number].should eq(2.0)
-    end
-    
-    it "should turn an array of hash-makeable objects into an array of Hash objects" do
-      obj2 = MyTestClass.new @obj.make_hash
-      @obj.ary_of_also_hash_makeables = [
-        AlsoHashMakeable.new(:a_number => 1),
-        AlsoHashMakeable.new(:a_number => 2),
-        AlsoHashMakeable.new(:a_number => 3),
-      ]
-      obj2 = MyTestClass.new @obj.make_hash
-      obj2.ary_of_also_hash_makeables.count.should be(3)
-      obj2.ary_of_also_hash_makeables[0].a_number.should eq(1)
-      obj2.ary_of_also_hash_makeables[1].a_number.should eq(2)
-      obj2.ary_of_also_hash_makeables[2].a_number.should eq(3)
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashmake
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-23 00:00:00.000000000 Z
+date: 2013-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,9 +112,13 @@ files:
 - hashmake.gemspec
 - lib/hashmake.rb
 - lib/hashmake/arg_spec.rb
+- lib/hashmake/array_arg_spec.rb
+- lib/hashmake/hash_arg_spec.rb
 - lib/hashmake/hash_makeable.rb
 - lib/hashmake/version.rb
 - spec/arg_spec_spec.rb
+- spec/array_arg_spec_spec.rb
+- spec/hash_arg_spec_spec.rb
 - spec/hash_makeable_spec.rb
 - spec/hashmake_spec.rb
 - spec/spec_helper.rb
@@ -133,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1181723344412730535
+      hash: -4514910862506440485
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -142,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1181723344412730535
+      hash: -4514910862506440485
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -151,6 +155,8 @@ specification_version: 3
 summary: Make hashed-based object initialization easy!
 test_files:
 - spec/arg_spec_spec.rb
+- spec/array_arg_spec_spec.rb
+- spec/hash_arg_spec_spec.rb
 - spec/hash_makeable_spec.rb
 - spec/hashmake_spec.rb
 - spec/spec_helper.rb