almodovar 0.1.0 → 0.1.2

data/vendor/resourceful-0.5.3-patched/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

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

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

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

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

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

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