confuddle 0.0.1

data/lib/graft/lib/graft/xml/type.rb

@@ -0,0 +1,91 @@
+module Graft
+  module Xml
+
+    # = 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
+end

data/lib/graft/test/test_helper.rb

@@ -0,0 +1,38 @@
+# 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/lib/graft/test/unit/core_ext/hash_test.rb

@@ -0,0 +1,29 @@
+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/lib/graft/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/lib/graft/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/lib/graft/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