sova 0.0.1

data/README.md

@@ -0,0 +1,4 @@
+# Sova is a CouchRest fork
+
+* Removed a lot of bulk
+* Added HTTPI support

data/lib/sova/database.rb

@@ -0,0 +1,349 @@
+require 'cgi'
+require "base64"
+
+module Sova
+  class Database
+    attr_reader :server, :host, :name, :root, :uri
+    attr_accessor :bulk_save_cache_limit
+     
+    # Create a Sova::Database adapter for the supplied Sova::Server
+    # and database name.
+    #  
+    # ==== Parameters
+    # server<Sova::Server>:: database host
+    # name<String>:: database name
+    #
+    def initialize(server, name)
+      @name = name
+      @server = server
+      @host = server.uri
+      @uri  = "/#{name.gsub('/','%2F')}"
+      @root = host + uri
+      @bulk_save_cache = []
+      @bulk_save_cache_limit = 500  # must be smaller than the uuid count
+    end
+    
+    # returns the database's uri
+    def to_s
+      @root
+    end
+    
+    # GET the database info from CouchDB
+    def info
+      HTTP.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 = Sova.paramify_url "#{@root}/_all_docs", params
+      if keys
+        HTTP.post(url, {:keys => keys})
+      else
+        HTTP.get url
+      end
+    end
+
+    # load a set of documents by passing an array of ids
+    def get_bulk(ids)
+      documents(:keys => ids, :include_docs => true)
+    end
+    alias :bulk_load :get_bulk
+  
+    # 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 = Sova.paramify_url "#{@root}/_temp_view", params
+      HTTP.post(url, funcs)
+    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 = Sova.paramify_url "#{@root}/_design/#{dname}/_view/#{vname}", params
+      if keys
+        HTTP.post(url, {:keys => keys})
+      else
+        HTTP.get url
+      end
+    end
+    
+    # GET a document from CouchDB, by id. Returns a Ruby Hash.
+    def get(id, params = {})
+      slug = escape_docid(id)
+      url = Sova.paramify_url("#{@root}/#{slug}", params)
+      result = HTTP.get(url)
+    end
+    
+    # GET an attachment directly from CouchDB
+    def fetch_attachment(doc, name)
+      uri = url_for_attachment(doc, name)
+      HTTP.request(:get, uri).body
+    end
+    
+    # PUT an attachment directly to CouchDB
+    def put_attachment(doc, name, file, options = {})
+      docid = escape_docid(doc['_id'])
+      uri = url_for_attachment(doc, name)
+      response = HTTP.request(:put, uri, file, options)
+      JSON.parse(response.body)
+    end
+    
+    # DELETE an attachment directly from CouchDB
+    def delete_attachment(doc, name, force=false)
+      uri = url_for_attachment(doc, name)
+      # this needs a rev
+      begin
+        HTTP.delete(uri)
+      rescue Exception => error
+        if force
+          # get over a 409
+          doc = get(doc['_id'])
+          uri = url_for_attachment(doc, name)
+          HTTP.delete(uri)
+        else
+          raise error
+        end
+      end
+    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.
+    #
+    # If <tt>batch</tt> is true (false by default) the document is saved in
+    # batch mode, "used to achieve higher throughput at the cost of lower
+    # guarantees. When [...] sent using this option, it is not immediately
+    # written to disk. Instead it is stored in memory on a per-user basis for a
+    # second or so (or the number of docs in memory reaches a certain point).
+    # After the threshold has passed, the docs are committed to disk. Instead
+    # of waiting for the doc to be written to disk before responding, CouchDB
+    # sends an HTTP 202 Accepted response immediately. batch=ok is not suitable
+    # for crucial data, but it ideal for applications like logging which can
+    # accept the risk that a small proportion of updates could be lost due to a
+    # crash."
+    def save_doc(doc, bulk = false, batch = false)
+      if doc['_attachments']
+        doc['_attachments'] = encode_attachments(doc['_attachments'])
+      end
+      if bulk
+        @bulk_save_cache << doc
+        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'])
+        begin     
+          uri = "#{@root}/#{slug}"
+          uri << "?batch=ok" if batch
+          HTTP.put uri, doc
+        rescue Sova::NotFound
+          p "resource not found when saving even tho an id was passed"
+          slug = doc['_id'] = @server.next_uuid
+          HTTP.put "#{@root}/#{slug}", doc
+        end
+      else
+        begin
+          slug = doc['_id'] = @server.next_uuid
+          HTTP.put "#{@root}/#{slug}", doc
+        rescue #old version of couchdb
+          HTTP.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
+    
+    # Save a document to CouchDB in bulk mode. See #save_doc's +bulk+ argument.
+    def bulk_save_doc(doc)
+      save_doc(doc, true)
+    end
+
+    # Save a document to CouchDB in batch mode. See #save_doc's +batch+ argument.
+    def batch_save_doc(doc)
+      save_doc(doc, false, true)
+    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
+      HTTP.post "#{@root}/_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'])        
+      HTTP.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(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
+      HTTP.copy "#{@root}/#{slug}", destination
+    end
+    
+    # Updates the given doc by yielding the current state of the doc
+    # and trying to update update_limit times. Returns the new doc
+    # if the doc was successfully updated without hitting the limit
+    def update_doc(doc_id, params = {}, update_limit=10)
+      resp = {'ok' => false}
+      new_doc = nil
+      last_fail = nil
+
+      until resp['ok'] or update_limit <= 0
+        doc = self.get(doc_id, params)  # grab the doc
+        new_doc = yield doc # give it to the caller to be updated
+        begin
+          resp = self.save_doc new_doc # try to PUT the updated doc into the db
+        rescue Sova::Conflict => e
+          update_limit -= 1
+          last_fail = e
+        end
+      end
+
+      raise last_fail unless resp['ok']
+      new_doc
+    end
+    
+    # Compact the database, removing old document revisions and optimizing space use.
+    def compact!
+      HTTP.post "#{@root}/_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 Sova::NotFound
+    ensure
+      create!
+    end
+
+    # Replicates via "pulling" from another database to this database. Makes no attempt to deal with conflicts.
+    def replicate_from(other_db, continuous = false, create_target = false)
+      replicate(other_db, continuous, :target => name, :create_target => create_target)
+    end
+
+    # Replicates via "pushing" to another database. Makes no attempt to deal with conflicts.
+    def replicate_to(other_db, continuous = false, create_target = false)
+      replicate(other_db, continuous, :source => name, :create_target => create_target)
+    end
+
+    # DELETE the database itself. This is not undoable and could be rather
+    # catastrophic. Use with care!
+    def delete!
+      HTTP.delete @root
+    end
+
+    private
+    
+    def replicate(other_db, continuous, options)
+      raise ArgumentError, "must provide a Sova::Database" unless other_db.kind_of?(Sova::Database)
+      raise ArgumentError, "must provide a target or source option" unless (options.key?(:target) || options.key?(:source))
+      payload = options
+      if options.has_key?(:target)
+        payload[:source] = other_db.root
+      else
+        payload[:target] = other_db.root
+      end
+      payload[:continuous] = continuous
+      HTTP.post "#{@host}/_replicate", payload
+    end
+
+    def uri_for_attachment(doc, name)
+      if doc.is_a?(String)
+        puts "Sova::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
+      "/#{docid}/#{name}#{rev}"
+    end
+
+    def url_for_attachment(doc, name)
+      @root + uri_for_attachment(doc, name)
+    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/sova/http.rb

@@ -0,0 +1,81 @@
+require "httpi"
+require "forwardable"
+
+module Sova
+  class HTTPError < StandardError
+    extend Forwardable
+
+    def_delegators :@response, :code, :headers, :body
+
+    def initialize response
+      @response = response
+    end
+  end
+  class NotFound < HTTPError; end
+  class Conflict < HTTPError; end
+  class Invalid < HTTPError; end
+
+  module HTTP
+    extend self
+
+    attr_accessor :adapter
+
+    def request method, uri, doc=nil, headers={}
+      request = HTTPI::Request.new
+      request.url     = uri
+      request.proxy   = Sova.proxy if Sova.proxy
+      request.body    = doc if doc
+      request.headers = {
+        "Content-Type" => "application/json",
+        "Accept"       => "application/json"
+      }.merge(headers)
+
+      response = HTTPI.request(method, request, adapter)
+      raise http_error(response) if response.error?
+      response
+    end
+
+    def put(uri, doc=nil, headers={})
+      doc = doc.to_json if doc
+      response = request(:put, uri, doc, headers)
+      JSON.parse(response.body, :max_nesting => false)
+    end
+
+    def get(uri)
+      response = request(:get, uri)
+      JSON.parse(response.body, :max_nesting => false)
+    end
+
+    def post(uri, doc=nil)
+      doc = doc.to_json if doc
+      response = request(:post, uri, doc)
+      JSON.parse(response.body, :max_nesting => false)
+    end
+
+    def delete(uri)
+      response = request(:delete, uri)
+      JSON.parse(response.body, :max_nesting => false)
+    end
+
+    def copy(uri, destination) 
+      headers = {'X-HTTP-Method-Override' => 'COPY', 'Destination' => destination}
+      response = request(:post, uri, nil, headers)
+      JSON.parse(response.body, :max_nesting => false)
+    end 
+
+    private
+
+    def http_error response
+      klass = 
+        case response.code
+        when 404 then
+          NotFound
+        when 409 then
+          Conflict
+        else
+          HTTPError
+        end
+      klass.new(response)
+    end
+  end
+end

data/lib/sova/server.rb

@@ -0,0 +1,50 @@
+module Sova
+  class Server
+    attr_accessor :uri, :uuid_batch_count, :available_databases
+    def initialize(server = 'http://127.0.0.1:5984', uuid_batch_count = 1000)
+      @uri = server
+      @uuid_batch_count = uuid_batch_count
+    end
+  
+    # Lists all databases on the server
+    def databases
+      HTTP.get "#{@uri}/_all_dbs"
+    end
+  
+    # Returns a Sova::Database for the given name
+    def database(name)
+      Sova::Database.new(self, name)
+    end
+  
+    # Creates the database if it doesn't exist
+    def database!(name)
+      create_db(name) rescue nil
+      database(name)
+    end
+  
+    # GET the welcome message
+    def info
+      HTTP.get "#{@uri}/"
+    end
+
+    # Create a database
+    def create_db(name)
+      HTTP.put "#{@uri}/#{name}"
+      database(name)
+    end
+
+    # Restart the CouchDB instance
+    def restart!
+      HTTP.post "#{@uri}/_restart"
+    end
+
+    # Retrive an unused UUID from CouchDB. Server instances manage caching a list of unused UUIDs.
+    def next_uuid(count = @uuid_batch_count)
+      @uuids ||= []
+      if @uuids.empty?
+        @uuids = HTTP.get("#{@uri}/_uuids?count=#{count}")["uuids"]
+      end
+      @uuids.pop
+    end
+  end
+end

data/lib/sova.rb

@@ -0,0 +1,100 @@
+# 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.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'json'
+    
+require 'sova/http'
+require 'sova/server'
+require 'sova/database'
+
+Sova::HTTP.adapter = :net_http
+
+# = CouchDB, close to the metal
+module Sova
+  VERSION = '1.0.1'
+
+  # The Sova module methods handle the basic JSON serialization 
+  # and deserialization, as well as query parameters. The module also includes
+  # some helpers for tasks like instantiating a new Database or Server instance.
+  class << self
+
+    # todo, make this parse the url and instantiate a Server or Database instance
+    # depending on the specificity.
+    def new(*opts)
+      Server.new(*opts)
+    end
+    
+    def parse url
+      case url
+      when /^(https?:\/\/)(.*)\/(.*)\/(.*)/
+        scheme = $1
+        host = $2
+        db = $3
+        docid = $4
+      when /^(https?:\/\/)(.*)\/(.*)/
+        scheme = $1
+        host = $2
+        db = $3
+      when /^(https?:\/\/)(.*)/
+        scheme = $1
+        host = $2
+      when /(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /(.*)\/(.*)/
+        host = $1
+        db = $2
+      else
+        db = url
+      end
+
+      db = nil if db && db.empty?
+      
+      {
+        :host => (scheme || "http://") + (host || "127.0.0.1:5984"),
+        :database => db,
+        :doc => docid
+      }
+    end
+
+    attr_accessor :proxy
+    
+    # ensure that a database exists
+    # creates it if it isn't already there
+    # returns it after it's been created
+    def database! url
+      parsed = parse url
+      cr = Sova.new(parsed[:host])
+      cr.database!(parsed[:database])
+    end
+  
+    def database url
+      parsed = parse url
+      cr = Sova.new(parsed[:host])
+      cr.database(parsed[:database])
+    end
+    
+    def paramify_url url, params = {}
+      if params && !params.empty?
+        query = params.collect do |k,v|
+          v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+          "#{k}=#{CGI.escape(v.to_s)}"
+        end.join("&")
+        url = "#{url}?#{query}"
+      end
+      url
+    end
+  end # class << self
+end

data/sova.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name     = "sova"
+  s.version  = "0.0.1"
+  s.date     = "2011-02-16"
+  s.summary  = "CouchDB library"
+  s.email    = "harry@vangberg.name"
+  s.homepage = "http://github.com/ichverstehe/sova"
+  s.has_rdoc = true
+  s.authors  = ["Harry Vangberg"]
+  s.files    = [
+    "README.md", 
+		"sova.gemspec", 
+		"lib/sova.rb",
+    "lib/sova/database.rb",
+    "lib/sova/http.rb",
+    "lib/sova/server.rb"
+  ]
+end
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: sova
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Harry Vangberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-16 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: harry@vangberg.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- sova.gemspec
+- lib/sova.rb
+- lib/sova/database.rb
+- lib/sova/http.rb
+- lib/sova/server.rb
+has_rdoc: true
+homepage: http://github.com/ichverstehe/sova
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: CouchDB library
+test_files: []
+