almodovar 0.1.0 → 0.1.2

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

@@ -0,0 +1,47 @@
+require 'resourceful/resource'
+  
+module Resourceful
+  class StubbedResourceProxy
+    def initialize(resource, canned_responses)
+      @resource = resource
+      
+      @canned_responses = {}
+      
+      canned_responses.each do |cr| 
+        mime_type = cr[:mime_type]
+        @canned_responses[mime_type] = resp = Net::HTTPOK.new('1.1', '200', 'OK')
+        resp['content-type'] = mime_type.to_str
+        resp.instance_variable_set(:@read, true)
+        resp.instance_variable_set(:@body, cr[:body])
+
+      end
+    end
+
+    def get_body(*args)
+      get(*args).body
+    end
+    
+    def get(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      
+      if accept = [(options[:accept] || '*/*')].flatten.compact
+        accept.each do |mt|
+          return canned_response(mt) || next
+        end
+        @resource.get(*args)
+       end
+    end
+
+    def method_missing(method, *args)
+      @resource.send(method, *args)
+    end
+    
+    protected
+    
+    def canned_response(mime_type)
+      mime_type = @canned_responses.keys.first if mime_type == '*/*'
+      @canned_responses[mime_type]
+    end
+    
+  end
+end

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

@@ -0,0 +1,6 @@
+
+class Object
+  def in?(arr)
+    arr.include?(self)
+  end
+end

data/vendor/resourceful-0.5.3-patched/resourceful.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{resourceful}
+  s.version = "0.5.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Sadauskas"]
+  s.date = %q{2009-07-15}
+  s.description = %q{An HTTP library for Ruby that takes advantage of everything HTTP has to offer.}
+  s.email = %q{psadauskas@gmail.com}
+  s.extra_rdoc_files = ["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"]
+  s.files = ["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", "resourceful.gemspec"]
+  s.homepage = %q{http://github.com/paul/resourceful}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Resourceful", "--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{resourceful}
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{An HTTP library for Ruby that takes advantage of everything HTTP has to offer.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<addressable>, [">= 0"])
+      s.add_runtime_dependency(%q<httpauth>, [">= 0"])
+      s.add_development_dependency(%q<thin>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<sinatra>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<addressable>, [">= 0"])
+      s.add_dependency(%q<httpauth>, [">= 0"])
+      s.add_dependency(%q<thin>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<addressable>, [">= 0"])
+    s.add_dependency(%q<httpauth>, [">= 0"])
+    s.add_dependency(%q<thin>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/vendor/resourceful-0.5.3-patched/spec/acceptance/authorization_spec.rb

@@ -0,0 +1,16 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe "basic auth" do
+
+  end
+
+  describe "digest auth" do
+
+  end
+
+end
+

data/vendor/resourceful-0.5.3-patched/spec/acceptance/caching_spec.rb

@@ -0,0 +1,192 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+require 'addressable/template'
+
+describe Resourceful do
+
+  describe "caching" do
+
+    before do
+      @http = Resourceful::HttpAccessor.new(:cache_manager => Resourceful::InMemoryCacheManager.new)
+      if ENV['SPEC_LOGGING']
+        @http.logger = Resourceful::StdOutLogger.new
+      end
+    end
+
+    def get_with_errors(resource)
+      begin
+        resp = resource.get
+      rescue Resourceful::UnsuccessfulHttpRequestError => e
+        resp = e.http_response
+      end
+      resp
+    end
+
+    def uri_plus_params(uri, params = {})
+      uri = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
+      uri.query_values = params
+      uri
+    end
+
+    def uri_for_code(code, params = {})
+      template = Addressable::Template.new("http://localhost:3000/code/{code}")
+      uri = template.expand("code" => code.to_s)
+
+      uri_plus_params(uri, params)
+    end
+
+    describe "response cacheability" do
+      Resourceful::Response::NORMALLY_CACHEABLE_RESPONSE_CODES.each do |code|
+        describe "response code #{code}" do
+          it "should normally be cached" do
+            resource = @http.resource(uri_for_code(code))
+
+            resp = get_with_errors(resource)
+            resp.should be_cacheable
+          end
+
+          it "should not be cached if Vary: *" do
+            resource = @http.resource(uri_for_code(200, "Vary" => "*"))
+
+            resp = get_with_errors(resource)
+            resp.should_not be_cacheable
+          end
+
+          it "should not be cached if Cache-Control: no-cache'" do
+            resource = @http.resource(uri_for_code(200, "Cache-Control" => "no-cache"))
+
+            resp = get_with_errors(resource)
+            resp.should_not be_cacheable
+          end
+        end
+      end
+
+      # I would prefer to do all other codes, but some of them do some magic stuff (100),
+      # so I'll just spot check. 
+      [201, 206, 302, 307, 404, 500].each do |code|
+        describe "response code #{code}" do
+          it "should not normally be cached" do
+            resource = @http.resource(uri_for_code(code))
+
+            resp = get_with_errors(resource)
+            resp.should_not be_cacheable
+          end
+          
+          it "should be cached if Cache-Control: public" do
+            resource = @http.resource(uri_for_code(code, "Cache-Control" => "public"))
+
+            resp = get_with_errors(resource)
+            resp.should be_cacheable
+          end
+
+          it "should be cached if Cache-Control: private" do
+            resource = @http.resource(uri_for_code(code, "Cache-Control" => "private"))
+
+            resp = get_with_errors(resource)
+            resp.should be_cacheable
+          end
+        end
+      end
+
+    end
+
+    describe "expiration" do
+      it 'should use the cached response if Expire: is in the future' do
+        in_the_future = (Time.now + 60).httpdate
+        resource = @http.resource(uri_for_code(200, "Expire" => in_the_future))
+
+        resp = resource.get
+        resp.should_not be_expired
+
+        resp = resource.get
+        resp.should be_ok
+        resp.should_not be_authoritative
+      end
+
+      it 'should revalidate the cached response if the response is expired' do
+        in_the_past = (Time.now - 60).httpdate
+        resource = @http.resource(uri_for_code(200, "Expire" => in_the_past))
+
+        resp = resource.get
+        resp.should be_expired
+
+        resp = resource.get
+        resp.should be_ok
+        resp.should be_authoritative
+      end
+    end
+
+    describe 'authoritative' do
+
+      it "should be authoritative if the response is directly from the server" do
+        resource = @http.resource(
+          uri_plus_params('http://localhost:3000/', "Cache-Control" => 'max-age=10')
+        )
+
+        response  = resource.get
+        response.should be_authoritative
+      end
+
+      it "should be authoritative if a cached response was revalidated with the server" do
+        now = Time.now.httpdate
+        resource = @http.resource(
+          uri_plus_params('http://localhost:3000/cached', 
+                          "modified" => now, 
+                          "Cache-Control" => 'max-age=0')
+        )
+
+        resource.get
+        response = resource.get("Cache-Control" => "max-age=0")
+        response.should be_authoritative
+      end
+
+      it "should not be authoritative if the cached response was not revalidated" do
+        now = Time.now.httpdate
+        resource = @http.resource(
+          uri_plus_params('http://localhost:3000/cached', 
+                          "modified" => now, 
+                          "Cache-Control" => 'max-age=10')
+        )
+
+        resource.get
+        response = resource.get
+        response.should_not be_authoritative
+
+      end
+
+    end
+    
+    describe "Not Modified responses" do
+      before do
+        now = Time.now.httpdate
+
+        resource = @http.resource(
+          uri_plus_params('http://localhost:3000/cached', 
+                          "modified" => now, 
+                          "Cache-Control" => 'max-age=0')
+        )
+
+        @first_response  = resource.get
+        @second_response = resource.get("Cache-Control" => "max-age=0") # Force revalidation
+      end
+
+      it "should replace the 304 response with whats in the cache" do
+        @second_response.code.should == @first_response.code
+      end
+
+      it "should provide a body identical to the original response" do
+        @second_response.body.should == @first_response.body
+      end
+
+      it "should override any cached headers with new ones"
+    end
+
+    describe "cache invalidation" do
+
+    end
+
+  end
+
+end
+

data/vendor/resourceful-0.5.3-patched/spec/acceptance/header_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe 'setting headers' do
+    before do
+      @http = Resourceful::HttpAccessor.new
+      @resource = @http.resource("http://localhost:3000/header")
+    end
+
+    it 'should handle "Content-Type"' do
+      resp = @resource.post("asdf", :content_type => 'foo/bar')
+
+      header = YAML.load(resp.body)
+
+      header.should have_key('CONTENT_TYPE')
+      header['CONTENT_TYPE'].should == 'foo/bar'
+
+    end
+
+  end
+end
+

data/vendor/resourceful-0.5.3-patched/spec/acceptance/redirecting_spec.rb

@@ -0,0 +1,12 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe "redirects" do
+
+  end
+
+end
+

data/vendor/resourceful-0.5.3-patched/spec/acceptance/resource_spec.rb

@@ -0,0 +1,84 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe "working with a resource" do
+    before do 
+      @http = Resourceful::HttpAccessor.new
+      @resource = @http.resource('http://localhost:3000/')
+    end
+
+    it 'should make the original uri available' do 
+      @resource.effective_uri.should == 'http://localhost:3000/'
+      @resource.uri.should == 'http://localhost:3000/'
+    end
+
+    it 'should set the user agent string on the default header' do
+      @resource.default_header.should have_key('User-Agent')
+      @resource.default_header['User-Agent'].should == Resourceful::RESOURCEFUL_USER_AGENT_TOKEN
+    end
+
+    describe "GET" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.get
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+    end
+
+    describe "POST" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.post
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+      it "should require Content-Type be set if a body is provided" do
+        lambda {
+          @resource.post("some text")
+        }.should raise_error(Resourceful::MissingContentType)
+      end
+
+    end
+
+    describe "PUT" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.put(nil)
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+      it "should require Content-Type be set if a body is provided" do
+        lambda {
+          @resource.put("some text")
+        }.should raise_error(Resourceful::MissingContentType)
+      end
+
+      it "should require an entity-body to be set" do
+        lambda {
+          @resource.put()
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should allow the entity-body to be nil" do
+        lambda {
+          @resource.put(nil)
+        }.should_not raise_error(ArgumentError)
+      end
+    end
+
+    describe "DELETE" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.delete
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+    end
+
+    
+  end
+end

data/vendor/resourceful-0.5.3-patched/spec/acceptance_shared_specs.rb

@@ -0,0 +1,44 @@
+describe 'redirect', :shared => true do
+  it 'should be followed by default on GET' do
+    resp = @resource.get
+    resp.should be_instance_of(Resourceful::Response)
+    resp.should be_ok
+    resp.header['Content-Type'].should == ['text/plain']
+  end
+
+  %w{PUT POST}.each do |method|
+    it "should not be followed by default on #{method}" do
+      resp = @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
+      resp.should be_redirect
+    end
+
+    it "should redirect on #{method.to_s.upcase} if the redirection callback returns true" do
+      @resource.on_redirect { true }
+      resp = @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
+      resp.should be_ok
+    end
+
+    it "should not follow redirect on #{method.to_s.upcase} if the redirection callback returns false" do
+      @resource.on_redirect { false }
+      resp = @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
+      resp.should be_redirect
+    end
+  end
+
+  it "should not be followed by default on DELETE" do
+    resp = @resource.delete
+    resp.should be_redirect
+  end
+
+  it "should redirect on DELETE if vthe redirection callback returns true" do
+    @resource.on_redirect { true }
+    resp = @resource.delete
+    resp.should be_ok
+  end
+
+  it "should not redirect on DELETE if the redirection callback returns false" do
+    resp = @resource.delete
+    resp.should be_redirect
+  end
+end
+