restfulie 0.7.2 → 0.8.0

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

@@ -0,0 +1,375 @@
+module Restfulie::Common::Representation::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
+    
+  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
+  
+  
+  class Base < XML
+  
+    ATOM_ATTRIBUTES = {
+      :feed  => {
+        :required    => [:id, :title, :updated],
+        :recommended => [:author, :link],
+        :optional    => [:category, :contributor, :rights, :generator, :icon, :logo, :subtitle]
+      },
+    
+      :entry => {
+        :required    => [:id, :title, :updated],
+        :recommended => [:author, :link, :content, :summary],
+        :optional    => [:category, :contributor, :rights, :published, :source]
+      }
+    }
+    
+    def initialize(xml_obj = nil)
+      @authors = nil
+      @contributors = nil
+      @links = nil
+      @categories = nil
+      @reserved = []
+      super(xml_obj)
+    end
+    
+    # lists all extension points available in this entry
+    def extensions
+      result = []
+      @doc.children.each do |e|
+        if e.element?
+          result << e unless @reserved.map(&:to_s).include?(e.node_name)
+        end
+      end
+      return result
+    end
+    
+    #simpletext
+    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
+  
+    # Author have name, and optional uri and email, this describes a person
+    def authors
+      unless @authors
+        @authors = TagCollection.new(@doc)
+        @doc.xpath("xmlns:author").each do |author|
+          @authors << Person.new("author", author)
+        end
+      end
+      
+      return @authors
+    end
+  
+    def contributors
+      unless @contributors
+        @contributors = TagCollection.new(@doc)
+        @doc.xpath("xmlns:author").each do |contributor|
+          @contributors << Person.new("contributor", contributor)
+        end
+      end
+      
+      return @contributor
+    end
+  
+    # It has one required attribute, href, and five optional attributes: rel, type, hreflang, title, and length
+    def links
+      unless @links
+        @links = TagCollection.new(@doc) do |array, symbol, *args|
+          linkset = array.select {|link| link.rel == symbol.to_s }
+          unless linkset.empty?
+            linkset.size == 1 ? linkset.first : linkset
+          else
+            nil
+          end          
+        end
+        @doc.xpath("xmlns:link").each do |link|
+          @links << Link.new(link)
+        end        
+      end
+      
+      return @links
+    end
+  
+    def categories
+      unless @categories
+        @categories = TagCollection.new(@doc)
+        @doc.xpath("xmlns:category").each do |category|
+          @categories << Link.new(category)
+        end        
+      end
+      
+      return @categories
+    end
+  end
+
+  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
+
+  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
+
+    alias_method :__type__, :type
+    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
+  
+  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
+  
+  class Category < XML    
+    def initialize(options_or_obj)
+      if options_or_obj.kind_of?(Hash)
+        @doc = Nokogiri::XML::Document.new()
+        options_or_obj = create_element("category", options_or_obj)
+      end
+      super(options_or_obj)
+    end
+    
+    def term
+      @doc["term"]
+    end
+    
+    def term=(value)
+      @doc["term"] = value
+    end
+    
+    def scheme
+      @doc["scheme"]
+    end
+    
+    def scheme=(value)
+      @doc["scheme"] = value
+    end
+
+    def label
+      @doc["label"]
+    end
+    
+    def label=(value)
+      @doc["label"] = value
+    end
+  end
+
+end

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

@@ -0,0 +1,107 @@
+module Restfulie::Common::Representation::Atom
+  
+  class Entry < Base   
+    
+    def initialize(xml_obj = nil)
+      @source = nil
+      super(xml_obj)
+      @reserved = Base::ATOM_ATTRIBUTES[:entry][:required] + Base::ATOM_ATTRIBUTES[:entry][:recommended] + Base::ATOM_ATTRIBUTES[:entry][:optional]
+    end
+     
+    #text
+    def content
+      text("content")
+    end
+
+    def content=(value)
+      set_text("content", value)
+    end
+  
+    #text
+    def summary
+      text("summary")
+    end
+
+    def summary=(value)
+      set_text("summary", value)
+    end
+  
+    #rfc 3339
+    def published
+      value = text("published")
+      Time.parse(value) unless value.nil?
+    end
+
+    def published=(value)
+      set_text("published", value)
+    end
+  
+    # comp: id, title, udpated, rights (optional)
+    def source
+      unless @source
+        @doc.xpath("xmlns:source").each do |source|
+          @source = Generator.new(source)
+        end 
+      end
+      
+      return source
+    end
+    
+    def source=(obj)
+      @source = obj
+    end
+  end
+  
+  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
+

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

@@ -0,0 +1,106 @@
+module Restfulie::Common::Representation::Atom
+  
+  class Feed < Base
+    
+    def initialize(xml_obj = nil)
+      @generator = nil
+      @entries = nil
+      super(xml_obj)
+      @reserved = Base::ATOM_ATTRIBUTES[:feed][:required] + Base::ATOM_ATTRIBUTES[:feed][:recommended] + Base::ATOM_ATTRIBUTES[:feed][:optional] + [:entry]
+    end
+    
+    def entries
+      unless @entries
+        @entries = TagCollection.new(@doc)
+        @doc.xpath("xmlns:entry").each do |entry|
+          @entries << Entry.new(entry)
+        end    
+      end
+      
+      return @entries
+    end
+  
+    # comp: attr: uri, version (optionals); content (mandatory)
+    def generator
+      unless @generator
+        @doc.xpath("xmlns:generator").each do |generator|
+          @generator = Generator.new(generator)
+        end 
+      end
+      
+      return generator
+    end
+    
+    def generator=(obj)
+      @generator = obj
+    end
+  
+    # simple text
+    def icon
+      text("icon")
+    end
+
+    def icon=(value)
+      set_text("icon", value)
+    end
+  
+    # simple text
+    def logo
+      text("logo")
+    end
+
+    def logo=(value)
+      set_text("logo", value)
+    end
+  
+    # text
+    def subtitle
+      text("subtitle")
+    end
+
+    def subtitle=(value)
+      set_text("subtitle", value)
+    end
+  end
+  
+  class Generator < XML    
+    def initialize(options_or_obj)
+      if options_or_obj.kind_of?(Hash)
+        @doc = Nokogiri::XML::Document.new()
+        node = @doc.create_element("generator")
+        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 content
+      @doc.content
+    end
+    
+    def content=(value)
+      @doc.content = value
+    end
+    
+    def uri
+      @doc["uri"]
+    end
+    
+    def uri=(value)
+      @doc["uri"] = value
+    end
+
+    def version
+      @doc["version"]
+    end
+    
+    def version=(value)
+      @doc["version"] = value
+    end
+  end
+end

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

@@ -1,42 +1,52 @@
-module Restfulie::Common::Representation
-  # Implements the interface for unmarshal Atom media type responses (application/atom+xml) to ruby objects instantiated by rAtom library.
-  #
-  # Furthermore, this class extends rAtom behavior to enable client users to easily access link relationships.
-  class Atom
-
-    cattr_reader :media_type_name
-    @@media_type_name = 'application/atom+xml'
-
-    cattr_reader :headers
-    @@headers = { 
-      :get  => { 'Accept'       => media_type_name },
-      :post => { 'Content-Type' => media_type_name }
-    }
-
-    #Convert raw string to rAtom instances (client side)
-    def unmarshal(content)
-      begin
-        ::Atom::Feed.load_feed(content)
-      rescue ::ArgumentError
-        ::Atom::Entry.load_entry(content)
-      end
-    end
+require 'nokogiri'
 
-    def marshal(entity, rel)
-      return entity if entity.kind_of? String
-      entity.to_xml
-      entity
+#initialize namespace
+module Restfulie::Common::Representation::Atom
+  
+  # Create a new Representation::Atom object using a +string_or_io+
+  # object.
+  #
+  # Examples
+  #   xml  = IO.read("spec/units/lib/atoms/full_atom.xml")
+  #   atom = Restfulie::Common::Representation::Atom.new(xml)
+  class Factory
+    # RelaxNG file to validate atom
+    RELAXNG_ATOM = File.join(File.dirname(__FILE__), 'atom', 'atom.rng')
+    
+    if Nokogiri::VERSION_INFO["libxml"]["loaded"] < "2.7.7"
+      puts "WARNING! In order to use schema validation on atom representations you need libxml version 2.7.7 or superior loaded in your system." 
+      SCHEMA       = nil
+    else
+      SCHEMA       = ::Nokogiri::XML::RelaxNG(File.open(RELAXNG_ATOM))
     end
 
-    # transforms this content into a parameter hash for rails (server-side usage)
-    def self.to_hash(content)
-      Hash.from_xml(content).with_indifferent_access
+    class << self
+      def create(string_or_io)
+        doc = string_or_io.kind_of?(Nokogiri::XML::Document) ? string_or_io : Nokogiri::XML(string_or_io) 
+        
+        if SCHEMA && !(errors = SCHEMA.validate(doc)).empty?
+          raise Restfulie::Common::Representation::Atom::AtomInvalid.new("Invalid Atom: "+ errors.join(", "))
+        end
+        
+        if doc.root.name == "feed"
+          Restfulie::Common::Representation::Atom::Feed.new(doc)
+        elsif doc.root.name == "entry"
+          Restfulie::Common::Representation::Atom::Entry.new(doc)
+        end        
+      end      
     end
     
-    def prepare_link_for(link)
-      link
-    end
   end
+  
+  class AtomInvalid < StandardError; end
+  
+end
 
+%w(
+  base
+  feed
+  entry
+).each do |file|
+  require File.join(File.dirname(__FILE__), 'atom', file)
 end
 

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

@@ -12,8 +12,7 @@ module Restfulie::Common::Representation
     }
 
     def unmarshal(string)
-      base = JSON.parse(string)
-      base == {} ? {} : base.values.first
+      JSON.parse(string)
     end
 
     def marshal(entity, rel)