pillow 0.5.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Alexander Kern and Artcentric Networks LLC
+
+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/README.md

@@ -0,0 +1,15 @@
+# Pillow
+
+Take a nap, Pillow lets you REST.
+
+## Description
+
+Pillow lets you use HTTP to its absolute fullest extent. Rather than expose an API to cover up the details of the protocol, it uses the protocol to structure the client itself. URL's are not defined in the resources, forcing the use of links and URL templates to navigate throughout the web service. Think of it like an automated web browser.
+
+## Examples
+
+_Coming soon_
+
+## License
+
+Pillow is licensed under the MIT License.

data/Rakefile

@@ -0,0 +1,18 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'pillow'
+    gemspec.summary = 'Take a nap, Pillow lets you REST.'
+    gemspec.description = 'Ruby HTTP client that takes full advantage of HTTP.'
+    gemspec.email = 'alex@kernul.com'
+    gemspec.authors = ['Alexander Kern']
+    
+    gemspec.add_dependency('patron')
+    gemspec.add_dependency('json')
+    gemspec.add_dependency('addressable')
+    
+    gemspec.add_development_dependency('rspec')
+  end
+rescue LoadError
+  puts 'Jeweler not available. Install it with: gem install jeweler'
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/lib/pillow.rb

@@ -0,0 +1,9 @@
+module Pillow
+  
+  autoload :Request, 'pillow/request'
+  autoload :Response, 'pillow/response'
+  
+  autoload :Resource, 'pillow/resource'
+  autoload :Method, 'pillow/method'
+  
+end

data/lib/pillow/method.rb

@@ -0,0 +1,41 @@
+class Pillow::Method
+  
+  attr_reader :method, :resource
+  
+  def initialize(method, resource)
+    @method = method
+    @resource = resource
+  end
+  
+  def before(&before)
+    @before = before if before
+    @before
+  end
+  
+  def after(&after)
+    @after = after if after
+    @after
+  end
+  
+  def process(*args)
+    request = Pillow::Request.new(method, resource.url)
+    request.query_values.replace(resource.query_values)
+    request.headers.replace(resource.headers)
+    
+    before.call(request, *args) if before
+    
+    options = {}
+    options[:data] = request.raw_body if request.raw_body
+    
+    raw_response = resource.session.request(request.method, request.full_url,
+                                            request.headers, options)
+    
+    response = Pillow::Response.new
+    response.status = raw_response.status
+    response.headers = raw_response.headers
+    response.raw_body = raw_response.body
+    
+    return after.call(response, *args) if after
+    response
+  end
+end

data/lib/pillow/request.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'addressable/uri'
+require 'json'
+
+class Pillow::Request
+  
+  HTTP_METHODS = [:options, :get, :head, :post, :put, :delete, :trace, :patch]
+  HTTP_METHODS_WITH_BODY = [:post, :put, :patch]
+  
+  attr_reader :method, :url, :query_values, :headers
+  
+  def initialize(method, url)
+    self.method = method
+    @url = url
+    @query_values = {}
+    @headers = {}
+  end
+  
+  def method=(method)
+    if HTTP_METHODS.include?(method)
+      @method = method
+    end
+    
+    @method ||= :get
+  end
+  
+  def body
+    if HTTP_METHODS_WITH_BODY.include?(method)
+      @body || ''
+    end
+  end
+  
+  def body=(body)
+    if HTTP_METHODS_WITH_BODY.include?(method)
+      @body = body
+      
+      if headers['Content-Type'] == 'application/json'
+        @raw_body = body.to_json
+      else
+        @raw_body = body
+      end
+    end
+  end
+  
+  def raw_body
+    if HTTP_METHODS_WITH_BODY.include?(method)
+      @raw_body || ''
+    end
+  end
+  
+  def raw_body=(raw_body)
+    if HTTP_METHODS_WITH_BODY.include?(method)
+      @raw_body = raw_body
+      @body = raw_body
+    end
+  end
+  
+  def full_url
+    if query_values.empty?
+      return url
+    end
+    
+    full_url = Addressable::URI.parse(url)
+    full_url.query_values = query_values
+    full_url.to_s
+  end
+end

data/lib/pillow/resource.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'addressable/uri'
+require 'addressable/template'
+require 'patron'
+
+class Pillow::Resource
+  
+  attr_reader :url
+  
+  def initialize(url)
+    @url = if url.is_a?(Hash)
+      self.class.template.expand(url).to_s
+    else
+      url.to_s
+    end
+  end
+  
+  class << self
+    def session
+      @session ||= Patron::Session.new
+    end
+    
+    def query_values
+      @query_values ||= {}
+    end
+    
+    def headers
+      @headers ||= {}
+    end
+    
+    def template(template = nil)
+      @template = Addressable::Template.new(template) if template
+      @template
+    end
+    
+    def options
+      @options ||= Pillow::Method.new(:options, self)
+    end
+    
+    def get
+      @get ||= Pillow::Method.new(:get, self)
+    end
+    
+    def head
+      @head ||= Pillow::Method.new(:head, self)
+    end
+    
+    def post
+      @post ||= Pillow::Method.new(:post, self)
+    end
+    
+    def put
+      @put ||= Pillow::Method.new(:put, self)
+    end
+    
+    def delete
+      @delete ||= Pillow::Method.new(:delete, self)
+    end
+    
+    def trace
+      @trace ||= Pillow::Method.new(:trace, self)
+    end
+    
+    def patch
+      @patch ||= Pillow::Method.new(:patch, self)
+    end
+  end
+  
+  def options(*args)
+    self.class.options.process(*args)
+  end
+  
+  def get(*args)
+    self.class.get.process(*args)
+  end
+  
+  def head(*args)
+    self.class.head.process(*args)
+  end
+  
+  def post(*args)
+    self.class.post.process(*args)
+  end
+  
+  def put(*args)
+    self.class.put.process(*args)
+  end
+  
+  def delete(*args)
+    self.class.delete.process(*args)
+  end
+  
+  def trace(*args)
+    self.class.trace.process(*args)
+  end
+  
+  def patch(*args)
+    self.class.patch.process(*args)
+  end
+end

data/lib/pillow/response.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'json'
+
+class Pillow::Response
+  
+  attr_accessor :status, :headers, :body
+  attr_reader :raw_body
+  
+  def raw_body=(raw_body)
+    @raw_body = raw_body
+    
+    if headers['Content-Type'] == 'application/json'
+      @body = JSON.parse(raw_body)
+    else
+      @body = raw_body
+    end
+  end
+end

data/spec/pillow/method_spec.rb

@@ -0,0 +1,228 @@
+require 'spec/spec_helper'
+
+describe Pillow::Method do
+  before do
+    @resource = stub('resource')
+    @session = mock('session')
+    @response = stub('response')
+    
+    @resource.stub!(:session).and_return(@session)
+    @resource.stub!(:url).and_return('http://foo.com/')
+    @resource.stub!(:query_values).and_return('foo' => 'bar')
+    @resource.stub!(:headers).and_return('X-Foo' => 'Bar')
+    
+    @session.stub!(:request).and_return(@response)
+    
+    @response.stub!(:body).and_return('test')
+    @response.stub!(:headers).and_return('X-Foo' => 'Bar')
+    @response.stub!(:status).and_return(200)
+    
+    @method = Pillow::Method.new(:get, @resource)
+  end
+  
+  context 'upon creation' do
+    it 'should have a method' do
+      @method.method.should == :get
+    end
+    
+    it 'should have a resource' do
+      @method.resource.should == @resource
+    end
+    
+    it 'should not have a before block' do
+      @method.before.should == nil
+    end
+    
+    it 'should not have an after block' do
+      @method.after.should == nil
+    end
+  end
+  
+  describe 'before block' do
+    it 'should be settable with a block' do
+      before_block = Proc.new {}
+      @method.before &before_block
+      
+      @method.before.should equal(before_block)
+    end
+    
+    it 'should be overwritable' do
+      before_block = Proc.new {}
+      before_block_2 = Proc.new {}
+      @method.before &before_block
+      @method.before &before_block_2
+      
+      @method.before.should equal(before_block_2)
+    end
+  end
+  
+  describe 'after block' do
+    it 'should be settable with a block' do
+      after_block = Proc.new {}
+      @method.after &after_block
+      
+      @method.after.should equal(after_block)
+    end
+    
+    it 'should be overwritable' do
+      after_block = Proc.new {}
+      after_block_2 = Proc.new {}
+      @method.after &after_block
+      @method.after &after_block_2
+      
+      @method.after.should equal(after_block_2)
+    end
+  end
+  
+  describe '#process' do
+    context 'when there is no before block' do
+      it 'should not call the before block' do
+        allow_message_expectations_on_nil
+        @method.before.should_not_receive(:call)
+        
+        @method.process
+      end
+    end
+    
+    context 'when there is a before block' do
+      before do
+        @method.before do |request|
+        end
+      end
+      
+      it 'should create a request with the method' do
+        @method.should_receive(:method).once
+        @method.process
+      end
+      
+      it 'should create a request with the resource url' do
+        @resource.should_receive(:url).once
+        @method.process
+      end
+      
+      it 'should receive a request with the resource query values' do
+        @method.before do |request|
+          request.query_values.should == {'foo' => 'bar'}
+        end
+        
+        @method.process
+      end
+      
+      it 'should receive a request with the resource headers' do
+        @method.before do |request|
+          request.headers.should == {'X-Foo' => 'Bar'}
+        end
+        
+        @method.process
+      end
+      
+      context 'when arguments are supplied' do
+        it 'should call the before block with the arguments' do
+          @method.before do |request, mock_1, mock_2|
+            mock_1.should == 'foo'
+            mock_2.should == 'bar'
+          end
+          
+          @method.process('foo', 'bar')
+        end
+      end
+    end
+    
+    it 'should request using the method' do
+      @session.should_receive(:request).with(:get, anything(), anything(), anything())
+      @method.process
+    end
+    
+    it 'should request the generated url with the resource session' do
+      @session.should_receive(:request).with(anything(), 'http://foo.com/?foo=bar', anything(), anything())
+      @method.process
+    end
+    
+    it 'should include headers with the request' do
+      @session.should_receive(:request).with(anything(), anything(), {'X-Foo' => 'Bar'}, anything())
+      @method.process
+    end
+    
+    it 'should include the raw body with the request' do
+      @method = Pillow::Method.new(:put, @resource)
+      @method.before do |request|
+        request.should_receive(:raw_body).at_least(:once).and_return('foo')
+      end
+      
+      @session.should_receive(:request).with(:put, anything(), anything(), :data => 'foo')
+      
+      @method.process
+    end
+    
+    context 'when there is no after block' do
+      it 'should not call the after block' do
+        allow_message_expectations_on_nil
+        @method.before.should_not_receive(:call)
+        
+        @method.process
+      end
+      
+      it 'should return the response' do
+        @method.process.should be_a_kind_of(Pillow::Response)
+      end
+    end
+    
+    context 'when there is an after block' do
+      before do
+        @method.after do |response|
+        end
+      end
+      
+      it 'should receive a response with the response status' do
+        @method.after do |response|
+          response.status.should == 200
+        end
+        
+        @method.process
+      end
+      
+      it 'should receive a response with the response headers' do
+        @method.after do |response|
+          response.headers.should == {'X-Foo' => 'Bar'}
+        end
+        
+        @method.process
+      end
+      
+      it 'should receive a response with the response raw body' do
+        @method.after do |response|
+          response.raw_body.should == 'test'
+        end
+        
+        @method.process
+      end
+      
+      it 'should receive a response with the response body' do
+        @method.after do |response|
+          response.body.should == 'test'
+        end
+        
+        @method.process
+      end
+      
+      it 'should return the output of the after block' do
+        @method.after do |response|
+          'test'
+        end
+        
+        @method.process.should == 'test'
+      end
+      
+      context 'when arguments are supplied' do
+        it 'should call the after block with the arguments' do
+          @method.after do |response, mock_1, mock_2|
+            mock_1.should == 'foo'
+            mock_2.should == 'bar'
+          end
+          
+          @method.process('foo', 'bar')
+        end
+      end
+    end
+  end
+end

data/spec/pillow/request_spec.rb

@@ -0,0 +1,230 @@
+require 'spec/spec_helper'
+
+describe Pillow::Request do
+  before do
+    @request = Pillow::Request.new(:get, 'http://foo.com/')
+  end
+  
+  it 'should have a url' do
+    @request.url.should == 'http://foo.com/'
+  end
+  
+  describe '#method' do
+    it 'should have a method' do
+      @request.method.should == :get
+    end
+    
+    context 'valid methods' do
+      it 'should allow the OPTIONS method' do
+        @request.method = :options
+        @request.method.should == :options
+      end
+      
+      it 'should allow the GET method' do
+        @request.method = :get
+        @request.method.should == :get
+      end
+      
+      it 'should allow the HEAD method' do
+        @request.method = :head
+        @request.method.should == :head
+      end
+      
+      it 'should allow the POST method' do
+        @request.method = :post
+        @request.method.should == :post
+      end
+      
+      it 'should allow the PUT method' do
+        @request.method = :put
+        @request.method.should == :put
+      end
+      
+      it 'should allow the DELETE method' do
+        @request.method = :delete
+        @request.method.should == :delete
+      end
+      
+      it 'should allow the TRACE method' do
+        @request.method = :trace
+        @request.method.should == :trace
+      end
+      
+      it 'should allow the PATCH method' do
+        @request.method = :patch
+        @request.method.should == :patch
+      end
+    end
+    
+    context 'invalid method' do
+      it 'should reset the method to GET' do
+        @request.method = :post
+        @request.method = :fake_method
+        @request.method = :get
+      end
+    end
+  end
+  
+  describe 'query values' do
+    it 'should by default be empty' do
+      @request.query_values.should be_empty
+    end
+    
+    it 'should have query values' do
+      @request.query_values['foo'] = 'bar'
+      @request.query_values['foo'].should == 'bar'
+    end
+  end
+  
+  describe 'headers' do
+    it 'should by default be empty' do
+      @request.headers.should be_empty
+    end
+    
+    it 'should have headers' do
+      @request.headers['foo'] = 'bar'
+      @request.headers['foo'].should == 'bar'
+    end
+  end
+  
+  describe '#body' do
+    context 'when the method should contain a body' do
+      it 'should by default be a blank string' do
+        @request.method = :put
+        @request.body.should == ''
+      end
+      
+      it 'should be settable for PUT' do
+        @request.method = :put
+        @request.body = 'foo'
+        @request.body.should == 'foo'
+      end
+      
+      it 'should be settable for POST' do
+        @request.method = :post
+        @request.body = 'foo'
+        @request.body.should == 'foo'
+      end
+      
+      it 'should be settable for PATCH' do
+        @request.method = :patch
+        @request.body = 'foo'
+        @request.body.should == 'foo'
+      end
+    end
+    
+    context 'when the method should not contain a body' do
+      it 'should by default be nil' do
+        @request.body.should be_nil
+      end
+      
+      it 'should not be settable' do
+        @request.method = :get
+        @request.body = 'foo'
+        @request.body.should be_nil
+      end
+    end
+  end
+  
+  describe '#raw_body' do
+    context 'when the method should contain a body' do
+      it 'should by default be a blank string' do
+        @request.method = :put
+        @request.body.should == ''
+      end
+    
+      it 'should be settable for PUT' do
+        @request.method = :put
+        @request.body = 'foo'
+        @request.body.should == 'foo'
+      end
+    
+      it 'should be settable for POST' do
+        @request.method = :post
+        @request.body = 'foo'
+        @request.body.should == 'foo'
+      end
+    
+      it 'should be settable for PATCH' do
+        @request.method = :patch
+        @request.body = 'foo'
+        @request.body.should == 'foo'
+      end
+    end
+    
+    context 'when the method should not contain a body' do
+      describe 'raw body' do
+        it 'should by default be nil' do
+          @request.raw_body.should be_nil
+        end
+
+        it 'should not be settable' do
+          @request.method = :get
+          @request.raw_body = 'foo'
+          @request.raw_body.should be_nil
+        end
+      end
+    end
+  end
+  
+  describe 'body parsing' do
+    before do
+      @request.method = :put
+    end
+    
+    context 'when the Content-Type is not application/json' do
+      before do
+        @request.headers['Content-Type'] = 'application/xml'
+      end
+      
+      it 'should be the same as the body' do
+        @request.body = 'foo'
+        @request.raw_body.should == 'foo'
+      end
+      
+      it 'should be settable' do
+        @request.raw_body = 'foo'
+        @request.raw_body.should == 'foo'
+      end
+      
+      it 'should be able to be set to change the body' do
+        @request.raw_body = 'foo'
+        @request.body.should == 'foo'
+      end
+    end
+    
+    context 'when the Content-Type is application/json' do
+      before do
+        @request.headers['Content-Type'] = 'application/json'
+      end
+      
+      it 'should convert the body from a hash to JSON' do
+        @request.body = {'foo' => 'bar'}
+        @request.raw_body.should == '{"foo":"bar"}'
+      end
+      
+      it 'should keep the original body in body' do
+        @request.body = {'foo' => 'bar'}
+        @request.body.should == {'foo' => 'bar'}
+      end
+    end
+  end
+  
+  describe '#full_url' do
+    context 'when there are no query values' do
+      it 'should be the same as the url' do
+        @request.full_url.should == @request.url
+      end
+    end
+    
+    context 'when there are query values' do
+      before do
+        @request.query_values['foo'] = 'bar'
+      end
+      
+      it 'should append the query values to the url' do
+        @request.full_url.should == @request.url + '?foo=bar'
+      end
+    end
+  end
+end

data/spec/pillow/resource_spec.rb

@@ -0,0 +1,156 @@
+require 'spec/spec_helper'
+
+describe Pillow::Resource do
+  before do
+    @klass = Class.new(Pillow::Resource)
+    @resource = @klass.new('http://foo.com/')
+  end
+  
+  describe '#self.session' do
+    subject { @klass.session }
+    it { should be_a_kind_of(Patron::Session) }
+  end
+  
+  describe '#self.query_values' do
+    subject { @klass.query_values }
+    
+    context 'when first created' do
+      it { should be_empty }
+    end
+    
+    it 'should store query values for the resource' do
+      @klass.query_values['foo'] = 'bar'
+      @klass.query_values['foo'].should == 'bar'
+    end
+  end
+  
+  describe '#self.headers' do
+    subject { @klass.headers }
+    
+    context 'when first created' do
+      it { should be_empty }
+    end
+    
+    it 'should store headers for the resource' do
+      @klass.headers['foo'] = 'bar'
+      @klass.headers['foo'].should == 'bar'
+    end
+  end
+  
+  describe '#self.template' do
+    subject { @klass.template }
+    
+    context 'when first created' do
+      it { should be_nil }
+    end
+    
+    context 'when set to a template' do
+      before do
+        @klass.template 'http://example.com/{foo}'
+      end
+      
+      it 'should store the template' do
+        @klass.template.should be_a_kind_of(Addressable::Template)
+      end
+    end
+  end
+  
+  describe '#initialize' do
+    context 'when given a url' do
+      before do
+        @resource = @klass.new('http://exmaple.com')
+      end
+      
+      it 'should store the url' do
+        @resource.url.should == 'http://exmaple.com'
+      end
+    end
+    
+    context 'when given a params list' do
+      before do
+        @klass.template 'http://example.com/{foo}'
+        @resource = @klass.new('foo' => 'test')
+      end
+      
+      it 'should expand the parent template with the params' do
+        @resource.url.should == 'http://example.com/test'
+      end
+    end
+  end
+  
+  describe 'methods definitions' do
+    it 'should have an OPTIONS method' do
+      @klass.options.method.should == :options
+    end
+    
+    it 'should have a GET method' do
+      @klass.get.method.should == :get
+    end
+    
+    it 'should have a HEAD method' do
+      @klass.head.method.should == :head
+    end
+    
+    it 'should have a POST method' do
+      @klass.post.method.should == :post
+    end
+    
+    it 'should have a PUT method' do
+      @klass.put.method.should == :put
+    end
+    
+    it 'should have a DELETE method' do
+      @klass.delete.method.should == :delete
+    end
+    
+    it 'should have a TRACE method' do
+      @klass.trace.method.should == :trace
+    end
+    
+    it 'should have a PATCH method' do
+      @klass.patch.method.should == :patch
+    end
+  end
+  
+  describe 'methods' do
+    it 'should be able to call OPTIONS' do
+      @klass.options.should_receive(:process).with('test').and_return(123)
+      @resource.options('test').should == 123
+    end
+    
+    it 'should be able to call GET' do
+      @klass.get.should_receive(:process).with('test').and_return(123)
+      @resource.get('test').should == 123
+    end
+    
+    it 'should be able to call HEAD' do
+      @klass.head.should_receive(:process).with('test').and_return(123)
+      @resource.head('test').should == 123
+    end
+    
+    it 'should be able to call POST' do
+      @klass.post.should_receive(:process).with('test').and_return(123)
+      @resource.post('test').should == 123
+    end
+    
+    it 'should be able to call PUT' do
+      @klass.put.should_receive(:process).with('test').and_return(123)
+      @resource.put('test').should == 123
+    end
+    
+    it 'should be able to call DELETE' do
+      @klass.delete.should_receive(:process).with('test').and_return(123)
+      @resource.delete('test').should == 123
+    end
+    
+    it 'should be able to call TRACE' do
+      @klass.trace.should_receive(:process).with('test').and_return(123)
+      @resource.trace('test').should == 123
+    end
+    
+    it 'should be able to call PATCH' do
+      @klass.patch.should_receive(:process).with('test').and_return(123)
+      @resource.patch('test').should == 123
+    end
+  end
+end

data/spec/pillow/response_spec.rb

@@ -0,0 +1,42 @@
+require 'spec/spec_helper'
+
+describe Pillow::Response do
+  before do
+    @response = Pillow::Response.new
+    @response.status = 200
+    @response.headers = {'X-Foo' => 'Bar'}
+    @response.raw_body = 'test'
+  end
+  
+  it 'should store the status' do
+    @response.status.should == 200
+  end
+  
+  it 'should store the headers' do
+    @response.headers.should == {'X-Foo' => 'Bar'}
+  end
+  
+  it 'should store the body' do
+    @response.body.should == 'test'
+  end
+  
+  it 'should store the origin raw body' do
+    @response.raw_body.should == 'test'
+  end
+  
+  context 'when the Content-Type is application/json' do
+    before do
+      @data = {'foo' => 'bar'}
+      @response.headers['Content-Type'] = 'application/json'
+      @response.raw_body = @data.to_json
+    end
+    
+    it 'should process the body' do
+      @response.body.should == @data
+    end
+    
+    it 'should store the origin body' do
+      @response.raw_body.should == @data.to_json
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'spec'
+require 'spec/autorun'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'pillow')
+
+Spec::Runner.configure do |config|
+end
+
+def mock_response(status, headers, body)
+  response = Patron::Response.new
+  response.instance_eval do
+    @status = status
+    @headers = headers
+    @body = body
+  end
+  response
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: pillow
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Alexander Kern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: patron
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Ruby HTTP client that takes full advantage of HTTP.
+email: alex@kernul.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/pillow.rb
+- lib/pillow/method.rb
+- lib/pillow/request.rb
+- lib/pillow/resource.rb
+- lib/pillow/response.rb
+- spec/pillow/method_spec.rb
+- spec/pillow/request_spec.rb
+- spec/pillow/resource_spec.rb
+- spec/pillow/response_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Take a nap, Pillow lets you REST.
+test_files: 
+- spec/pillow/method_spec.rb
+- spec/pillow/request_spec.rb
+- spec/pillow/resource_spec.rb
+- spec/pillow/response_spec.rb
+- spec/spec_helper.rb