restfulie 0.4.0 → 0.5.0

data/LICENSE

@@ -0,0 +1,17 @@
+/***
+ * Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); 
+ * you may not use this file except in compliance with the License. 
+ * You may obtain a copy of the License at 
+ * 
+ * 	http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License. 
+ */
+

data/README.textile

@@ -1,3 +1,7 @@
+h1. Web site
+
+Restulie's website can be found at "http://restfulie.caelum.com.br":http://restfulie.caelum.com.br
+
 h1. Quit pretending
 
 CRUD through HTTP is a good step forward to using resources and becoming RESTful, another step further into it is to make use of hypermedia based services and this gem allows you to do it really fast.
@@ -12,10 +16,6 @@ h2. Why would I use restfulie?
 4. HATEOAS --> clients you are unaware of will not bother if you change your URIs
 5. HATEOAS --> services that you consume will not affect your software whenever they change part of their flow or URIs
 
-h2. Restfulie
-
-The documentation is at "http://wiki.github.com/caelum/restfulie":http://wiki.github.com/caelum/restfulie
-
 
 <script type="text/javascript">
 var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");

data/Rakefile

@@ -5,11 +5,11 @@ require 'rake/gempackagetask'
 require 'spec/rake/spectask'
 
 GEM = "restfulie"
-GEM_VERSION = "0.4.0"
+GEM_VERSION = "0.5.0"
 SUMMARY = "Hypermedia aware resource based library in ruby (client side) and ruby on rails (server side)."
 AUTHOR = "Guilherme Silveira, Caue Guerra"
 EMAIL = "guilherme.silveira@caelum.com.br"
-HOMEPAGE = "http://github.com/caelum/restfulie"
+HOMEPAGE = "http://restfulie.caelumobjects.com"
 
 spec = Gem::Specification.new do |s|
   s.name = GEM
@@ -18,6 +18,8 @@ spec = Gem::Specification.new do |s|
   s.summary = SUMMARY
   s.require_paths = ['lib']
   s.files = FileList['lib/**/*.rb', '[A-Z]*'].to_a
+#  s.add_dependency("ratom", [">= 0.6.3"])
+  # s.add_dependency("jeokkarak", [">= 1.0.3"])
 
   # s.add_dependency(%q<rubigen>, [">= 1.3.4"])
 

data/lib/restfulie/client/atom_media_type.rb

@@ -0,0 +1,58 @@
+module Restfulie
+  
+  # TODO break media type registering for DECODING and ENCODING appart, so we can have two files
+  module Server
+    
+    # a decoder from atom an feed
+    class AtomMediaType < Restfulie::MediaType::Type
+      
+      def self.from_xml(xml)
+        hash = Hash.from_xml xml
+        AtomFeedDecoded.new(hash.values.first)
+      end
+      
+    end
+    
+    # an atom feed
+    class AtomFeedDecoded < Hashi::CustomHash
+      
+      def initialize(hash)
+        super(hash)
+      end
+  
+      # retrieves the nth element from an atom feed
+      def [](position)
+        
+        hash = entry[position].content.hash
+        hash = hash.dup
+        hash.delete("type")
+        result = Restfulie::MediaType::DefaultMediaTypeDecoder.from_hash(hash)
+        
+        add_links_to(result, entry[position]) if entry[position].respond_to?(:link)
+        result
+        
+      end
+      
+      private
+      
+      def add_links_to(result, entry)
+        links = entry.link.hash
+        links = [links] if links.kind_of? Hash
+        self_definition = self_from(links)
+        links << {:rel => "destroy", :method => "delete", :href => self_definition["href"]} unless self_definition.nil?
+        result.add_transitions(links)
+      end
+      
+      def self_from(links)
+        links.find do |link|
+          link["rel"] == "self" || link[:rel] == "self"
+        end
+      end
+      
+    end
+    
+  end
+  
+  Restfulie::MediaType.register(Restfulie::MediaType.rendering_type('application/atom+xml', Server::AtomMediaType))
+  
+end

data/lib/restfulie/client/base.rb

@@ -1,43 +1,50 @@
+class Hash
+  def to_object(body)
+    if keys.length>1
+      raise "unable to parse an xml with more than one root element"
+    elsif keys.length == 0
+      self
+    else
+      type = keys[0].camelize.constantize
+      type.from_xml(body)
+    end
+  end
+end
+
 module Restfulie
+
+  # will execute some action in a specific URI
+  def self.at(uri)
+    Client::RequestExecution.new(nil).at uri
+  end
+
   module Client
     module Base
 
       SELF_RETRIEVAL = [:latest, :refresh, :reload]
       
-      class UnsupportedContentType < Exception
-        attr_reader :msg
-        def initialize(msg)
-          @msg = msg
-        end
-        def to_s
-          @msg
-        end
-      end
-
       # translates a response to an object
       def from_response(res, invoking_object)
         
         return invoking_object if res.code=="304"
         
         raise UnsupportedContentType.new("unsupported content type '#{res.content_type}' '#{res.code}'") unless res.content_type=="application/xml"
+        
+        # TODO this method should use the RequestExecution process to parse the content type and body
+        # TODO add default html parser: do nothin
 
         body = res.body
         return {} if body.empty?
         
         hash = Hash.from_xml body
-        return hash if hash.keys.length == 0
+        hash.to_object(body)
         
-        raise "unable to parse an xml with more than one root element" if hash.keys.length>1
-      
-        type = hash.keys[0].camelize.constantize
-        type.from_xml(body)
-      
       end
     
       def requisition_method_for(overriden_option,name)
         basic_mapping = { :delete => Net::HTTP::Delete, :put => Net::HTTP::Put, :get => Net::HTTP::Get, :post => Net::HTTP::Post}
         defaults = {:destroy => Net::HTTP::Delete, :delete => Net::HTTP::Delete, :cancel => Net::HTTP::Delete,
-                    :refresh => Net::HTTP::Get, :reload => Net::HTTP::Get, :show => Net::HTTP::Get, :latest => Net::HTTP::Get}
+                    :refresh => Net::HTTP::Get, :reload => Net::HTTP::Get, :show => Net::HTTP::Get, :latest => Net::HTTP::Get, :self => Net::HTTP::Get}
 
         return basic_mapping[overriden_option.to_sym] if overriden_option
         defaults[name.to_sym] || Net::HTTP::Post

data/lib/restfulie/client/entry_point.rb

@@ -22,61 +22,16 @@ module Restfulie
       
       # retrieves a resource form a specific uri
       def from_web(uri, options = {})
-        uri = URI.parse(uri)
-        req = Net::HTTP::Get.new(uri.path)
-        options.each do |key,value| req[key] = value end 
-        res = Net::HTTP.start(uri.host, uri.port) {|http|
-          http.request(req) # canc hange to straight .request(req)
-        }
-
-        code = res.code
-        return from_web(res["Location"]) if code=="301"
-
-        if code=="200"
-          # TODO really support different content types
-          case res.content_type
-          when "application/xml"
-            result = self.from_xml res.body
-          when "application/json"
-            result = self.from_json res.body
-          else
-            raise "unknown content type: #{res.content_type}"
-          end
-          result.etag = res['Etag'] unless res['Etag'].nil?
-          result.last_modified = res['Last-Modified'] unless res['Last-Modified'].nil?
-          result
-        else
-          res
-        end
-      
+        RequestExecution.new(self).at(uri).get(options)
       end
 
       private
       def remote_post(content)
-        remote_post_to(entry_point_for.create.uri, content)
+        RequestExecution.new(self).at(entry_point_for.create.uri).post(content)
       end
-      def remote_post_to(uri, content)
-        
-        url = URI.parse(uri)
-        req = Net::HTTP::Post.new(url.path)
-        req.body = content
-        req.add_field("Accept", "application/xml")
-
-        response = Net::HTTP.new(url.host, url.port).request(req)
-        code = response.code
-        
-        if code=="301" && follows.moved_permanently? == :all
-          remote_post_to(response["Location"], content)
-        elsif code=="201"
-          from_web(response["Location"], "Accept" => "application/xml")
-        else
-          response
-        end
 
-      end
-      
     end
-    
+
     class FollowConfig
       def initialize
         @entries = {
@@ -84,7 +39,7 @@ module Restfulie
         }
       end
       def method_missing(name, *args)
-        return value_for name if name.to_s[-1,1]=="?"
+        return value_for(name) if name.to_s[-1,1] == "?"
         set_all_for name
       end
       

data/lib/restfulie/client/instance.rb

@@ -18,24 +18,31 @@ module Restfulie
         url = URI.parse(state["href"] || state[:href])
         req = method.new(url.path)
         req.body = options[:data] if options[:data]
-        req.add_field("Accept", "application/xml") if self._came_from == :xml
-        req.add_field("If-None-Match", self.etag) if self.class.is_self_retrieval?(name) && self.respond_to?(:etag)
-        req.add_field("If-Modified-Since", self.last_modified) if self.class.is_self_retrieval?(name) && self.respond_to?(:last_modified)
-
+        add_request_headers(req, name)
+        
         response = Net::HTTP.new(url.host, url.port).request(req)
 
         return block.call(response) if block
         return response unless method == Net::HTTP::Get
         self.class.from_response response, self
       end
+      
+      private
+      def add_request_headers(req, name)
+        req.add_field("Accept", "application/xml") if self._came_from == :xml
+        req.add_field("If-None-Match", self.etag) if self.class.is_self_retrieval?(name) && self.respond_to?(:etag)
+        req.add_field("If-Modified-Since", self.last_modified) if self.class.is_self_retrieval?(name) && self.respond_to?(:last_modified)
+      end
+
+      public
 
   
-      # inserts all transitions from this object as can_xxx and xxx methods
-      def add_transitions(transitions)
+      # inserts all links from this object as can_xxx and xxx methods
+      def add_transitions(links)
 
-        transitions.each do |state|
-          self._possible_states[state["rel"] || state[:rel]] = state
-          self.add_state(state)
+        links.each do |t|
+          self._possible_states[t["rel"] || t[:rel]] = t
+          self.add_state(t)
         end
         self.extend Restfulie::Client::State
       end

data/lib/restfulie/client/request_execution.rb

@@ -0,0 +1,131 @@
+module Restfulie
+  module Client
+
+    class RequestExecution
+      
+      def initialize(type)
+        @type = type
+        @content_type = "application/xml"
+        @accepts = "application/xml"
+      end
+
+      def at(uri)
+        @uri = uri
+        self
+      end
+      
+      # sets the Content-type AND Accept headers for this request
+      def as(content_type)
+        @content_type = content_type
+        @accepts = content_type
+        self
+      end
+      
+      # sets the Accept header for this request
+      def accepts(content_type)
+        @accepts = content_type
+        self
+      end
+
+      # asks to create this content on the server (post it)
+      def create(content)
+        post(content)
+      end
+
+      # post this content to the server
+      def post(content)
+        remote_post_to(@uri, content)
+      end
+      
+      # retrieves information from the server using a GET request
+      def get(options = {})
+        from_web(@uri, options)
+      end
+
+      private
+      def remote_post_to(uri, content)
+        
+        url = URI.parse(uri)
+        req = Net::HTTP::Post.new(url.path)
+        req.body = content
+        add_basic_request_headers(req)
+        req.add_field("Content-type", @content_type)
+
+        response = Net::HTTP.new(url.host, url.port).request(req)
+        parse_post_response(response, content)
+      end
+      
+      def parse_post_response(response, content)
+        code = response.code
+        if code=="301" && @type.follows.moved_permanently? == :all
+          remote_post_to(response["Location"], content)
+        elsif code=="201"
+          from_web(response["Location"], "Accept" => "application/xml")
+        else
+          response
+        end
+      end
+
+      def from_web(uri, options = {})
+        uri = URI.parse(uri)
+        req = Net::HTTP::Get.new(uri.path)
+        options.each do |key,value| req[key] = value end 
+        add_basic_request_headers(req)
+        
+        res = Net::HTTP.new(uri.host, uri.port).request(req)
+        parse_get_response(res)
+      end
+      
+      private
+      
+      def add_basic_request_headers(req)
+        req.add_field("Accept", @accepts) unless @accepts.nil?
+      end
+      
+      # parses a get response.
+      # if the result code is 301, redirect
+      # otherwise, parses an ok response
+      def parse_get_response(res)
+        
+        code = res.code
+        return from_web(res["Location"]) if code=="301"
+        parse_get_ok_response(res, code)
+        
+      end
+      
+      # parses a successful get response.
+      # parses the entity and add extra (response related) fields.
+      def parse_get_ok_response(res, code)
+        result = parse_get_entity(res, code)
+        add_extra_fields(result, res)
+        result
+      end
+      
+      # add etag, last_modified and web_response fields to the resulting object
+      def add_extra_fields(result,res)
+        result.etag = res['Etag'] unless res['Etag'].nil?
+        result.last_modified = res['Last-Modified'] unless res['Last-Modified'].nil?
+        result.web_response = res
+      end
+      
+      # returns an entity for a specific response
+      def parse_get_entity(res, code)
+        if code=="200"
+          content_type = res.content_type
+          type = Restfulie::MediaType.type_for(content_type)
+          if content_type[-3,3]=="xml"
+            result = type.from_xml res.body
+          elsif content_type[-4,4]=="json"
+            result = type.from_json res.body
+          else
+            raise Restfulie::UnsupportedContentType.new("unsupported content type '#{content_type}'")
+          end
+          result
+        else
+          res
+        end
+      end
+      
+    end
+  end
+end

data/lib/restfulie/client.rb

@@ -1,10 +1,14 @@
 require 'net/http'
 require 'uri'
+require 'vendor/jeokkarak/jeokkarak'
 
+require 'restfulie/media_type'
+require 'restfulie/client/atom_media_type'
 require 'restfulie/client/base'
 require 'restfulie/client/entry_point'
 require 'restfulie/client/helper'
 require 'restfulie/client/instance'
+require 'restfulie/client/request_execution'
 require 'restfulie/client/state'
 
 module Restfulie
@@ -23,3 +27,9 @@ end
 Object.extend Restfulie
 
 require 'restfulie/unmarshalling'
+
+module Hashi
+  class CustomHash
+    uses_restfulie
+  end
+end

data/lib/restfulie/media_type.rb

@@ -0,0 +1,124 @@
+require 'restfulie/media_type_control'
+
+module Restfulie
+  
+  # represents an error when we are unable to support the desired content type
+  class UnsupportedContentType < Exception
+    
+    attr_reader :msg
+    def initialize(msg)
+      @msg = msg
+    end
+    
+    def to_s
+      @msg
+    end
+    
+  end
+
+  module MediaType
+    
+    # returns the decoder type for a specific content type
+    def self.type_for(content_type)
+      if Restfulie::MediaType.supports? content_type
+        Restfulie::MediaType.media_type(content_type)
+      else
+        Restfulie::MediaType::DefaultMediaTypeDecoder
+      end
+    end
+
+    # TODO removethis nasty method
+    def self.rendering_type(name, type)
+      Restfulie::MediaType.media_types[name] || Type.new(name,type)
+    end
+  
+    # TODO remove this method
+    def self.custom_type(name, type, l)
+      Restfulie::MediaType.media_types[name] || CustomType.new(name, type, l)
+    end
+  
+    class Type
+      attr_reader :name, :type
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+      def short_name
+        name.gsub(/\//,'_').gsub(/\+/,'_').gsub(/\./,'_')
+      end
+    
+      def format_name
+        name[/(.*[\+\/])?(.*)/,2]
+      end
+      def execute_for(controller, resource, options, render_options)
+        response = ["xml", "json"].include?(format_name) ? resource.send(:"to_#{format_name}", options) : resource
+        render(controller, response, render_options)
+      end
+      def render(controller, response, options)
+        options[:text] = response
+        options[:content_type] = name
+        controller.render options
+      end
+    end
+  
+    class CustomType < Type
+      def initialize(name, type, l)
+        super(name, type)
+        @lambda = l
+      end
+      def execute_for(controller, resource, options, render_options)
+        @lambda.call
+      end
+    end
+    
+    # from rails source code
+    def self.constantize(camel_cased_word)
+     unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+       raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+     end
+
+     Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+
+    module DefaultMediaTypeDecoder
+    
+      def self.from_xml(xml)
+        hash = Hash.from_xml xml
+        from_hash(hash)
+      end
+      
+      def self.from_hash(hash)
+
+        # TODO atom media type from_xml on entry is not working correctly
+        # raise "there should be only one root element but got #{hash.keys}" unless hash.keys.size==1
+
+        type = Restfulie::MediaType.constantize(hash.keys.first.camelize) rescue Hashi
+
+        result = type.from_hash hash.values.first
+        return nil if result.nil?
+        if result.respond_to? :_came_from=
+          result._came_from = :xml
+        end
+        result
+        
+      end
+      
+      def self.from_json(json)
+        hash = safe_json_decode(json)
+        type = hash.keys.first.camelize.constantize
+        type.from_hash(hash.values.first)
+      end
+    
+    end
+  end
+  
+end
+
+def safe_json_decode(json)
+  return {} if !json
+  begin
+    ActiveSupport::JSON.decode json
+  rescue ; {} end
+end
+
+require 'restfulie/media_type_defaults'

data/lib/restfulie/media_type_control.rb

@@ -0,0 +1,76 @@
+module Restfulie
+  
+  module MediaTypeControl
+    
+    # defines a custom media_type for this type
+    def media_type(*args)
+      args.each do |name|
+        custom_representations << name
+        type = Restfulie::MediaType.rendering_type(name, self)
+        Restfulie::MediaType.register(type)
+      end
+    end
+    
+    # returns the list of media types available for this resource to be deserialized from
+    def media_types
+      Restfulie::MediaType.default_types + MediaType.medias_for(self)
+    end
+    
+    # returns a list of media types that this resource can be serialized to
+    def media_type_representations
+      custom_representations + Restfulie::MediaType.default_representations.dup
+    end
+    
+    private
+    
+    # this model's custom representations. those representations were added through media_type definitions
+    def custom_representations
+      @custom_representations ||= []
+    end
+    
+  end
+  
+
+  module MediaType
+    
+    class << self
+    
+      def register(type)
+        Mime::Type.register(type.name, type.short_name.to_sym)
+        media_types[type.name] = type
+      end
+    
+      # TODO rename to type for mt
+      def media_type(name)
+        name = normalize(name)
+        raise Restfulie::UnsupportedContentType.new("unsupported content type '#{name}'") if media_types[name].nil?
+        media_types[name].type
+      end
+    
+      def supports?(name)
+        name = normalize(name)
+        !media_types[name].nil?
+      end
+    
+      def normalize(name)
+        name[/[^;]*/]
+      end
+    
+      def media_types
+        @media_types ||= {}
+      end
+    
+      # TODO move to MediaTypeControl.custom_media_types
+      def medias_for(type)
+        found = {}
+        type.media_type_representations.each do |key|
+          found[key] = media_types[key]
+        end
+        found.values
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/restfulie/media_type_defaults.rb

@@ -0,0 +1,34 @@
+module Restfulie
+  
+  module MediaType
+    def self.HtmlType
+      custom_type('html', self, lambda {})
+    end
+    def self.TextHtmlType
+      custom_type('text/html', self, lambda {})
+    end
+  
+    # TODO rename it and move it
+    def self.default_types
+      [Restfulie::MediaType.HtmlType,
+        Restfulie::MediaType.TextHtmlType,
+        rendering_type('application/xml', self),
+        rendering_type('application/json', self),
+        rendering_type('xml', self),
+        rendering_type('json', self)]
+    end
+    
+    # Default representations: every object can be serialized to those types
+    def self.default_representations
+      ['html','text/html','application/xml','application/json','xml','json']
+    end
+
+    # TODO should allow aliases...
+    register(Restfulie::MediaType.HtmlType)
+    register(Restfulie::MediaType.TextHtmlType)
+    register(rendering_type('application/xml', DefaultMediaTypeDecoder))
+    register(rendering_type('application/json', DefaultMediaTypeDecoder))
+    register(rendering_type('xml', DefaultMediaTypeDecoder))
+    register(rendering_type('json', DefaultMediaTypeDecoder))
+  end
+end

data/lib/restfulie/server/atom_media_type.rb

@@ -0,0 +1,102 @@
+module Restfulie
+  
+  module Server
+    
+    class AtomMediaType < Restfulie::MediaType::Type
+      def initialize(name, type)
+        super(name, type)
+      end
+      def execute_for(controller, resource, options, render_options)
+        response = ["atom"].include?(format_name) ? resource.send(:"to_#{format_name}", options) : resource
+        render(controller, response, render_options)
+      end
+    end
+    
+  end
+  
+  Restfulie::MediaType.register(Restfulie::MediaType.rendering_type('application/atom+xml', Server::AtomMediaType))
+  
+end
+
+class Array
+  extend Restfulie::MediaTypeControl
+  media_type "application/atom+xml"
+  
+  def to_atom(options = {}, &block)
+    AtomFeed.new(self).title(options[:title]).to_atom(options[:controller], block)
+  end
+  
+end
+
+class AtomFeed
+  def initialize(feed)
+    @feed = feed
+    @title = "feed"
+  end
+  
+  def title(title)
+    @title = title
+    self
+  end
+  
+  def to_atom(controller, block = nil)
+    last_modified = updated_at
+    id = id_for(controller)
+    xml = items_to_atom_xml(controller, block)
+    """<?xml version=\"1.0\"?>
+      <feed xmlns=\"http://www.w3.org/2005/Atom\">
+        <id>#{id}</id>
+        <title type=\"text\">#{@title}</title>
+        <updated>"""  + last_modified.strftime("%Y-%m-%dT%H:%M:%S-08:00") + """</updated>
+        <author><name>#{@title}</name></author>
+        #{self_link(controller)}
+        #{xml}
+      </feed>"""
+  end
+  
+  def id_for(controller)
+    @id || controller.url_for({})
+  end
+  
+  def id(*id)
+    @id = id
+    self
+  end
+  
+  def self_link(controller, what = {})
+    uri = controller.url_for(what)
+    "<link rel=\"self\" href=\"#{uri}\"/>"
+  end
+  
+  def updated_at
+    last = nil
+    @feed.each do |item|
+      last = item.updated_at if item.respond_to?(:updated_at) && (last.nil? || item.updated_at > last)
+    end
+    last || Time.now
+  end
+  
+  def items_to_atom_xml(controller, serializer = nil)
+    xml = ""
+    @feed.each do |item|
+      uri = controller.url_for(item)
+      media_type = item.class.respond_to?(:media_type_representations) ? item.class.media_type_representations[0] : 'application/xml'
+      item_xml = serializer.nil? ? item.to_xml(:controller => controller, :skip_instruct => true) : serializer.call(item)
+      xml += """          <entry>
+            <id>#{uri}</id>
+            <title type=\"text\">#{item.class.name}</title>
+            <updated>#{modification_for(item).strftime("%Y-%m-%dT%H:%M:%S-08:00")}</updated>
+            #{self_link(controller, item)}
+            <content type=\"#{media_type}\">
+              #{item_xml}
+            </content>
+          </entry>\n"""
+    end
+    xml
+  end
+  
+  def modification_for(item)
+    item.respond_to?(:updated_at) ? item.updated_at : Time.now
+  end
+
+end

data/lib/restfulie/server/base.rb

@@ -3,7 +3,7 @@ module Restfulie
     module Base
     
       # returns the definition for the transaction
-      def existing_transitions(name)
+      def existing_transition(name)
         transitions[name]
       end
     
@@ -45,9 +45,11 @@ module Restfulie
           @type.define_can_method(@type, name)
           self
         end
+        
         def at(options)
           @transition.options = options
         end
+        
         def results_in(result)
           @transition.result = result
         end

data/lib/restfulie/server/controller.rb

@@ -3,19 +3,33 @@ module ActionController
     
     # renders an specific resource to xml
     # using any extra options to render it (invoke to_xml).
-    def render_resource(resource, options = {})
-      cache_info = {:etag => resource}
-      cache_info[:last_modified] = resource.updated_at.utc if resource.respond_to? :updated_at
-      if stale? cache_info
-        options[:controller] = self
-        format = (self.params && self.params[:format]) || "xml"
-        if ["xml", "json"].include?(format)
-          render format.to_sym => resource.send(:"to_#{format}", options)
-        else
-          render format.to_sym => resource
-        end
-      end
-    end
+    def render_resource(resource, options = {}, render_options = {})
+       cache_info = {:etag => resource}
+       cache_info[:last_modified] = resource.updated_at.utc if resource.respond_to? :updated_at
+       if stale? cache_info
+         options[:controller] = self
+     
+         respond_to do |format|
+           add_media_responses(format, resource, options, render_options)
+         end
+       end
+     end
+
+ 
+   def add_media_responses(format, resource, options, render_options)
+     types = Restfulie::MediaType.default_types
+     types = resource.class.media_types if resource.class.respond_to? :media_types
+     types.each do |media_type|
+       add_media_response(format, resource, media_type, options, render_options)
+     end
+   end
+
+   def add_media_response(format, resource, media_type, options, render_options)
+     controller = self
+     format.send media_type.short_name.to_sym do
+       media_type.execute_for(controller, resource, options, render_options)
+     end
+   end
 
     # adds support to rendering resources, i.e.:
     # render :resource => @order, :with => { :except => [:paid_at] }
@@ -29,5 +43,27 @@ module ActionController
       end
     end
     
+    # renders a created resource including its required headers:
+    # Location and 201
+    def render_created(resource, options = {})
+      location= url_for resource
+      render_resource resource, options, {:status => :created, :location => location}
+    end
+  end
+  
+  module MimeResponds
+    class Responder
+      attr_reader :mime_type_priority
+      alias_method :old_respond, :respond unless method_defined?(:old_respond)
+      def respond
+        RestfulieResponder.new.respond(self)
+      end
+    end
+    
+    class RestfulieResponder
+      def respond(instance)
+        instance.old_respond unless instance.mime_type_priority.include? "html"
+      end
+    end
   end
 end

data/lib/restfulie/server/instance.rb

@@ -25,6 +25,25 @@ module Restfulie
         raise "Current state #{status} is invalid in order to execute #{name}. It must be one of #{transitions}" unless available_transitions[:allow].include? name
         self.class.transitions[name].execute_at self
       end
+      
+      # gets all the links for each transition
+      def links(controller)
+        links = []
+        unless controller.nil?
+          all_following_transitions.each do |transition|
+            rel, uri = link_for(transition, controller)
+            links << {:rel => rel, :uri => uri}
+          end
+        end
+        links
+      end
+
+      private
+      # gets a link for this transition
+      def link_for(transition, controller) 
+        transition = self.class.existing_transition(transition.to_sym) unless transition.kind_of? Restfulie::Server::Transition
+        transition.link_for(self, controller)
+      end
 
     end
   end

data/lib/restfulie/server/marshalling.rb

@@ -5,36 +5,26 @@ module Restfulie
   
     module Marshalling
   
+      # marshalls your object to json.
+      # adds all links if there are any available.
       def to_json(options = {})
         Hash.from_xml(to_xml(options)).to_json
       end
-  
-      # adds a link for each transition to the current xml writer
-      def add_links(xml, all, options)
-        all.each do |transition|
-          add_link(transition, xml, options)
-        end
-      end
-
-      # adds a link for this transition to the current xml writer
-      def add_link(transition, xml, options) 
-        transition = self.class.existing_transitions(transition.to_sym) unless transition.kind_of? Restfulie::Server::Transition
-        transition.add_link_to(xml, self, options)
-      end
 
       # marshalls your object to xml.
       # adds all links if there are any available.
       def to_xml(options = {})
-    
-        transitions = all_following_transitions
-        return super(options) if transitions.empty? || options[:controller].nil?
-
         options[:skip_types] = true
         super options do |xml|
-          add_links xml, transitions, options
+          links(options[:controller]).each do |link|
+            if options[:use_name_based_link]
+              xml.tag!(link[:rel], link[:uri])
+            else
+              xml.tag!('atom:link', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', :rel => link[:rel], :href => link[:uri])
+            end
+          end
         end
       end
-  
     end
 
   end  

data/lib/restfulie/server/restfulie_controller.rb

@@ -0,0 +1,56 @@
+module Restfulie
+  
+  module Server
+  
+    # Controller which adds default CRUD + search + other operations.
+    module Controller
+    
+      # creates a model based on the request media-type extracted from its content-type
+      # 
+      def create
+
+        type = model_type
+        return head 415 unless fits_content(type, request.headers['CONTENT_TYPE'])
+
+        @model = type.from_xml request.body.string
+        if @model.save
+          render_created @model
+        else
+          render :xml => @model.errors, :status => :unprocessable_entity
+        end
+
+      end
+    
+      # renders this resource
+      def show
+        @model = model_type.find(params[:id])
+        instance_variable_set(model_variable_name, @model)
+        render_resource(@model)
+      end
+      
+      def model_variable_name
+        ("@" + model_type.to_s.downcase).to_sym
+      end
+
+      # destroys this resource
+      def destroy
+        @model = model_type.find(params[:id])
+        @model.destroy
+        head :ok
+      end
+
+      # returns the model for this controller
+      def model_type
+        self.class.name[/(.*)Controller/,1].singularize.constantize
+      end
+    
+      def fits_content(type, content_type)
+        Restfulie::MediaType.supports?(content_type) &&
+                type.media_type_representations.include?(content_type)
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/restfulie/server/transition.rb

@@ -7,49 +7,53 @@ module Restfulie
       attr_reader :body, :name
       attr_writer :options
       attr_accessor :result
+      
       def initialize(name, options = {}, result = nil, body = nil)
         @name = name
         @options = options
         @result = result
         @body = body
       end
+      
       def action
         @options || {}
       end
       
       # executes this transition in a resource
       def execute_at(target_object)
-        target_object.status = result.to_s unless result.nil?
+        target_object.status = @result.to_s unless @result.nil?
       end
     
-      # adds a link to this transition's uri on a xml writer
-      def add_link_to(xml, model, options)
-        specific_action = action.dup
-        specific_action = @body.call(model) if @body
+      # return the link to this transitions's uri
+      def link_for(model, controller)
+        specific_action = @body ? @body.call(model) : action.dup
 
-        # if you use the class level DSL, you will need to add a lambda for instance level accessors:
-        #   transition :show, {:action => :show, :foo_id => lambda { |model| model.id }}
-        # but you can replace it for a symbol and defer the model call
-        #   transition :show, {:action => :show, :foo_id => :id}
-        specific_action = specific_action.inject({}) do |actions, pair|
-          if pair.last.is_a?( Symbol ) && model.attributes.include?(pair.last)
-            actions.merge!( pair.first => model.send(pair.last) )
-          else
-            actions.merge!( pair.first => pair.last )
-          end
-        end
+        specific_action = parse_specific_action(specific_action, model)
 
         rel = specific_action[:rel] || @name
         specific_action[:rel] = nil
 
         specific_action[:action] ||= @name
-        uri = options[:controller].url_for(specific_action)
+        uri = controller.url_for(specific_action)
+        
+        return rel, uri
+      end
       
-        if options[:use_name_based_link]
-          xml.tag!(rel, uri)
-        else
-          xml.tag!('atom:link', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', :rel => rel, :href => uri)
+      private
+
+      # if you use the class level DSL, you will need to add a lambda for instance level accessors:
+      #   transition :show, {:action => :show, :foo_id => lambda { |model| model.id }}
+      # but you can replace it for a symbol and defer the model call
+      #   transition :show, {:action => :show, :foo_id => :id}
+      def parse_specific_action(action, model)
+        action.inject({}) do |actions, pair|
+          if pair.last.is_a?( Symbol ) && model.attributes.include?(pair.last)
+            actions.merge!( pair.first => model.send(pair.last) )
+          else
+            actions.merge!( pair.first => pair.last )
+          end
         end
+        action
       end
       
     end

data/lib/restfulie/unmarshalling.rb

@@ -28,8 +28,7 @@ module Restfulie
     # found at http://www.xcombinator.com/2008/08/11/activerecord-from_xml-and-from_json-part-2/
     # addapted to support links
     def from_hash( hash )
-      h = {}
-      h = hash.dup if hash
+      h = hash ? hash.dup : {}
       links = nil
       h.each do |key,value|
         case value.class.to_s
@@ -62,7 +61,6 @@ end
 module ActiveRecord
   class Base
     extend Restfulie::Unmarshalling
-    # acts_as_jeokkarak
 
     def self.from_json(json)
       from_hash(safe_json_decode(json).values.first)

data/lib/restfulie.rb

@@ -1,5 +1,8 @@
 require 'net/http'
 require 'uri'
+require 'vendor/jeokkarak/jeokkarak'
+
+require 'restfulie/media_type'
 
 require 'restfulie/client'
 
@@ -8,6 +11,8 @@ require 'restfulie/server/controller'
 require 'restfulie/server/instance'
 require 'restfulie/server/marshalling'
 require 'restfulie/server/transition'
+require 'restfulie/server/restfulie_controller'
+require 'restfulie/server/atom_media_type'
 
 module Restfulie
 
@@ -29,6 +34,7 @@ module Restfulie
   # the transition's uri.
   def acts_as_restfulie
     extend Restfulie::Server::Base
+    extend Restfulie::MediaTypeControl
     include Restfulie::Server::Instance
     include Restfulie::Server::Marshalling
     
@@ -38,7 +44,7 @@ module Restfulie
       transitions
     end
   end
-  
+
 end
 
 Object.extend Restfulie

data/lib/vendor/jeokkarak/hashi.rb

@@ -0,0 +1,61 @@
+module Hashi
+  class UndefinedMethod < Exception
+    attr_reader :msg
+    def initialize(msg)
+      @msg = msg
+    end
+    def to_s
+      @msg
+    end
+  end
+  
+  class CustomHash
+    
+    attr_reader :hash
+ 
+    def initialize(h = {})
+      @hash = h
+    end
+    
+    def method_missing(name, *args)
+      name = name.to_s if name.kind_of? Symbol
+      if name[-1,1] == "?"
+        parse(name, @hash[name.chop])
+      elsif name[-1,1] == "="
+        @hash[name.chop] = args[0]
+      else
+        return nil if @hash.has_key?(name) && @hash[name].nil?
+        parse(name, transform(@hash[name]))
+      end
+    end
+    
+    def respond_to?(symbol)
+      super.respond_to?(symbol) || @hash.key?(symbol.to_s)
+    end
+    
+    def [](x)
+      transform(@hash[x])
+    end
+    
+    private
+    def transform(value)
+      return CustomHash.new(value) if value.kind_of?(Hash) || value.kind_of?(Array)
+      value
+    end
+    
+    def parse(name, val)
+      raise Hashi::UndefinedMethod.new("undefined method '#{name}'") if val.nil?
+      val
+    end
+    
+  end
+  
+  def self.from_hash(h)
+    CustomHash.new(h)
+  end
+  
+  def self.to_object(h)
+    CustomHash.new(h)
+  end
+  
+end

data/lib/vendor/jeokkarak/jeokkarak.rb

@@ -0,0 +1,65 @@
+require 'vendor/jeokkarak/hashi'
+ 
+module Jeokkarak
+  module Base
+    
+    # defines that this type has a child element
+    def has_child(type, options={})
+      resource_children[options[:as]] = type
+    end
+    
+    # checks what is the type element for this type (supports rails ActiveRecord, has_child and Hashi)
+    def child_type_for(name)
+      return reflect_on_association(name.to_sym ).klass if respond_to? :reflect_on_association
+      resource_children[name] || Hashi
+    end
+    
+    # returns the registered children list for this resource
+    def resource_children
+      @children ||= {}
+      @children
+    end
+    
+    # creates an instance of this type based on this hash
+    def from_hash(h)
+      h = {} if h.nil? # nasty required check
+      h = h.dup
+      result = self.new
+      result._internal_hash = h
+      h.each do |key,value|
+        from_hash_parse result, h, key, value
+      end
+      def result.method_missing(name, *args, &block)
+        Hashi.to_object(@_internal_hash).send(name, args[0], block)
+      end
+      result
+    end
+    
+    # extension point to parse a value
+    def from_hash_parse(result,h,key,value)
+      case value.class.to_s
+      when 'Array'
+        h[key].map! { |e| child_type_for(key).from_hash e }
+      when /\AHash(WithIndifferentAccess)?\Z/
+        h[key] = child_type_for(key ).from_hash value
+      end
+      name = "#{key}="
+      result.send(name, value) if result.respond_to?(name)
+    end
+  end
+end
+ 
+module Jeokkarak
+  module Config
+    
+    # entry point to define a jeokkarak type
+    def acts_as_jeokkarak
+      self.module_eval do
+        attr_accessor :_internal_hash
+      end
+      self.extend Jeokkarak::Base
+    end
+  end
+end
+ 
+Object.extend Jeokkarak::Config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: restfulie
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Guilherme Silveira, Caue Guerra
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-10 00:00:00 -02:00
+date: 2010-01-06 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -22,23 +22,33 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/restfulie/client/atom_media_type.rb
 - lib/restfulie/client/base.rb
 - lib/restfulie/client/entry_point.rb
 - lib/restfulie/client/helper.rb
 - lib/restfulie/client/instance.rb
+- lib/restfulie/client/request_execution.rb
 - lib/restfulie/client/state.rb
 - lib/restfulie/client.rb
+- lib/restfulie/media_type.rb
+- lib/restfulie/media_type_control.rb
+- lib/restfulie/media_type_defaults.rb
+- lib/restfulie/server/atom_media_type.rb
 - lib/restfulie/server/base.rb
 - lib/restfulie/server/controller.rb
 - lib/restfulie/server/instance.rb
 - lib/restfulie/server/marshalling.rb
+- lib/restfulie/server/restfulie_controller.rb
 - lib/restfulie/server/transition.rb
 - lib/restfulie/unmarshalling.rb
 - lib/restfulie.rb
+- lib/vendor/jeokkarak/hashi.rb
+- lib/vendor/jeokkarak/jeokkarak.rb
+- LICENSE
 - Rakefile
 - README.textile
 has_rdoc: true
-homepage: http://github.com/caelum/restfulie
+homepage: http://restfulie.caelumobjects.com
 licenses: []
 
 post_install_message: