restfully 0.6.3 → 0.7.0.pre

data/lib/restfully/error.rb

@@ -1,4 +1,6 @@
 
 module Restfully  
   class Error < StandardError; end
+  class NotImplemented < Error; end
+  class MethodNotAllowed < Error; end
 end

data/lib/restfully/http.rb

@@ -1,9 +1,9 @@
-require 'restfully/http/headers'
+require 'restfully/http/helper'
 require 'restfully/http/error'
 require 'restfully/http/request'
 require 'restfully/http/response'
-require 'restfully/http/adapters/abstract_adapter'
+
 module Restfully
   module HTTP
   end
-end
+end

data/lib/restfully/http/error.rb

@@ -1,25 +1,6 @@
 module Restfully
   module HTTP
-    class Error < Restfully::Error
-      STATUS_CODES = {
-        400 => "Bad Request",
-        401 => "Authorization Required",
-        403 => "Forbiden",
-        406 => "Not Acceptable"        
-      }
-      
-      attr_reader :response
-      def initialize(response)
-        @response = response
-        response_body = response.body rescue response.raw_body
-        if response_body.kind_of?(Hash)
-          message = "#{response.status} #{response_body['title']}. #{response_body['message']}"
-        else
-          message = "#{response.status} #{STATUS_CODES[response.status] || (response_body[0..100]+"...")}"
-        end
-        super(message)
-      end
-    end
+    class Error < Restfully::Error; end
     class ClientError < Restfully::HTTP::Error; end
     class ServerError < Restfully::HTTP::Error; end
   end

data/lib/restfully/http/helper.rb

@@ -0,0 +1,49 @@
+module Restfully
+  module HTTP
+    module Helper
+
+      def sanitize_head(h = {})
+        sanitized_headers = {}
+        h.each do |key, value|
+          sanitized_key = key.to_s.
+            downcase.
+            gsub(/[_-]/, ' ').
+            split(' ').
+            map{|word| word.capitalize}.
+            join("-")
+          sanitized_value = case value
+          when Array 
+            value.join(", ")
+          else 
+            value
+          end
+          sanitized_headers[sanitized_key] = sanitized_value
+        end
+        sanitized_headers
+      end
+    
+      def sanitize_query(h = {})
+        sanitized_query = {}
+        h.each do |key,value|
+          sanitized_query[key] = stringify(value)
+        end
+        sanitized_query
+      end
+      
+      protected
+      def stringify(value)
+        case value
+        when Hash
+          h = {}
+          value.each{|k,v| h[k] = stringify(v)}
+          h
+        when Array
+          value.map!{|v| stringify(v)}
+        else
+          value.to_s
+        end
+      end
+    
+    end
+  end
+end

data/lib/restfully/http/request.rb

@@ -1,42 +1,78 @@
-require 'uri'
+
+
 module Restfully
   module HTTP
     
     class Request
-      include Headers, Restfully::Parsing
-      attr_reader :headers, :uri
-      attr_accessor :retries
+      include Helper
       
-      def initialize(url, options = {})
-        options = options.symbolize_keys
-        @uri = url.kind_of?(URI) ? url : URI.parse(url)
-        @headers = sanitize_http_headers(options.delete(:headers) || {})
-        if query = options.delete(:query)
-          @uri.query = [@uri.query, query.to_params].compact.join("&")
+      attr_reader :method, :uri, :head, :body
+      
+      def initialize(session, method, path, options)
+        @session = session
+        
+        request = options.symbolize_keys
+        request[:method] = method
+
+        request[:head] = sanitize_head(@session.default_headers).merge(
+          build_head(request)
+        )
+        
+        request[:uri] = @session.uri_to(path)
+        if request[:query]
+          request[:uri].query_values = sanitize_query(request[:query])
+        end
+        
+        request[:body] = if [:post, :put].include?(request[:method])
+          build_body(request)
         end
-        @body = options.delete(:body)
-        @retries = 0
+
+        @method, @uri, @head, @body = request.values_at(
+          :method, :uri, :head, :body
+        )
       end
       
-      def body
-        if @body.kind_of?(String)
-          @unserialized_body ||= unserialize(@body, :content_type => @headers['Content-Type'])
+      # Updates the request header and query parameters
+      # Returns nil if no changes were made, otherwise self.
+      def update!(options = {})
+        objects_that_may_be_updated = [@uri, @head]
+        old_hash = objects_that_may_be_updated.map(&:hash)
+        opts = options.symbolize_keys
+        @head.merge!(build_head(opts))
+        if opts[:query]
+          @uri.query_values = sanitize_query(opts[:query])
+        end
+        if old_hash == objects_that_may_be_updated.map(&:hash)
+          nil
         else
-          @body
+          self
         end
       end
       
-      def raw_body
-        if @body.kind_of?(String)
-          @body
+      def no_cache?
+        head['Cache-Control'] && head['Cache-Control'].include?('no-cache')
+      end
+      
+      protected
+      def build_head(options = {})
+        sanitize_head(
+          options.delete(:headers) || options.delete(:head) || {}
+        )
+      end
+
+      def build_body(options = {})
+        if options[:body]
+          type = MediaType.find(options[:head]['Content-Type'])
+          if type.nil?
+            type = MediaType.find('application/x-www-form-urlencoded')
+            options[:head]['Content-Type'] = type.default_type
+          end
+          type.serialize(options[:body], :uri => options[:uri])
         else
-          @serialized_body ||= serialize(@body, :content_type => @headers['Content-Type'])
+          nil
         end
       end
       
-      def add_headers(headers = {})
-        @headers.merge!(sanitize_http_headers(headers || {}))
-      end
     end
   end
-end
+end

data/lib/restfully/http/response.rb

@@ -1,37 +1,68 @@
 module Restfully
   module HTTP
-    # Container for an HTTP Response. Has <tt>status</tt>, <tt>headers</tt> and <tt>body</tt> properties.
     class Response
-      include Headers, Restfully::Parsing
-      attr_reader :status, :headers
-      
-      # <tt>body</tt>:: may be a string (that will be parsed when calling the #body function), or an object (that will be returned as is when calling the #body function)
-      def initialize(status, headers, body)
-        @status = status.to_i
-        @headers = sanitize_http_headers(headers)
-        @body = body
-      end
+      include Helper
       
-      def body
-        if @body.kind_of?(String)
-          if @body.empty?
-            nil
-          else
-            @unserialized_body ||= unserialize(@body, :content_type => @headers['Content-Type'])
-          end
+      attr_reader :io, :code, :head
+      
+      def initialize(session, code, head, body)
+        @session = session
+        @io = StringIO.new
+        case body
+        when String
+          @io << body
         else
-          @body
+          body.each{|chunk| @io << chunk}
         end
+        @io.rewind
+        
+        @code = code
+        @head = sanitize_head(head)
       end
       
-      def raw_body
-        if @body.kind_of?(String)
-          @body
-        else
-          @serialized_body ||= serialize(@body, :content_type => @headers['Content-Type']) unless @body.nil?
+      def body
+        @io.rewind
+        @body = @io.read
+        @io.rewind
+        @body
+      end
+      
+      def io
+        @io
+      end
+      
+      def media_type
+        @media_type ||= begin
+          m = MediaType.find(head['Content-Type'])
+          raise Error, "Cannot find a media-type for content-type=#{head['Content-Type'].inspect}" if m.nil?
+          @session.logger.debug "Using media-type #{m.inspect}"
+          m.new(io, @session)
         end
       end
       
+      # TODO: we could also search for Link headers here.
+      def links
+        media_type.links
+      end
+      
+      def property(key)
+        media_type.property(key)
+      end
+      
+      def allow?(http_method)
+        http_method = http_method.to_sym
+        return true if http_method == :get
+        (
+          media_type.respond_to?(:allow?) && 
+          media_type.allow?(http_method)
+        ) || (
+          head['Allow'] &&
+          head['Allow'].split(/\s*,\s*/).map{|m| 
+            m.downcase.to_sym
+          }.include?(http_method)
+        )          
+      end
+      
     end
   end
-end
+end

data/lib/restfully/link.rb

@@ -1,36 +1,44 @@
 require 'uri'
 module Restfully
   class Link
-    
-    VALID_RELATIONSHIPS = %w{member parent collection self alternate next}
-    RELATIONSHIPS_REQUIRING_TITLE = %w{collection member}
-    
-    attr_reader :rel, :title, :href, :errors
-    
+
+    attr_reader :rel, :title, :href, :errors, :type
+
     def initialize(attributes = {})
-      @rel = attributes['rel']
-      @title = attributes['title']
-      @href = URI.parse(attributes['href'].to_s)
-      @resolvable = attributes['resolvable'] || false
-      @resolved = attributes['resolved'] || false
+      attributes = attributes.symbolize_keys
+      @rel = attributes[:rel]
+      @title = attributes[:title] || @rel
+      @href = URI.parse(attributes[:href].to_s)
+      @type = attributes[:type]
+      @id = attributes[:id]
     end
-    
-    def resolvable?; @resolvable == true; end
-    def resolved?; @resolved == true; end
+
     def self?; @rel == 'self'; end
-    
+
+    def types
+      type.split(";")
+    end
+
     def valid?
       @errors = []
-      if href.nil?
-        errors << "href cannot be nil."
-      end
-      unless VALID_RELATIONSHIPS.include?(rel)
-        errors << "#{rel} is not a valid link relationship."
+      if type.nil? || type.empty?
+        errors << "type cannot be blank"
+      elsif media_type.nil?
+        errors << "cannot find a MediaType for type #{type.inspect}"
       end
-      if (!title || title.empty?) && RELATIONSHIPS_REQUIRING_TITLE.include?(rel)
-        errors << "#{rel} #{href} has no title."
+      if href.nil?
+        errors << "href cannot be nil"
       end
       errors.empty?
     end
-  end
-end
+
+    def media_type
+      @media_type ||= MediaType.find(type)
+    end # def catalog
+    
+    def id
+      title.to_s.downcase.gsub(/[^a-z]/,'_').squeeze('_').to_sym
+    end
+
+  end # class Link
+end

data/lib/restfully/media_type.rb

@@ -0,0 +1,70 @@
+require 'restfully/media_type/abstract_media_type'
+
+module Restfully
+  module MediaType
+    class << self
+      def catalog
+        @catalog ||= Set.new
+      end
+
+      def find(*types)
+        return nil if types.compact.empty?
+
+        found = {}
+
+        catalog.each{ |media_type|
+          match = media_type.supports?(*types)
+          found[match] = media_type unless match.nil?
+        }
+        
+        if found.empty?
+          nil
+        else
+          found.sort{|a, b| a[0].length <=> b[0].length }.last[1]
+        end
+      end
+
+
+      def unregister(media_type)
+        catalog.delete(media_type)
+        build_index
+        self
+      end
+
+      def register(media_type)
+        if media_type.signature.empty?
+          raise ArgumentError, "The given MediaType (#{media_type}) has no signature"
+        end
+        if media_type.parser.nil?
+          raise ArgumentError, "The given MediaType (#{media_type}) has no parser"
+        end
+        unregister(media_type).catalog.add(media_type)
+      end
+
+      # Reset the catalog to the default list of media types
+      def reset
+        %w{
+          wildcard
+          application_json
+          application_x_www_form_urlencoded
+          grid5000
+        }.each do |m|
+          require "restfully/media_type/#{m}"
+          register MediaType.const_get(m.camelize)
+        end
+      end
+
+      def build_index
+        # @index = []
+        # catalog.each do |media_type|
+        #
+        # end
+      end
+
+
+    end
+
+    reset
+
+  end
+end

data/lib/restfully/media_type/abstract_media_type.rb

@@ -0,0 +1,162 @@
+require 'set'
+
+module Restfully
+  module MediaType
+
+    class AbstractMediaType
+
+      # 
+      # These class functions should NOT be overwritten by descendants.
+      # 
+      class << self
+        
+        def parent(method)
+          if superclass.respond_to?(method)
+            superclass.send(method)
+          else
+            nil
+          end
+        end
+
+        # @return [Hash] the hash of default options set.
+        def defaults
+          @defaults ||= (parent(:defaults) || {}).dup
+        end
+
+        # Sets a new <tt>value</tt> for a default <tt>attribute</tt>.
+        def set(attribute, value)
+          defaults[attribute.to_sym] = value
+        end
+        
+        # Returns the media-type signature, i.e. the list of metia-type it
+        # supports.
+        def signature
+          [(defaults[:signature] || [])].flatten
+        end
+        
+        # Returns the media-type parser.
+        def parser
+          defaults[:parser]
+        end
+        
+        # Returns the media-type default signature.
+        def default_type
+          signature.first
+        end
+        
+        # Returns the first supported media-type of the signature that matches
+        # one of the given <tt>types</tt>.
+        def supports?(*types)
+          types.each do |type|
+            type = type.to_s.downcase.split(";")[0]
+            found = signature.find{ |s|
+              type =~ Regexp.new(Regexp.escape(s.downcase).gsub('\*', ".*"))
+            }
+            return found if found
+          end
+          nil
+        end
+        
+        # Serialize an object into a String.
+        # Calls parser#dump.
+        def serialize(object, *args)
+          case object
+          when String
+            object
+          else
+            parser.dump(object, *args)
+          end
+        end
+        
+        # Unserialize an io object into a Hash.
+        # Calls parser#load.
+        def unserialize(io, *args)
+          parser.load(io, *args)
+        end
+        
+      end
+      
+      
+      attr_reader :io, :session
+
+      # A MediaType instance takes the original io object and the current
+      # session object as input.
+      def initialize(io, session)
+        @io = io
+        @session = session
+      end
+
+      # Returns an array of Link objects.
+      # Do not overwrite directly. Overwrite #extract_links instead.
+      def links
+        @links ||= extract_links.select{|l| l.valid?}
+      end
+
+      # Returns the unserialized version of the io object.
+      def unserialized
+        @unserialized ||= self.class.unserialize(@io)
+      end
+
+      # Without argument, returns the properties Hash obtained from calling
+      # #unserialized.
+      # With an argument, returns the value corresponding to that key.
+      #
+      # Should be overwritten if required.
+      def property(key = nil)
+        @properties ||= unserialized
+        if key
+          @properties[key]
+        else
+          @properties
+        end
+      end
+      
+      # Should return true if the current resource represented by this
+      # media-type can be designated with <tt>id</tt>.
+      #
+      # Should be overwritten.
+      def represents?(id)
+        false
+      end
+      
+      # Returns true if the current io object must be handled as a Collection.
+      # 
+      # Should be overwritten.
+      def collection?
+        false
+      end
+      
+      # Returns true if the current io object is completely loaded.
+      # Overwrite and return false to force a reloading if your object is just
+      #  a URI reference.
+      def complete?
+        true
+      end
+      
+      # An object to display on Resource#inspect.
+      #
+      # Should be overwritten.
+      def meta
+        property
+      end
+
+      # How to iterate over a collection
+      #
+      # Should be overwritten.
+      def each(*args, &block)
+        raise NotImplemented
+      end
+
+      
+      protected
+      # The function that returns the array of Link object.
+      #
+      # Should be overwritten.
+      def extract_links
+        []
+      end
+    end
+
+  end
+
+end