tokamak 1.0.0.beta2 → 1.0.0.beta4

data/lib/tokamak/representation/generic.rb

@@ -1,20 +0,0 @@
-module Tokamak
-  # Unknown representation's unmarshalling on the client side
-  module Representation
-  class Generic
-
-    # Because there is no media type registered, return the content itself
-    def unmarshal(content)
-      def content.links
-        []
-      end
-      content
-    end
-
-    def marshal(string, rel)
-      string
-    end
-
-  end
-end
-end

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

@@ -1,25 +0,0 @@
-module Tokamak
-  module Representation
-  class Json
-    module Base
-      module ClassMethods
-        
-        # creates a json unmarshalled version of this object
-        def create(obj = nil)
-          @json = {}
-          return @json.extend(KeysAsMethods) unless obj
-          
-          if obj.kind_of?(Hash) || obj.kind_of?(Array)
-            @json = obj
-          else 
-            @json = ::JSON.parse(obj)
-          end
-          
-          @json.extend(KeysAsMethods)
-        end
-        
-      end
-    end
-  end
-  end
-end

data/lib/tokamak/representation/json/keys_as_methods.rb

@@ -1,72 +0,0 @@
-module Tokamak
-  module Representation
-  class Json
-    module KeysAsMethods
-      def self.extended(base)
-        [:type, :id].each { |m| base.__free_method__(m) }      
-      end
-      
-      def [](key)
-        __normalize__(super(key))
-      end
-  
-      def []=(key, value)
-        super(key,value)
-      end
-  
-      def to_s
-        super.to_json
-      end
-  
-      def method_missing(name, *args)
-        method_name = name.to_s
-        if method_name[-1] == "="[-1] #1.8 and 1.9 compatible
-          self[method_name.chop] = args[0]
-        else
-          self[method_name]
-        end
-      end
-  
-      # if you have a key that is also a method (such as Array#size)
-      # you can use this to free the method and use the method obj.size
-      # to access the value of key "size".
-      # you still can access the old method with __[method_name]__
-      def __free_method__(sym)
-        if self.__metaclass__.method_defined?(sym) && !respond_to?("__#{sym}__")
-          self.__metaclass__.send(:alias_method, "__#{sym}__", sym)
-        end
-        self.__metaclass__.send(:define_method, sym) { method_missing(sym.to_s) }
-        self
-      end
-  
-      def __metaclass__
-        class << self; self; end
-      end
-      
-      include Tokamak::Representation::Links
-
-      # easy accessors to links
-      def links
-        some_links = self["link"]
-        return nil unless some_links
-        some_links = [some_links] unless some_links.kind_of? Array
-        LinkCollection.new(some_links)
-      end
-          
-    private
-  
-      def __normalize__(value)
-        case value
-        when Hash
-          value.extend(KeysAsMethods)
-        when Array
-          value.map { |v| __normalize__(v) }
-        else
-          value
-        end
-        value
-      end
-    end
-  end
-end
-end

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

@@ -1,27 +0,0 @@
-module Tokamak
-  module Representation
-  class Json
-    class Link
-      def initialize(obj)
-        @obj = obj
-      end
-      
-      def type
-        @obj.type
-      end
-      
-      def href
-        @obj.href
-      end
-      
-      def rel
-        @obj.rel
-      end
-          
-      def method_missing(symbol, *args, &block)
-        @obj.send(symbol, *args, &block)
-      end
-    end
-  end
-end
-end

data/lib/tokamak/representation/json/link_collection.rb

@@ -1,21 +0,0 @@
-module Tokamak
-  module Representation
-  class Json
-    class LinkCollection
-      def initialize(parent_node)
-        @node = parent_node
-      end
-      
-      def method_missing(symbol, *args, &block)
-        linkset = @node.select {|link| link.rel == symbol.to_s }
-        linkset.map! { |link| Link.new(link) }
-        unless linkset.empty?
-          linkset.size == 1 ? linkset.first : linkset
-        else
-          nil
-        end
-      end
-    end
-  end
-end
-end

data/lib/tokamak/representation/json.rb

@@ -1,11 +0,0 @@
-module Tokamak
-  module Representation
-  class Json
-    autoload :Base, 'tokamak/representation/json/base' 
-    autoload :KeysAsMethods, 'tokamak/representation/json/keys_as_methods' 
-    autoload :Link, 'tokamak/representation/json/link' 
-    autoload :LinkCollection, 'tokamak/representation/json/link_collection' 
-    extend Base::ClassMethods
-  end
-end
-end

data/lib/tokamak/representation/links.rb

@@ -1,9 +0,0 @@
-module Tokamak
-  module Representation
-    module Links
-      def self.extract_link_header(links)
-        links.collect {|link| "<#{link.href}>; rel=#{link.rel}"}.join(', ')
-      end
-    end
-  end
-end

data/lib/tokamak/representation.rb

@@ -1,3 +0,0 @@
-module Tokamak::Representation
-  Dir["#{File.dirname(__FILE__)}/representation/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
-end

data/lib/tokamak/values.rb

@@ -1,29 +0,0 @@
-module Tokamak
-  # This is a Blank Slate class to support the renderization of the values block for Resource Representation Interfaces
-  # Every Media type should implement a Builder with a insert_value method that renders the values block to a specific format
-  class Values
-    attr_accessor :builder
-
-    # remove all methods from this class
-    instance_methods.each do |m|
-      undef_method m unless m.to_s =~ /\[\]|method_missing|send|respond_to\?|^__/
-    end
-
-    def initialize(builder)
-      @builder = builder
-      @current_prefix = nil
-    end
-
-    def [](prefix)
-      @current_prefix = prefix
-      self
-    end
-
-    def method_missing(symbol, *args, &block)
-      name = symbol.to_s
-      prefix = @current_prefix
-      @current_prefix = nil
-      @builder.insert_value(name, prefix, *args, &block)
-    end
-  end
-end

data/lib/tokamak/xml/base.rb

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

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

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

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

@@ -1,35 +0,0 @@
-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/lib/tokamak/xml.rb

@@ -1,12 +0,0 @@
-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/spec/integration/atom/atom_spec.rb

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