restfulie 0.8.0 → 0.8.1

data/lib/restfulie/common/representation/atom/link.rb

@@ -0,0 +1,68 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        class Link < XML    
+          def initialize(options_or_obj)
+            if options_or_obj.kind_of?(Hash)
+              @doc = Nokogiri::XML::Document.new()
+              options_or_obj = create_element("link", options_or_obj)
+            end
+            super(options_or_obj)
+          end
+          
+          def href
+            @doc["href"]
+          end
+          
+          def href=(value)
+            @doc["href"] = value
+          end
+          
+          def rel
+            @doc["rel"]
+          end
+          
+          def rel=(value)
+            @doc["rel"] = value
+          end
+      
+          if method_defined?(:type)
+            alias_method :__type__, :type
+          end
+          def type
+            @doc["type"]
+          end
+          
+          def type=(value)
+            @doc["type"] = value
+          end
+      
+          def hreflang
+            @doc["hreflang"]
+          end
+          
+          def hreflang=(value)
+            @doc["hreflang"] = value
+          end
+      
+          def title
+            @doc["title"]
+          end
+          
+          def title=(value)
+            @doc["title"] = value
+          end
+          
+          def length
+            @doc["length"]
+          end
+          
+          def length=(value)
+            @doc["length"] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/atom/person.rb

@@ -0,0 +1,48 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        class Person < XML    
+          def initialize(node_type, options_or_obj)
+            if options_or_obj.kind_of?(Hash)
+              @doc = Nokogiri::XML::Document.new()
+              node = @doc.create_element(node_type)
+              node.add_namespace_definition(nil, "http://www.w3.org/2005/Atom")
+              node.parent = @doc
+              super(node)
+              options_or_obj.each do |key,value|
+                self.send("#{key}=".to_sym, value)
+              end
+            else
+              super(options_or_obj)
+            end
+          end
+          
+          def name
+            text("name")
+          end
+          
+          def name=(value)
+            set_text("name", value)
+          end
+          
+          def uri
+            text("uri")
+          end
+          
+          def uri=(value)
+            set_text("uri", value)
+          end
+      
+          def email
+            text("email")
+          end
+          
+          def email=(value)
+            set_text("email", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/atom/source.rb

@@ -0,0 +1,59 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        class Source < XML    
+          def initialize(options_or_obj)
+            if options_or_obj.kind_of?(Hash)
+              @doc = Nokogiri::XML::Document.new()
+              node = @doc.create_element("source")
+              node.add_namespace_definition(nil, "http://www.w3.org/2005/Atom")
+              node.parent = @doc
+              super(node)
+              options_or_obj.each do |key,value|
+                self.send("#{key}=".to_sym, value)
+              end
+            else
+              super(options_or_obj)
+            end
+          end
+          
+          def id
+            text("id")
+          end
+      
+          def id=(value)
+            set_text("id", value)
+          end
+      
+          # text
+          def title
+            text("title")
+          end
+        
+          def title=(value)
+            set_text("title", value)
+          end
+      
+          def updated
+            value = text("updated")
+            Time.parse(value) unless value.nil?
+          end
+        
+          def updated=(value)
+            set_text("updated", value)
+          end
+      
+          # text
+          def rights
+            text("rights")
+          end
+      
+          def rights=(value)
+            set_text("rights", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/atom/tag_collection.rb

@@ -0,0 +1,38 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        class TagCollection < ::Array
+          def initialize(parent_node, &block)
+            @node = parent_node
+            @method_missing_block = block_given? ? block : nil
+            super(0)
+          end
+          
+          def <<(obj)
+            obj = [obj] unless obj.kind_of?(Array)
+            obj.each do |o|
+              o.doc.parent = @node
+              super(o)
+            end
+          end
+          
+          def delete(obj)
+            if super(obj)
+              obj.doc.unlink
+              obj = nil
+            end
+          end
+          
+          def method_missing(symbol, *args, &block)
+            if @method_missing_block
+              @method_missing_block.call(self, symbol, *args)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/atom/xml.rb

@@ -0,0 +1,95 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        class XML
+          attr_accessor :doc
+        
+          def initialize(xml_obj = nil)
+            if xml_obj
+              xml_obj.kind_of?(Nokogiri::XML::Document) ? @doc = xml_obj.root : @doc = xml_obj
+            else
+              @doc    = Nokogiri::XML::Document.new
+              root_node = @doc.create_element(atom_type.to_s)
+              root_node.add_namespace_definition(nil, "http://www.w3.org/2005/Atom")
+              root_node.parent = @doc
+              @doc = @doc.root
+            end
+          end
+          
+          # Tools
+          def css(*args)
+            @doc.css(*args)
+          end
+        
+          def xpath(*args)
+            @doc.xpath(*args)
+          end
+      
+          def atom_type
+            self.class.name.demodulize.downcase
+          end
+      
+          def to_xml
+            @doc.to_xml
+          end
+        
+          def to_s
+            to_xml
+          end
+
+          def method_missing(method)
+            value = text(method)
+            unless value
+              super
+            else
+              value
+            end
+          end
+
+        protected 
+      
+          def text(node_name)
+            (node = @doc.at_xpath("xmlns:#{node_name}")) ? node.content : nil
+          end
+      
+          def set_text(node_name, value)
+            unless (node = @doc.at_xpath("xmlns:#{node_name}"))
+              node = create_element(node_name, value)
+              node.parent = @doc
+            else
+              value = value.xmlschema if value.kind_of?(Time) || value.kind_of?(DateTime)
+              node.content = value
+            end
+          end
+      
+        private
+      
+          def create_element(node, *args)
+            node = @doc.document.create_element(node) do |n|
+              args.each do |arg|
+                case arg
+                # Adding XML attributes
+                when Hash
+                  arg.each { |k,v|
+                    key = k.to_s
+                    if key =~ /^xmlns(:\w+)?$/
+                      ns_name = key.split(":", 2)[1]
+                      n.add_namespace_definition(ns_name, v)
+                      next
+                    end
+                    n[k.to_s] = v.to_s
+                  }
+                # Adding XML node content
+                else            
+                  arg.kind_of?(Time) || arg.kind_of?(DateTime) ? content = arg.xmlschema : content = arg
+                  n.content = content
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/generic.rb

@@ -1,33 +1,34 @@
-module Restfulie::Common::Representation
-  # Unknown representation's unmarshalling on the client side
-  class Generic
-
-    def self.media_type_name
-      raise Restfulie::Common::Error::RestfulieError.new("Generic representation does not have a specific media type")
-    end
-
-    cattr_reader :headers
-    @@headers = { 
-      :get  => { },
-      :post => { }
-    }
-
-    # Because there is no media type registered, return the content itself
-    def unmarshal(content)
-      def content.links
-        []
+module Restfulie
+  module Common
+    module Representation
+      # Unknown representation's unmarshalling on the client side
+      class Generic
+        def self.media_type_name
+          raise Error::RestfulieError.new("Generic representation does not have a specific media type")
+        end
+    
+        cattr_reader :headers
+        @@headers = { 
+          :get  => { },
+          :post => { }
+        }
+    
+        # Because there is no media type registered, return the content itself
+        def unmarshal(content)
+          def content.links
+            []
+          end
+          content
+        end
+    
+        def marshal(string, rel)
+          string
+        end
+    
+        def prepare_link_for(link)
+          link
+        end
       end
-      content
-    end
-
-    def marshal(string, rel)
-      string
-    end
-
-    def prepare_link_for(link)
-      link
     end
   end
-
 end
-

data/lib/restfulie/common/representation/json.rb

@@ -1,25 +1,13 @@
-module Restfulie::Common::Representation
-
-  # Implements the interface for marshal Xml media type requests (application/xml)
-  class Json
-
-    cattr_reader :media_type_name
-    @@media_type_name = 'application/json'
-
-    cattr_reader :headers
-    @@headers = { 
-      :post => { 'Content-Type' => media_type_name }
-    }
-
-    def unmarshal(string)
-      JSON.parse(string)
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        autoload :Base, 'restfulie/common/representation/json/base' 
+        autoload :KeysAsMethods, 'restfulie/common/representation/json/keys_as_methods' 
+        autoload :Link, 'restfulie/common/representation/json/link' 
+        autoload :LinkCollection, 'restfulie/common/representation/json/link_collection' 
+        extend Base::ClassMethods
+      end
     end
-
-    def marshal(entity, rel)
-      return entity if entity.kind_of? String
-      entity.to_json
-    end
-
   end
-
 end

data/lib/restfulie/common/representation/json/base.rb

@@ -0,0 +1,27 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        module Base
+          module ClassMethods
+            
+            # creates a json unmarshalled version of this object
+            def create(obj = nil)
+              @json = {}
+              return @json.extend(KeysAsMethods) unless obj
+              
+              if obj.kind_of?(Hash) || obj.kind_of?(Array)
+                @json = obj
+              else 
+                @json = ::JSON.parse(obj)
+              end
+              
+              @json.extend(KeysAsMethods)
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/json/keys_as_methods.rb

@@ -0,0 +1,72 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        module KeysAsMethods
+          def self.extended(base)
+            [:type, :id].each { |m| base.__free_method__(m) }      
+          end
+          
+          def [](key)
+            __normalize__(super(key))
+          end
+      
+          def []=(key, value)
+            super(key,value)
+          end
+      
+          def to_s
+            super.to_json
+          end
+      
+          def method_missing(name, *args)
+            method_name = name.to_s
+            if method_name.last == '='
+              self[method_name.chop] = args[0]
+            else
+              self[method_name]
+            end
+          end
+      
+          # if you have a key that is also a method (such as Array#size)
+          # you can use this to free the method and use the method obj.size
+          # to access the value of key "size".
+          # you still can access the old method with __[method_name]__
+          def __free_method__(sym)
+            if self.__metaclass__.method_defined?(sym) && !respond_to?("__#{sym}__")
+              self.__metaclass__.send(:alias_method, "__#{sym}__", sym)
+            end
+            self.__metaclass__.send(:define_method, sym) { method_missing(sym.to_s) }
+            self
+          end
+      
+          def __metaclass__
+            class << self; self; end
+          end
+          
+          # easy accessors to links
+          def links
+            some_links = self["link"]
+            return nil unless some_links
+            some_links = [some_links] unless some_links.kind_of? Array
+            LinkCollection.new(some_links)
+          end
+              
+        private
+      
+          def __normalize__(value)
+            case value
+            when Hash
+              value.extend(KeysAsMethods)
+            when Array
+              value.map { |v| __normalize__(v) }
+            else
+              value
+            end
+            value
+          end
+        end
+      end
+    end
+  end
+end