almodovar 0.1.0 → 0.1.2

data/vendor/resourceful-0.5.3-patched/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Absolute-Performance, Inc
+Copyright (c) 2008 Peter Williams
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/resourceful-0.5.3-patched/Manifest

@@ -0,0 +1,29 @@
+lib/resourceful.rb
+lib/resourceful/net_http_adapter.rb
+lib/resourceful/stubbed_resource_proxy.rb
+lib/resourceful/header.rb
+lib/resourceful/memcache_cache_manager.rb
+lib/resourceful/response.rb
+lib/resourceful/util.rb
+lib/resourceful/options_interpreter.rb
+lib/resourceful/cache_manager.rb
+lib/resourceful/request.rb
+lib/resourceful/resource.rb
+lib/resourceful/exceptions.rb
+lib/resourceful/http_accessor.rb
+lib/resourceful/authentication_manager.rb
+README.markdown
+MIT-LICENSE
+Rakefile
+Manifest
+spec/simple_sinatra_server_spec.rb
+spec/old_acceptance_specs.rb
+spec/acceptance_shared_specs.rb
+spec/spec_helper.rb
+spec/simple_sinatra_server.rb
+spec/acceptance/authorization_spec.rb
+spec/acceptance/header_spec.rb
+spec/acceptance/resource_spec.rb
+spec/acceptance/caching_spec.rb
+spec/acceptance/redirecting_spec.rb
+spec/spec.opts

data/vendor/resourceful-0.5.3-patched/README.markdown

@@ -0,0 +1,84 @@
+Resourceful
+===========
+
+Resourceful provides a convenient Ruby API for making HTTP requests.
+
+Features:
+
+ * GET, PUT, POST and DELETE HTTP requests
+ * HTTP Basic and Digest authentication
+ * HTTP Caching with pluggable backends
+ * Follow redirects based on the results of a callback
+
+More Info
+=========
+ 
+ * Source: [Github](http://github.com/paul/resourceful/tree/master)
+ * Bug Tracking: [Lighthouse](http://resourceful.lighthouseapp.com)
+ * Project Page: [Rubyforge](http://rubyforge.org/projects/resourceful/)
+ * Documentation: [API Docs](http://resourceful.rubyforge.org)
+
+Examples
+========
+
+Getting started
+---------------
+
+    gem install resourceful
+
+Simplest example
+---------------
+
+    require 'resourceful'
+    http = Resourceful::HttpAccessor.new
+    resp = http.resource('http://rubyforge.org').get
+    puts resp.body
+
+Get a page requiring HTTP Authentication
+----------------------------------------
+
+    my_realm_authenticator = Resourceful::BasicAuthenticator.new('My Realm', 'admin', 'secret')
+    http = Resourceful::HttpAccessor.new(:authenticator => my_realm_authenticator)
+    resp = http.resource('http://example.com/').get
+    puts resp.body
+
+Redirection based on callback results
+-------------------------------------
+
+Resourceful will by default follow redirects on read requests (GET and HEAD), but not for 
+POST, etc. If you want to follow a redirect after a post, you will need to set the resource#on_redirect
+callback. If the callback evaluates to true, it will follow the redirect.
+
+    resource = http.resource('http://example.com/redirect_me')
+    resource.on_redirect { |req, resp| resp.header['Location'] =~ /example.com/ }
+    resource.get  # Will only follow the redirect if the new location is example.com
+
+Post a URL encoded form
+-----------------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     resp = http.resource('http://mysite.example/service').
+              post('hostname=test&level=super', :content_type => 'application/x-www-form-urlencoded')
+
+Put an XML document
+-------------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     resp = http.resource('http://mysite.example/service').
+              put('<?xml version="1.0"?><test/>', :content_type => 'application/xml')
+    
+Delete a resource
+-----------------
+
+     require 'resourceful'
+     http = Resourceful::HttpAccessor.new
+     resp = http.resource('http://mysite.example/service').delete
+
+
+Copyright
+---------
+
+Copyright (c) 2008 Absolute Performance, Inc, Peter Williams.  Released under the MIT License.
+

data/vendor/resourceful-0.5.3-patched/Rakefile

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'rake'
+require 'lib/resourceful'
+
+begin
+  require 'echoe'
+
+  Echoe.new('resourceful', Resourceful::VERSION) do |p|
+    p.description     = "An HTTP library for Ruby that takes advantage of everything HTTP has to offer."
+    p.url             = "http://github.com/paul/resourceful"
+    p.author          = "Paul Sadauskas"
+    p.email           = "psadauskas@gmail.com"
+
+    p.ignore_pattern  = ["pkg/*", "tmp/*"]
+    p.dependencies    = ['addressable', 'httpauth']
+    p.development_dependencies = ['thin', 'yard', 'sinatra', 'rspec']
+  end
+rescue LoadError => e
+  puts "install 'echoe' gem to be able to build the gem"
+end
+
+require 'spec/rake/spectask'
+
+desc 'Run all specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.libs << 'lib'
+  t.spec_files = FileList['spec/acceptance/*_spec.rb'] 
+end
+
+desc 'Run the specs for the server'
+Spec::Rake::SpecTask.new('spec:server') do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.libs << 'lib'
+  t.spec_files = FileList['spec/simple_sinatra_server_spec.rb'] 
+end
+
+begin 
+  require 'spec/simple_sinatra_server'
+  desc "Run the sinatra echo server, with loggin" 
+  task :server do
+    Sinatra::Default.set(
+      :run => true,
+      :logging => true
+    )
+  end
+rescue LoadError => e
+  puts "Install 'sinatra' gem to run the server"
+end
+
+desc 'Default: Run Specs'
+task :default => :spec
+
+desc 'Run all tests'
+task :test => :spec
+
+begin
+  require 'yard'
+
+  desc "Generate Yardoc"
+  YARD::Rake::YardocTask.new do |t|
+    t.files = ['lib/**/*.rb', 'README.markdown']
+  end
+rescue LoadError => e
+  puts "Install 'yard' gem to generate docs"
+end
+
+desc "Update rubyforge documentation"
+task :update_docs => :yardoc do
+  puts %x{rsync -aPz doc/* psadauskas@resourceful.rubyforge.org:/var/www/gforge-projects/resourceful/}
+end

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

@@ -0,0 +1,18 @@
+
+__DIR__ = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift __DIR__ unless
+  $LOAD_PATH.include?(__DIR__) ||
+  $LOAD_PATH.include?(File.expand_path(__DIR__))
+
+require 'resourceful/util'
+
+require 'resourceful/header'
+require 'resourceful/http_accessor'
+
+# Resourceful is a library that provides a high level HTTP interface.
+module Resourceful
+  VERSION = "0.5.3"
+  RESOURCEFUL_USER_AGENT_TOKEN = "Resourceful/#{VERSION}(Ruby/#{RUBY_VERSION})"
+
+end

data/vendor/resourceful-0.5.3-patched/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      => ::URI.parse(request.uri).request_uri).to_header
+    end
+
+  end
+
+
+end
+

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

@@ -0,0 +1,240 @@
+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 of a 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]
+      end if response.header['Vary']
+
+      header
+    end
+
+  end # class CacheEntry
+
+end