graft 0.2.1 → 0.3.0

data/test/test_helper.rb

@@ -1,38 +0,0 @@
-# http://sneaq.net/textmate-wtf
-$:.reject! { |e| e.include? 'TextMate' }
-
-require 'rubygems'
-require 'throat_punch'
-
-require File.dirname(__FILE__) + '/../lib/graft/xml'
-require File.dirname(__FILE__) + '/../lib/graft/json'
-
-class Test::Unit::TestCase
-  
-  def self.implementation_klass
-    class_name = self.to_s.match(/([a-zA-Z]+)Test$/)[1]
-    klass      = Graft::Xml::Type.const_get(class_name)
-    
-    klass
-  end
-  
-  def self.should_convert(source, options)
-    klass  = self.implementation_klass
-    target = options[:to]
-
-    should "be able to convert '#{source}' to #{target}" do
-      o = klass.new(source)
-      o.value.should == target
-    end
-  end
-  
-  def self.should_fail_when_converting(source)
-    klass = self.implementation_klass
-    
-    should "fail when converting '#{source}'" do
-      o = klass.new(source)
-      lambda { o.value }.should raise_error(Graft::Xml::Type::ConversionError)
-    end
-  end
-  
-end

data/test/unit/core_ext/hash_test.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-class HashTest < Test::Unit::TestCase
-  
-  context "An instance of Hash" do
-    
-    should "be able to extract a value using the / operator" do
-      hash = {'key' => 'value'}
-      (hash/'key').should == 'value'
-    end
-    
-    should "be able to extract nested values using the / operator" do
-      hash = {'user' => {'name' => 'luser'}}
-      (hash/'user/name').should == 'luser'
-    end
-    
-    should "return nil when attempting to extract a value that doesn't exist" do
-      hash = {'user' => {'name' => 'luser'}}
-      (hash/'user/username').should be(nil)
-    end
-    
-    should "be able to fetch a value using a symbol" do
-      hash = {'key' => 'value'}
-      (hash/:key).should == 'value'
-    end
-    
-  end
-  
-end

data/test/unit/json/attribute_test.rb

@@ -1,51 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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/xml/model_test.rb

@@ -1,173 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-class EmptyXmlModel
-  include Graft::Xml::Model
-end
-
-class XmlModelWithAttributes
-  include Graft::Xml::Model
-
-  attribute :name
-  attribute :description, :from => 'desc'
-  attribute :rating,      :from => 'rating@value'
-  attribute :size,        :from => "node[@type='size']@value"
-  
-end
-
-class XmlModelWithAttributeType
-  include Graft::Xml::Model
-  
-  attribute :id, :type => :integer
-end
-
-class XmlModelTest < Test::Unit::TestCase
-
-  context "The EmptyXmlModel class" do
-    should "have an empty list of attributes if none are supplied" do
-      EmptyXmlModel.attributes.should == []
-    end
-    
-    should "be able to return a collection of XML nodes" do
-      xml =<<-XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <things>
-          <thing><id>1</id></thing>
-          <thing><id>2</id></thing>
-        </things>
-      XML
-      
-      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 = 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 "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 XmlModelWithAttributes class" do
-    should "know the names of all its attributes" do
-      XmlModelWithAttributes.attributes.map {|a| a.name.to_s }.should == %w(name description rating size)
-    end
-  end
-  
-  context "The XmlModelWithAttributeType class" do
-    should "know that it's attribute is of type :integer" do
-      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 = XmlModelWithAttributeType.new
-      m.id = 1
-      
-      xml = String.new
-      xml << '<?xml version="1.0" encoding="UTF-8"?>'
-      xml << '<model>'
-      xml << '<id>1</id>'
-      xml << '</model>'
-      
-      m.to_xml('model').should == xml
-      
-    end
-  end
-
-  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
-      XmlModelWithAttributes.new.respond_to?(:name).should be(true)
-    end
-    
-    should "be able to populate its data on initialization" do
-      xml = Hpricot.XML(@simple_xml)
-      XmlModelWithAttributes.new(xml).name.should == 'Graft'
-    end
-    
-    should "have a reference to the original document" do
-      xml = Hpricot.XML(@simple_xml)
-      XmlModelWithAttributes.new(xml).source_data.should == xml
-    end
-    
-    should "be able to populate from an XML string" do
-      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
-      
-      setup do
-        xml = <<-XML
-          <name>Graft</name>
-          <desc>A sweet Ruby library</desc>
-          <rating value="100" />
-          <node type="color" value="blue" />
-          <node type="size" value="large" />
-        XML
-
-        @model = XmlModelWithAttributes.new
-        @model.populate_from(Hpricot.XML(xml))
-      end
-
-      should "have the correct value for :name" do
-        @model.name.should == 'Graft'
-      end
-      
-      should "have the correct value for :description" do
-        @model.description.should == 'A sweet Ruby library'
-      end
-      
-      should "have the correct value for :rating" do
-        @model.rating.should == '100'
-      end
-      
-      # should "have the correct value for :size" do
-      #   @model.size.should == 'large'
-      # end
-      
-    end
-  end
-  
-end

data/test/unit/xml/type_test.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Graft
-  module Xml
-
-    class StringTest < Test::Unit::TestCase
-      context "An instance of the Graft::Xml::Type::String class" do
-
-        should_convert 'a string', :to => 'a string'
-        should_convert '',         :to => nil
-
-      end
-    end
-
-    class BooleanTest < Test::Unit::TestCase
-      context "An instance of the Graft::Xml::Type::Boolean class" do
-
-        should_convert 'true',  :to => true
-        should_convert 'false', :to => false
-        should_convert '0',     :to => false
-        should_convert '1',     :to => true
-        should_convert '',      :to => nil
-
-        should_fail_when_converting 'foo'
-
-      end
-    end
-
-    class IntegerTest < Test::Unit::TestCase
-      context "An instance of the Graft::Xml::Type::Integer class" do
-
-        should_convert '1', :to => 1
-        should_convert '',  :to => nil
-
-        should_fail_when_converting 'foo'
-
-      end
-    end
-
-    class DateTest < Test::Unit::TestCase
-
-      context "An instance of the Graft::Xml::Type::Date class" do
-
-        should_convert '2008-08-01', :to => Date.parse('2008-08-01')
-        should_convert '',           :to => nil
-
-      end
-
-    end
-
-    class TimeTest < Test::Unit::TestCase
-
-      context "An instance of the Graft::Xml::Type::Time class" do
-
-        should_convert '2008-07-28T16:57:10Z', :to => Time.parse('2008-07-28T16:57:10Z')
-        should_convert '2008-12-25 18:26:55',  :to => Time.parse('2008-12-25 18:26:55')
-        should_convert '1230274722',           :to => Time.at(1230274722)
-        should_convert '',                     :to => nil
-
-      end
-
-    end
-
-  end
-end