graft 0.1.1 → 0.2.0

data/Rakefile

@@ -22,6 +22,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('tzinfo', '>= 0.3.12')
   s.add_dependency('builder', '>= 2.1.2')
   s.add_dependency('activesupport', '>= 2.0')
+  s.add_dependency('json', '>= 1.1.7')
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/lib/graft/core_ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  
+  def /(path)
+    path.to_s.split('/').inject(self) do |data, key|
+      (data.is_a?(Hash) && data[key]) ? data[key] : nil
+    end
+  end
+  
+end

data/lib/graft/json.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__) + '/..'
+
+require 'json'
+require 'graft/core_ext/hash'
+
+require 'graft/model'
+require 'graft/json/attribute'
+require 'graft/json/model'
+
+module Graft
+  def self.included(other)
+    other.send(:include, Graft::Json::Model)
+  end
+end

data/lib/graft/json/attribute.rb

@@ -0,0 +1,18 @@
+module Graft
+  module Json
+    class Attribute
+
+      attr_reader :name, :source
+
+      def initialize(name, source = nil)
+        @name   = name
+        @source = source.nil? ? @name.to_s : source
+      end
+
+      def value_from(data)
+        data/source
+      end
+
+    end
+  end
+end

data/lib/graft/json/model.rb

@@ -0,0 +1,28 @@
+module Graft
+  module Json
+    module Model
+
+      module ClassMethods
+
+        def attribute(name, options = {})
+          source = options[:from]
+
+          self.attributes << Graft::Json::Attribute.new(name, source)
+          class_eval "attr_accessor :#{name}"
+        end
+        
+        def data_from(json_or_hash)
+          json_or_hash.is_a?(String) ? JSON.parse(json_or_hash) : json_or_hash
+        end
+
+      end
+
+      def self.included(other)
+        other.send(:extend, Graft::Model::ClassMethods)
+        other.send(:extend, Graft::Json::Model::ClassMethods)
+        other.send(:include, Graft::Model::InstanceMethods)
+      end
+
+    end
+  end
+end

data/lib/graft/model.rb

@@ -1,69 +1,38 @@
 module Graft
   module Model
-    
+
     module ClassMethods
-      
       def attributes
         @attributes ||= []
       end
       
-      def attribute(name, options = {})
-        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 }
+      def collection_from(data_source, node)
+        (data_from(data_source)/node).map {|n| new n }
       end
-      
     end
-    
+
     module InstanceMethods
       
-      def initialize(document = nil)
-        self.document = document
-        self.populate_from(self.document) unless self.document.nil?
+      def initialize(source_data = nil)
+        self.source_data = source_data
+        self.populate_from(self.source_data) unless self.source_data.nil?
       end
       
-      def document=(document)
-        @document = document.is_a?(String) ? Hpricot.XML(document) : document
+      def source_data=(source_data)
+        @source_data = self.class.data_from(source_data)
       end
       
-      def document
-        @document
+      def source_data
+        @source_data
       end
       
-      def populate_from(document)
+      def populate_from(data_source)
         self.class.attributes.each do |attribute|
-          value = attribute.value_from(document)
+          value = attribute.value_from(self.class.data_from(data_source))
           self.send("#{attribute.name}=".to_sym, value) unless value.nil?
         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)
-      other.send(:extend, Graft::Model::ClassMethods)
-      other.send(:include, Graft::Model::InstanceMethods)
     end
     
   end

data/lib/graft/version.rb

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

data/lib/graft/xml.rb

@@ -0,0 +1,19 @@
+$:.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/model'
+require 'graft/xml/type'
+require 'graft/xml/attribute'
+require 'graft/xml/model'
+
+module Graft
+  def self.included(other)
+    other.send(:include, Graft::Xml::Model)
+  end
+end

data/lib/graft/xml/attribute.rb

@@ -0,0 +1,52 @@
+module Graft
+  module Xml
+    class Attribute
+
+      # TODO: Refactor the location / attribute logic into a Source class
+
+      attr_reader :name, :sources
+
+      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::Xml::Type::#{@type.to_s.camelize}".constantize
+      end
+
+      def split(source)
+        location, attribute = source.split('@')
+        location = self.name.to_s if location.blank?
+
+        [location, attribute]
+      end
+
+      def node_for(document, source)
+        document.at(location(source)) || document.search("//[@#{attribute(source)}]").first
+      end
+
+      def attribute(source)
+        location, attribute = source.split('@')
+        attribute || location
+      end
+
+      def location(source)
+        split(source).first
+      end
+
+      def value_from(document)
+        values = sources.map do |source|
+          node = node_for(document, source)
+          (node.attributes[attribute(source)] || node.inner_text) unless node.nil?
+        end
+
+        type_class.new(values.compact.first).value
+      end
+
+    end
+  end
+end

data/lib/graft/xml/model.rb

@@ -0,0 +1,49 @@
+module Graft
+  module Xml
+    module Model
+
+      module ClassMethods
+
+        def attribute(name, options = {})
+          source = options[:from]
+          type   = options[:type] || :string
+
+          self.attributes << Graft::Xml::Attribute.new(name, type, source)
+          class_eval "attr_accessor :#{name}"
+        end
+
+        def data_from(xml_or_document)
+          xml_or_document.is_a?(String) ? Hpricot.XML(xml_or_document) : xml_or_document
+        end
+
+      end
+
+      module InstanceMethods
+
+        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)
+        other.send(:extend, Graft::Model::ClassMethods)
+        other.send(:extend, Graft::Xml::Model::ClassMethods)
+        other.send(:include, Graft::Model::InstanceMethods)
+        other.send(:include, Graft::Xml::Model::InstanceMethods)
+      end
+
+    end
+  end
+end

data/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/test/test_helper.rb

@@ -4,13 +4,14 @@ $:.reject! { |e| e.include? 'TextMate' }
 require 'rubygems'
 require 'throat_punch'
 
-require File.dirname(__FILE__) + '/../lib/graft'
+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::Type.const_get(class_name)
+    klass      = Graft::Xml::Type.const_get(class_name)
     
     klass
   end
@@ -30,7 +31,7 @@ class Test::Unit::TestCase
     
     should "fail when converting '#{source}'" do
       o = klass.new(source)
-      lambda { o.value }.should raise_error(Graft::Type::ConversionError)
+      lambda { o.value }.should raise_error(Graft::Xml::Type::ConversionError)
     end
   end
   

data/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