jchris-couchrest 0.2.2 → 0.7.99

data/lib/couchrest/core/database.rb

@@ -1,318 +0,0 @@
-require 'cgi'
-require "base64"
-
-module CouchRest
-  class Database
-    attr_reader :server, :host, :name, :root, :uri
-    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
-      @uri = @root = "#{host}/#{name}"
-      @streamer = Streamer.new(self)
-      @bulk_save_cache = []
-      @bulk_save_cache_limit = 500  # must be smaller than the uuid count
-    end
-    
-    # returns the database's uri
-    def to_s
-      @uri
-    end
-    
-    # GET the database info from CouchDB
-    def info
-      CouchRest.get @uri
-    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 "#{@uri}/_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 "#{@uri}/_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)
-      name = name.split('/') # I think this will always be length == 2, but maybe not...
-      dname = name.shift
-      vname = name.join('/')
-      url = CouchRest.paramify_url "#{@uri}/_design/#{dname}/_view/#{vname}", params
-      if keys
-        CouchRest.post(url, {:keys => keys})
-      else
-        if block_given?
-          @streamer.view("_design/#{dname}/_view/#{vname}", params, &block)
-        else
-          CouchRest.get url
-        end
-      end
-    end
-    
-    # GET a document from CouchDB, by id. Returns a Ruby Hash.
-    def get(id, params = {})
-      slug = escape_docid(id)
-      url = CouchRest.paramify_url("#{@uri}/#{slug}", params)
-      result = CouchRest.get(url)
-      return result unless result.is_a?(Hash)
-      doc = if /^_design/ =~ result["_id"]
-        Design.new(result)
-      else
-        Document.new(result)
-      end
-      doc.database = self
-      doc
-    end
-    
-    # GET an attachment directly from CouchDB
-    def fetch_attachment(doc, name)
-      # slug = escape_docid(docid)        
-      # name = CGI.escape(name)
-      uri = uri_for_attachment(doc, name)
-      RestClient.get uri
-      # "#{@uri}/#{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 = uri_for_attachment(doc, name)       
-      JSON.parse(RestClient.put(uri, file, options))
-    end
-    
-    # DELETE an attachment directly from CouchDB
-    def delete_attachment doc, name
-      uri = uri_for_attachment(doc, name)
-      # this needs a rev
-      JSON.parse(RestClient.delete(uri))
-    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(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 "#{@uri}/#{slug}", doc
-      else
-        begin
-          slug = doc['_id'] = @server.next_uuid
-          CouchRest.put "#{@uri}/#{slug}", doc
-        rescue #old version of couchdb
-          CouchRest.post @uri, 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
-    
-    ### DEPRECATION NOTICE
-    def save(doc, bulk=false)
-      puts "CouchRest::Database's save method is being deprecated, please use save_doc instead"
-      save_doc(doc, bulk)
-    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 "#{@uri}/_bulk_docs", {:docs => docs}
-    end
-    alias :bulk_delete :bulk_save
-    
-    # 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(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 "#{@uri}/#{slug}?rev=#{doc['_rev']}"
-    end
-    
-    ### DEPRECATION NOTICE
-    def delete(doc, bulk=false)
-      puts "CouchRest::Database's delete method is being deprecated, please use delete_doc instead"
-      delete_doc(doc, bulk)
-    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(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 "#{@uri}/#{slug}", destination
-    end
-    
-    ### DEPRECATION NOTICE
-    def copy(doc, dest)
-      puts "CouchRest::Database's copy method is being deprecated, please use copy_doc instead"
-      copy_doc(doc, dest)
-    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(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 "#{@uri}/#{slug}?rev=#{doc['_rev']}", destination
-    end
-    
-    ### DEPRECATION NOTICE
-    def move(doc, dest)
-      puts "CouchRest::Database's move method is being deprecated, please use move_doc instead"
-      move_doc(doc, dest)
-    end
-    
-    # Compact the database, removing old document revisions and optimizing space use.
-    def compact!
-      CouchRest.post "#{@uri}/_compact"
-    end
-    
-    # Create the database
-    def create!
-      bool = server.create_db(@name) rescue false
-      bool && true
-    end
-    
-    # Delete and re create the database
-    def recreate!
-      delete!
-      create!
-    rescue RestClient::ResourceNotFound
-    ensure
-      create!
-    end
-    
-    # Replicates via "pulling" from another database to this database. Makes no attempt to deal with conflicts.
-    def replicate_from other_db
-      raise ArgumentError, "must provide a CouchReset::Database" unless other_db.kind_of?(CouchRest::Database)
-      CouchRest.post "#{@host}/_replicate", :source => other_db.root, :target => name
-    end
-    
-    # Replicates via "pushing" to another database. Makes no attempt to deal with conflicts.
-    def replicate_to other_db
-      raise ArgumentError, "must provide a CouchReset::Database" unless other_db.kind_of?(CouchRest::Database)
-      CouchRest.post "#{@host}/_replicate", :target => other_db.root, :source => name
-    end
-    
-    # DELETE the database itself. This is not undoable and could be rather
-    # catastrophic. Use with care!
-    def delete!
-      CouchRest.delete @uri
-    end
-
-    private
-    
-    def uri_for_attachment(doc, name)
-      if doc.is_a?(String)
-        puts "CouchRest::Database#fetch_attachment will eventually require a doc as the first argument, not a doc.id"
-        docid = doc
-        rev = nil
-      else
-        docid = doc['_id']
-        rev = doc['_rev']
-      end
-      docid = escape_docid(docid)
-      name = CGI.escape(name)
-      rev = "?rev=#{doc['_rev']}" if rev
-      "#{@root}/#{docid}/#{name}#{rev}"
-    end
-    
-    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

@@ -1,89 +0,0 @@
-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

@@ -1,96 +0,0 @@
-require 'delegate'
-
-module CouchRest  
-  class Document < Response
-    include CouchRest::Mixins::Attachments
-
-    # def self.inherited(subklass)
-    #   subklass.send(:class_inheritable_accessor, :database)
-    # end
-    
-    class_inheritable_accessor :database
-    attr_accessor :database
-    
-    # override the CouchRest::Model-wide default_database
-    # This is not a thread safe operation, do not change the model
-    # database at runtime.
-    def self.use_database(db)
-      self.database = db
-    end
-    
-    def id
-      self['_id']
-    end
-    
-    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_doc self, 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_doc(self, bulk)
-      if result['ok']
-        self['_rev'] = nil
-        self['_id'] = nil
-      end
-      result['ok']
-    end
-    
-    # copies the 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(dest)
-      raise ArgumentError, "doc.database required to copy" unless database
-      result = database.copy_doc(self, dest)
-      result['ok']
-    end
-    
-    # moves the 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(dest)
-      raise ArgumentError, "doc.database required to copy" unless database
-      result = database.move_doc(self, dest)
-      result['ok']
-    end
-    
-    # Returns the CouchDB uri for the document
-    def uri(append_rev = false)
-      return nil if new_document?
-      couch_uri = "http://#{database.uri}/#{CGI.escape(id)}"
-      if append_rev == true
-        couch_uri << "?rev=#{rev}"
-      elsif append_rev.kind_of?(Integer)
-        couch_uri << "?rev=#{append_rev}"
-      end
-      couch_uri
-    end
-    
-    # Returns the document's database
-    def database
-      @database || self.class.database
-    end
-    
-  end
-  
-end