tokamak 1.0.0.beta2

data/lib/tokamak/xml.rb

@@ -0,0 +1,12 @@
+require 'nokogiri'
+
+module Tokamak
+  module Xml
+    autoload :Base, 'tokamak/xml/base'
+    autoload :Builder, 'tokamak/xml/builder'
+    autoload :Helpers, 'tokamak/xml/helpers'
+    autoload :Links, 'tokamak/xml/links'
+    autoload :Link, 'tokamak/xml/link'
+    extend Base::ClassMethods
+  end
+end

data/lib/tokamak/xml/base.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/hash/conversions'
+
+module Tokamak
+  module Xml
+    module Base
+      module ClassMethods
+        mattr_reader :media_type_name
+        @@media_type_name = 'application/xml'
+    
+        mattr_reader :headers
+        @@headers = { 
+          :post => { 'Content-Type' => media_type_name }
+        }
+    
+        def marshal(entity, options = {})
+          to_xml(entity, options)
+        end
+    
+        def unmarshal(string)
+          Hash.from_xml string
+        end
+    
+        mattr_reader :recipes
+        @@recipes = {}
+    
+        def describe_recipe(recipe_name, options={}, &block)
+          raise 'Undefined recipe' unless block_given?
+          raise 'Undefined recipe_name'   unless recipe_name
+          @@recipes[recipe_name] = block
+        end
+    
+        def to_xml(obj, options = {}, &block)
+          return obj if obj.kind_of?(String)
+          
+          if block_given?
+            recipe = block 
+          elsif options[:recipe]
+            recipe = @@recipes[options[:recipe]]
+          elsif obj.kind_of?(Hash) && obj.size==1
+            root = obj.values.first
+            return root.to_xml(:root => obj.keys.first)
+          else
+            return obj.to_xml
+          end
+          
+          # Create representation and proxy
+          builder = Builder.new(obj, options)
+    
+          # Check recipe arity size before calling it
+          recipe.call(*[builder, obj, options][0,recipe.arity])
+          builder.doc.to_xml
+        end
+        
+        def helper
+          Helpers
+        end
+      end
+    end
+  end
+end

data/lib/tokamak/xml/builder.rb

@@ -0,0 +1,115 @@
+module Tokamak
+  module Xml
+    # Implements the interface for marshal Xml media type requests (application/xml)
+    class Builder
+      attr_reader :doc
+      def initialize(obj, options = {})
+        @doc    = Nokogiri::XML::Document.new
+        @obj    = obj
+        root = options[:root] || Tokamak.root_element_for(obj)
+        @parent = @doc.create_element(root)
+        @parent.parent = @doc
+      end
+      
+      def method_missing(sym, *args, &block)
+        values do |v|
+          v.send sym, *args, &block
+        end
+      end
+      
+      def values(options = {}, &block)
+        options.each do |key,value|
+          attr = key.to_s
+          if attr =~ /^xmlns(:\w+)?$/
+            ns = attr.split(":", 2)[1]
+            @parent.add_namespace_definition(ns, value)
+          end
+        end             
+        yield Values.new(self)
+      end
+    
+      def insert_value(name, prefix, *args, &block)
+        node = create_element(name.to_s, prefix, *args)
+        node.parent = @parent
+        
+        if block_given?
+          @parent = node
+          block.call
+          @parent = node.parent
+        end
+      end
+      
+      def link(relationship, uri, options = {})
+        options["rel"] = relationship.to_s
+        options["href"] = uri
+        options["type"] ||= "application/xml"
+        insert_value("link", nil, options)
+      end
+      
+      def members(a_collection = nil, options = {}, &block)
+        collection = a_collection || @obj 
+        raise Error::BuilderError("Members method require a collection to execute") unless collection.respond_to?(:each)
+        collection.each do |member|
+          root = options[:root] || Tokamak.root_element_for(member)
+          entry = @doc.create_element(root)
+          entry.parent = @parent
+          @parent = entry
+          block.call(self, member)
+          @parent = entry.parent
+        end
+      end
+      
+      private
+      
+      def create_element(node, prefix, *args)
+        node = @doc.create_element(node) do |n|
+          if prefix
+            if namespace = prefix_valid?(prefix)
+              # Adding namespace prefix
+              n.namespace = namespace
+              namespace = nil
+            end
+          end
+    
+          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            
+              content = if arg.kind_of?(Time) || arg.kind_of?(DateTime)
+                  arg.xmlschema
+                else
+                  arg
+                end
+              n.content = content
+            end
+          end
+        end
+      end
+      
+      def prefix_valid?(prefix)
+        ns = @parent.namespace_definitions.find { |x| x.prefix == prefix.to_s }
+        
+        unless ns
+          @parent.ancestors.each do |a|
+            next if a == @doc
+            ns = a.namespace_definitions.find { |x| x.prefix == prefix.to_s }
+            break if ns
+          end      
+        end
+        
+        return ns
+      end
+    end
+  end
+end

data/lib/tokamak/xml/helpers.rb

@@ -0,0 +1,13 @@
+module Tokamak
+  module Xml
+    module Helpers
+      def collection(obj, opts = {}, &block)
+        Xml.to_xml(obj, opts, &block)
+      end
+    
+      def member(obj, opts = {}, &block)
+        Xml.to_xml(obj, opts, &block)
+      end
+    end
+  end
+end

data/lib/tokamak/xml/link.rb

@@ -0,0 +1,31 @@
+module Tokamak
+  module Xml
+    class Link
+      def initialize(options = {})
+        @options = options
+      end
+      def href
+        @options["href"]
+      end
+      def rel
+        @options["rel"]
+      end
+      def content_type
+        @options["type"]
+      end
+      def type
+        content_type
+      end
+      def follow
+        r = Restfulie.at(href)
+        r = r.as(content_type) if content_type
+        r
+      end
+      
+      def to_s
+        "<link to #{@options}>"
+      end
+      
+    end
+  end
+end

data/lib/tokamak/xml/links.rb

@@ -0,0 +1,35 @@
+module Tokamak
+  module Xml
+        
+    # an object to represent a list of links that can be invoked
+    class Links
+      
+      def initialize(links)
+        @hash = {}
+        links = [links] unless links.kind_of? Array
+        links = [] unless links
+        links.each { |l|
+          link = Tokamak::Xml::Link.new(l)
+          @hash[link.rel.to_s] = link
+        }
+      end
+
+      def [](name)
+        @hash[name]
+      end
+      
+      def size
+        @hash.size
+      end
+      
+      def keys
+        @hash.keys
+      end
+      
+      def method_missing(sym, *args)
+        raise "Links can not receive arguments" unless args.empty?
+        self[sym.to_s]
+      end
+    end
+  end
+end

data/spec/integration/atom/atom_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Tokamak::Test
+  class SimpleClass
+    attr_accessor :id, :title, :updated
+    def initialize(id,title,updated)
+      @id, @title, @updated = id, title, updated
+    end
+  end
+end
+
+describe Tokamak do
+  describe 'Atom' do
+
+    describe "Feed" do
+      it "should create a feed from builder DSL" do
+        time = Time.now
+        some_articles = [
+          {:id => 1, :title => "a great article", :updated => time},
+          {:id => 2, :title => "another great article", :updated => time}
+        ]
+        
+        feed = to_atom(some_articles) do |collection|
+          collection.values do |values|
+            values.id      "http://example.com/feed"
+            values.title   "Feed"
+            values.updated time
+
+            values.author { 
+              values.name  "John Doe"
+              values.email "joedoe@example.com"
+            }
+            
+            values.author { 
+              values.name  "Foo Bar"
+              values.email "foobar@example.com"
+            }
+          end
+          
+          collection.link("next", "http://a.link.com/next")
+          collection.link("previous", "http://a.link.com/previous")
+          
+          collection.members do |member, article|
+            member.values do |values|
+              values.id      "uri:#{article[:id]}"                   
+              values.title   article[:title]
+              values.updated article[:updated]
+            end
+            
+            member.link("image", "http://example.com/image/1")
+            member.link("image", "http://example.com/image/2", :type => "application/atom+xml")                                
+          end
+        end
+        
+        feed.atom_type.should == "feed"
+        feed.id.should == "http://example.com/feed"
+        feed.title.should == "Feed"
+        feed.updated.should == DateTime.parse(time.xmlschema)
+        feed.authors.first.name.should == "John Doe"
+        feed.authors.last.email.should == "foobar@example.com"
+        
+        feed.entries.first.id.should == "uri:1"
+        feed.entries.first.title.should == "a great article"
+     end
+     
+     it "should create a feed from a string input" do
+       full_atom = IO.read(File.dirname(__FILE__) + '/../full_atom.xml')
+       feed = to_atom(full_atom)
+       
+       feed.id.should == "http://example.com/albums/1"
+       feed.title.should == "Albums feed"
+       feed.updated.should be_kind_of(Time)
+       feed.updated.should == Time.parse("2010-05-03T16:29:26-03:00")
+    end
+
+    end
+
+    describe "Entry" do
+      it "should create an entry from builder DSL" do
+        time = Time.now
+        an_article = {:id => 1, :title => "a great article", :updated => time}
+        
+        entry = to_atom(an_article, :atom_type => :entry) do |member, article|
+          member.values do |values|
+            values.id      "uri:#{article[:id]}"                   
+            values.title   article[:title]
+            values.updated article[:updated]
+          end
+          
+          member.link("image", "http://example.com/image/1")
+          member.link("image", "http://example.com/image/2", :type => "application/atom+xml")                                
+        end
+        
+        entry.atom_type.should == "entry"
+        entry.id.should == "uri:1"
+        entry.title.should == "a great article"
+        entry.updated.should == DateTime.parse(time.xmlschema)
+      end
+
+      it "should be able to declare links inside values block" do
+        time = Time.now
+        an_article = {:id => 1, :title => "a great article", :updated => time}
+
+        entry = to_atom(an_article, :atom_type => :entry) do |member, article|
+          member.values do |values|
+            values.id      "uri:#{article[:id]}"                   
+            values.title   article[:title]
+            values.updated article[:updated]
+            
+            values.domain("xmlns" => "http://a.namespace.com") {
+              member.link("image", "http://example.com/image/1")
+              member.link("image", "http://example.com/image/2", :type => "application/atom+xml")
+            }
+          end
+        end
+
+        entry.atom_type.should == "entry"
+        entry.id.should == "uri:1"
+        entry.title.should == "a great article"
+        entry.updated.should == DateTime.parse(time.xmlschema)
+        
+        entry.doc.xpath("xmlns:domain", "xmlns" => "http://a.namespace.com").children.first.node_name.should == "link"
+      end
+      
+      it "should create an entry from an already declared recipe" do
+       
+        describe_recipe(:simple_entry) do |member, article|
+          member.values do |values|
+            values.id      "uri:#{article[:id]}"                   
+            values.title   article[:title]
+            values.updated article[:updated]
+          end
+          
+          member.link("image", "http://example.com/image/1")
+          member.link("image", "http://example.com/image/2", :type => "application/atom+xml")                                
+        end
+       
+        time = Time.now
+        an_article = {:id => 1, :title => "a great article", :updated => time}
+        
+        entry = to_atom(an_article, :atom_type => :entry, :recipe => :simple_entry)
+        
+        entry.atom_type.should == "entry"
+        entry.id.should == "uri:1"
+        entry.title.should == "a great article"
+        entry.updated.should == DateTime.parse(time.xmlschema)
+      end
+    
+    end
+
+    describe "Errors" do
+      it "should raise error for converter without recipe" do
+        lambda {
+          to_atom
+        }.should raise_error(Tokamak::ConverterError, "Recipe required")
+      end
+      
+      it "raise error to invalid atom type" do
+        lambda {
+          obj = Object.new
+          describe_recipe(:simple_entry) do |member, article|
+            member.values do |values|
+              values.id      "uri:#{article[:id]}"                   
+              values.title   article[:title]
+              values.updated article[:updated]
+            end
+
+            member.link("image", "http://example.com/image/1")
+            member.link("image", "http://example.com/image/2", :type => "application/atom+xml")                                
+          end
+          
+          Tokamak::Atom.to_atom(obj, :recipe => :simple_entry, :atom_type => :foo)
+        }.should raise_error(Tokamak::ConverterError, "Undefined atom type foo")
+      end
+    end
+
+  end
+
+  def to_atom(*args, &recipe)
+    Tokamak::Atom.to_atom(*args, &recipe)
+  end
+
+  def describe_recipe(*args, &recipe)
+    Tokamak::Atom.describe_recipe(*args, &recipe)
+  end
+  
+  def simple_object(*args)
+    Tokamak::Test::SimpleClass.new(*args)
+  end
+
+end