almodovar 0.5.6 → 0.6.0

data/vendor/resourceful-0.5.3-patched/lib/resourceful/request.rb

@@ -1,230 +0,0 @@
-require 'pathname'
-require 'benchmark'
-require 'resourceful/response'
-require 'resourceful/net_http_adapter'
-require 'resourceful/exceptions'
-
-module Resourceful
-
-  class Request
-
-    REDIRECTABLE_METHODS = [:get, :head]
-    CACHEABLE_METHODS = [:get, :head]
-    INVALIDATING_METHODS = [:post, :put, :delete]
-
-    attr_accessor :method, :resource, :body, :header
-    attr_reader   :request_time, :accessor
-
-    # @param [Symbol] http_method
-    #   :get, :put, :post, :delete or :head
-    # @param [Resourceful::Resource] resource
-    # @param [String] body
-    # @param [Resourceful::Header, Hash] header
-    def initialize(http_method, resource, body = nil, header = nil)
-      @method, @resource, @body = http_method, resource, body
-      @accessor = @resource.accessor
-      @header = header.is_a?(Resourceful::Header) ? header : Resourceful::Header.new(header)
-
-      # Resourceful handled gzip encoding transparently, so set that up
-      @header.accept_encoding ||= 'gzip, identity'
-
-      # 'Host' is a required HTTP/1.1 header, overrides Host in user-provided headers
-      @header.host = @resource.host
-
-      # Setting the date isn't a bad idea, either
-      @header.date ||= Time.now.httpdate
-
-      # Add any auth credentials we might want
-      add_credentials!
-
-    end
-
-    # Uses the auth manager to add any valid credentials to this request
-    def add_credentials!
-      @accessor.auth_manager.add_credentials(self)
-    end
-
-    # Performs all the work. Handles caching, redirects, auth retries, etc
-    def fetch_response
-      if cached_response
-        if needs_revalidation?(cached_response)
-          logger.info("    Cache needs revalidation")
-          set_validation_headers!(cached_response)
-        else
-          # We're done!
-          return cached_response
-        end
-      end
-
-      response = perform!
-
-      response = revalidate_cached_response(response) if cached_response && response.not_modified?
-      response = follow_redirect(response)            if should_be_redirected?(response)
-      response = retry_with_auth(response)            if needs_authorization?(response)
-
-      raise UnsuccessfulHttpRequestError.new(self, response) if response.error?
-
-      if cacheable?(response)
-        store_in_cache(response)
-      elsif invalidates_cache?
-        invalidate_cache
-      end
-
-      return response
-    end
-
-    # Should we look for a response to this request in the cache?
-    def skip_cache?
-      return true unless method.in? CACHEABLE_METHODS
-      header.cache_control && header.cache_control.include?('no-cache')
-    end
-
-    # The cached response
-    def cached_response
-      return if skip_cache?
-      return if @cached_response.nil? && @already_checked_cache
-      @cached_response ||= begin
-        @already_checked_cache = true
-        resp = accessor.cache_manager.lookup(self)
-        logger.info("    Retrieved from cache") if resp
-        resp
-      end
-    end
-
-    # Revalidate the cached response with what we got from a 304 response
-    def revalidate_cached_response(not_modified_response)
-      logger.info("    Resource not modified")
-      cached_response.revalidate!(not_modified_response)
-      cached_response
-    end
-
-    # Follow a redirect response
-    def follow_redirect(response)
-      raise MalformedServerResponse.new(self, response) unless response.header.location
-      if response.moved_permanently?
-        new_uri = response.header.location.first
-        logger.info("    Permanently redirected to #{new_uri} - Storing new location.")
-        resource.update_uri new_uri
-        @header.host = resource.host
-        response = fetch_response
-      elsif response.see_other? # Always use GET for this redirect, regardless of initial method
-        redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
-        response = Request.new(:get, redirected_resource, body, header).fetch_response
-      else
-        redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
-        logger.info("    Redirected to #{redirected_resource.uri} - Caching new location.")
-        response = Request.new(method, redirected_resource, body, header).fetch_response
-      end
-    end
-
-    # Add any auth headers from the response to the auth manager, and try the request again
-    def retry_with_auth(response)
-      @already_tried_with_auth = true
-      logger.info("Authentication Required. Retrying with auth info")
-      accessor.auth_manager.associate_auth_info(response)
-      add_credentials!
-      response = fetch_response
-    end
-
-    # Does this request need to be authorized? Will only be true if we haven't already tried with auth
-    def needs_authorization?(response)
-      !@already_tried_with_auth && response.unauthorized?
-    end
-
-    # Store the response to this request in the cache
-    def store_in_cache(response)
-      # RFC2618 - 14.18 : A received message that does not have a Date header 
-      # field MUST be assigned one by the recipient if the message will be cached 
-      # by that recipient.
-      response.header.date ||= response.response_time.httpdate
-
-      accessor.cache_manager.store(self, response) 
-    end
-
-    # Invalidated the cache for this uri (eg, after a POST)
-    def invalidate_cache
-      accessor.cache_manager.invalidate(resource.uri)
-    end
-
-    # Is this request & response permitted to be stored in this (private) cache?
-    def cacheable?(response)
-      return false unless response.success?
-      return false unless method.in? CACHEABLE_METHODS
-      return false if header.cache_control && header.cache_control.include?('no-store')
-      true
-    end
-
-    # Does this request invalidate the cache?
-    def invalidates_cache?
-      return true if method.in? INVALIDATING_METHODS
-    end
-
-    # Perform the request, with no magic handling of anything.
-    def perform!
-      @request_time = Time.now
-
-      http_resp = NetHttpAdapter.make_request(@method, @resource.uri, @body, @header)
-      @response = Resourceful::Response.new(uri, *http_resp)
-      @response.request_time = @request_time
-      @response.authoritative = true
-
-      @response
-    end
-
-    # Is this a response a redirect, and are we permitted to follow it?
-    def should_be_redirected?(response)
-      return false unless response.redirect?
-      if resource.on_redirect.nil?
-        return true if method.in? REDIRECTABLE_METHODS
-        false
-      else
-        resource.on_redirect.call(self, response)
-      end
-    end
-
-    # Do we need to revalidate our cache?
-    def needs_revalidation?(response)
-      return true if forces_revalidation?
-      return true if response.stale?
-      return true if max_age && response.current_age > max_age
-      return true if response.must_be_revalidated?
-      false
-    end
-
-    # Set the validation headers of a request based on the response in the cache
-    def set_validation_headers!(response)
-      @header['If-None-Match'] = response.header['ETag'] if response.header.has_key?('ETag')
-      @header['If-Modified-Since'] = response.header['Last-Modified'] if response.header.has_key?('Last-Modified')
-      @header['Cache-Control'] = 'max-age=0' if response.must_be_revalidated?    
-    end
-
-    # @return [String]   The URI against which this request will be, or was, made.
-    def uri
-      resource.uri
-    end
-
-    # Does this request force us to revalidate the cache?
-    def forces_revalidation?
-      if max_age == 0 || header.cache_control && cc.include?('no-cache')
-        logger.info("    Client forced revalidation")
-        true
-      else 
-        false
-      end
-    end
-
-    # Indicates the maxmimum response age in seconds we are willing to accept
-    #
-    # Returns nil if we don't care how old the response is
-    def max_age
-      if header['Cache-Control'] and header['Cache-Control'].include?('max-age')
-        header['Cache-Control'].split(',').grep(/max-age/).first.split('=').last.to_i
-      end
-    end
-
-    def logger
-      resource.logger
-    end
-  end
-
-end

data/vendor/resourceful-0.5.3-patched/lib/resourceful/resource.rb

@@ -1,165 +0,0 @@
-require 'pathname'
-require 'resourceful/request'
-
-module Resourceful
-
-  class Resource
-    attr_reader :accessor
-    attr_accessor :default_header
-
-    # 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
-
-    # Returns the host for this Resource's current uri
-    def host
-      parsed_uri = URI.parse(uri)
-      port_string = (parsed_uri.port == parsed_uri.default_port ? "" : ":#{parsed_uri.port}")
-      "#{parsed_uri.host}#{port_string}"
-    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
-
-    # :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 = {})
-      check_content_type_exists(data, 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 = {})
-      check_content_type_exists(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
-
-    private
-
-    # Ensures that the request has a content type header
-    # TODO Move this to request
-    def check_content_type_exists(body, header)
-      if body
-        raise MissingContentType unless header.has_key?(:content_type) or default_header.has_key?(:content_type)
-      end
-    end
-
-    # Actually make the request
-    def request(method, data, header)
-      log_request_with_time "#{method.to_s.upcase} [#{uri}]" do
-        request = Request.new(method, self, data, default_header.merge(header))
-        request.fetch_response
-      end
-    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/vendor/resourceful-0.5.3-patched/lib/resourceful/response.rb

@@ -1,221 +0,0 @@
-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 header['Cache-Control'].first.include?('max-age')
-        max_age = header['Cache-Control'].first.split(',').grep(/max-age/).first.split('=').last.to_i
-        return true if current_age > max_age
-      elsif header['Expire']
-        return true if Time.httpdate(header['Expire'].first) < Time.now
-      end
-
-      false
-    end
-
-    # Is this a cached response that is stale?
-    #
-    # @return true|false
-    def stale?
-      return true if expired?
-      if header['Cache-Control']
-        return true if header['Cache-Control'].include?('must-revalidate')
-        return true if header['Cache-Control'].include?('no-cache')
-      end
-
-      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
-      @authoritative = true
-    end
-
-    # Algorithm taken from RCF2616#13.2.3
-    def current_age
-      age_value   = header['Age'] ? header['Age'].first.to_i : 0
-      date_value  = Time.httpdate(header['Date'].first)
-      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
-      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