jgre-couchrest 0.12.6

data/lib/couchrest/core/database.rb

@@ -0,0 +1,241 @@
+require 'cgi'
+require "base64"
+
+module CouchRest
+  class Database
+    attr_reader :server, :host, :name, :root
+    attr_accessor :bulk_save_cache_limit
+     
+    # Create a CouchRest::Database adapter for the supplied CouchRest::Server
+    # and database name.
+    #  
+    # ==== Parameters
+    # server<CouchRest::Server>:: database host
+    # name<String>:: database name
+    #
+    def initialize server, name
+      @name = name
+      @server = server
+      @host = server.uri
+      @root = "#{host}/#{name}"
+      @streamer = Streamer.new(self)
+      @bulk_save_cache = []
+      @bulk_save_cache_limit = 50
+    end
+    
+    # returns the database's uri
+    def to_s
+      @root
+    end
+    
+    # GET the database info from CouchDB
+    def info
+      CouchRest.get @root
+    end
+    
+    # Query the <tt>_all_docs</tt> view. Accepts all the same arguments as view.
+    def documents params = {}
+      keys = params.delete(:keys)
+      url = CouchRest.paramify_url "#{@root}/_all_docs", params
+      if keys
+        CouchRest.post(url, {:keys => keys})
+      else
+        CouchRest.get url
+      end
+    end
+  
+    # POST a temporary view function to CouchDB for querying. This is not
+    # recommended, as you don't get any performance benefit from CouchDB's
+    # materialized views. Can be quite slow on large databases.
+    def slow_view funcs, params = {}
+      keys = params.delete(:keys)
+      funcs = funcs.merge({:keys => keys}) if keys
+      url = CouchRest.paramify_url "#{@root}/_temp_view", params
+      JSON.parse(RestClient.post(url, funcs.to_json, {"Content-Type" => 'application/json'}))
+    end
+    
+    # backwards compatibility is a plus
+    alias :temp_view :slow_view
+  
+    # Query a CouchDB view as defined by a <tt>_design</tt> document. Accepts
+    # paramaters as described in http://wiki.apache.org/couchdb/HttpViewApi
+    def view name, params = {}, &block
+      keys = params.delete(:keys)
+      url = CouchRest.paramify_url "#{@root}/_view/#{name}", params
+      if keys
+        CouchRest.post(url, {:keys => keys})
+      else
+        if block_given?
+          @streamer.view(name, params, &block)
+        else
+          CouchRest.get url
+        end
+      end
+    end
+    
+    # GET a document from CouchDB, by id. Returns a Ruby Hash.
+    def get id
+      slug = escape_docid(id)
+      hash = CouchRest.get("#{@root}/#{slug}")
+      doc = if /^_design/ =~ hash["_id"]
+        Design.new(hash)
+      else
+        Document.new(hash)
+      end
+      doc.database = self
+      doc
+    end
+    
+    # GET an attachment directly from CouchDB
+    def fetch_attachment docid, name
+      slug = escape_docid(docid)        
+      name = CGI.escape(name)
+      RestClient.get "#{@root}/#{slug}/#{name}"
+    end
+    
+    # PUT an attachment directly to CouchDB
+    def put_attachment doc, name, file, options = {}
+      docid = escape_docid(doc['_id'])
+      name = CGI.escape(name)
+      uri = if doc['_rev']
+        "#{@root}/#{docid}/#{name}?rev=#{doc['_rev']}"
+      else
+        "#{@root}/#{docid}/#{name}"
+      end
+        
+      JSON.parse(RestClient.put(uri, file, options))
+    end
+    
+    # Save a document to CouchDB. This will use the <tt>_id</tt> field from
+    # the document as the id for PUT, or request a new UUID from CouchDB, if
+    # no <tt>_id</tt> is present on the document. IDs are attached to
+    # documents on the client side because POST has the curious property of
+    # being automatically retried by proxies in the event of network
+    # segmentation and lost responses.
+    #
+    # If <tt>bulk</tt> is true (false by default) the document is cached for bulk-saving later.
+    # Bulk saving happens automatically when #bulk_save_cache limit is exceded, or on the next non bulk save.
+    def save (doc, bulk = false)
+      if doc['_attachments']
+        doc['_attachments'] = encode_attachments(doc['_attachments'])
+      end
+      if bulk
+        @bulk_save_cache << doc
+        return bulk_save if @bulk_save_cache.length >= @bulk_save_cache_limit
+        return {"ok" => true} # Compatibility with Document#save
+      elsif !bulk && @bulk_save_cache.length > 0
+        bulk_save
+      end
+      result = if doc['_id']
+        slug = escape_docid(doc['_id'])        
+        CouchRest.put "#{@root}/#{slug}", doc
+      else
+        begin
+          slug = doc['_id'] = @server.next_uuid
+          CouchRest.put "#{@root}/#{slug}", doc
+        rescue #old version of couchdb
+          CouchRest.post @root, doc
+        end
+      end
+      if result['ok']
+        doc['_id'] = result['id']
+        doc['_rev'] = result['rev']
+        doc.database = self if doc.respond_to?(:database=)
+      end
+      result
+    end
+    
+    # POST an array of documents to CouchDB. If any of the documents are
+    # missing ids, supply one from the uuid cache.
+    #
+    # If called with no arguments, bulk saves the cache of documents to be bulk saved.
+    def bulk_save(docs = nil, use_uuids = true)
+      if docs.nil?
+        docs = @bulk_save_cache
+        @bulk_save_cache = []
+      end
+      if (use_uuids) 
+        ids, noids = docs.partition{|d|d['_id']}
+        uuid_count = [noids.length, @server.uuid_batch_count].max
+        noids.each do |doc|
+          nextid = @server.next_uuid(uuid_count) rescue nil
+          doc['_id'] = nextid if nextid
+        end
+      end
+      CouchRest.post "#{@root}/_bulk_docs", {:docs => docs}
+    end
+    
+    # DELETE the document from CouchDB that has the given <tt>_id</tt> and
+    # <tt>_rev</tt>.
+    #
+    # If <tt>bulk</tt> is true (false by default) the deletion is recorded for bulk-saving (bulk-deletion :) later.
+    # Bulk saving happens automatically when #bulk_save_cache limit is exceded, or on the next non bulk save.
+    def delete (doc, bulk = false)
+      raise ArgumentError, "_id and _rev required for deleting" unless doc['_id'] && doc['_rev']      
+      if bulk
+        @bulk_save_cache << { '_id' => doc['_id'], '_rev' => doc['_rev'], '_deleted' => true }
+        return bulk_save if @bulk_save_cache.length >= @bulk_save_cache_limit
+        return { "ok" => true } # Mimic the non-deferred version
+      end
+      slug = escape_docid(doc['_id'])        
+      CouchRest.delete "#{@root}/#{slug}?rev=#{doc['_rev']}"
+    end
+    
+    # COPY an existing document to a new id. If the destination id currently exists, a rev must be provided.
+    # <tt>dest</tt> can take one of two forms if overwriting: "id_to_overwrite?rev=revision" or the actual doc
+    # hash with a '_rev' key
+    def copy doc, dest
+      raise ArgumentError, "_id is required for copying" unless doc['_id']
+      slug = escape_docid(doc['_id'])        
+      destination = if dest.respond_to?(:has_key?) && dest['_id'] && dest['_rev']
+        "#{dest['_id']}?rev=#{dest['_rev']}"
+      else
+        dest
+      end
+      CouchRest.copy "#{@root}/#{slug}", destination
+    end
+    
+    # MOVE an existing document to a new id. If the destination id currently exists, a rev must be provided.
+    # <tt>dest</tt> can take one of two forms if overwriting: "id_to_overwrite?rev=revision" or the actual doc
+    # hash with a '_rev' key
+    def move doc, dest
+      raise ArgumentError, "_id and _rev are required for moving" unless doc['_id'] && doc['_rev']
+      slug = escape_docid(doc['_id'])        
+      destination = if dest.respond_to?(:has_key?) && dest['_id'] && dest['_rev']
+        "#{dest['_id']}?rev=#{dest['_rev']}"
+      else
+        dest
+      end
+      CouchRest.move "#{@root}/#{slug}?rev=#{doc['_rev']}", destination
+    end
+    
+    # Compact the database, removing old document revisions and optimizing space use.
+    def compact!
+      CouchRest.post "#{@root}/_compact"
+    end
+
+    # DELETE the database itself. This is not undoable and could be rather
+    # catastrophic. Use with care!
+    def delete!
+      CouchRest.delete @root
+    end
+
+    private
+
+    def escape_docid id      
+      /^_design\/(.*)/ =~ id ? "_design/#{CGI.escape($1)}" : CGI.escape(id) 
+    end
+
+    def encode_attachments attachments
+      attachments.each do |k,v|
+        next if v['stub']
+        v['data'] = base64(v['data'])
+      end
+      attachments
+    end
+
+    def base64 data
+      Base64.encode64(data).gsub(/\s/,'')
+    end
+  end
+end

data/lib/couchrest/core/design.rb

@@ -0,0 +1,89 @@
+module CouchRest  
+  class Design < Document
+    def view_by *keys
+      opts = keys.pop if keys.last.is_a?(Hash)
+      opts ||= {}
+      self['views'] ||= {}
+      method_name = "by_#{keys.join('_and_')}"
+      
+      if opts[:map]
+        view = {}
+        view['map'] = opts.delete(:map)
+        if opts[:reduce]
+          view['reduce'] = opts.delete(:reduce)
+          opts[:reduce] = false
+        end
+        self['views'][method_name] = view
+      else
+        doc_keys = keys.collect{|k|"doc['#{k}']"} # this is where :require => 'doc.x == true' would show up
+        key_emit = doc_keys.length == 1 ? "#{doc_keys.first}" : "[#{doc_keys.join(', ')}]"
+        guards = opts.delete(:guards) || []
+        guards.concat doc_keys
+        map_function = <<-JAVASCRIPT
+function(doc) {
+  if (#{guards.join(' && ')}) {
+    emit(#{key_emit}, null);
+  }
+}
+JAVASCRIPT
+        self['views'][method_name] = {
+          'map' => map_function
+        }
+      end
+      self['views'][method_name]['couchrest-defaults'] = opts unless opts.empty?
+      method_name
+    end
+    
+    # Dispatches to any named view.
+    def view view_name, query={}, &block
+      view_name = view_name.to_s
+      view_slug = "#{name}/#{view_name}"
+      defaults = (self['views'][view_name] && self['views'][view_name]["couchrest-defaults"]) || {}
+      fetch_view(view_slug, defaults.merge(query), &block)
+    end
+
+    def name
+      id.sub('_design/','') if id
+    end
+
+    def name= newname
+      self['_id'] = "_design/#{newname}"
+    end
+
+    def save
+      raise ArgumentError, "_design docs require a name" unless name && name.length > 0
+      super
+    end
+
+    private
+
+    # returns stored defaults if the there is a view named this in the design doc
+    def has_view?(view)
+      view = view.to_s
+      self['views'][view] &&
+        (self['views'][view]["couchrest-defaults"]||{})
+    end
+
+    # def fetch_view_with_docs name, opts, raw=false, &block
+    #   if raw
+    #     fetch_view name, opts, &block
+    #   else
+    #     begin
+    #       view = fetch_view name, opts.merge({:include_docs => true}), &block
+    #       view['rows'].collect{|r|new(r['doc'])} if view['rows']
+    #     rescue
+    #       # fallback for old versions of couchdb that don't 
+    #       # have include_docs support
+    #       view = fetch_view name, opts, &block
+    #       view['rows'].collect{|r|new(database.get(r['id']))} if view['rows']
+    #     end
+    #   end
+    # end
+
+    def fetch_view view_name, opts, &block
+      database.view(view_name, opts, &block)
+    end
+
+  end
+  
+end

data/lib/couchrest/core/document.rb

@@ -0,0 +1,94 @@
+module CouchRest
+  class Response
+    def initialize keys = {}
+      @hash = {}
+      keys.each do |k,v|
+        self[k.to_s] = v
+      end
+    end
+    attr_reader :hash
+    def ==(other)
+      @hash == other.hash
+    end
+    def each(&blk)
+      @hash.each(&blk)
+    end
+    def []= key, value
+      @hash[key.to_s] = value
+    end
+    def [] key
+      @hash[key.to_s]
+    end
+    def to_json
+      @hash.to_json
+    end
+    def delete key
+      @hash.delete key
+    end
+    def key? key
+      @hash.key? key
+    end
+    def has_key? key
+      @hash.has_key key
+    end
+  end
+  
+  class Document < Response
+
+    attr_accessor :database
+
+    # alias for self['_id']
+    def id
+      self['_id']
+    end
+
+    # alias for self['_rev']      
+    def rev
+      self['_rev']
+    end
+
+    # returns true if the document has never been saved
+    def new_document?
+      !rev
+    end
+
+    # Saves the document to the db using create or update. Also runs the :save
+    # callbacks. Sets the <tt>_id</tt> and <tt>_rev</tt> fields based on
+    # CouchDB's response.
+    # If <tt>bulk</tt> is <tt>true</tt> (defaults to false) the document is cached for bulk save.
+    def save(bulk = false)
+      raise ArgumentError, "doc.database required for saving" unless database
+      result = database.save @hash, bulk
+      result['ok']
+    end
+
+    # Deletes the document from the database. Runs the :delete callbacks.
+    # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
+    # document to be saved to a new <tt>_id</tt>.
+    # If <tt>bulk</tt> is <tt>true</tt> (defaults to false) the document won't 
+    # actually be deleted from the db until bulk save.
+    def destroy(bulk = false)
+      raise ArgumentError, "doc.database required to destroy" unless database
+      result = database.delete(@hash, bulk)
+      if result['ok']
+        self['_rev'] = nil
+        self['_id'] = nil
+      end
+      result['ok']
+    end
+    
+    def copy(dest)
+      raise ArgumentError, "doc.database required to copy" unless database
+      result = database.copy(@hash, dest)
+      result['ok']
+    end
+    
+    def move(dest)
+      raise ArgumentError, "doc.database required to copy" unless database
+      result = database.move(@hash, dest)
+      result['ok']
+    end
+
+  end
+
+end

data/lib/couchrest/core/model.rb

@@ -0,0 +1,613 @@
+require 'rubygems'
+begin
+  require 'extlib'
+rescue 
+  puts "CouchRest::Model requires extlib. This is left out of the gemspec on purpose."
+  raise
+end
+require 'digest/md5'
+require File.dirname(__FILE__) + '/document'
+require 'mime/types'
+
+# = CouchRest::Model - Document modeling, the CouchDB way
+module CouchRest
+  # = CouchRest::Model - Document modeling, the CouchDB way
+  #    
+  # CouchRest::Model provides an ORM-like interface for CouchDB documents. It
+  # avoids all usage of <tt>method_missing</tt>, and tries to strike a balance
+  # between usability and magic. See CouchRest::Model#view_by for
+  # documentation about the view-generation system.
+  #    
+  # ==== Example
+  #    
+  # This is an example class using CouchRest::Model. It is taken from the
+  # spec/couchrest/core/model_spec.rb file, which may be even more up to date
+  # than this example.
+  #    
+  #   class Article < CouchRest::Model
+  #     use_database CouchRest.database!('http://127.0.0.1:5984/couchrest-model-test')
+  #     unique_id :slug
+  #
+  #     view_by :date, :descending => true
+  #     view_by :user_id, :date
+  #
+  #     view_by :tags,
+  #       :map => 
+  #         "function(doc) {
+  #           if (doc['couchrest-type'] == 'Article' && doc.tags) {
+  #             doc.tags.forEach(function(tag){
+  #               emit(tag, 1);
+  #             });
+  #           }
+  #         }",
+  #       :reduce => 
+  #         "function(keys, values, rereduce) {
+  #           return sum(values);
+  #         }"  
+  #
+  #     key_writer :date
+  #     key_reader :slug, :created_at, :updated_at
+  #     key_accessor :title, :tags
+  #
+  #     timestamps!
+  #
+  #     before(:create, :generate_slug_from_title)  
+  #     def generate_slug_from_title
+  #       self['slug'] = title.downcase.gsub(/[^a-z0-9]/,'-').squeeze('-').gsub(/^\-|\-$/,'')
+  #     end
+  #   end
+  #   
+  # ==== Examples of finding articles with these views: 
+  #   
+  # * All the articles by Barney published in the last 24 hours. Note that we
+  #   use <tt>{}</tt> as a special value that sorts after all strings,
+  #   numbers, and arrays.
+  #   
+  #     Article.by_user_id_and_date :startkey => ["barney", Time.now - 24 * 3600], :endkey => ["barney", {}]
+  #    
+  # * The most recent 20 articles. Remember that the <tt>view_by :date</tt>
+  #   has the default option <tt>:descending => true</tt>.
+  #  
+  #     Article.by_date :limit => 20
+  #  
+  # * The raw CouchDB view reduce result for the custom <tt>:tags</tt> view.
+  #   In this case we'll get a count of the number of articles tagged "ruby".
+  #  
+  #     Article.by_tags :key => "ruby", :reduce => true
+  #  
+  class Model < Document
+
+    # instantiates the hash by converting all the keys to strings.
+    def initialize keys = {}
+      super(keys)
+      apply_defaults
+      cast_keys
+      unless self['_id'] && self['_rev']
+        self['couchrest-type'] = self.class.to_s
+      end
+    end
+
+    # this is the CouchRest::Database that model classes will use unless
+    # they override it with <tt>use_database</tt>
+    cattr_accessor :default_database
+
+    class_inheritable_accessor :casts
+    class_inheritable_accessor :default_obj
+    class_inheritable_accessor :class_database
+    class_inheritable_accessor :design_doc
+    class_inheritable_accessor :design_doc_slug_cache
+    class_inheritable_accessor :design_doc_fresh
+
+    class << self
+      # override the CouchRest::Model-wide default_database
+      def use_database db
+        self.class_database = db
+      end
+
+      # returns the CouchRest::Database instance that this class uses
+      def database
+        self.class_database || CouchRest::Model.default_database
+      end
+
+      # Load a document from the database by id
+      def get id
+        doc = database.get id
+        new(doc)
+      end
+
+      # Load all documents that have the "couchrest-type" field equal to the
+      # name of the current class. Take the standard set of
+      # CouchRest::Database#view options.
+      def all opts = {}, &block
+        self.design_doc ||= Design.new(default_design_doc)
+        unless design_doc_fresh
+          refresh_design_doc
+        end
+        view :all, opts, &block
+      end
+      
+      # Load the first document that have the "couchrest-type" field equal to
+      # the name of the current class.
+      #
+      # ==== Returns
+      # Object:: The first object instance available
+      # or
+      # Nil:: if no instances available
+      #
+      # ==== Parameters
+      # opts<Hash>::
+      # View options, see <tt>CouchRest::Database#view</tt> options for more info.
+      def first opts = {}
+        first_instance = self.all(opts.merge!(:limit => 1))
+        first_instance.empty? ? nil : first_instance.first
+      end
+      
+      # Cast a field as another class. The class must be happy to have the
+      # field's primitive type as the argument to it's constuctur. Classes
+      # which inherit from CouchRest::Model are happy to act as sub-objects
+      # for any fields that are stored in JSON as object (and therefore are
+      # parsed from the JSON as Ruby Hashes).
+      # 
+      # Example:
+      #
+      #   class Post < CouchRest::Model
+      #
+      #     key_accessor :title, :body, :author
+      #
+      #     cast :author, :as => 'Author'
+      #
+      #   end
+      # 
+      #   post.author.class #=> Author
+      #
+      # Using the same example, if a Post should have many Comments, we 
+      # would declare it like this:
+      #
+      #   class Post < CouchRest::Model
+      #
+      #     key_accessor :title, :body, :author, comments
+      #
+      #     cast :author, :as => 'Author'
+      #     cast :comments, :as => ['Comment']
+      #
+      #   end
+      #
+      #   post.author.class #=> Author
+      #   post.comments.class #=> Array
+      #   post.comments.first #=> Comment
+      # 
+      def cast field, opts = {}
+        self.casts ||= {}
+        self.casts[field.to_s] = opts
+      end
+
+      # Defines methods for reading and writing from fields in the document.
+      # Uses key_writer and key_reader internally.
+      def key_accessor *keys
+        key_writer *keys
+        key_reader *keys
+      end
+
+      # For each argument key, define a method <tt>key=</tt> that sets the
+      # corresponding field on the CouchDB document.
+      def key_writer *keys
+        keys.each do |method|
+          key = method.to_s
+          define_method "#{method}=" do |value|
+            self[key] = value
+          end
+        end
+      end
+
+      # For each argument key, define a method <tt>key</tt> that reads the
+      # corresponding field on the CouchDB document.      
+      def key_reader *keys
+        keys.each do |method|
+          key = method.to_s
+          define_method method do
+            self[key]
+          end
+        end
+      end
+
+      def default
+        self.default_obj
+      end
+      
+      def set_default hash
+        self.default_obj = hash
+      end
+
+      # Automatically set <tt>updated_at</tt> and <tt>created_at</tt> fields
+      # on the document whenever saving occurs. CouchRest uses a pretty
+      # decent time format by default. See Time#to_json
+      def timestamps!
+        before(:save) do
+          self['updated_at'] = Time.now
+          self['created_at'] = self['updated_at'] if new_document?
+        end
+      end
+
+      # Name a method that will be called before the document is first saved,
+      # which returns a string to be used for the document's <tt>_id</tt>.
+      # Because CouchDB enforces a constraint that each id must be unique,
+      # this can be used to enforce eg: uniq usernames. Note that this id
+      # must be globally unique across all document types which share a
+      # database, so if you'd like to scope uniqueness to this class, you
+      # should use the class name as part of the unique id.
+      def unique_id method = nil, &block
+        if method
+          define_method :set_unique_id do
+            self['_id'] ||= self.send(method)
+          end
+        elsif block
+          define_method :set_unique_id do
+            uniqid = block.call(self)
+            raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
+            self['_id'] ||= uniqid
+          end
+        end
+      end
+
+      # Define a CouchDB view. The name of the view will be the concatenation
+      # of <tt>by</tt> and the keys joined by <tt>_and_</tt>
+      #  
+      # ==== Example views:
+      #  
+      #   class Post
+      #     # view with default options
+      #     # query with Post.by_date
+      #     view_by :date, :descending => true
+      #  
+      #     # view with compound sort-keys
+      #     # query with Post.by_user_id_and_date
+      #     view_by :user_id, :date
+      #  
+      #     # view with custom map/reduce functions
+      #     # query with Post.by_tags :reduce => true
+      #     view_by :tags,                                                
+      #       :map =>                                                     
+      #         "function(doc) {                                          
+      #           if (doc['couchrest-type'] == 'Post' && doc.tags) {                   
+      #             doc.tags.forEach(function(tag){                       
+      #               emit(doc.tag, 1);                                   
+      #             });                                                   
+      #           }                                                       
+      #         }",                                                       
+      #       :reduce =>                                                  
+      #         "function(keys, values, rereduce) {                       
+      #           return sum(values);                                     
+      #         }"                                                        
+      #   end
+      #  
+      # <tt>view_by :date</tt> will create a view defined by this Javascript
+      # function:
+      #  
+      #   function(doc) {
+      #     if (doc['couchrest-type'] == 'Post' && doc.date) {
+      #       emit(doc.date, null);
+      #     }
+      #   }
+      #  
+      # It can be queried by calling <tt>Post.by_date</tt> which accepts all
+      # valid options for CouchRest::Database#view. In addition, calling with
+      # the <tt>:raw => true</tt> option will return the view rows
+      # themselves. By default <tt>Post.by_date</tt> will return the
+      # documents included in the generated view.
+      #  
+      # CouchRest::Database#view options can be applied at view definition
+      # time as defaults, and they will be curried and used at view query
+      # time. Or they can be overridden at query time.
+      #  
+      # Custom views can be queried with <tt>:reduce => true</tt> to return
+      # reduce results. The default for custom views is to query with
+      # <tt>:reduce => false</tt>.
+      #  
+      # Views are generated (on a per-model basis) lazily on first-access.
+      # This means that if you are deploying changes to a view, the views for
+      # that model won't be available until generation is complete. This can
+      # take some time with large databases. Strategies are in the works.
+      #  
+      # To understand the capabilities of this view system more compeletly,
+      # it is recommended that you read the RSpec file at
+      # <tt>spec/core/model_spec.rb</tt>.
+
+      def view_by *keys
+        self.design_doc ||= Design.new(default_design_doc)
+        opts = keys.pop if keys.last.is_a?(Hash)
+        opts ||= {}
+        ducktype = opts.delete(:ducktype)
+        unless ducktype || opts[:map]
+          opts[:guards] ||= []
+          opts[:guards].push "(doc['couchrest-type'] == '#{self.to_s}')"
+        end
+        keys.push opts
+        self.design_doc.view_by(*keys)
+        self.design_doc_fresh = false
+      end
+
+      def method_missing m, *args
+        if has_view?(m)
+          query = args.shift || {}
+          view(m, query, *args)
+        else
+          super
+        end
+      end
+
+      # returns stored defaults if the there is a view named this in the design doc
+      def has_view?(view)
+        view = view.to_s
+        design_doc && design_doc['views'] && design_doc['views'][view]
+      end
+
+      # Dispatches to any named view.
+      def view name, query={}, &block
+        unless design_doc_fresh
+          refresh_design_doc
+        end
+        query[:raw] = true if query[:reduce]        
+        raw = query.delete(:raw)
+        fetch_view_with_docs(name, query, raw, &block)
+      end
+
+      def all_design_doc_versions
+        database.documents :startkey => "_design/#{self.to_s}-", 
+          :endkey => "_design/#{self.to_s}-\u9999"
+      end
+
+      # Deletes any non-current design docs that were created by this class. 
+      # Running this when you're deployed version of your application is steadily 
+      # and consistently using the latest code, is the way to clear out old design 
+      # docs. Running it to early could mean that live code has to regenerate
+      # potentially large indexes.
+      def cleanup_design_docs!
+        ddocs = all_design_doc_versions
+        ddocs["rows"].each do |row|
+          if (row['id'] != design_doc_id)
+            database.delete({
+              "_id" => row['id'],
+              "_rev" => row['value']['rev']
+            })
+          end
+        end
+      end
+
+      private
+
+      def fetch_view_with_docs name, opts, raw=false, &block
+        if raw
+          fetch_view name, opts, &block
+        else
+          begin
+            view = fetch_view name, opts.merge({:include_docs => true}), &block
+            view['rows'].collect{|r|new(r['doc'])} if view['rows']
+          rescue
+            # fallback for old versions of couchdb that don't 
+            # have include_docs support
+            view = fetch_view name, opts, &block
+            view['rows'].collect{|r|new(database.get(r['id']))} if view['rows']
+          end
+        end
+      end
+
+      def fetch_view view_name, opts, &block
+        retryable = true
+        begin
+          design_doc.view(view_name, opts, &block)
+          # the design doc could have been deleted by a rouge process
+        rescue RestClient::ResourceNotFound => e
+          if retryable
+            refresh_design_doc
+            retryable = false
+            retry
+          else
+            raise e
+          end
+        end
+      end
+
+      def design_doc_id
+        "_design/#{design_doc_slug}"
+      end
+
+      def design_doc_slug
+        return design_doc_slug_cache if design_doc_slug_cache && design_doc_fresh
+        funcs = []
+        design_doc['views'].each do |name, view|
+          funcs << "#{name}/#{view['map']}#{view['reduce']}"
+        end
+        md5 = Digest::MD5.hexdigest(funcs.sort.join(''))
+        self.design_doc_slug_cache = "#{self.to_s}-#{md5}"
+      end
+
+      def default_design_doc
+        {
+          "language" => "javascript",
+          "views" => {
+            'all' => {
+              'map' => "function(doc) {
+                if (doc['couchrest-type'] == '#{self.to_s}') {
+                  emit(null,null);
+                }
+              }"
+            }
+          }
+        }
+      end
+
+      def refresh_design_doc
+        did = design_doc_id
+        saved = database.get(did) rescue nil
+        if saved
+          design_doc['views'].each do |name, view|
+            saved['views'][name] = view
+          end
+          database.save(saved)
+          self.design_doc = saved
+        else
+          design_doc['_id'] = did
+          design_doc.delete('_rev')
+          design_doc.database = database
+          design_doc.save
+        end
+        self.design_doc_fresh = true
+      end
+
+    end # class << self
+
+    # returns the database used by this model's class
+    def database
+      self.class.database
+    end
+
+    # Takes a hash as argument, and applies the values by using writer methods
+    # for each key. It doesn't save the document at the end. Raises a NoMethodError if the corresponding methods are
+    # missing. In case of error, no attributes are changed.    
+    def update_attributes_without_saving hash
+      hash.each do |k, v|
+        raise NoMethodError, "#{k}= method not available, use key_accessor or key_writer :#{k}" unless self.respond_to?("#{k}=")
+      end      
+      hash.each do |k, v|
+        self.send("#{k}=",v)
+      end
+    end
+
+    # Takes a hash as argument, and applies the values by using writer methods
+    # for each key. Raises a NoMethodError if the corresponding methods are
+    # missing. In case of error, no attributes are changed.
+    def update_attributes hash
+      update_attributes_without_saving hash
+      save
+    end
+
+    # for compatibility with old-school frameworks
+    alias :new_record? :new_document? 
+
+    # Overridden to set the unique ID.
+    def save bulk = false
+      set_unique_id if new_document? && self.respond_to?(:set_unique_id)
+      super(bulk)
+    end
+    
+    # Saves the document to the db using create or update. Raises an exception
+    # if the document is not saved properly.
+    def save!
+      raise "#{self.inspect} failed to save" unless self.save
+    end
+
+    # Deletes the document from the database. Runs the :destroy callbacks.
+    # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
+    # document to be saved to a new <tt>_id</tt>.
+    def destroy
+      result = database.delete self
+      if result['ok']
+        self['_rev'] = nil
+        self['_id'] = nil
+      end
+      result['ok']
+    end
+
+    # creates a file attachment to the current doc
+    def create_attachment(args={})
+      raise ArgumentError unless args[:file] && args[:name]
+      return if has_attachment?(args[:name])
+      self['_attachments'] ||= {}
+      set_attachment_attr(args)
+    rescue ArgumentError => e
+      raise ArgumentError, 'You must specify :file and :name'
+    end
+    
+    # reads the data from an attachment
+    def read_attachment(attachment_name)
+      Base64.decode64(database.fetch_attachment(self.id, attachment_name))
+    end
+    
+    # modifies a file attachment on the current doc
+    def update_attachment(args={})
+      raise ArgumentError unless args[:file] && args[:name]
+      return unless has_attachment?(args[:name])
+      delete_attachment(args[:name])
+      set_attachment_attr(args)
+    rescue ArgumentError => e
+      raise ArgumentError, 'You must specify :file and :name'
+    end
+    
+    # deletes a file attachment from the current doc
+    def delete_attachment(attachment_name)
+      return unless self['_attachments']
+      self['_attachments'].delete attachment_name
+    end
+    
+    # returns true if attachment_name exists
+    def has_attachment?(attachment_name)
+      !!(self['_attachments'] && self['_attachments'][attachment_name] && !self['_attachments'][attachment_name].empty?)
+    end
+
+    # returns URL to fetch the attachment from
+    def attachment_url(attachment_name)
+      return unless has_attachment?(attachment_name)
+      "#{database.root}/#{self.id}/#{attachment_name}"
+    end
+
+    private
+
+    def apply_defaults
+      return unless new_document?
+      if self.class.default
+        self.class.default.each do |k,v|
+          unless self.key?(k.to_s)
+            if v.class == Proc
+              self[k.to_s] = v.call
+            else
+              self[k.to_s] = Marshal.load(Marshal.dump(v))
+            end
+          end
+        end
+      end
+    end
+
+    def cast_keys
+      return unless self.class.casts
+      # TODO move the argument checking to the cast method for early crashes
+      self.class.casts.each do |k,v|
+        next unless self[k]
+        target = v[:as]
+        v[:send] || 'new'
+        if target.is_a?(Array)
+          klass = ::Extlib::Inflection.constantize(target[0])
+          self[k] = self[k].collect do |value|
+            (!v[:send] && klass == Time) ? Time.parse(value) : klass.send((v[:send] || 'new'), value)
+          end
+        else
+          self[k] = if (!v[:send] && target == 'Time') 
+            Time.parse(self[k])
+          else
+            ::Extlib::Inflection.constantize(target).send((v[:send] || 'new'), self[k])
+          end
+        end
+      end
+    end
+
+    def encode_attachment(data)
+      Base64.encode64(data).gsub(/\r|\n/,'')
+    end
+    
+    def get_mime_type(file)
+      MIME::Types.type_for(file.path).empty? ? 
+        'text\/plain' : MIME::Types.type_for(file.path).first.content_type.gsub(/\//,'\/')
+    end
+
+    def set_attachment_attr(args)
+      content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file])
+      self['_attachments'][args[:name]] = {
+        'content-type' => content_type,
+        'data'         => encode_attachment(args[:file].read)
+      }
+    end
+
+    include ::Extlib::Hook
+    register_instance_hooks :save, :destroy
+
+  end # class Model
+end # module CouchRest