graft 0.1.1 → 0.2.0

data/test/unit/json/attribute_test.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Graft
+  module Json
+    class AttributeTest < Test::Unit::TestCase
+
+      context "An instance of the Graft::Json::Attribute class" do
+
+        should "know its name" do
+          attr = Graft::Json::Attribute.new(:foo)
+          attr.name.should == :foo
+        end
+
+        should "have a default source" do
+          attr = Graft::Json::Attribute.new(:foo)
+          attr.source.should == 'foo'
+        end
+
+        should "be able to extract a value from a hash" do
+          data = {"first_name" => "Richerd"}
+
+          attr = Graft::Json::Attribute.new(:first_name)
+          attr.value_from(data).should == 'Richerd'
+        end
+        
+        should "be able to extract a value from a hash when provided with a symbol for the source" do
+          data = {"firstname" => "Richerd"}
+          
+          attr = Graft::Json::Attribute.new(:first_name, :firstname)
+          attr.value_from(data).should == 'Richerd'
+        end
+
+        should "be able to extract a nested value from a JSON string" do
+          data = {"user" => {"first_name" => "Richerd"}}
+
+          attr = Graft::Json::Attribute.new(:first_name, 'user/first_name')
+          attr.value_from(data).should == 'Richerd'
+        end
+
+        should "return nil when the value doesn't exist" do
+          data = {"first_name" => "Richerd"}
+
+          attr = Graft::Json::Attribute.new(:last_name, 'last_name')
+          attr.value_from(data).should be(nil)
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/json/model_test.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class EmptyJsonModel
+  include Graft::Json::Model
+end
+
+class JsonModelWithAttributes
+  include Graft::Json::Model
+
+  attribute :name
+  attribute :description, :from => 'desc'
+  attribute :rating,      :from => 'rsp/rating'
+end
+
+class JsonModelTest < Test::Unit::TestCase
+
+  context "The EmptyJsonModel class" do
+    should "have an empty list of attributes if none are supplied" do
+      EmptyJsonModel.attributes.should == []
+    end
+    
+    should "be able to return a collection of instances" do
+      json_data = '{"results":[{"name":"one"},{"name":"two"}]}'
+      
+      EmptyJsonModel.expects(:new).with({'name' => 'one'}).returns('model_1')
+      EmptyJsonModel.expects(:new).with({'name' => 'two'}).returns('model_2')
+      
+      collection = EmptyJsonModel.collection_from(json_data, 'results')
+      collection.should == ['model_1', 'model_2']
+    end
+    
+    should "be able to retrieve data from the source JSON string" do
+      json_data = '{"name":"Graft"}'
+      EmptyJsonModel.data_from(json_data).should == {'name' => 'Graft'}
+    end
+    
+    should "be able to retrieve data from the source hash data" do
+      data = {'name' => 'Graft'}
+      EmptyJsonModel.data_from(data).should == {'name' => 'Graft'}
+    end
+  end
+
+  context "The JsonModelWithAttributes class" do
+    should "know the names of all its attributes" do
+      JsonModelWithAttributes.attributes.map {|a| a.name.to_s }.should == %w(name description rating)
+    end
+  end
+  
+  context "An instance of the JsonModelWithAttributes class" do
+    
+    should "assign attributes upon initialization" do
+      json_data = '{"name":"Graft"}'
+      JsonModelWithAttributes.new(json_data).name.should == 'Graft'
+    end
+    
+    should "have a reference to the original source data" do
+      json_data = '{"name":"Graft"}'
+      data = JSON.parse(json_data)
+      
+      m = JsonModelWithAttributes.new(json_data)
+      m.source_data.should == data
+    end
+    
+    context "when populating from JSON data" do
+      setup do
+        json_data = '{"name":"Graft", "desc":"library", "rsp":{"rating":10}}'
+        @model = JsonModelWithAttributes.new
+        @model.populate_from(json_data)
+      end
+
+      should "have a value for :name" do
+        @model.name.should == 'Graft'
+      end
+
+      should "have a value for :description" do
+        @model.description.should == 'library'
+      end
+
+      should "have a value for :rating" do
+        @model.rating.should == 10
+      end
+    end
+    
+  end
+  
+end

data/test/unit/xml/attribute_test.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Graft
+  module Xml
+    class AttributeTest < Test::Unit::TestCase
+      context "An instance of the Graft::Xml::Attribute class" do
+
+        should "know the name of the attribute" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.name.should == :foo
+        end
+
+        should "have a default type class" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.type_class.should == Graft::Xml::Type::String
+        end
+
+        should "have a default source" do
+          attr = Graft::Xml::Attribute.new(:foo)
+          attr.sources.should == ['foo']
+        end
+
+        should "be able to assign multiple sources" do
+          attr = Graft::Xml::Attribute.new(:foo, :string, ['foo1', 'foo2'])
+          attr.sources.should == ['foo1', 'foo2']
+        end
+
+        should "pull the location from the source" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.location('foo').should == 'foo'
+        end
+
+        should "return the location when splitting" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.split('foo').should == ['foo', nil]
+        end
+
+        should "return the name for the location when splitting if the location isn't specified" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.split('@bar').should == ['foo', 'bar']
+        end
+
+        should "allow the setting of the location information" do
+          attr = Graft::Xml::Attribute.new('foo', :string, 'bar')
+          attr.sources.should == ['bar']
+        end
+
+        should "allow the setting of the attribute value" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.attribute('@bogon').should == 'bogon'
+        end
+
+        should "use the location as the attribute" do
+          attr = Graft::Xml::Attribute.new('foo')
+          attr.attribute('foo').should == 'foo'
+        end
+
+        should "use the attribute for the attribute if specified" do
+          attr = Graft::Xml::Attribute.new(:id, :string, '@nsid')
+          attr.attribute('@nsid').should == 'nsid'
+        end
+
+        should "be able to retrieve the node from the path" do
+          document = Hpricot.XML('<name>Bassdrive</name>')
+          expected = document.at('name')
+
+          attr = Graft::Xml::Attribute.new(:name)
+          attr.node_for(document, 'name').should == expected
+        end
+
+        should "be able to retrieve the node that contains the specified attribute" do
+          document = Hpricot.XML('<user id="1337" />')
+          expected = document.at('user')
+
+          attr = Graft::Xml::Attribute.new(:id)
+          attr.node_for(document, '@id').should == expected
+        end
+
+        should "be able to retrieve the node for the specified attribute" do
+          document = Hpricot.XML('<user nsid="1337" />')
+          expected = document.at('user')
+
+          attr = Graft::Xml::Attribute.new(:id, :string, '@nsid')
+          attr.node_for(document, '@nsid').should == expected
+        end
+
+        should "be able to pull simple values from an XML document" do
+          document = Hpricot.XML('<name>Bassdrive</name>')
+          attr = Graft::Xml::Attribute.new(:name)
+          attr.value_from(document).should == 'Bassdrive'
+        end
+
+        should "be able to pull an attribute value from the current XML node" do
+          document = Hpricot.XML('<user id="1337" />')
+          attr = Graft::Xml::Attribute.new(:id)
+          attr.value_from(document).should == '1337'
+        end
+
+        should "be able to pull a specific attribute value from the current XML node" do
+          document = Hpricot.XML('<user nsid="1337" />')
+          attr = Graft::Xml::Attribute.new(:id, :string, '@nsid')
+          attr.value_from(document).should  == '1337'
+        end
+
+        should "be able to pull an attribute value for a node and attribute" do
+          document = Hpricot.XML('<station><genre slug="dnb">Drum & Bass</genre></station>')
+          attr = Graft::Xml::Attribute.new(:slug, :string, 'station/genre@slug')
+          attr.value_from(document).should == 'dnb'
+        end
+
+        should "be able to pull a value from a nested XML node" do
+          document = Hpricot.XML('<rsp><user>blip</user></rsp>')
+          attr = Graft::Xml::Attribute.new(:user)
+          attr.value_from(document).should == 'blip'
+        end
+
+        should "return nil if it cannot find the specified node" do
+          document = Hpricot.XML('<user id="1" />')
+          attr = Graft::Xml::Attribute.new(:photoset, :string, '@nsid')
+          attr.value_from(document).should be(nil)
+        end
+
+        should "be able to try a series of nodes to find a value" do
+          document = Hpricot.XML('<photoid>123</photoid>')
+
+          attr = Graft::Xml::Attribute.new(:id, :string, ['photo@nsid', 'photoid'])
+          attr.value_from(document).should == '123'
+        end
+
+        should "be able to convert an integer value" do
+          document = Hpricot.XML('<id>1</id>')
+
+          attr = Graft::Xml::Attribute.new(:id, :integer)
+          attr.value_from(document).should == 1
+        end
+
+        should "be able to convert a boolean value" do
+          document = Hpricot.XML('<active>true</active>')
+
+          attr = Graft::Xml::Attribute.new(:active, :boolean)
+          attr.value_from(document).should == true
+        end
+
+        should "be able to convert a date value" do
+          document = Hpricot.XML('<due_on>2009-08-01</due_on>')
+
+          attr = Graft::Xml::Attribute.new(:due_on, :date)
+          attr.value_from(document).should == Date.parse('2009-08-01')
+        end
+
+        should "be able to convert a time value" do
+          document = Hpricot.XML('<created_at>2009-08-01 00:00:00</created_at>')
+
+          attr = Graft::Xml::Attribute.new(:created_at, :time)
+          attr.value_from(document).should == Time.parse('2009-08-01 00:00:00')
+        end
+
+      end
+    end
+  end
+end

data/test/unit/{model_test.rb → xml/model_test.rb}

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../test_helper'
 
-class EmptyModel
-  include Graft::Model
+class EmptyXmlModel
+  include Graft::Xml::Model
 end
 
-class ModelWithAttributes
-  include Graft::Model
+class XmlModelWithAttributes
+  include Graft::Xml::Model
 
   attribute :name
   attribute :description, :from => 'desc'
@@ -14,18 +14,17 @@ class ModelWithAttributes
   
 end
 
-class ModelWithAttributeType
-  include Graft::Model
+class XmlModelWithAttributeType
+  include Graft::Xml::Model
   
   attribute :id, :type => :integer
-  
 end
 
-class ModelTest < Test::Unit::TestCase
+class XmlModelTest < Test::Unit::TestCase
 
-  context "The EmptyModel class" do
+  context "The EmptyXmlModel class" do
     should "have an empty list of attributes if none are supplied" do
-      EmptyModel.attributes.should == []
+      EmptyXmlModel.attributes.should == []
     end
     
     should "be able to return a collection of XML nodes" do
@@ -37,52 +36,46 @@ class ModelTest < Test::Unit::TestCase
         </things>
       XML
       
-      EmptyModel.expects(:new).with('<thing><id>1</id></thing>').returns('model_1')
-      EmptyModel.expects(:new).with('<thing><id>2</id></thing>').returns('model_2')
+      document = Hpricot.XML(xml)
+      
+      EmptyXmlModel.expects(:data_from).with(xml).returns(document)
+      
+      EmptyXmlModel.expects(:new).with((document/'things/thing').first).returns('model_1')
+      EmptyXmlModel.expects(:new).with((document/'things/thing').last).returns('model_2')
       
-      collection = EmptyModel.collection_from(xml, 'things/thing')
+      collection = EmptyXmlModel.collection_from(xml, 'things/thing')
       collection.should == ['model_1', 'model_2']
     end
+
+    should "be able to retrieve data from the source XML string" do
+      xml = '<name>Graft</name>'
+      Hpricot.expects(:XML).with(xml).returns('document')
+
+      EmptyXmlModel.data_from(xml).should == 'document'
+    end
     
-    should "return an empty hash when calling :to_hash" do
-      m = EmptyModel.new
-      m.to_hash.should == {}
+    should "be able to retrieve data from the source document data" do
+      document = Hpricot.XML('<name>Graft</name>')
+      EmptyXmlModel.data_from(document).should == document
     end
-
+    
   end
   
-  context "The ModelWithAttributes class" do
+  context "The XmlModelWithAttributes class" do
     should "know the names of all its attributes" do
-      ModelWithAttributes.attributes.map {|a| a.name.to_s }.should == %w(name description rating size)
-    end
-    
-    should "return a hash representation of itself" do
-      m = ModelWithAttributes.new
-      
-      m.name        = 'name'
-      m.description = 'description'
-      m.rating      = '5'
-      m.size        = 'large'
-    
-      m.to_hash.should == {
-        'name'        => 'name',
-        'description' => 'description',
-        'rating'      => '5',
-        'size'        => 'large'
-      }
-
+      XmlModelWithAttributes.attributes.map {|a| a.name.to_s }.should == %w(name description rating size)
     end
   end
   
-  context "The ModelWithAttributeType class" do
+  context "The XmlModelWithAttributeType class" do
     should "know that it's attribute is of type :integer" do
-      attribute = ModelWithAttributeType.attributes.first
-      attribute.type_class.should == Graft::Type::Integer
+      attribute = XmlModelWithAttributeType.attributes.first
+      attribute.type_class.should == Graft::Xml::Type::Integer
     end
     
     should "be able to generate an XML representation of itself" do
       
-      m = ModelWithAttributeType.new
+      m = XmlModelWithAttributeType.new
       m.id = 1
       
       xml = String.new
@@ -96,26 +89,51 @@ class ModelTest < Test::Unit::TestCase
     end
   end
 
-  context "An instance of the ModelWithAttributes class" do
+  context "An instance of the EmptyXmlModel class" do
+    
+    should "return an empty hash when calling :to_hash" do
+      m = EmptyXmlModel.new
+      m.to_hash.should == {}
+    end
+    
+  end
+
+  context "An instance of the XmlModelWithAttributes class" do
 
     setup { @simple_xml = '<name>Graft</name>' }
 
     should "have default reader method for :name" do
-      ModelWithAttributes.new.respond_to?(:name).should be(true)
+      XmlModelWithAttributes.new.respond_to?(:name).should be(true)
     end
     
     should "be able to populate its data on initialization" do
       xml = Hpricot.XML(@simple_xml)
-      ModelWithAttributes.new(xml).name.should == 'Graft'
+      XmlModelWithAttributes.new(xml).name.should == 'Graft'
     end
     
     should "have a reference to the original document" do
       xml = Hpricot.XML(@simple_xml)
-      ModelWithAttributes.new(xml).document.should == xml
+      XmlModelWithAttributes.new(xml).source_data.should == xml
     end
     
     should "be able to populate from an XML string" do
-      ModelWithAttributes.new(@simple_xml).name.should == 'Graft'
+      XmlModelWithAttributes.new(@simple_xml).name.should == 'Graft'
+    end
+    
+    should "return a hash representation of itself" do
+      m = XmlModelWithAttributes.new
+      
+      m.name        = 'name'
+      m.description = 'description'
+      m.rating      = '5'
+      m.size        = 'large'
+    
+      m.to_hash.should == {
+        'name'        => 'name',
+        'description' => 'description',
+        'rating'      => '5',
+        'size'        => 'large'
+      }
     end
     
     context "when populating data from an XML document" do
@@ -129,7 +147,7 @@ class ModelTest < Test::Unit::TestCase
           <node type="size" value="large" />
         XML
 
-        @model = ModelWithAttributes.new
+        @model = XmlModelWithAttributes.new
         @model.populate_from(Hpricot.XML(xml))
       end