tokamak 1.0.0.beta2

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

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

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

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

@@ -0,0 +1,94 @@
+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/generic.rb

@@ -0,0 +1,20 @@
+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.rb

@@ -0,0 +1,11 @@
+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/json/base.rb

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

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

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

@@ -0,0 +1,21 @@
+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/links.rb

@@ -0,0 +1,9 @@
+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/values.rb

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