openlogic-resourceful 1.2.0

data/lib/resourceful/resource.rb

@@ -0,0 +1,179 @@
+require 'pathname'
+require 'resourceful/request'
+
+module Resourceful
+
+  class Resource
+    attr_reader :accessor
+
+    # Build a new resource for a uri
+    #
+    # @param accessor<HttpAccessor>
+    #   The parent http accessor
+    # @param uri<String, Addressable::URI>
+    #   The uri for the location of the resource
+    def initialize(accessor, uri, default_header = {})
+      @accessor, @uris = accessor, [uri]
+      @default_header = Resourceful::Header.new({'User-Agent' => Resourceful::RESOURCEFUL_USER_AGENT_TOKEN}.merge(default_header))
+      @on_redirect = nil
+    end
+
+    # The uri used to identify this resource. This is almost always the uri
+    # used to create the resource, but in the case of a permanent redirect, this
+    # will always reflect the lastest uri.
+    #
+    # @return Addressable::URI
+    #   The current uri of the resource
+    def effective_uri
+      @uris.first
+    end
+    alias uri effective_uri
+
+    def default_header(temp_defaults = {})
+      @default_header.merge(temp_defaults)
+    end
+
+    # Returns the host for this Resource's current uri
+    def host
+      Addressable::URI.parse(uri).host
+    end
+
+    # Updates the effective uri after following a permanent redirect
+    def update_uri(uri)
+      @uris.unshift(uri)
+    end
+
+    # When performing a redirect, this callback will be executed first. If the callback
+    # returns true, then the redirect is followed, otherwise it is not. The request that
+    # triggered the redirect and the response will be passed into the block. This can be
+    # used to update any links on the client side.
+    #
+    # Example:
+    #
+    #   author_resource.on_redirect do |req, resp|
+    #     post.author_uri = resp.header['Location']
+    #   end
+    #
+    # @yieldparam callback<request, response>
+    #   The action to be executed when a request results in a redirect. Yields the
+    #   current request and result objects to the callback.
+    #
+    # @raise ArgumentError if called without a block
+    def on_redirect(&callback)
+      if block_given?
+        @on_redirect = callback
+      else
+        @on_redirect
+      end
+    end
+
+    # Performs a GET on the resource, following redirects as neccessary, and retriving
+    # it from the local cache if its available and valid.
+    #
+    # @return [Response] The Response to the final request made.
+    #
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def get(header = {})
+      request(:get, nil, header)
+    end
+
+    def head(header = {})
+      request(:head, nil, header)
+    end
+    # :call-seq:
+    #   post(data = "", :content_type => mime_type)
+    #
+    # Performs a POST with the given data to the resource, following redirects as
+    # neccessary.
+    #
+    # @param [String] data
+    #   The body of the data to be posted
+    # @param [Hash] options
+    #   Options to pass into the request header. At the least, :content_type is required.
+    #
+    # @return [Response]  The Response to the final request that was made.
+    #
+    # @raise [ArgumentError] unless :content-type is specified in options
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def post(data = nil, header = {})
+      request(:post, data, header)
+    end
+
+    # :call-seq:
+    #   put(data = "", :content_type => mime_type)
+    #
+    # Performs a PUT with the given data to the resource, following redirects as
+    # neccessary.
+    #
+    # @param [String] data
+    #   The body of the data to be posted
+    # @param [Hash] options
+    #   Options to pass into the request header. At the least, :content_type is required.
+    #
+    # @return [Response] The response to the final request made.
+    #
+    # @raise [ArgumentError] unless :content-type is specified in options
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def put(data, header = {})
+      request(:put, data, header)
+    end
+
+    # Performs a DELETE on the resource, following redirects as neccessary.
+    #
+    # @return <Response>
+    #
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def delete(header = {})
+      request(:delete, nil, header)
+    end
+
+    def logger
+      accessor.logger
+    end
+
+    # Actually make the request
+    def request(method, data, header)
+      header = default_header.merge(header)
+      ensure_content_type(data, header) if data
+
+      data = StringIO.new(data) if data.kind_of?(String)
+
+      log_request_with_time "#{method.to_s.upcase} [#{uri}]" do
+        request = Request.new(method, self, data, header)
+        request.fetch_response
+      end
+    end
+
+    private
+
+    # Ensures that the request has a content type header
+    def ensure_content_type(body, header)
+      return if header.has_key?('Content-Type')
+
+      if body.respond_to?(:content_type)
+        header['Content-Type'] = body.content_type
+        return
+      end
+
+      return if default_header.has_key?('Content-Type')
+
+      # could not figure it out
+      raise MissingContentType
+    end
+
+    # Log it took the time to make the request
+    def log_request_with_time(msg, indent = 2)
+      logger.info(" " * indent + msg)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      logger.info(" " * indent + "-> Returned #{result.code} in %.4fs" % time.real)
+      result
+    end
+
+  end
+
+end

data/lib/resourceful/response.rb

@@ -0,0 +1,221 @@
+require 'net/http'
+require 'time'
+require 'zlib'
+
+module Resourceful
+
+  class Response
+    REDIRECT_RESPONSE_CODES = [301,302,303,307]
+    NORMALLY_CACHEABLE_RESPONSE_CODES = [200, 203, 300, 301, 410]
+
+    attr_reader :uri, :code, :header, :body, :response_time
+    alias headers header
+
+    attr_accessor :authoritative, :request_time
+    alias authoritative? authoritative
+
+    def initialize(uri, code, header, body)
+      @uri, @code, @header, @body = uri, code, header, body
+      @response_time = Time.now
+    end
+
+    # Is this a cached response that has expired?
+    #
+    # @return true|false
+    def expired?
+      if header.cache_control and m_age_str = header.cache_control.find{|cc| /^max-age=/ === cc}
+        return current_age > m_age_str[/\d+/].to_i
+      elsif header.expires
+        return Time.httpdate(header.expires) < Time.now
+      end
+
+      false
+    end
+
+    # Is this a cached response that is stale?
+    #
+    # @return true|false
+    def stale?
+      return true if expired?
+      return false unless header.has_field?(Header::CACHE_CONTROL)
+      return true if header.cache_control.any?{|cc| /must-revalidate|no-cache/ === cc}
+
+      false
+    end
+
+    # Is this response cachable?
+    #
+    # @return true|false
+    def cacheable?
+      @cacheable ||= begin
+        @cacheable = true  if NORMALLY_CACHEABLE_RESPONSE_CODES.include?(code.to_i)
+        @cacheable = false if header.vary && header.vary.include?('*')
+        @cacheable = false if header.cache_control && header.cache_control.include?('no-cache')
+        @cacheable = true  if header.cache_control && header.cache_control.include?('public')
+        @cacheable = true  if header.cache_control && header.cache_control.include?('private')
+        @cacheable || false
+      end
+    end
+
+    # Does this response force revalidation?
+    def must_be_revalidated?
+      header.cache_control && header.cache_control.include?('must-revalidate')
+    end
+    
+    # Update our headers from a later 304 response
+    def revalidate!(not_modified_response)
+      header.merge!(not_modified_response.header)
+      @request_time  = not_modified_response.request_time
+      @response_time = not_modified_response.response_time
+      @authoritative = true
+    end
+
+    # Algorithm taken from RCF2616#13.2.3
+    def current_age
+      age_value   = header.age.to_i
+      date_value  = Time.httpdate(header.date)
+      now         = Time.now
+
+      apparent_age = [0, response_time - date_value].max
+      corrected_received_age = [apparent_age, age_value].max
+      current_age = corrected_received_age + (response_time - request_time) + (now - response_time)
+    end
+
+    def body
+      raise(NotImplementedError, 'Chained encodings are not supported') if header['Content-Encoding'] && header['Content-Encoding'].length > 1
+      encoding = header['Content-Encoding'] && header['Content-Encoding'].first
+
+      case encoding
+      when nil
+        # body is identity encoded; just return it
+        @body
+      when /^\s*gzip\s*$/i
+        gz_in = ::Zlib::GzipReader.new(StringIO.new(@body, 'r'))
+        @body = gz_in.read
+        gz_in.close
+        header.delete('Content-Encoding')
+        @body
+      else
+        raise UnsupportedContentCoding, "Resourceful does not support #{encoding} content coding" 
+      end
+    end
+
+    CODE_NAMES = {
+      100 => "Continue".freeze,
+      101 => "Switching Protocols".freeze,
+
+      200 => "OK".freeze,
+      201 => "Created".freeze,
+      202 => "Accepted".freeze,
+      203 => "Non-Authoritative Information".freeze,
+      204 => "No Content".freeze,
+      205 => "Reset Content".freeze,
+      206 => "Partial Content".freeze,
+
+      300 => "Multiple Choices".freeze,
+      301 => "Moved Permanently".freeze,
+      302 => "Found".freeze,
+      303 => "See Other".freeze,
+      304 => "Not Modified".freeze,
+      305 => "Use Proxy".freeze,
+      307 => "Temporary Redirect".freeze,
+
+      400 => "Bad Request".freeze,
+      401 => "Unauthorized".freeze,
+      402 => "Payment Required".freeze,
+      403 => "Forbidden".freeze,
+      404 => "Not Found".freeze,
+      405 => "Method Not Allowed".freeze,
+      406 => "Not Acceptable".freeze,
+      407 => "Proxy Authentication Required".freeze,
+      408 => "Request Timeout".freeze,
+      409 => "Conflict".freeze,
+      410 => "Gone".freeze,
+      411 => "Length Required".freeze,
+      412 => "Precondition Failed".freeze,
+      413 => "Request Entity Too Large".freeze,
+      414 => "Request-URI Too Long".freeze,
+      415 => "Unsupported Media Type".freeze,
+      416 => "Requested Range Not Satisfiable".freeze,
+      417 => "Expectation Failed".freeze,
+
+      500 => "Internal Server Error".freeze,
+      501 => "Not Implemented".freeze,
+      502 => "Bad Gateway".freeze,
+      503 => "Service Unavailable".freeze,
+      504 => "Gateway Timeout".freeze,
+      505 => "HTTP Version Not Supported".freeze,
+    }.freeze
+
+    CODES = CODE_NAMES.keys
+
+    CODE_NAMES.each do |code, msg|
+      method_name = msg.downcase.gsub(/[- ]/, "_")
+
+      class_eval <<-RUBY
+        def #{method_name}?                           # def ok?
+          @code == #{code}                            #   @code == 200
+        end                                           # end
+      RUBY
+    end
+
+    # Is the response informational? True for
+    # 1xx series response codes
+    #
+    # @return true|false
+    def informational?
+      @code.in? 100..199
+    end
+
+    # Is the response code sucessful? True for only 2xx series
+    # response codes.
+    #
+    # @return true|false
+    def successful?
+      @code.in? 200..299
+    end
+    alias success? successful?
+
+    # Is the response a redirect? True for
+    # 3xx series response codes
+    #
+    # @return true|false
+    def redirection?
+      @code.in? 300..399
+    end
+
+    # Is the response a actual redirect? True for
+    # 301, 302, 303, 307 response codes
+    #
+    # @return true|false
+    def redirect?
+      @code.in? REDIRECT_RESPONSE_CODES
+    end
+
+    # Is the response the result of a client error? True for
+    # 4xx series response codes
+    #
+    # @return true|false
+    def client_error?
+      @code.in? 400..499
+    end
+
+    # Is the response the result of a server error? True for
+    # 5xx series response codes
+    #
+    # @return true|false
+    def server_error?
+      @code.in? 500..599
+    end
+
+    # Is the response the result of any kind of error? True for
+    # 4xx and 5xx series response codes
+    #
+    # @return true|false
+    def error?
+      server_error? || client_error?
+    end
+
+  end
+  
+end

data/lib/resourceful/simple.rb

@@ -0,0 +1,36 @@
+module Resourceful
+  module Simple
+    def request(method, uri, header = {}, data = nil)
+      default_accessor.resource(uri).request(method, data, header)
+    end
+    
+    def default_accessor
+      @default_accessor ||= Resourceful::HttpAccessor.new
+    end
+    
+    def add_authenticator(an_authenticator)
+      default_accessor.add_authenticator(an_authenticator)
+    end
+
+    def get(uri, header = {})
+      request(:get, uri, header)
+    end
+
+    def head(uri, header = {})
+      request(:head, uri, header)
+    end
+
+    def delete(uri, header = {})
+      request(:delete, uri, header)
+    end
+ 
+    def post(uri, data = nil, header = {})
+      request(:post, uri, header, data)
+    end
+
+    def put(uri, data = nil, header = {})
+      request(:put, uri, header, data)
+    end
+  end
+
+end

data/lib/resourceful/stubbed_resource_proxy.rb

@@ -0,0 +1,47 @@
+require 'resourceful/resource'
+  
+module Resourceful
+  class StubbedResourceProxy
+    def initialize(resource, canned_responses)
+      @resource = resource
+      
+      @canned_responses = {}
+      
+      canned_responses.each do |cr| 
+        mime_type = cr[:mime_type]
+        @canned_responses[mime_type] = resp = Net::HTTPOK.new('1.1', '200', 'OK')
+        resp['content-type'] = mime_type.to_str
+        resp.instance_variable_set(:@read, true)
+        resp.instance_variable_set(:@body, cr[:body])
+
+      end
+    end
+
+    def get_body(*args)
+      get(*args).body
+    end
+    
+    def get(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      
+      if accept = [(options[:accept] || '*/*')].flatten.compact
+        accept.each do |mt|
+          return canned_response(mt) || next
+        end
+        @resource.get(*args)
+       end
+    end
+
+    def method_missing(method, *args)
+      @resource.send(method, *args)
+    end
+    
+    protected
+    
+    def canned_response(mime_type)
+      mime_type = @canned_responses.keys.first if mime_type == '*/*'
+      @canned_responses[mime_type]
+    end
+    
+  end
+end