restfulie 0.1.0.beta1

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

@@ -0,0 +1,142 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        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
+
+          def published
+            value = text("published")
+            Time.parse(value) unless value.nil?
+          end
+
+          def published=(value)
+            set_text("published", 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
+            return @authors if @authors
+
+            @authors = TagCollection.new(@doc)
+            @doc.xpath("xmlns:author").each do |author|
+              @authors << Person.new("author", author)
+            end
+            @authors
+            
+          end
+        
+          def contributors
+            return @contributors if @contributors
+
+            @contributors = TagCollection.new(@doc)
+            @doc.xpath("xmlns:author").each do |contributor|
+              @contributors << Person.new("contributor", contributor)
+            end
+            @contributors
+          end
+        
+          include Restfulie::Common::Links
+
+          # It has one required attribute, href, and five optional attributes: rel, type, hreflang, title, and length
+          def links
+            return @links if @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        
+            @links
+            
+          end
+        
+          def categories
+            return @categories if @categories
+            
+            @categories = TagCollection.new(@doc)
+            @doc.xpath("xmlns:category").each do |category|
+              @categories << Link.new(category)
+            end        
+            @categories
+            
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        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
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Restfulie
+  module Common
+    module Representation
+      module 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
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,43 @@
+module Restfulie
+  module Common
+    module Representation
+      module 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.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
+      
+          def self.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 AtomInvalid.new("Invalid Atom: "+ errors.join(", "))
+            end
+            
+            case doc.root.name
+            when "feed"
+              Restfulie::Common::Representation::Atom::Feed.new(doc)
+            when "entry"
+              Restfulie::Common::Representation::Atom::Entry.new(doc)
+            end        
+          end      
+        end
+        
+        class AtomInvalid < StandardError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module Restfulie
+  module Common
+    module Representation
+      module 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
+    end
+  end
+end

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,90 @@
+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)
+            text(method) || super
+          end
+
+        protected 
+      
+          def text(node_name)
+            (node = @doc.at_xpath("xmlns:#{node_name}")) ? node.content : nil
+          end
+      
+          def set_text(node_name, value)
+            if (node = @doc.at_xpath("xmlns:#{node_name}"))
+              value = value.xmlschema if value.kind_of?(Time) || value.kind_of?(DateTime)
+              node.content = value
+            else
+              node = create_element(node_name, value)
+              node.parent = @doc
+            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