hashmake 0.1.5 → 0.1.6

data/ChangeLog.rdoc

@@ -20,4 +20,15 @@ In hash_make, add support for Hash containers which contain objects of type :typ
 
 === 0.1.4 / 2013-02-06
 
-Add tests to verify array and hash container support.
+Add tests to verify array and hash container support.
+
+=== 0.1.5 / 2013-03-04
+
+Hash arg specs to key name.
+Instead of enumerating containers (e.g CONTAINER_HASH) just use class (Hash).
+Validate args in validate_arg (which could be called independently from hash_make).
+
+=== 0.1.6 / 2013-03-21
+
+Add Hashmake::hash_makeable? for testing if a class includes Hashmake::HashMakeable.
+Add #find_arg_specs and #make_hash methods to HashMakeable.

data/README.rdoc

@@ -2,13 +2,15 @@
 
 * {Homepage}[https://rubygems.org/gems/hashmake]
 * {Documentation}[http://rubydoc.info/gems/hashmake/frames]
-* {Email}[mailto:jamestunnell at lavabit.com]
+* {Email}[mailto:jamestunnell@lavabit.com]
 
 == Description
 
 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. By default it the value given with the arg key to to an instance variable of same name as parameter.
+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.
 
 == Features
 
@@ -19,10 +21,10 @@ Provides hash_make method that can consider parameter name, type, default value,
   class MyClass
     include Hashmake::HashMakeable
     
-    ARG_SPECS = [
-      ArgSpec.new(:key => :x, :reqd => true, :type => Float, :validator => ->(a){ a.between?(0.0,1.0) }),
-      ArgSpec.new(:key => :y, :reqd => false, :type => Float, :validator => ->(a){ a.between?(0.0,1.0) }, :default => 0.0),
-    ]
+    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),
+    }
     
     attr_reader :x, :y
     

data/lib/hashmake/arg_spec.rb

@@ -22,14 +22,12 @@ class ArgSpec
     :type => Object,
   }
   
-  attr_reader :key, :type, :validator, :reqd, :default, :container
+  attr_reader :type, :validator, :reqd, :default, :container
   
   # A new instance of ArgSpec. 
   # 
-  # @param [Hash] hashed_args Hash to use in initializing an instance. Required
-  #                           keys are :key and :type. Optional keys are :reqd,
-  #                           :validator, :container, and :default.
-  #                           :key => the key used to identify a hashed arg.
+  # @param [Hash] hashed_args Hash to use in initializing an instance. Optional keys
+  #                           are :type, :reqd, :validator, :container, 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
@@ -49,7 +47,6 @@ class ArgSpec
   def initialize hashed_args
     new_args = DEFAULT_ARGS.merge(hashed_args)
     
-    @key = new_args[:key]
     @type = new_args[:type]
     raise ArgumentError, "args[:type] #{@type} is not a Class" unless @type.is_a?(Class)
     

data/lib/hashmake/hash_makeable.rb

@@ -1,5 +1,10 @@
 module Hashmake
 
+# Determine if a class includes the HashMakeable module.
+def self.hash_makeable? klass
+  klass.included_modules.include?(HashMakeable)
+end
+
 # This module should be included for any class that wants to be 'hash-makeable',
 # which means that a new object instance expects all its arguments to come in a
 # single Hash. See the hash_make method in this module and the ArgSpec class for
@@ -32,6 +37,30 @@ module HashMakeable
     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}"
@@ -51,6 +80,8 @@ module HashMakeable
     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)
@@ -73,19 +104,118 @@ module HashMakeable
     
     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.
+  def find_arg_specs
+    self.class.constants.each do |constant|
+      val = self.class.const_get(constant)
+      if val.is_a? Hash
+        all_arg_specs = true
+        val.each do |key,value|
+          unless value.is_a? ArgSpec
+            all_arg_specs = false
+            break
+          end
+        end
+        
+        if all_arg_specs
+          return val
+        end
+      end
+    end
+    
+    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
+              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
+              val[hsh_key] = item.make_hash
+            else
+              val[hsh_key] = item
+            end
+          end
+        elsif Hashmake::hash_makeable?(val.class)
+          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.
   module ClassMethods
+    # Helper method to make a generic new ArgSpec object
     def arg_spec args
       ArgSpec.new args
     end
     
+    # 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
     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

data/lib/hashmake/version.rb

@@ -4,5 +4,5 @@
 #
 module Hashmake
   # hashmake version
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/spec/hash_makeable_spec.rb

@@ -2,17 +2,41 @@ 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
     
+    NON_REQD_FLOAT_DEFAULT = 0.0
+    
     ARG_SPECS = {
       :reqd_string => arg_spec(:reqd => true, :type => String, :validator => ->(a){ a.length < 10 }),
-      :not_reqd_float => arg_spec(:reqd => false, :type => Float, :default => 0.0, :validator => ->(a){ a.between?(0.0,1.0) }),
+      :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_reader :reqd_string, :not_reqd_float, :not_reqd_array_of_float, :not_reqd_hash_of_float
+    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
     
     def initialize hashed_args = {}
       hash_make ARG_SPECS, hashed_args
@@ -104,6 +128,64 @@ 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
+  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
 
-  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.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-04 00:00:00.000000000 Z
+date: 2013-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -133,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 144920435
+      hash: 77734045
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -142,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 144920435
+      hash: 77734045
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23