almodovar 0.5.6 → 0.6.0

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

@@ -1,34 +0,0 @@
-
-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

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

@@ -1,126 +0,0 @@
-# A case-normalizing Hash, adjusting on [] and []=.
-# Shamelessly swiped from Rack
-module Resourceful
-  class Header < Hash
-    def initialize(hash={})
-      hash.each { |k, v| self[k] = v }
-    end
-
-    def to_hash
-      {}.replace(self)
-    end
-
-    def [](k)
-      super capitalize(k)
-    end
-
-    def []=(k, v)
-      super capitalize(k), v
-    end
-
-    def has_key?(k)
-      super capitalize(k)
-    end
-
-    def capitalize(k)
-      k.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }.gsub('_', '-')
-    end
-
-    def each_field(&blk)
-      to_hash.each { |k,v|
-        blk.call capitalize(k), v
-      }
-    end
-
-    HEADERS = %w[
-      Accept
-      Accept-Charset
-      Accept-Encoding
-      Accept-Language
-      Accept-Ranges
-      Age
-      Allow
-      Authorization
-      Cache-Control
-      Connection
-      Content-Encoding
-      Content-Language
-      Content-Length
-      Content-Location
-      Content-MD5
-      Content-Range
-      Content-Type
-      Date
-      ETag
-      Expect
-      Expires
-      From
-      Host
-      If-Match
-      If-Modified-Since
-      If-None-Match
-      If-Range
-      If-Unmodified-Since
-      Keep-Alive
-      Last-Modified
-      Location
-      Max-Forwards
-      Pragma
-      Proxy-Authenticate
-      Proxy-Authorization
-      Range
-      Referer
-      Retry-After
-      Server
-      TE
-      Trailer
-      Transfer-Encoding
-      Upgrade
-      User-Agent
-      Vary
-      Via
-      Warning
-      WWW-Authenticate
-    ]
-
-    HEADERS.each do |header|
-      const = header.upcase.gsub('-', '_')
-      meth  = header.downcase.gsub('-', '_')
-
-      class_eval <<-RUBY, __FILE__, __LINE__
-        #{const} = "#{header}".freeze    # ACCEPT = "accept".freeze
-
-        def #{meth}                      # def accept
-          self[#{const}]                 #   self[ACCEPT]
-        end                              # end
-
-        def #{meth}=(str)                # def accept=(str)
-          self[#{const}] = str           #   self[ACCEPT] = str
-        end                              # end
-      RUBY
-
-    end
-
-    HOP_BY_HOP_HEADERS = [
-      CONNECTION,
-      KEEP_ALIVE,
-      PROXY_AUTHENTICATE,
-      PROXY_AUTHORIZATION,
-      TE,
-      TRAILER,
-      TRANSFER_ENCODING,
-      UPGRADE
-    ].freeze
-
-    NON_MODIFIABLE_HEADERS = [
-      CONTENT_LOCATION,
-      CONTENT_MD5,
-      ETAG,
-      LAST_MODIFIED,
-      EXPIRES
-    ].freeze
-
-  end
-end
-
-

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

@@ -1,98 +0,0 @@
-require 'net/http'
-
-require 'resourceful/options_interpreter'
-require 'resourceful/authentication_manager'
-require 'resourceful/cache_manager'
-require 'resourceful/resource'
-require 'resourceful/stubbed_resource_proxy'
-
-module Resourceful
-  # This is an imitation Logger used when no real logger is
-  # registered.  This allows most of the code to assume that there
-  # is always a logger available, which significantly improved the
-  # readability of the logging related code.
-  class BitBucketLogger
-    def warn(*args); end
-    def info(*args); end
-    def debug(*args); end
-  end
-
-  # This is the simplest logger. It just writes everything to STDOUT.
-  class StdOutLogger
-    def warn(*args); puts args; end
-    def info(*args); puts args; end
-    def debug(*args); puts args; end
-  end
-  
-  # This class provides a simple interface to the functionality
-  # provided by the Resourceful library.  Conceptually this object
-  # acts a collection of all the resources available via HTTP.
-  class HttpAccessor
-    
-    # A logger object to which messages about the activities of this
-    # object will be written.  This should be an object that responds
-    # to +#info(message)+ and +#debug(message)+.  
-    #
-    # Errors will not be logged.  Instead an exception will be raised
-    # and the application code should log it if appropriate.
-    attr_accessor :logger, :cache_manager
-    
-    attr_reader :auth_manager
-    attr_reader :user_agent_tokens  
-    
-    INIT_OPTIONS = OptionsInterpreter.new do 
-      option(:logger, :default => Resourceful::BitBucketLogger.new)
-      option(:user_agent, :default => []) {|ua| [ua].flatten}
-      option(:cache_manager, :default => NullCacheManager.new)
-      option(:authenticator)
-      option(:authenticators, :default => [])
-    end
-    
-    # Initializes a new HttpAccessor.  Valid options:
-    #
-    #  +:logger+:: A Logger object that the new HTTP accessor should
-    #    send log messages
-    #
-    #  +:user_agent+:: One or more additional user agent tokens to
-    #    added to the user agent string.
-    #
-    #  +:cache_manager+:: The cache manager this accessor should use.
-    #
-    #  +:authenticator+:: Add a single authenticator for this accessor.
-    #
-    #  +:authenticators+:: Enumerable of the authenticators for this
-    #    accessor.
-    def initialize(options = {})
-      @user_agent_tokens = [RESOURCEFUL_USER_AGENT_TOKEN]
-      
-      INIT_OPTIONS.interpret(options) do |opts|
-        @user_agent_tokens.push(*opts[:user_agent].reverse)
-        self.logger = opts[:logger]
-        @auth_manager = AuthenticationManager.new()
-        @cache_manager = opts[:cache_manager]
-        
-        add_authenticator(opts[:authenticator]) if opts[:authenticator]
-        opts[:authenticators].each { |a| add_authenticator(a) }
-      end     
-    end
-    
-    # Returns the string that identifies this HTTP accessor.  If you
-    # want to add a token to the user agent string simply add the new
-    # token to the end of +#user_agent_tokens+.
-    def user_agent_string
-      user_agent_tokens.reverse.join(' ')
-    end
-    
-    # Returns a resource object representing the resource indicated
-    # by the specified URI.  A resource object will be created if necessary.
-    def resource(uri, opts = {})
-      resource = Resource.new(self, uri, opts)
-    end
-    alias [] resource
-
-    # Adds an Authenticator to the set used by the accessor.
-    def add_authenticator(an_authenticator)
-      auth_manager.add_auth_handler(an_authenticator)
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-require "resourceful/cache_manager"
-
-require 'memcache'
-
-module Resourceful
-  class MemcacheCacheManager < AbstractCacheManager
-  
-    # Create a new Memcached backed cache manager
-    #
-    # @param [*String] memcache_servers  
-    #   list of all Memcached servers this cache manager should use.
-    def initialize(*memcache_servers)
-      @memcache = MemCache.new(memcache_servers, :multithread => true)
-    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, nil] 
-    #   A (possibly stale) response for the request provided or nil if 
-    #   no matching response is found.
-    def lookup(request)
-      resp = cache_entries_for(request)[request]
-      return if resp.nil?
-
-      resp.authoritative = false
-
-      resp
-    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 [Resourceful::Request] request
-    #   The request used to obtain the response. This is needed so the 
-    #   values from the response's Vary header can be stored.
-    # @param [Resourceful::Response] response
-    #   The response to be stored.
-    def store(request, response)
-      return unless response.cachable?
-
-      entries = cache_entries_for(request)
-      entries[request] = response
-
-      @memcache[request.to_mc_key] = entries
-    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 [String] uri
-    #   The uri of the resource to be invalidated
-    def invalidate(uri)
-      @memcache.delete(uri_hash(uri))
-    end
-
-
-    private 
-
-    ##
-    # The memcache proxy.
-    attr_reader :memcache
-
-    def cache_entries_for(a_request)
-      @memcache.get(uri_hash(a_request.uri)) || Resourceful::CacheEntryCollection.new
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-require 'net/http'
-require 'net/https'
-require 'addressable/uri'
-
-require 'pathname'
-require 'resourceful/header'
-
-module Addressable
-  class URI
-    def absolute_path
-      absolute_path = ""
-      absolute_path << self.path.to_s
-      absolute_path << "?#{self.query}" if self.query != nil
-      absolute_path << "##{self.fragment}" if self.fragment != nil
-      return absolute_path
-    end
-  end
-end
-
-module Resourceful
-
-  class NetHttpAdapter
-    # Make an HTTP request using the standard library net/http.
-    #
-    # Will use a proxy defined in the http_proxy environment variable, if set.
-    def self.make_request(method, uri, body = nil, header = nil)
-      uri = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
-
-      req = net_http_request_class(method).new(uri.absolute_path)
-      header.each_field { |k,v| req[k] = v } if header
-      https = ("https" == uri.scheme)
-      conn = Net::HTTP.Proxy(*proxy_details).new(uri.host, uri.port || (https ? 443 : 80))
-      conn.use_ssl = https
-      begin 
-        conn.start
-        res = conn.request(req, body)
-      ensure
-        conn.finish if conn.started?
-      end
-
-      [ Integer(res.code),
-        Resourceful::Header.new(res.header.to_hash),
-        res.body
-      ]
-    ensure
-      
-    end
-
-    private
-
-    # Parse proxy details from http_proxy environment variable
-    def self.proxy_details
-      proxy = Addressable::URI.parse(ENV["http_proxy"])
-      [proxy.host, proxy.port, proxy.user, proxy.password] if proxy
-    end
-
-    def self.net_http_request_class(method)
-      case method
-      when :get     then Net::HTTP::Get
-      when :head    then Net::HTTP::Head
-      when :post    then Net::HTTP::Post
-      when :put     then Net::HTTP::Put
-      when :delete  then Net::HTTP::Delete
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,78 +0,0 @@
-require 'set'
-
-module Resourceful
-  # Class that supports a declarative way to pick apart an options
-  # hash.
-  #
-  #     OptionsInterpreter.new do 
-  #       option(:accept) { |accept| [accept].flatten.map{|m| m.to_str} }
-  #       option(:http_header_fields, :default => {})
-  #     end.interpret(:accept => 'this/that')
-  #     # => {:accept => ['this/that'], :http_header_fields => { } }
-  #
-  # The returned hash contains :accept with the pass accept option
-  # value transformed into an array and :http_header_fields with its
-  # default value.
-  #     
-  #     OptionsInterpreter.new do 
-  #       option(:max_redirects)
-  #     end.interpret(:foo => 1, :bar => 2)
-  #     # Raises ArgumentError: Unrecognized options: foo, bar
-  #
-  # If options are passed that are not defined an exception is raised.
-  #
-  class OptionsInterpreter
-    def self.interpret(options_hash, &block)
-      interpreter = self.new(options_hash)
-      interpreter.instance_eval(&block)
-      
-      interpreter.interpret
-    end      
-    
-    def initialize(&block)
-      @handlers = Hash.new
-      
-      instance_eval(&block) if block_given?
-    end
-    
-    def interpret(options_hash, &block) 
-      unless (unrecognized_options = (options_hash.keys - supported_options)).empty?
-        raise ArgumentError, "Unrecognized options: #{unrecognized_options.join(", ")}"
-      end
-      
-      options = Hash.new
-      handlers.each do |opt_name, a_handler|
-        opt_val = a_handler.call(options_hash)
-        options[opt_name] = opt_val if opt_val
-      end
-      
-      yield(options) if block_given?
-      
-      options
-    end
-    
-    def option(name, opts = {}, &block)
-
-      passed_value_fetcher = if opts[:default] 
-                               default_value = opts[:default]
-                               lambda{|options_hash| options_hash[name] || default_value}
-                             else
-                               lambda{|options_hash| options_hash[name]}
-                             end
-      
-      handlers[name] = if block_given?
-                         lambda{|options_hash| (val = passed_value_fetcher.call(options_hash)) ? block.call(val) : nil}
-                       else
-                         passed_value_fetcher
-                       end
-    end
-    
-    def supported_options
-      handlers.keys
-    end
-    
-    private
-    
-    attr_reader :handlers
-  end
-end