tokamak 1.0.0.beta2

data/lib/tokamak/representation/atom/base.rb

@@ -0,0 +1,140 @@
+module Tokamak
+  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? && !@reserved.map(&:to_s).include?(e.node_name)
+            result << e
+          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 Tokamak::Representation::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

data/lib/tokamak/representation/atom/category.rb

@@ -0,0 +1,39 @@
+module Tokamak
+  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

data/lib/tokamak/representation/atom/entry.rb

@@ -0,0 +1,56 @@
+module Tokamak
+  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

data/lib/tokamak/representation/atom/factory.rb

@@ -0,0 +1,48 @@
+module Tokamak
+  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 = Tokamak::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
+          
+          representation_for doc
+        
+        end      
+        
+        private
+        def self.representation_for(doc)
+          case doc.root.name
+          when "feed"
+            Tokamak::Representation::Atom::Feed.new(doc)
+          when "entry"
+            Tokamak::Representation::Atom::Entry.new(doc)
+          end        
+        end
+        
+      end
+    
+      class AtomInvalid < StandardError
+      end
+    end
+  end
+end

data/lib/tokamak/representation/atom/feed.rb

@@ -0,0 +1,108 @@
+module Tokamak
+  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

data/lib/tokamak/representation/atom/link.rb

@@ -0,0 +1,66 @@
+module Tokamak
+  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