abiquo-etk 0.4.13

data/vendor/resourceful-1.0.1/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-1.0.1/lib/resourceful/urlencoded_form_data.rb

@@ -0,0 +1,17 @@
+require 'resourceful/abstract_form_data'
+require 'cgi'
+
+module Resourceful
+  class UrlencodedFormData < AbstractFormData
+
+    def content_type
+      "application/x-www-form-urlencoded"
+    end
+
+    def read
+      @form_data.map do |k,v|
+        CGI.escape(k) + '=' + CGI.escape(v)
+      end.join('&')
+    end
+  end
+end

data/vendor/resourceful-1.0.1/lib/resourceful/util.rb

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

data/vendor/resourceful-1.0.1/lib/resourceful.rb

@@ -0,0 +1,26 @@
+
+__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'
+require 'resourceful/simple'
+
+module Resourceful
+  autoload :MultipartFormData, 'resourceful/multipart_form_data'
+  autoload :UrlencodedFormData, 'resourceful/urlencoded_form_data'
+  autoload :StubbedResourceProxy, 'resourceful/stubbed_resource_proxy'
+
+  extend Simple
+end
+
+# Resourceful is a library that provides a high level HTTP interface.
+module Resourceful
+  VERSION = "1.0.1"
+  RESOURCEFUL_USER_AGENT_TOKEN = "Resourceful/#{VERSION}(Ruby/#{RUBY_VERSION})"
+end

data/vendor/resourceful-1.0.1/resourceful.gemspec

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{resourceful}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Sadauskas"]
+  s.date = %q{2010-01-26}
+  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 = ["README.markdown", "lib/resourceful.rb", "lib/resourceful/abstract_form_data.rb", "lib/resourceful/authentication_manager.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/exceptions.rb", "lib/resourceful/header.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/memcache_cache_manager.rb", "lib/resourceful/multipart_form_data.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/request.rb", "lib/resourceful/resource.rb", "lib/resourceful/response.rb", "lib/resourceful/simple.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/urlencoded_form_data.rb", "lib/resourceful/util.rb"]
+  s.files = ["History.txt", "MIT-LICENSE", "Manifest", "README.markdown", "Rakefile", "lib/resourceful.rb", "lib/resourceful/abstract_form_data.rb", "lib/resourceful/authentication_manager.rb", "lib/resourceful/cache_manager.rb", "lib/resourceful/exceptions.rb", "lib/resourceful/header.rb", "lib/resourceful/http_accessor.rb", "lib/resourceful/memcache_cache_manager.rb", "lib/resourceful/multipart_form_data.rb", "lib/resourceful/net_http_adapter.rb", "lib/resourceful/request.rb", "lib/resourceful/resource.rb", "lib/resourceful/response.rb", "lib/resourceful/simple.rb", "lib/resourceful/stubbed_resource_proxy.rb", "lib/resourceful/urlencoded_form_data.rb", "lib/resourceful/util.rb", "resourceful.gemspec", "spec/acceptance/authorization_spec.rb", "spec/acceptance/caching_spec.rb", "spec/acceptance/header_spec.rb", "spec/acceptance/redirecting_spec.rb", "spec/acceptance/resource_spec.rb", "spec/acceptance/resourceful_spec.rb", "spec/acceptance_shared_specs.rb", "spec/caching_spec.rb", "spec/old_acceptance_specs.rb", "spec/resourceful/header_spec.rb", "spec/resourceful/http_accessor_spec.rb", "spec/resourceful/multipart_form_data_spec.rb", "spec/resourceful/resource_spec.rb", "spec/resourceful/response_spec.rb", "spec/resourceful/urlencoded_form_data_spec.rb", "spec/resourceful_spec.rb", "spec/simple_sinatra_server.rb", "spec/simple_sinatra_server_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  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.5}
+  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>, [">= 2.1.0"])
+      s.add_runtime_dependency(%q<httpauth>, [">= 0"])
+      s.add_runtime_dependency(%q<options>, [">= 2.1.1"])
+      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>, [">= 2.1.0"])
+      s.add_dependency(%q<httpauth>, [">= 0"])
+      s.add_dependency(%q<options>, [">= 2.1.1"])
+      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>, [">= 2.1.0"])
+    s.add_dependency(%q<httpauth>, [">= 0"])
+    s.add_dependency(%q<options>, [">= 2.1.1"])
+    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-1.0.1/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-1.0.1/spec/acceptance/caching_spec.rb

@@ -0,0 +1,190 @@
+
+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 = {})
+      uri = Addressable::Template.new("http://localhost:42682/code/{code}").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, "Expires" => 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:42682/', "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:42682/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:42682/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:42682/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-1.0.1/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:42682/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-1.0.1/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-1.0.1/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:42682/')
+    end
+
+    it 'should make the original uri available' do 
+      @resource.effective_uri.should == 'http://localhost:42682/'
+      @resource.uri.should == 'http://localhost:42682/'
+    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-1.0.1/spec/acceptance/resourceful_spec.rb

@@ -0,0 +1,56 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe ".get()" do
+    it "should be performable on a resource and return a response" do
+      response = Resourceful.get('http://localhost:42682/')
+      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 = Resourceful.post('http://localhost:42682/')
+      response.should be_kind_of(Resourceful::Response)
+    end
+    
+    it "should require Content-Type be set if a body is provided" do
+      lambda {
+        Resourceful.post('http://localhost:42682/', {}, 'body')
+      }.should raise_error(Resourceful::MissingContentType)
+    end
+    
+  end
+  
+  describe ".put()" do
+    
+    it "should be performable on a resource and return a response" do
+      response = Resourceful.put('http://localhost:42682/')
+        response.should be_kind_of(Resourceful::Response)
+    end
+    
+    it "should require Content-Type be set if a body is provided" do
+      lambda {
+        Resourceful.put('http://localhost:42682/', "some text", {})
+      }.should raise_error(Resourceful::MissingContentType)
+    end
+    
+    it "should allow the entity-body to be nil" do
+      lambda {
+        Resourceful.put('http://localhost:42682/', nil, {})
+      }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe ".delete()" do
+
+    it "should be performable on a resource and return a response" do
+      response = Resourceful.delete('http://localhost:42682/')
+      response.should be_kind_of(Resourceful::Response)
+    end
+
+  end
+end

data/vendor/resourceful-1.0.1/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
+

data/vendor/resourceful-1.0.1/spec/caching_spec.rb

@@ -0,0 +1,89 @@
+
+require 'rubygems'
+require 'fakeweb'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+require 'resourceful'
+
+describe "Caching" do
+
+  before do
+    FakeWeb.allow_net_connect = false
+    FakeWeb.clean_registry
+
+    @http = Resourceful::HttpAccessor.new(:cache_manager => Resourceful::InMemoryCacheManager.new)
+    if ENV['SPEC_LOGGING']
+      @http.logger = Resourceful::StdOutLogger.new
+    end
+  end
+
+  describe "should cache" do
+
+    before do
+      FakeWeb.register_uri(:get, "http://example.com/cache",
+                           [{:body => "Original response", :cache_control => "private,max-age=15"},
+                            {:body => "Overrode cached response"}]
+                          )
+
+      @resource = @http.resource("http://example.com/cache")
+    end
+
+    it "should cache the response" do
+      resp = @resource.get
+      resp.body.should == "Original response"
+
+      resp = @resource.get
+      resp.body.should == "Original response"
+    end
+
+  end
+
+  describe "updating headers" do
+    before do
+      FakeWeb.register_uri(:get, "http://example.com/override",
+                           [{:body => "Original response", :cache_control => "private,max-age=0", :x_updateme => "foo"},
+                            {:body => "Overrode cached response", :status => 304, :x_updateme => "bar"} ]
+                          )
+
+      @resource = @http.resource("http://example.com/override")
+    end
+
+    it "should update headers from the 304" do
+      resp = @resource.get
+      resp.headers['X-Updateme'].should == ["foo"]
+
+      resp = @resource.get
+      resp.headers['X-Updateme'].should == ["bar"]
+      resp.headers['Cache-Control'].should == ["private", "max-age=0"]
+    end
+
+  end
+
+  describe "updating expiration" do
+    before do
+      FakeWeb.register_uri(:get, "http://example.com/timeout",
+                           [{:body => "Original response", :cache_control => "private,max-age=1"},
+                            {:body => "cached response",   :cache_control => "private,max-age=1"}]
+                          )
+
+      @resource = @http.resource("http://example.com/timeout")
+    end
+
+    it "should refresh the expiration timer" do
+      resp = @resource.get
+      resp.should_not be_stale
+
+      sleep 2
+
+      resp.should be_stale
+
+      resp = @resource.get
+      resp.should_not be_stale
+
+      resp = @resource.get
+    end
+
+  end
+
+
+end