couchrest 1.1.0.pre3 → 1.1.0

data/history.txt

@@ -1,3 +1,9 @@
+== 1.1.0 - 2011-06-25
+
+* Minor changes
+  * Refactored basic CouchRest API (get, post, etc.) to pass-through RestClient and MultiJSON options, including headers.
+  * CouchRest::Attributes module created to make attribute related methods independent.
+
 == 1.1.0.pre3 - 2011-06-06
 
 * Major changes

data/lib/couchrest.rb

@@ -1,11 +1,11 @@
 # Copyright 2008 J. Chris Anderson
-# 
+#
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
 #    You may obtain a copy of the License at
-# 
+#
 #        http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 #    Unless required by applicable law or agreed to in writing, software
 #    distributed under the License is distributed on an "AS IS" BASIS,
 #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -29,6 +29,7 @@ require 'forwardable'
 
 # = CouchDB, close to the metal
 module CouchRest
+  autoload :Attributes,   'couchrest/attributes'
   autoload :Server,       'couchrest/server'
   autoload :Database,     'couchrest/database'
   autoload :Document,     'couchrest/document'
@@ -80,7 +81,7 @@ module CouchRest
       end
 
       db = nil if db && db.empty?
-      
+
       {
         :host => (scheme || "http://") + (host || "127.0.0.1:5984"),
         :database => db,
@@ -92,7 +93,7 @@ module CouchRest
     def proxy url
       RestClient.proxy = url
     end
-    
+
     # ensure that a database exists
     # creates it if it isn't already there
     # returns it after it's been created
@@ -101,13 +102,13 @@ module CouchRest
       cr = CouchRest.new(parsed[:host])
       cr.database!(parsed[:database])
     end
-  
+
     def database url
       parsed = parse url
       cr = CouchRest.new(parsed[:host])
       cr.database(parsed[:database])
     end
-    
+
     def paramify_url url, params = {}
       if params && !params.empty?
         query = params.collect do |k,v|

data/lib/couchrest/attributes.rb

@@ -0,0 +1,75 @@
+#
+# CouchRest::Attributes
+#
+# When included, provide the owner with an attributes hash and
+# accessors that forward calls to it.
+#
+# Provides the basic functionality of Hash without actually being
+# a Hash using Ruby's standard Forwardable module.
+#
+module CouchRest
+
+  module Attributes
+    extend Forwardable
+
+    # Initialize a new CouchRest Document and prepare 
+    # a hidden attributes hash.
+    #
+    # When inherting a Document, it is essential that the 
+    # super method is called before you own changes to ensure
+    # that the attributes hash has been initialized before
+    # you attempt to use it.
+    def initialize(attrs = nil)
+      @_attributes = {}
+      attrs.each{|k,v| self[k] = v} unless attrs.nil?
+    end
+
+    # Hash equivilent methods to access the attributes
+    def_delegators :@_attributes, :to_a, :==, :eql?, :keys, :values, :each,
+      :reject, :reject!, :empty?, :clear, :merge, :merge!,
+      :encode_json, :as_json, :to_json, :frozen?
+
+    def []=(key, value)
+      @_attributes[key.to_s] = value
+    end
+    def [](key)
+      @_attributes[key.to_s]
+    end
+    def has_key?(key)
+      @_attributes.has_key?(key.to_s)
+    end
+    def delete(key)
+      @_attributes.delete(key.to_s)
+    end
+    def dup
+      new = super
+      @_attributes = @_attributes.dup
+      new
+    end
+    def clone
+      new = super
+      @_attributes = @_attributes.dup
+      new
+    end
+    def to_hash
+      @_attributes
+    end
+
+    # Freeze the object's attributes instead of the actual document.
+    # This prevents further modifications to stored data, but does allow access
+    # to local variables useful for callbacks or cached data.
+    def freeze
+      @_attributes.freeze; self
+    end
+
+    # Provide details of the current keys in the reponse. Based on ActiveRecord::Base.
+    def inspect
+      attributes_as_nice_string = self.keys.collect { |key|
+        "#{key}: #{self[key].inspect}"
+      }.compact.join(", ")
+      "#<#{self.class} #{attributes_as_nice_string}>"
+    end
+
+  end
+
+end

data/lib/couchrest/database.rb

@@ -245,7 +245,7 @@ module CouchRest
     def view(name, params = {}, payload = {}, &block)
       payload['keys'] = params.delete(:keys) if params[:keys]
       # Try recognising the name, otherwise assume already prepared
-      view_path = name =~ /^([^_].+?)\/(.*)$/ ? "_design/#{$1}/_view/#{$2}" : name
+      view_path = name_to_view_path(name)
       url = CouchRest.paramify_url "#{@root}/#{view_path}", params
       if block_given?
         if !payload.empty?
@@ -386,5 +386,11 @@ module CouchRest
     def base64(data)
       Base64.encode64(data).gsub(/\s/,'')
     end
+
+    # Convert a simplified view name into a complete view path. If
+    # the name already starts with a "_" no alterations will be made.
+    def name_to_view_path(name)
+      name =~ /^([^_].+?)\/(.*)$/ ? "_design/#{$1}/_view/#{$2}" : name
+    end
   end
 end

data/lib/couchrest/document.rb

@@ -17,57 +17,13 @@
 
 module CouchRest
   class Document
-    extend Forwardable
+    include CouchRest::Attributes
     include CouchRest::Attachments
     extend CouchRest::InheritableAttributes
 
     couchrest_inheritable_accessor :database
     attr_accessor :database
 
-    # Initialize a new CouchRest Document and prepare 
-    # a hidden attributes hash.
-    #
-    # When inherting a Document, it is essential that the 
-    # super method is called before you own changes to ensure
-    # that the attributes hash has been initialized before
-    # you attempt to use it.
-    def initialize(attrs = nil)
-      @_attributes = {}
-      attrs.each{|k,v| self[k] = v} unless attrs.nil?
-    end
-
-    # Hash equivilent methods to access the attributes
-
-    def_delegators :@_attributes, :to_a, :==, :eql?, :keys, :values, :each,
-      :reject, :reject!, :empty?, :clear, :merge, :merge!,
-      :encode_json, :as_json, :to_json
-
-    def []=(key, value)
-      @_attributes[key.to_s] = value
-    end
-    def [](key)
-      @_attributes[key.to_s]
-    end
-    def has_key?(key)
-      @_attributes.has_key?(key.to_s)
-    end
-    def delete(key)
-      @_attributes.delete(key.to_s)
-    end
-    def dup
-      new = super
-      @_attributes = @_attributes.dup
-      new
-    end
-    def clone
-      new = super
-      @_attributes = @_attributes.dup
-      new
-    end
-    def to_hash
-      @_attributes
-    end
-
     def id
       self['_id']
     end
@@ -135,14 +91,6 @@ module CouchRest
       @database || self.class.database
     end
 
-    # Provide details of the current keys in the reponse. Based on ActiveRecord::Base.
-    def inspect
-      attributes_as_nice_string = self.keys.collect { |key|
-        "#{key}: #{self[key].inspect}"
-      }.compact.join(", ")
-      "#<#{self.class} #{attributes_as_nice_string}>"
-    end
-
     class << self
       # override the CouchRest::Model-wide default_database
       # This is not a thread safe operation, do not change the model

data/lib/couchrest/rest_api.rb

@@ -1,7 +1,75 @@
 module CouchRest
 
+  # CouchRest RestAPI
+  #
+  # The basic low-level interface for all REST requests to the database. Everything must pass
+  # through here before it is sent to the server.
+  #
+  # Five types of REST requests are supported: get, put, post, delete, and copy.
+  #
+  # Requests that do not have a payload, get, delete and copy, accept the URI and options parameters,
+  # where as put and post both expect a document as the second parameter.
+  #
+  # The API will try to intelegently split the options between the JSON parser and RestClient API.
+  #
+  # The following options will be recognised as header options and automatically added
+  # to the header hash:
+  #
+  # * :content_type, type of content to be sent, especially useful when sending files as this will set the file type. The default is :json.
+  # * :accept, the content type to accept in the response. This should pretty much always be :json.
+  #
+  # The following request options are supported:
+  #
+  # * :method override the requested method (should not be used!).
+  # * :url override the URL used in the request.
+  # * :payload override the document or data sent in the message body (only PUT or POST).
+  # * :headers any additional headers (overrides :content_type and :accept)
+  # * :timeout and :open_timeout the time in miliseconds to wait for the request, see RestClient API for more details.
+  # * :verify_ssl, :ssl_client_cert, :ssl_client_key, and :ssl_ca_file, SSL handling methods.
+  #
+  #
+  # Any other remaining options will be sent to the MultiJSON backend except for the :raw option.
+  #
+  # When :raw is true in PUT and POST requests, no attempt will be made to convert the document payload to JSON. This is 
+  # not normally necessary as IO and Tempfile objects will not be parsed anyway. The result of the request will
+  # *always* be parsed.
+  #
+  # For all other requests, mainly GET, the :raw option will make no attempt to parse the result. This
+  # is useful for receiving files from the database.
+  #
+
   module RestAPI
 
+    # Send a GET request.
+    def get(uri, options = {})
+      execute(uri, :get, options)
+    end
+
+    # Send a PUT request.
+    def put(uri, doc = nil, options = {})
+      execute(uri, :put, options, doc)
+    end
+
+    # Send a POST request.
+    def post(uri, doc = nil, options = {})
+      execute(uri, :post, options, doc)
+    end
+
+    # Send a DELETE request.
+    def delete(uri, options = {})
+      execute(uri, :delete, options)
+    end
+
+    # Send a COPY request to the URI provided.
+    def copy(uri, destination, options = {})
+      opts = options.nil? ? {} : options.dup
+      # also copy headers!
+      opts[:headers] = options[:headers].nil? ? {} : options[:headers].dup
+      opts[:headers]['Destination'] = destination
+      execute(uri, :copy, opts)
+    end
+
+    # The default RestClient headers used in each request.
     def default_headers
       {
         :content_type => :json,
@@ -9,61 +77,60 @@ module CouchRest
       }
     end
 
-    def get(uri, options = {})
-      begin
-        parse_response(RestClient.get(uri, default_headers), options.dup)
-      rescue => e
-        if $DEBUG
-          raise "Error while sending a GET request #{uri}\n: #{e}"
-        else
-          raise e
-        end
-      end
-    end
+    private
 
-    def put(uri, doc = nil, options = {})
-      opts = options.dup
-      payload = payload_from_doc(doc, opts)
+    # Perform the RestClient request by removing the parse specific options, ensuring the 
+    # payload is prepared, and sending the request ready to parse the response.
+    def execute(url, method, options = {}, payload = nil)
+      request, parser = prepare_and_split_options(url, method, options)
+      # Prepare the payload if it is provided
+      request[:payload] = payload_from_doc(payload, parser) if payload
       begin
-        parse_response(RestClient.put(uri, payload, default_headers.merge(opts)), opts)
+        parse_response(RestClient::Request.execute(request), parser)
       rescue Exception => e
         if $DEBUG
-          raise "Error while sending a PUT request #{uri}\npayload: #{payload.inspect}\n#{e}"
+          raise "Error while sending a #{method.to_s.upcase} request #{uri}\noptions: #{opts.inspect}\n#{e}"
         else
           raise e
         end
       end
     end
 
-    def post(uri, doc = nil, options = {})
-      opts = options.dup
-      payload = payload_from_doc(doc, opts)
-      begin
-        parse_response(RestClient.post(uri, payload, default_headers.merge(opts)), opts)
-      rescue Exception => e
-        if $DEBUG
-          raise "Error while sending a POST request #{uri}\npayload: #{payload.inspect}\n#{e}"
+    # Prepare a two hashes, one for the request to the REST backend and a second
+    # for the JSON parser.
+    #
+    # Returns and array of request options and parser options.
+    #
+    def prepare_and_split_options(url, method, options)
+      request = {
+        :url => url,
+        :method => method,
+        :headers => default_headers.merge(options[:headers] || {})
+      }
+      parser = {
+        :raw => false
+      }
+      # Split the options
+      (options || {}).each do |k,v|
+        k = k.to_sym
+        next if k == :headers # already dealt with
+        if restclient_option_keys.include?(k)
+          request[k] = v
+        elsif header_option_keys.include?(k)
+          request[:headers][k] = v
         else
-          raise e
+          parser[k] = v
         end
       end
+      [request, parser]
     end
 
-    def delete(uri, options = {})
-      parse_response(RestClient.delete(uri, default_headers), options.dup)
-    end
-
-    def copy(uri, destination, options = {})
-      parse_response(RestClient::Request.execute( :method => :copy,
-                                              :url => uri,
-                                              :headers => default_headers.merge('Destination' => destination)
-                                            ).to_s, options)
-    end
-
-    protected
-
     # Check if the provided doc is nil or special IO device or temp file. If not, 
     # encode it into a string.
+    #
+    # The options supported are:
+    # * :raw TrueClass, if true the payload will not be altered.
+    #
     def payload_from_doc(doc, opts = {})
       (opts.delete(:raw) || doc.nil? || doc.is_a?(IO) || doc.is_a?(Tempfile)) ? doc : MultiJson.encode(doc)
     end
@@ -73,5 +140,16 @@ module CouchRest
       opts.delete(:raw) ? result : MultiJson.decode(result, opts.update(:max_nesting => false))
     end
 
+    # An array of all the options that should be passed through to restclient.
+    # Anything not in this list will be passed to the JSON parser.
+    def restclient_option_keys
+      [:method, :url, :payload, :headers, :timeout, :open_timeout,
+        :verify_ssl, :ssl_client_cert, :ssl_client_key, :ssl_ca_file]
+    end
+
+    def header_option_keys
+      [ :content_type, :accept ]
+    end
+
   end
 end

data/lib/couchrest/version.rb

@@ -1,3 +1,3 @@
 module CouchRest
-  VERSION = '1.1.0.pre3'
+  VERSION = '1.1.0'
 end

data/spec/couchrest/couchrest_spec.rb

@@ -25,7 +25,7 @@ describe CouchRest do
       @cr.info.class.should == Hash   
     end
   end
-  
+
   it "should restart" do
     @cr.restart!
     begin

data/spec/couchrest/database_spec.rb

@@ -303,7 +303,7 @@ describe CouchRest::Database do
       @db.fetch_attachment(@db.get('mydocwithattachment'), 'test.html').should == @attach
     end
   end
-  
+
   describe "PUT attachment from file" do
     before(:each) do
       filename = FIXTURE_PATH + '/attachments/couchdb.png'
@@ -316,12 +316,11 @@ describe CouchRest::Database do
       r = @db.put_attachment({'_id' => 'attach-this'}, 'couchdb.png', image = @file.read, {:content_type => 'image/png'})
       r['ok'].should == true
       doc = @db.get("attach-this")
-      attachment = @db.fetch_attachment(doc,"couchdb.png")
-      if attachment.respond_to?(:net_http_res)  
-        attachment.net_http_res.body.should == image
-      else
-        attachment.should == image
-      end
+      attachment = @db.fetch_attachment(doc, "couchdb.png")
+      (attachment == image).should be_true
+      #if attachment.respond_to?(:net_http_res)  
+      #  attachment.net_http_res.body.should == image
+      #end
     end
   end
 

data/spec/couchrest/document_spec.rb

@@ -33,7 +33,7 @@ describe CouchRest::Document do
     it "should respond to forwarded hash methods" do
       @doc = CouchRest::Document.new(:foo => 'bar')
       [:to_a, :==, :eql?, :keys, :values, :each, :reject, :reject!, :empty?,
-        :clear, :merge, :merge!, :encode_json, :as_json, :to_json].each do |call|
+        :clear, :merge, :merge!, :encode_json, :as_json, :to_json, :frozen?].each do |call|
         @doc.should respond_to(call)
       end
     end
@@ -94,6 +94,17 @@ describe CouchRest::Document do
     end
   end
 
+  describe "#freeze" do
+    it "should freeze the attributes, but not actual model" do
+      klass = Class.new(CouchRest::Document)
+      klass.class_eval { attr_accessor :test_attr }
+      @doc = klass.new('foo' => 'bar')
+      @doc.freeze
+      lambda { @doc['foo'] = 'bar2' }.should raise_error(/frozen/)
+      lambda { @doc.test_attr = "bar3" }.should_not raise_error
+    end
+  end
+
 
   describe "#inspect" do
     it "should provide a string of keys and values of the Response" do

data/spec/couchrest/rest_api_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CouchRest::RestAPI do
+
+  describe "class methods" do
+
+    subject { CouchRest }
+
+    let(:request) { RestClient::Request }
+    let(:simple_response) { "{\"ok\":true}" }
+    let(:parser) { MultiJson }
+    let(:parser_opts) { {:max_nesting => false} }
+
+    it "should exist" do
+      should respond_to :get
+      should respond_to :put
+      should respond_to :post
+      should respond_to :copy
+      should respond_to :delete
+    end
+
+    it "should provide default headers" do
+      should respond_to :default_headers
+      CouchRest.default_headers.should be_a(Hash)
+    end
+
+
+    describe :get do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo')
+      end
+
+      it "should never modify options" do
+        options = {:timeout => 1000}
+        options.freeze
+        request.should_receive(:execute).and_return(simple_response)
+        parser.should_receive(:decode)
+        expect { CouchRest.get('foo', options) }.to_not raise_error
+      end
+
+
+      it "should accept 'content_type' header" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers.merge(:content_type => :foo)}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :content_type => :foo)
+      end
+
+      it "should accept 'accept' header" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers.merge(:accept => :foo)}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :accept => :foo)
+      end
+
+      it "should forward RestClient options" do
+        req = {:url => 'foo', :method => :get, :timeout => 1000, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :timeout => 1000)
+      end
+
+      it "should forward parser options" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts.merge(:random => 'foo'))
+        CouchRest.get('foo', :random => 'foo')
+      end
+
+      it "should accept raw option" do
+        req = {:url => 'foo', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:decode)
+        CouchRest.get('foo', :raw => true).should eql(simple_response)
+      end
+
+      it "should allow override of method (not that you'd want to!)" do
+        req = {:url => 'foo', :method => :fubar, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :method => :fubar)
+      end
+
+      it "should allow override of url (not that you'd want to!)" do
+        req = {:url => 'foobardom', :method => :get, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.get('foo', :url => 'foobardom')
+      end
+
+
+      it "should forward an exception if raised" do
+        request.should_receive(:execute).and_raise(RestClient::Exception)
+        expect { CouchRest.get('foo') }.to raise_error(RestClient::Exception)
+      end
+
+    end
+
+    describe :post do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:encode).with('data').and_return('data')
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', 'data')
+      end
+
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:encode).with('data').and_return('data')
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', 'data')
+      end
+
+      it "should send raw request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', 'data', :raw => true)
+      end
+
+      it "should not encode nil request" do
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', nil)
+      end
+
+      it "should send raw request automatically if file provided" do
+        f = File.open(FIXTURE_PATH + '/attachments/couchdb.png')
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => f}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', f)
+        f.close
+      end
+
+      it "should send raw request automatically if Tempfile provided" do
+        f = Tempfile.new('couchrest')
+        req = {:url => 'foo', :method => :post, :headers => CouchRest.default_headers, :payload => f}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_not_receive(:encode)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.post('foo', f)
+        f.close
+      end
+
+
+    end
+
+
+    describe :put do
+      # Only test basic as practically same as post
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :put, :headers => CouchRest.default_headers, :payload => 'data'}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:encode).with('data').and_return('data')
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.put('foo', 'data')
+      end
+
+    end
+
+    describe :delete do
+      it "should send basic request" do
+        req = {:url => 'foo', :method => :delete, :headers => CouchRest.default_headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.delete('foo')
+      end
+    end
+
+    describe :copy do
+      it "should send basic request" do
+        headers = CouchRest.default_headers.merge(
+          'Destination' => 'fooobar'
+        )
+        req = {:url => 'foo', :method => :copy, :headers => headers}
+        request.should_receive(:execute).with(req).and_return(simple_response)
+        parser.should_receive(:decode).with(simple_response, parser_opts)
+        CouchRest.copy('foo', 'fooobar')
+      end
+
+      it "should never modify header options" do
+        options = {:headers => {:content_type => :foo}}
+        options.freeze
+        request.should_receive(:execute).and_return(simple_response)
+        parser.should_receive(:decode)
+        expect { CouchRest.copy('foo', 'foobar', options) }.to_not raise_error
+      end
+
+    end
+
+
+  end
+
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: couchrest
 version: !ruby/object:Gem::Version 
-  prerelease: 6
-  version: 1.1.0.pre3
+  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors: 
 - J. Chris Anderson
@@ -103,6 +103,7 @@ files:
 - history.txt
 - init.rb
 - lib/couchrest.rb
+- lib/couchrest/attributes.rb
 - lib/couchrest/commands/generate.rb
 - lib/couchrest/commands/push.rb
 - lib/couchrest/database.rb
@@ -125,6 +126,7 @@ files:
 - spec/couchrest/document_spec.rb
 - spec/couchrest/helpers/pager_spec.rb
 - spec/couchrest/helpers/streamer_spec.rb
+- spec/couchrest/rest_api_spec.rb
 - spec/couchrest/server_spec.rb
 - spec/fixtures/attachments/README
 - spec/fixtures/attachments/couchdb.png