graft 0.1.0 → 0.1.1

data/Rakefile

@@ -18,8 +18,10 @@ spec = Gem::Specification.new do |s|
   s.homepage         = 'http://sneaq.net/'
   s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib,test}/**/*")
   
-  s.add_dependency('hpricot', '~> 0.6.0')
-  s.add_dependency('activesupport', '~> 2.0')
+  s.add_dependency('hpricot', '>= 0.6.164')
+  s.add_dependency('tzinfo', '>= 0.3.12')
+  s.add_dependency('builder', '>= 2.1.2')
+  s.add_dependency('activesupport', '>= 2.0')
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/lib/graft.rb

@@ -1,7 +1,13 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'hpricot'
+require 'builder'
+require 'tzinfo'
 require 'active_support/core_ext/blank'
+require 'active_support/time_with_zone'
+require 'active_support/inflector'
+
 
 require 'graft/attribute'
-require 'graft/model'
+require 'graft/model'
+require 'graft/type'

data/lib/graft/attribute.rb

@@ -5,12 +5,17 @@ module Graft
 
     attr_reader :name, :sources
 
-    def initialize(name, sources = nil)
+    def initialize(name, type = :string, sources = nil)
       @name = name.to_sym
+      @type = type
 
       @sources = Array(sources)
       @sources << @name.to_s if @sources.empty?
     end
+    
+    def type_class
+      "Graft::Type::#{@type.to_s.camelize}".constantize
+    end
 
     def split(source)
       location, attribute = source.split('@')
@@ -37,7 +42,8 @@ module Graft
         node = node_for(document, source)
         (node.attributes[attribute(source)] || node.inner_text) unless node.nil?
       end
-      values.compact.first
+      
+      type_class.new(values.compact.first).value
     end
 
   end

data/lib/graft/model.rb

@@ -8,9 +8,16 @@ module Graft
       end
       
       def attribute(name, options = {})
-        self.attributes << Attribute.new(name, options[:from])
+        source = options[:from]
+        type   = options[:type] || :string
+        
+        self.attributes << Attribute.new(name, type, source)
         class_eval "attr_accessor :#{name}"
       end
+
+      def collection_from(xml, node)
+        (Hpricot.XML(xml)/node).map {|n| new n.to_s }
+      end
       
     end
     
@@ -36,6 +43,22 @@ module Graft
         end
       end
       
+      def to_hash
+        self.class.attributes.inject({}) {|h,a| h.merge(a.name.to_s => send(a.name)) }
+      end
+      
+      def to_xml(tag_name)
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.tag! tag_name do
+          to_hash.each do |attribute, value|
+            xml.tag! attribute, value
+          end
+        end
+        xml.target!
+      end
+
+      
     end
     
     def self.included(other)

data/lib/graft/type.rb

@@ -0,0 +1,89 @@
+module Graft
+  
+  # = Type
+  #
+  class Type
+
+    class ConversionError < StandardError; end
+    
+    def initialize(source)
+      @source = source
+    end
+    
+    def convertible?
+      true
+    end
+    
+    def value
+      raise ConversionError unless (@source.blank? || convertible?)
+      @source.blank? ? nil : convert
+    end
+    
+    # = String
+    #
+    class String < Type
+      
+      def convert
+        @source
+      end
+      
+    end
+    
+    # = Boolean
+    #
+    class Boolean < Type
+      def true_values
+        ['true', '1']
+      end
+      
+      def false_values
+        ['false', '0']
+      end
+    
+      def convertible?
+        (true_values + false_values).include?(@source)
+      end
+    
+      def convert
+        true_values.include?(@source) ? true : false
+      end
+    end
+    
+    # = Integer
+    #
+    class Integer < Type
+      def convertible?
+        !@source.match(/\d+/).nil?
+      end
+      
+      def convert
+        @source.to_i
+      end
+    end
+    
+    # = Time
+    #
+    class Time < Type
+
+      def timestamp?
+        !@source.match(/^\d+$/).nil?
+      end
+      
+      def convert
+        timestamp? ? ::Time.at(@source.to_i) : ::Time.parse(@source)
+      end
+      
+    end
+    
+    # = Date
+    #
+    class Date < Type
+      
+      def convert
+        ::Date.parse(@source)
+      end
+      
+    end
+    
+  end
+end

data/lib/graft/version.rb

@@ -3,7 +3,7 @@ module Graft
     
     MAJOR = 0
     MINOR = 1
-    TINY  = 0
+    TINY  = 1
     
     def self.to_s # :nodoc:
       [MAJOR, MINOR, TINY].join('.')

data/test/test_helper.rb

@@ -4,4 +4,34 @@ $:.reject! { |e| e.include? 'TextMate' }
 require 'rubygems'
 require 'throat_punch'
 
-require File.dirname(__FILE__) + '/../lib/graft'
+require File.dirname(__FILE__) + '/../lib/graft'
+
+class Test::Unit::TestCase
+  
+  def self.implementation_klass
+    class_name = self.to_s.match(/([a-zA-Z]+)Test$/)[1]
+    klass      = Graft::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::Type::ConversionError)
+    end
+  end
+  
+end

data/test/unit/attribute_test.rb

@@ -2,59 +2,64 @@ require File.dirname(__FILE__) + '/../test_helper'
 
 module Graft
   class AttributeTest < Test::Unit::TestCase
-    describe "An instance of the Attribute class" do
+    context "An instance of the Attribute class" do
 
-      it "should know the name of the attribute" do
+      should "know the name of the attribute" do
         attr = Attribute.new('foo')
         attr.name.should == :foo
       end
+      
+      should "have a default type class" do
+        attr = Attribute.new('foo')
+        attr.type_class.should == Graft::Type::String
+      end
 
-      it "should have a default source" do
+      should "have a default source" do
         attr = Attribute.new(:foo)
         attr.sources.should == ['foo']
       end
       
-      it "should be able to assign multiple sources" do
-        attr = Attribute.new(:foo, ['foo1', 'foo2'])
+      should "be able to assign multiple sources" do
+        attr = Attribute.new(:foo, :string, ['foo1', 'foo2'])
         attr.sources.should == ['foo1', 'foo2']
       end
 
-      it "should pull the location from the source" do
+      should "pull the location from the source" do
         attr = Attribute.new('foo')
         attr.location('foo').should == 'foo'
       end
       
-      it "should return the location when splitting" do
+      should "return the location when splitting" do
         attr = Attribute.new('foo')
         attr.split('foo').should == ['foo', nil]
       end
       
-      it "should return the name for the location when splitting if the location isn't specified" do
+      should "return the name for the location when splitting if the location isn't specified" do
         attr = Attribute.new('foo')
         attr.split('@bar').should == ['foo', 'bar']
       end
       
-      it "should allow the setting of the location information" do
-        attr = Attribute.new('foo', 'bar')
+      should "allow the setting of the location information" do
+        attr = Attribute.new('foo', :string, 'bar')
         attr.sources.should == ['bar']
       end
       
-      it "should allow the setting of the attribute value" do
+      should "allow the setting of the attribute value" do
         attr = Attribute.new('foo')
         attr.attribute('@bogon').should == 'bogon'
       end
       
-      it "should use the location as the attribute" do
+      should "use the location as the attribute" do
         attr = Attribute.new('foo')
         attr.attribute('foo').should == 'foo'
       end
       
-      it "should use the attribute for the attribute if specified" do
-        attr = Attribute.new(:id, '@nsid')
+      should "use the attribute for the attribute if specified" do
+        attr = Attribute.new(:id, :string, '@nsid')
         attr.attribute('@nsid').should == 'nsid'
       end
 
-      it "should be able to retrieve the node from the path" do
+      should "be able to retrieve the node from the path" do
         document = Hpricot.XML('<name>Bassdrive</name>')
         expected = document.at('name')
         
@@ -62,7 +67,7 @@ module Graft
         attr.node_for(document, 'name').should == expected
       end
       
-      it "should be able to retrieve the node that contains the specified attribute" do
+      should "be able to retrieve the node that contains the specified attribute" do
         document = Hpricot.XML('<user id="1337" />')
         expected = document.at('user')
         
@@ -70,63 +75,84 @@ module Graft
         attr.node_for(document, '@id').should == expected
       end
 
-      it "should be able to retrieve the node for the specified attribute" do
+      should "be able to retrieve the node for the specified attribute" do
         document = Hpricot.XML('<user nsid="1337" />')
         expected = document.at('user')
         
-        attr = Attribute.new(:id, '@nsid')
+        attr = Attribute.new(:id, :string, '@nsid')
         attr.node_for(document, '@nsid').should == expected
       end
       
-      it "should be able to pull simple values from an XML document" do
+      should "be able to pull simple values from an XML document" do
         document = Hpricot.XML('<name>Bassdrive</name>')
         attr = Attribute.new(:name)
         attr.value_from(document).should == 'Bassdrive'
       end
 
-      it "should be able to pull an attribute value from the current XML node" do
+      should "be able to pull an attribute value from the current XML node" do
         document = Hpricot.XML('<user id="1337" />')
         attr = Attribute.new(:id)
         attr.value_from(document).should == '1337'
       end
         
-      it "should be able to pull a specific attribute value from the current XML node" do
+      should "be able to pull a specific attribute value from the current XML node" do
         document = Hpricot.XML('<user nsid="1337" />')
-        attr = Attribute.new(:id, '@nsid')
+        attr = Attribute.new(:id, :string, '@nsid')
         attr.value_from(document).should  == '1337'
       end
 
-      it "should be able to pull an attribute value for a node and attribute" do
+      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 = Attribute.new(:slug, 'station/genre@slug')
+        attr = Attribute.new(:slug, :string, 'station/genre@slug')
         attr.value_from(document).should == 'dnb'
       end
         
-      it "should be able to pull a value from a nested XML node" do
+      should "be able to pull a value from a nested XML node" do
         document = Hpricot.XML('<rsp><user>blip</user></rsp>')
         attr = Attribute.new(:user)
         attr.value_from(document).should == 'blip'
       end
       
-      # it "should be able to pull a value from an attribute once it's found a node by another attribute" do
-      #   document = Hpricot.XML('<node type="blip" value="bleep" />')
-      #   attr = Attribute.new(:blip, "node[@type='blip]@value")
-      #   
-      #   attr.value_from(document).should == 'bleep'
-      # end
-
-      it "should return nil if it cannot find the specified node" do
+      should "return nil if it cannot find the specified node" do
         document = Hpricot.XML('<user id="1" />')
-        attr = Attribute.new(:photoset, '@nsid')
+        attr = Attribute.new(:photoset, :string, '@nsid')
         attr.value_from(document).should be(nil)
       end
 
-      it "should be able to try a series of nodes to find a value" do
+      should "be able to try a series of nodes to find a value" do
         document = Hpricot.XML('<photoid>123</photoid>')
 
-        attr = Attribute.new(:id, ['photo@nsid', 'photoid'])
+        attr = 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 = 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 = 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 = 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 = Attribute.new(:created_at, :time)
+        attr.value_from(document).should == Time.parse('2009-08-01 00:00:00')
+      end
 
     end
   end

data/test/unit/model_test.rb

@@ -14,46 +14,113 @@ class ModelWithAttributes
   
 end
 
+class ModelWithAttributeType
+  include Graft::Model
+  
+  attribute :id, :type => :integer
+  
+end
+
 class ModelTest < Test::Unit::TestCase
 
-  describe "The EmptyModel class" do
-    it "should have an empty list of attributes if none are supplied" do
+  context "The EmptyModel class" do
+    should "have an empty list of attributes if none are supplied" do
       EmptyModel.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
+      
+      EmptyModel.expects(:new).with('<thing><id>1</id></thing>').returns('model_1')
+      EmptyModel.expects(:new).with('<thing><id>2</id></thing>').returns('model_2')
+      
+      collection = EmptyModel.collection_from(xml, 'things/thing')
+      collection.should == ['model_1', 'model_2']
+    end
+    
+    should "return an empty hash when calling :to_hash" do
+      m = EmptyModel.new
+      m.to_hash.should == {}
+    end
 
   end
-
-  describe "The ModelWithAttributes class" do
-    it "should know the names of all its attributes" do
+  
+  context "The ModelWithAttributes 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'
+      }
+
+    end
+  end
+  
+  context "The ModelWithAttributeType class" do
+    should "know that it's attribute is of type :integer" do
+      attribute = ModelWithAttributeType.attributes.first
+      attribute.type_class.should == Graft::Type::Integer
+    end
+    
+    should "be able to generate an XML representation of itself" do
+      
+      m = ModelWithAttributeType.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
 
-  describe "An instance of the ModelWithAttributes class" do
+  context "An instance of the ModelWithAttributes class" do
 
-    before { @simple_xml = '<name>Graft</name>' }
+    setup { @simple_xml = '<name>Graft</name>' }
 
-    it "should have default reader method for :name" do
+    should "have default reader method for :name" do
       ModelWithAttributes.new.respond_to?(:name).should be(true)
     end
     
-    it "should be able to populate its data on initialization" do
+    should "be able to populate its data on initialization" do
       xml = Hpricot.XML(@simple_xml)
       ModelWithAttributes.new(xml).name.should == 'Graft'
     end
     
-    it "should have a reference to the original document" do
+    should "have a reference to the original document" do
       xml = Hpricot.XML(@simple_xml)
       ModelWithAttributes.new(xml).document.should == xml
     end
     
-    it "should be able to populate from an XML string" do
+    should "be able to populate from an XML string" do
       ModelWithAttributes.new(@simple_xml).name.should == 'Graft'
     end
     
     context "when populating data from an XML document" do
       
-      before do
+      setup do
         xml = <<-XML
           <name>Graft</name>
           <desc>A sweet Ruby library</desc>
@@ -66,19 +133,19 @@ class ModelTest < Test::Unit::TestCase
         @model.populate_from(Hpricot.XML(xml))
       end
 
-      it "should have the correct value for :name" do
+      should "have the correct value for :name" do
         @model.name.should == 'Graft'
       end
       
-      it "should have the correct value for :description" do
+      should "have the correct value for :description" do
         @model.description.should == 'A sweet Ruby library'
       end
       
-      it "should have the correct value for :rating" do
+      should "have the correct value for :rating" do
         @model.rating.should == '100'
       end
       
-      # it "should have the correct value for :size" do
+      # should "have the correct value for :size" do
       #   @model.size.should == 'large'
       # end
       

data/test/unit/source_test.rb

@@ -3,8 +3,11 @@ require File.dirname(__FILE__) + '/../test_helper'
 module Graft
   class SourceTest < Test::Unit::TestCase
     
-    describe "An instance of the Source class" do
+    context "An instance of the Source class" do
       
+      should "be defined" do
+        true.should == true
+      end
       
       
     end

data/test/unit/type_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+module Graft
+  
+  class StringTest < Test::Unit::TestCase
+    context "An instance of the Graft::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::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::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::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::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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: graft
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Patrick Reagan
@@ -18,9 +18,29 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.6.0
+        version: 0.6.164
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.12
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
@@ -28,7 +48,7 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         version: "2.0"
     version: 
@@ -45,12 +65,14 @@ files:
 - Rakefile
 - lib/graft/attribute.rb
 - lib/graft/model.rb
+- lib/graft/type.rb
 - lib/graft/version.rb
 - lib/graft.rb
 - test/test_helper.rb
 - test/unit/attribute_test.rb
 - test/unit/model_test.rb
 - test/unit/source_test.rb
+- test/unit/type_test.rb
 has_rdoc: true
 homepage: http://sneaq.net/
 licenses: []