abiquo-etk 0.4.13

data/vendor/resourceful-1.0.1/lib/resourceful/abstract_form_data.rb

@@ -0,0 +1,18 @@
+module Resourceful
+  class AbstractFormData
+    def initialize(contents = {})
+      @form_data = []
+      
+      contents.each do |k,v|
+        add(k, v)
+      end
+    end
+
+    def add(name, value)
+      form_data << [name.to_s, value]
+    end
+
+    protected
+    attr_reader :form_data
+  end
+end

data/vendor/resourceful-1.0.1/lib/resourceful/authentication_manager.rb

@@ -0,0 +1,108 @@
+#require 'rubygems'
+require 'httpauth'
+require 'addressable/uri'
+
+module Resourceful
+
+  class AuthenticationManager
+    def initialize
+      @authenticators = []
+    end
+
+    def add_auth_handler(authenticator)
+      @authenticators << authenticator
+    end
+
+    def associate_auth_info(challenge)
+      @authenticators.each do |authenticator|
+        authenticator.update_credentials(challenge) if authenticator.valid_for?(challenge)
+      end
+    end
+
+    def add_credentials(request)
+      @authenticators.each do |authenticator|
+        authenticator.add_credentials_to(request) if authenticator.can_handle?(request)
+      end
+    end
+
+  end
+
+  class BasicAuthenticator
+
+    def initialize(realm, username, password)
+      @realm, @username, @password = realm, username, password
+      @domain = nil
+    end
+
+    def valid_for?(challenge_response)
+      return false unless challenge_response.header['WWW-Authenticate']
+
+      !challenge_response.header['WWW-Authenticate'].grep(/^\s*basic/i).find do |a_challenge|
+        @realm.downcase == /realm="([^"]+)"/i.match(a_challenge)[1].downcase
+      end.nil?
+    end
+
+    def update_credentials(challenge)
+      @domain = Addressable::URI.parse(challenge.uri).host
+    end
+
+    def can_handle?(request)
+      Addressable::URI.parse(request.uri).host == @domain
+    end
+
+    def add_credentials_to(request)
+      request.header['Authorization'] = credentials
+    end
+
+    def credentials
+      HTTPAuth::Basic.pack_authorization(@username, @password)
+    end
+
+  end
+
+  class DigestAuthenticator
+
+    attr_reader :username, :password, :realm, :domain, :challenge
+
+    def initialize(realm, username, password)
+      @realm = realm
+      @username, @password = username, password
+      @domain = nil
+    end
+
+    def update_credentials(challenge_response)
+      @domain = Addressable::URI.parse(challenge_response.uri).host
+      @challenge = HTTPAuth::Digest::Challenge.from_header(challenge_response.header['WWW-Authenticate'].first)
+    end
+
+    def valid_for?(challenge_response)
+      return false unless challenge_header = challenge_response.header['WWW-Authenticate']
+      begin
+        challenge = HTTPAuth::Digest::Challenge.from_header(challenge_header.first)
+      rescue HTTPAuth::UnwellformedHeader
+        return false
+      end
+      challenge.realm == @realm
+    end
+
+    def can_handle?(request)
+      Addressable::URI.parse(request.uri).host == @domain
+    end
+
+    def add_credentials_to(request)
+      request.header['Authorization'] = credentials_for(request)
+    end
+
+    def credentials_for(request)
+      HTTPAuth::Digest::Credentials.from_challenge(@challenge, 
+                                                   :username => @username,
+                                                   :password => @password,
+                                                   :method   => request.method.to_s.upcase,
+                                                   :uri      => Addressable::URI.parse(request.uri).path).to_header
+    end
+
+  end
+
+
+end
+

data/vendor/resourceful-1.0.1/lib/resourceful/cache_manager.rb

@@ -0,0 +1,242 @@
+require 'resourceful/header'
+require 'digest/md5'
+
+module Resourceful
+
+  class AbstractCacheManager
+    def initialize
+      raise NotImplementedError,
+        "Use one of CacheManager's child classes instead. Try NullCacheManager if you don't want any caching at all."
+    end
+
+    # Finds a previously cached response to the provided request.  The
+    # response returned may be stale.
+    #
+    # @param [Resourceful::Request] request 
+    #   The request for which we are looking for a response.
+    #
+    # @return [Resourceful::Response] 
+    #   A (possibly stale) response for the request provided.
+    def lookup(request); end
+    
+    # Store a response in the cache. 
+    #
+    # This method is smart enough to not store responses that cannot be 
+    # cached (Vary: * or Cache-Control: no-cache, private, ...)
+    #
+    # @param request<Resourceful::Request>
+    #   The request used to obtain the response. This is needed so the 
+    #   values from the response's Vary header can be stored.
+    # @param response<Resourceful::Response>
+    #   The response to be stored.
+    def store(request, response); end
+
+    # Invalidates a all cached entries for a uri. 
+    #
+    # This is used, for example, to invalidate the cache for a resource 
+    # that gets POSTed to.
+    #
+    # @param uri<String>
+    #   The uri of the resource to be invalidated
+    def invalidate(uri); end
+
+    protected
+
+    # Returns an alphanumeric hash of a URI
+    def uri_hash(uri)
+      Digest::MD5.hexdigest(uri)
+    end
+  end
+
+  # This is the default cache, and does not do any caching. All lookups
+  # result in nil, and all attempts to store a response are a no-op.
+  class NullCacheManager < AbstractCacheManager
+    def initialize; end
+
+    def lookup(request)
+      nil
+    end
+
+    def store(request, response); end
+  end
+
+  # This is a nieve implementation of caching. Unused entries are never
+  # removed, and this may eventually eat up all your memory and cause your
+  # machine to explode.
+  class InMemoryCacheManager < AbstractCacheManager
+
+    def initialize
+      @collection = Hash.new{ |h,k| h[k] = CacheEntryCollection.new}
+    end
+
+    def lookup(request)
+      response = @collection[request.uri.to_s][request]
+      response.authoritative = false if response
+      response
+    end
+
+    def store(request, response)
+      return unless response.cacheable?
+
+      @collection[request.uri.to_s][request] = response
+    end
+
+    def invalidate(uri)
+      @collection.delete(uri)
+    end
+  end  # class InMemoryCacheManager
+
+  # Stores cache entries in a directory on the filesystem. Similarly to the 
+  # InMemoryCacheManager there are no limits on storage, so this will eventually 
+  # eat up all your disk!
+  class FileCacheManager < AbstractCacheManager
+    # Create a new FileCacheManager
+    #
+    # @param [String] location
+    #   A directory on the filesystem to store cache entries. This directory
+    #   will be created if it doesn't exist
+    def initialize(location="/tmp/resourceful")
+      require 'fileutils'
+      require 'yaml'
+      @dir = FileUtils.mkdir_p(location)
+    end
+
+    def lookup(request)
+      response = cache_entries_for(request)[request]
+      response.authoritative = false if response
+      response
+    end
+
+    def store(request, response)
+      return unless response.cacheable?
+
+      entries = cache_entries_for(request)
+      entries[request] = response
+      File.open(cache_file(request.uri), "w") {|fh| fh.write( YAML.dump(entries) ) }
+    end
+
+    def invalidate(uri);
+      File.unlink(cache_file(uri));
+    end
+
+    private
+    
+    def cache_entries_for(request)
+      if File.readable?( cache_file(request.uri) )
+        YAML.load_file( cache_file(request.uri) )
+      else
+        Resourceful::CacheEntryCollection.new
+      end
+    end
+
+    def cache_file(uri)
+      "#{@dir}/#{uri_hash(uri)}"
+    end
+  end # class FileCacheManager
+
+  
+  # The collection of cached entries.  Nominally all the entry in a
+  # collection of this sort will be for the same resource but that is
+  # not required to be true.
+  class CacheEntryCollection
+    include Enumerable
+    
+    def initialize
+      @entries = []
+    end
+    
+    # Iterates over the entries. Needed for Enumerable
+    def each(&block)
+      @entries.each(&block)
+    end
+    
+    # Looks for an Entry that could fullfil the request. Returns nil if none
+    # was found.
+    #
+    # @param [Resourceful::Request] request
+    #   The request to use for the lookup.
+    #
+    # @return [Resourceful::Response] 
+    #   The cached response for the specified request if one is available.
+    def [](request)
+      entry = find { |entry| entry.valid_for?(request) }
+      entry.response if entry
+    end
+    
+    # Saves an entry into the collection. Replaces any existing ones that could 
+    # be used with the updated response.
+    #
+    # @param [Resourceful::Request] request
+    #   The request that was used to obtain the response
+    # @param [Resourceful::Response] response
+    #   The cache_entry generated from response that was obtained.
+    def []=(request, response)
+      @entries.delete_if { |e| e.valid_for?(request) }
+      @entries << CacheEntry.new(request, response)
+
+      response
+    end
+  end # class CacheEntryCollection
+
+  # Represents a previous request and cached response with enough
+  # detail to determine construct a cached response to a matching
+  # request in the future.  It also understands what a matching
+  # request means.
+  class CacheEntry
+    # request_vary_headers is a HttpHeader with keys from the Vary
+    # header of the response, plus the values from the matching fields
+    # in the request
+    attr_reader :request_vary_headers
+    
+    # The time at which the client believes the request was made.
+    attr_reader :request_time
+
+    # The URI of the request
+    attr_reader :request_uri
+
+    # The response to that we are caching
+    attr_reader :response
+
+    # @param [Resourceful::Request] request
+    #   The request whose response we are storing in the cache.
+    # @param response<Resourceful::Response>
+    #   The Response obhect to be stored.
+    def initialize(request, response)
+      @request_uri = request.uri
+      @request_time = request.request_time
+      @request_vary_headers = select_request_headers(request, response)
+      @response = response
+    end
+
+    # Returns true if this entry may be used to fullfil the given request, 
+    # according to the vary headers.
+    #
+    # @param request<Resourceful::Request>
+    #   The request to do the lookup on. 
+    def valid_for?(request)
+      request.uri == @request_uri and 
+        @request_vary_headers.all? {|key, value| 
+          request.header[key] == value
+        }
+    end
+
+    # Selects the headers from the request named by the response's Vary header
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.6
+    #
+    # @param [Resourceful::Request] request
+    #   The request used to obtain the response.
+    # @param [Resourceful::Response] response
+    #   The response obtained from the request.
+    def select_request_headers(request, response)
+      header = Resourceful::Header.new
+
+      response.header['Vary'].each do |name|
+        header[name] = request.header[name] if request.header[name]
+      end if response.header['Vary']
+
+      header
+    end
+
+  end # class CacheEntry
+
+end

data/vendor/resourceful-1.0.1/lib/resourceful/exceptions.rb

@@ -0,0 +1,34 @@
+
+module Resourceful
+
+  # This exception used to indicate that the request did not succeed.
+  # The HTTP response is included so that the appropriate actions can
+  # be taken based on the details of that response
+  class UnsuccessfulHttpRequestError < Exception
+    attr_reader :http_response, :http_request
+ 
+    # Initialize new error from the HTTP request and response attributes.
+    def initialize(http_request, http_response)
+      super("#{http_request.method} request to <#{http_request.uri}> failed with code #{http_response.code}")
+      @http_request = http_request
+      @http_response = http_response
+    end
+  end
+
+  class MalformedServerResponse < UnsuccessfulHttpRequestError
+  end
+      
+
+  # Exception indicating that the server used a content coding scheme
+  # that Resourceful is unable to handle.
+  class UnsupportedContentCoding < Exception
+  end
+
+  # Raised when a body is supplied, but not a content-type header
+  class MissingContentType < ArgumentError
+    def initialize
+      super("A Content-Type must be specified when an entity-body is supplied.")
+    end
+  end
+
+end