tokamak 1.0.0.beta2 → 1.0.0.beta4

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

@@ -1,140 +0,0 @@
-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

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

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

@@ -1,48 +0,0 @@
-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

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

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

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

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

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

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

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

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

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

@@ -1,94 +0,0 @@
-module Tokamak
-  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, *args, &block)
-          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|
-              include_arg n, arg
-            end
-          end
-        end
-      
-        def include_arg(n, arg)
-          case arg
-          when Hash
-            # Adding XML attributes
-            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)
-                return
-              end
-              n[k.to_s] = v.to_s
-            }
-          else            
-            # Adding XML node content
-            arg.kind_of?(Time) || arg.kind_of?(DateTime) ? content = arg.xmlschema : content = arg
-            n.content = content
-          end
-        end
-      
-      
-      end
-    end
-  end
-end

data/lib/tokamak/representation/atom.rb

@@ -1,18 +0,0 @@
-require 'nokogiri'
-
-module Tokamak
-  module Representation
-  module Atom
-    autoload :Factory, 'tokamak/representation/atom/factory'
-    autoload :XML, 'tokamak/representation/atom/xml'
-    autoload :Base, 'tokamak/representation/atom/base'
-    autoload :TagCollection, 'tokamak/representation/atom/tag_collection'
-    autoload :Link, 'tokamak/representation/atom/link'
-    autoload :Person, 'tokamak/representation/atom/person'
-    autoload :Category, 'tokamak/representation/atom/category'
-    autoload :Feed, 'tokamak/representation/atom/feed'
-    autoload :Entry, 'tokamak/representation/atom/entry'
-    autoload :Source, 'tokamak/representation/atom/source'
-  end
-end
-end