almodovar 0.5.6 → 0.6.0

data/lib/to_xml.rb

@@ -1,24 +0,0 @@
-require 'active_support/all'
-
-module Almodovar
-  
-  module ToXml
-    
-    def to_xml_with_links(options = {})
-      if options[:convert_links] && options[:builder]
-        options[:builder].tag!(:link, :rel => options[:root]) do
-          to_xml_without_links(options)
-        end
-      else
-        to_xml_without_links(options)
-      end
-    end
-    
-  end
-  
-end
-
-class Array
-  include Almodovar::ToXml
-  alias_method_chain :to_xml, :links
-end

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

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

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

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

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

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

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

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