restfulie 0.5.0 → 0.6.0

data/lib/restfulie/client/request_execution.rb

@@ -1,12 +1,183 @@
+#
+#  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. 
+#
+
+require 'restfulie/client/extensions/http'
+
 module Restfulie
   module Client
+    
+    # extension to all answers that allows you to access the web response
+    module WebResponse
+      attr_accessor :web_response
+    end
+    
+    # some error ocurred while processing the request
+    class ResponseError < Exception
+    end
+    
+    # Handles response answered by servers by accessing the specific callback for a http response code.
+    module ResponseHandler
+      
+      class << self
+
+        # registers a new callback for a specific range of response codes
+        #
+        # Restfulie::Client::ResponseHandler.register(400, 599) do |restfulie_response|
+        #   # returns the original reponse object
+        #   restfulie_response.response
+        # end
+        def register(min_code, max_code, &block)
+          (min_code..max_code).each do |code|
+            handlers[code] = block
+          end
+        end
+
+        # callback that returns the http response object
+        def pure_response_return(restfulie_response)
+          restfulie_response.response
+        end
+
+        # callback that raises a ResponseError
+        def raise_error(restfulie_response)
+          raise Restfulie::Client::ResponseError.new(restfulie_response.response)
+        end
+
+        # callback that parses the response media type and body,
+        # returning a deserialized representation of the resource.
+        # note that this will also set the _came_from instance variable with the content type
+        # this resource was represented, in order to allow further requests to prefer this content type.
+        def parse_entity(restfulie_response)
+          response = restfulie_response.response
+          content_type = response.content_type
+          type = Restfulie::MediaType.type_for(content_type)
+          if content_type[-3,3]=="xml"
+            result = type.from_xml response.body
+          elsif content_type[-4,4]=="json"
+            result = type.from_json response.body
+          else
+            result = generic_parse_entity restfulie_response
+          end
+          result.instance_variable_set :@_came_from, content_type
+          result
+        end
+
+        # callback taht executes a GET request to the response Location header.
+        # this is the typical callback for 200 response codes.
+        def retrieve_resource_from_location(restfulie_response)
+          restfulie_response.type.from_web restfulie_response.response["Location"]
+        end
+
+        # given a restfulie response, extracts the response code and invoke the registered callback.
+        def handle(restfulie_response)
+          handlers[restfulie_response.response.code.to_i].call(restfulie_response)
+        end
+        
+        def generic_parse_entity(restfulie_response)
+          response = restfulie_response.response
+          content_type = response.content_type
+          type = Restfulie::MediaType.type_for(content_type)
+          method = "from_#{content_type}".to_sym
+          raise Restfulie::UnsupportedContentType.new("unsupported content type '#{content_type}' because '#{type}.#{method.to_s}' was not found") unless type.respond_to? method
+          type.send(method, response.body)
+        end
+
+        private
+        def handlers
+          @handlers ||= {}
+        end
+        
+        def register_func(min, max, proc)
+          register(min, max) { |r| proc.call(r) }
+        end
+
+      end
+      
+      register_func( 100, 599, Proc.new{ |r| pure_response_return r} )
+      register_func( 200, 200, Proc.new{ |r| parse_entity r} )
+      register_func( 301, 301, Proc.new{ |r| retrieve_resource_from_location r} )
+      
+    end
+
+    
+    # TODO there should be a response for each method type
+    class Response
+      
+      attr_reader :type, :response
+      
+      def initialize(type, response)
+        @type = type
+        @response = response
+      end
+
+      # TODO remote_post can probably be moved, does not need to be on the object's class itself
+      # the expected_content_type is used in case a redirection takes place
+      def parse_post(expected_content_type)
+        code = @response.code
+        if code=="301" && @type.follows.moved_permanently? == :all
+          result = @type.remote_post_to(@response["Location"], @response.body)
+          enhance(result)
+        elsif code=="201"
+          Restfulie.at(@response["Location"]).accepts(expected_content_type).get
+        else
+          final_parse
+        end
+      end
+      
+      # gets a result object and enhances it with web response methods
+      # by extending WebResponse and defining the attribute web_response
+      def enhance(result)
+        @response.previous = result.web_response if result.respond_to? :web_response
+        result.extend Restfulie::Client::WebResponse
+        result.web_response = @response
+        result
+      end
+      
+      # parses this response using the correct ResponseHandler and enhances it
+      def final_parse
+        enhance Restfulie::Client::ResponseHandler.handle(@response)
+      end
+
+      # detects which type of method invocation it was and act accordingly
+      # TODO this should be called by RequestExcution, not instance
+      def parse(method, invoking_object, content_type)
+
+        return enhance(invoking_object) if @response.code == "304"
+
+        # return block.call(@response) if block
+
+        return final_parse if method == Net::HTTP::Get
+        return parse_post(content_type) if method == Net::HTTP::Post
+        final_parse
+        
+      end
+      
+    end
 
     class RequestExecution
       
       def initialize(type)
+        initialize(type, nil)
+      end
+
+      def initialize(type, invoking_object)
         @type = type
         @content_type = "application/xml"
         @accepts = "application/xml"
+        @invoking_object = invoking_object
       end
 
       def at(uri)
@@ -26,12 +197,51 @@ module Restfulie
         @accepts = content_type
         self
       end
+      
+      def with(headers)
+        @headers = headers
+        self
+      end
 
       # asks to create this content on the server (post it)
       def create(content)
         post(content)
       end
+      
+      # executes an http request using the specified verb
+      #
+      # example:
+      # do(Net::HTTP::Get, 'self', nil)
+      # do(Net::HTTP::Post, 'payment', '<payment/>')
+      def do(verb, relation_name, body = nil)
+        url, http_request = prepare_request(verb, relation_name, body)
+        response = execute_request(url, http_request)
+        Restfulie::Client::Response.new(@type, response).parse(verb, @invoking_object, "application/xml")
+      end
+      
+      private
+      def execute_request(url, http_request)
+        cached = Restfulie.cache_provider.get(url, http_request) 
+        return cached if cached
 
+        response = Net::HTTP.new(url.host, url.port).request(http_request)
+        Restfulie.cache_provider.put(url, http_request, response)
+      end
+      
+      public
+      
+      def prepare_request(verb, relation_name, body = nil)
+        url = URI.parse(@uri)
+        req = verb.new(url.path)
+        add_basic_request_headers(req, relation_name)
+        
+        if body
+          req.body = body
+          req.add_field("Content-type", "application/xml") if req.get_fields("Content-type").nil?
+        end
+        [url, req]
+      end
+      
       # post this content to the server
       def post(content)
         remote_post_to(@uri, content)
@@ -41,6 +251,48 @@ module Restfulie
       def get(options = {})
         from_web(@uri, options)
       end
+      
+      def add_headers_to(hash)
+        hash[:headers] = {} unless hash[:headers]
+        hash[:headers]["Content-type"] = @content_type
+        hash[:headers]["Accept"] = @accepts
+        hash
+      end
+      
+      def change_to_state(name, args)
+        if !args.empty? && args[args.size-1].kind_of?(Hash)
+          add_headers_to(args[args.size-1])
+        else
+          args << add_headers_to({})
+        end
+        @invoking_object.invoke_remote_transition name, args
+      end
+      
+      # invokes an existing relation or delegates to the existing definition of method_missing
+      def method_missing(name, *args)
+        if @invoking_object && @invoking_object.existing_relations[name.to_s]
+          change_to_state(name.to_s, args)
+        else
+          super(name, args)
+        end
+      end
+
+      def add_basic_request_headers(req, name = nil)
+        
+        req.add_field("Accept", @accepts) unless @accepts.nil?
+        
+        @headers.each do |key, value|
+          req.add_field(key, value)
+        end if @headers
+        
+        req.add_field("Accept", @invoking_object._came_from) if req.get_fields("Accept")==["*/*"]
+        
+        if @type && name && @type.is_self_retrieval?(name) && @invoking_object.respond_to?(:web_response)
+          req.add_field("If-None-Match", @invoking_object.web_response.etag) if !@invoking_object.web_response.etag.nil?
+          req.add_field("If-Modified-Since", @invoking_object.web_response.last_modified) if !@invoking_object.web_response.last_modified.nil?
+        end
+        
+      end
 
       private
       def remote_post_to(uri, content)
@@ -52,78 +304,16 @@ module Restfulie
         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
+        Restfulie::Client::Response.new(@type, response).parse_post(@content_type)
       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 
+        options.each { |key,value| req[key] = value }
         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
+        Restfulie::Client::Response.new(@type, res).final_parse
       end
       
     end

data/lib/restfulie/client/state.rb

@@ -1,3 +1,20 @@
+#
+#  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. 
+#
+
 module Restfulie
   
   module Client
@@ -12,7 +29,7 @@ module Restfulie
 
       # returns true if this resource has a state named name
       def has_state(name)
-        !@_possible_states[name].nil?
+        !@existing_relations[name].nil?
       end
     end
   end

data/lib/restfulie/client.rb

@@ -1,3 +1,22 @@
+#
+#  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. 
+#
+
+require 'restfulie/logger'
+
 require 'net/http'
 require 'uri'
 require 'vendor/jeokkarak/jeokkarak'
@@ -10,9 +29,15 @@ require 'restfulie/client/helper'
 require 'restfulie/client/instance'
 require 'restfulie/client/request_execution'
 require 'restfulie/client/state'
+require 'restfulie/client/cache'
+require 'restfulie/unmarshalling'
 
 module Restfulie
   
+  class << self
+    attr_accessor :cache_provider
+  end
+  
   # Extends your class to support restfulie-client side's code.
   # This will extends Restfulie::Client::Base methods as class methods,
   # Restfulie::Client::Instance as instance methods and Restfulie::Unmarshalling as class methods.
@@ -26,10 +51,10 @@ end
 
 Object.extend Restfulie
 
-require 'restfulie/unmarshalling'
+include ActiveSupport::CoreExtensions::Hash
 
-module Hashi
-  class CustomHash
+class Hashi::CustomHash
     uses_restfulie
-  end
 end
+
+Restfulie.cache_provider = Restfulie::BasicCache.new

data/lib/restfulie/logger.rb

@@ -0,0 +1,13 @@
+module Restfulie 
+
+  # Configure the logger used by Restfulie
+  # 
+  # The logger defaults to ActiveSupport::BufferedLogger.new(STDOUT)
+  class << self
+    attr_accessor :logger
+  end
+
+end
+
+Restfulie.logger = ActiveSupport::BufferedLogger.new(STDOUT)
+Restfulie.logger.level = Logger::DEBUG

data/lib/restfulie/media_type.rb

@@ -1,3 +1,20 @@
+#
+#  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. 
+#
+
 require 'restfulie/media_type_control'
 
 module Restfulie
@@ -89,16 +106,10 @@ module Restfulie
       
       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
@@ -108,6 +119,14 @@ module Restfulie
         type = hash.keys.first.camelize.constantize
         type.from_hash(hash.values.first)
       end
+
+      def self.from_html(body)
+        Hashi::CustomHash.new :body => body
+      end
+    
+      def self.from_xhtml(body)
+        Hashi::CustomHash.new :body => body
+      end
     
     end
   end

data/lib/restfulie/media_type_control.rb

@@ -1,3 +1,32 @@
+#
+#  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. 
+
+# extends Rails mime type
+
+module Mime
+  class << self
+    # alias_method :old_const_set, :const_set
+    
+    # ignores setting the contest again
+    # def const_set(a,b)
+      # super(a,b) unless Mime.const_defined?(a)
+    # end
+  end
+end
+
 module Restfulie
   
   module MediaTypeControl
@@ -31,12 +60,22 @@ module Restfulie
   end
   
 
+  def register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], skip_lookup = false)
+    SET << Mime.const_get(symbol.to_s.upcase)
+
+    ([string] + mime_type_synonyms).each { |string| LOOKUP[string] = SET.last } unless skip_lookup
+    ([symbol.to_s] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext] = SET.last }
+  end
+
   module MediaType
     
     class << self
     
       def register(type)
-        Mime::Type.register(type.name, type.short_name.to_sym)
+        silence_warnings do
+          Mime::Type.register(type.name, type.short_name.to_sym)
+        end
+        
         media_types[type.name] = type
       end
     

data/lib/restfulie/media_type_defaults.rb

@@ -1,11 +1,28 @@
+#
+#  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. 
+#
+
 module Restfulie
   
   module MediaType
     def self.HtmlType
-      custom_type('html', self, lambda {})
+      custom_type('html', DefaultMediaTypeDecoder, lambda {})
     end
     def self.TextHtmlType
-      custom_type('text/html', self, lambda {})
+      custom_type('text/html', DefaultMediaTypeDecoder, lambda {})
     end
   
     # TODO rename it and move it

data/lib/restfulie/server/atom_media_type.rb

@@ -1,3 +1,20 @@
+#
+#  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. 
+#
+
 module Restfulie
   
   module Server
@@ -69,11 +86,7 @@ class AtomFeed
   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
+    @feed.updated_at
   end
   
   def items_to_atom_xml(controller, serializer = nil)

data/lib/restfulie/server/base.rb

@@ -1,7 +1,24 @@
+#
+#  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. 
+#
+
 module Restfulie
   module Server
     module Base
-    
+
       # returns the definition for the transaction
       def existing_transition(name)
         transitions[name]