object_struct 0.0.2 → 0.0.3

data/CHANGELOG

@@ -1,3 +1,8 @@
+## 0.0.3 (September 22, 2010)
+
+Fix failing has_property_name? test. API change: has_property_name? is
+ guaranteed to return either true, or false.
+
 ## 0.0.2 (September 22, 2010)
 
 Protected ObjectStruct#convert method

data/lib/object_struct/object_struct.rb

@@ -25,7 +25,7 @@
 # @abstract You probably want to subclass ObjectStruct, to reflect your business
 #  entities. See the README for example use.
 class ObjectStruct < OpenStruct
-	VERSION = '0.0.2'
+	VERSION = '0.0.3'
 
 	# Delegated to Hash#each
 	def each &blk
@@ -74,10 +74,10 @@ class ObjectStruct < OpenStruct
 		if name =~ /^has_([a-z_]+)\?$/
 			if respond_to? (field = $1.to_sym)
 				result = (send field)
-				if result.respond_to?(:count) && result.method(:count).arity == 0
+				if result.respond_to?(:count) && result.method(:count).arity < 1
 					(result.count > 0)
 				else
-					result
+					result ? true : false
 				end
 			end
 		else

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Quid, Inc.
@@ -52,7 +52,6 @@ extra_rdoc_files: []
 
 files: 
 - lib/object_struct/object_struct.rb
-- lib/object_struct/#object_struct.rb#
 - lib/object_struct.rb
 - test/test_data.json
 - test/test_object_struct.rb

data/lib/object_struct/#object_struct.rb#

@@ -1,154 +0,0 @@
-# ---------------------------------------------------------------------------
-# Copyright 2010, Quid, Inc.
-#
-# object_struct is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# object_struct is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with object_struct. If not, see <http://www.gnu.org/licenses/>.
-#
-# ---------------------------------------------------------------------------
-
-
-# Inherit from ObjectStruct to allow object-style accesses to a hash parameter
-# passed to {ObjectStruct#initialize initialize}. Properties are lazy-loaded.
-#
-# @see OpenStruct
-#
-# @abstract You probably want to subclass ObjectStruct, to reflect your business
-#  entities. See the README for example use.
-class ObjectStruct < OpenStruct
-	VERSION = '0.0.2 '
-
-	# Delegated to Hash#each
-	def each &blk
-		to_h.each &blk
-	end
-
-	# Delegated to Hash#values
-	def values
-		to_h.values
-	end
-
-	# Specify the type of a particular property.
-	#
-	# @param [Hash] options The options hash. Pass any :property_name => ClassName
-	#  to enforce that type.
-	#
-	# @option options [Boolean] :plural (false) Whether the property is plural,
-	#  e.g. an Array of the class specified. (Yes, this means that if you have a
-	#  property named :plural, you cannot specify its type.)
-	def self.property_type(options)
-		plural = options.delete(:plural)
-		property, type = *options.first
-		class_name = plural ? property.to_s.classify : property.to_s.camelize
-		Object.const_set class_name, Class.new(type)
-	end
-
-	# Create a new ObjectStruct.
-	#
-	# @param [Hash] data a Hash representing your data. Keys are used to identify
-	#  the type of the property.
-	def initialize(data)
-		@table = Hash.new {|h, k| raise NoMethodError, "undefined property #{k} for #{self}"}
-		data = {'data' => data} unless data.respond_to? :each
-		for k,v in data
-			@table[k.to_sym] = self.class.value_maybe_promise(k, v)
-			new_ostruct_member(k)
-		end
-	end
-
-	# Provides has_property_name? methods. Intercepts messages matching
-	# /^has_[a-z_]+\?$/. If the method matches this regex, ObjectStruct will see
-	# if it responds to such a property. If that property responds to a count
-	# method, it will furthermore make sure #count is greater than zero.
-	# @return the property, if it exists, nil otherwise
-	def method_missing(name, *args)
-		if name =~ /^has_([a-z_]+)\?$/
-			if respond_to? (field = $1.to_sym)
-				result = (send field)
-				if result.respond_to?(:count) && result.method(:count).arity == 0
-					(result.count > 0)
-				else
-					result
-				end
-			end
-		else
-			super(name, *args)
-		end
-	end
-
-	# Specifically provide the object_id. If your objects have IDs, choose a more
-	# descriptive name.
-	def id
-		object_id
-	end
-
-	protected
-
-	def new_ostruct_member(name)
-		name = name.to_sym
-		unless self.respond_to?(name)
-			class << self; self; end.class_eval do
-				define_method(name) { ObjectStruct.demand @table[name] }
-				define_method("#{name}=") { |x| @table[name] = x }
-			end
-		end
-		name
-	end
-
-	# Recursively convert a value to an ObjectStruct (or a class matching the
-	# type, if it exists).
-	#
-	# @param [Array, Hash] value the value to convert. Arrays are converted
-	#  recursively, each value to the requested type. Hashes are converted
-	#  directly to the requested type.
-	#
-	# @param [String, #to_s] type the type of the value (or values in the array).
-	#  This method falls back to ObjectStruct if it cannot find a class matching
-	#  the type.
-	#
-	# @return [type/ObjectStruct, Array<type/ObjectStruct>, value] the type
-	#  requested, or an ObjectStruct; or an Array thereof; or the value if it
-	#  neither an Array nor Hash.
-	def self.convert(value, type = nil)
-		klass = ((value.is_a? Array) ? type.to_s.classify : type.to_s.camelize).constantize rescue ObjectStruct
-
-		case value
-		when Array
-			value.map{|e| convert(e, klass.to_s)}
-		when Hash
-			klass.new(value)
-		else
-			value
-		end
-	end
-
-	private
-
-	def to_h
-		result = {}
-		@table.each {|name, value| result[name.to_s] = value}
-		result
-	end
-
-	def self.value_maybe_promise(key, value)
-		case value
-		when Array, Hash
-			Lazy::Promise.new {convert(value, key)}
-		else
-			value
-		end
-	end
-
-	def self.demand value
-		(value.is_a? Lazy::Promise) ? value.__result__ : value
-	end
-end