@@ -1,3 +1,11 @@ +== 0.2.5 +* 1 minor tweak + * Classes can now be strings instead of constants so you don't have to worry about class definition order (this was all for technicalpickles, enjoy!) + +== 0.2.4 +* 1 minor tweak + * Added a patch that allows even crazy namespaces to work + == 0.2.3 * 1 minor tweak * bumped the version of libxml-ruby to 1.1.3 History @@ -21,6 +21,10 @@ module HappyMapper @xml_type = self.class.to_s.split('::').last.downcase end + + def constant + @constant ||= constantize(type) + end def from_xml_node(node, namespace) if primitive? @@ -41,13 +45,13 @@ module HappyMapper end begin - type.send(options[:parser].to_sym, value) + constant.send(options[:parser].to_sym, value) rescue nil end end else - type.parse(node, options) + constant.parse(node, options) end end end @@ -62,7 +66,7 @@ module HappyMapper end def primitive? - Types.include?(type) + Types.include?(constant) end def element? @@ -78,15 +82,15 @@ module HappyMapper end def typecast(value) - return value if value.kind_of?(type) || value.nil? + return value if value.kind_of?(constant) || value.nil? begin - if type == String then value.to_s - elsif type == Float then value.to_f - elsif type == Time then Time.parse(value.to_s) - elsif type == Date then Date.parse(value.to_s) - elsif type == DateTime then DateTime.parse(value.to_s) - elsif type == Boolean then ['true', 't', '1'].include?(value.to_s.downcase) - elsif type == Integer + if constant == String then value.to_s + elsif constant == Float then value.to_f + elsif constant == Time then Time.parse(value.to_s) + elsif constant == Date then Date.parse(value.to_s) + elsif constant == DateTime then DateTime.parse(value.to_s) + elsif constant == Boolean then ['true', 't', '1'].include?(value.to_s.downcase) + elsif constant == Integer # ganked from datamapper value_to_i = value.to_i if value_to_i == 0 && value != '0' @@ -108,6 +112,21 @@ module HappyMapper end private + def constantize(type) + if type.is_a?(String) + names = type.split('::') + constant = Object + names.each do |name| + constant = constant.const_defined?(name) ? + constant.const_get(name) : + constant.const_missing(name) + end + constant + else + type + end + end + def find(node, namespace, &block) # this node has a custom namespace (that is present in the doc) if self.namespace && node.namespaces.find_by_prefix(self.namespace) lib/happymapper/item.rb @@ -1,3 +1,3 @@ module HappyMapper - Version = '0.2.4' + Version = '0.2.5' end lib/happymapper/version.rb @@ -1,5 +1,9 @@ require File.dirname(__FILE__) + '/spec_helper.rb' +module Foo + class Bar; end +end + describe HappyMapper::Item do describe "new instance" do @@ -24,6 +28,23 @@ describe HappyMapper::Item do end end + describe "#constant" do + it "should just use type if constant" do + item = HappyMapper::Item.new(:foo, String) + item.constant.should == String + end + + it "should convert string type to constant" do + item = HappyMapper::Item.new(:foo, 'String') + item.constant.should == String + end + + it "should convert string with :: to constant" do + item = HappyMapper::Item.new(:foo, 'Foo::Bar') + item.constant.should == Foo::Bar + end + end + describe "#method_name" do it "should convert dashes to underscores" do item = HappyMapper::Item.new(:'foo-bar', String, :tag => 'foobar') spec/happymapper_item_spec.rb @@ -274,72 +274,76 @@ describe HappyMapper do describe "being included into another class" do before do - Foo.instance_variable_set("@attributes", {}) - Foo.instance_variable_set("@elements", {}) + @klass = Class.new do + include HappyMapper + + def self.to_s + 'Foo' + end + end end - class Foo; include HappyMapper end it "should set attributes to an array" do - Foo.attributes.should == [] + @klass.attributes.should == [] end it "should set @elements to a hash" do - Foo.elements.should == [] + @klass.elements.should == [] end it "should allow adding an attribute" do lambda { - Foo.attribute :name, String - }.should change(Foo, :attributes) + @klass.attribute :name, String + }.should change(@klass, :attributes) end it "should allow adding an attribute containing a dash" do lambda { - Foo.attribute :'bar-baz', String - }.should change(Foo, :attributes) + @klass.attribute :'bar-baz', String + }.should change(@klass, :attributes) end it "should be able to get all attributes in array" do - Foo.attribute :name, String - Foo.attributes.size.should == 1 + @klass.attribute :name, String + @klass.attributes.size.should == 1 end it "should allow adding an element" do lambda { - Foo.element :name, String - }.should change(Foo, :elements) + @klass.element :name, String + }.should change(@klass, :elements) end it "should allow adding an element containing a dash" do lambda { - Foo.element :'bar-baz', String - }.should change(Foo, :elements) + @klass.element :'bar-baz', String + }.should change(@klass, :elements) end it "should be able to get all elements in array" do - Foo.element(:name, String) - Foo.elements.size.should == 1 + @klass.element(:name, String) + @klass.elements.size.should == 1 end it "should allow has one association" do - Foo.has_one(:user, User) - element = Foo.elements.first + @klass.has_one(:user, User) + element = @klass.elements.first element.name.should == 'user' element.type.should == User element.options[:single] = true end it "should allow has many association" do - Foo.has_many(:users, User) - element = Foo.elements.first + @klass.has_many(:users, User) + element = @klass.elements.first element.name.should == 'users' element.type.should == User element.options[:single] = false end it "should default tag name to lowercase class" do - Foo.tag_name.should == 'foo' + @klass.tag_name.should == 'foo' end it "should default tag name of class in modules to the last constant lowercase" do @@ -348,17 +352,17 @@ describe HappyMapper do end it "should allow setting tag name" do - Foo.tag('FooBar') - Foo.tag_name.should == 'FooBar' + @klass.tag('FooBar') + @klass.tag_name.should == 'FooBar' end it "should allow setting a namespace" do - Foo.namespace(namespace = "foo") - Foo.namespace.should == namespace + @klass.namespace(namespace = "foo") + @klass.namespace.should == namespace end it "should provide #parse" do - Foo.should respond_to(:parse) + @klass.should respond_to(:parse) end end @@ -551,6 +555,19 @@ describe HappyMapper do property.value.should == '85301' end + it "should allow instantiating with a string" do + module StringFoo + class Bar + include HappyMapper + has_many :things, 'StringFoo::Thing' + end + + class Thing + include HappyMapper + end + end + end + xit "should parse family search xml" do tree = FamilySearch::FamilyTree.parse(fixture_file('family_tree.xml')) tree.version.should == '1.0.20071213.942' spec/happymapper_spec.rb 741b7d5b007c0832807ce9f86c7800efc7f8bd51 John Nunemaker nunemaker@gmail.com http://github.com/jnunemaker/happymapper/commit/a377d9776f359448c58cfc9379aeb1af05dc7298 a377d9776f359448c58cfc9379aeb1af05dc7298 2009-05-27T20:42:05-07:00 2009-05-27T20:42:05-07:00 Classes can now be strings instead of constants so you don't have to worry about class definition order (this was all for technicalpickles, enjoy!) 12afd5400d0c07488fa07cc1c4542e4de3c9275a John Nunemaker nunemaker@gmail.com