samflores-couchrest 0.2.1

data/lib/couchrest/core/response.rb

@@ -0,0 +1,16 @@
+module CouchRest
+  class Response < Hash
+    def initialize(pkeys = {})
+      pkeys ||= {}
+      pkeys.each do |k,v|
+        self[k.to_s] = v
+      end
+    end
+    def []=(key, value)
+      super(key.to_s, value)
+    end
+    def [](key)
+      super(key.to_s)
+    end
+  end
+end

data/lib/couchrest/core/server.rb

@@ -0,0 +1,88 @@
+module CouchRest
+  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 "available" databases.
+    # An available database, is a database that was specified
+    # as avaiable by your code.
+    # It allows to define common databases to use and reuse in your code
+    def available_databases
+      @available_databases ||= {}
+    end
+    
+    # Adds a new available database and create it unless it already exists
+    #
+    # Example:
+    #
+    # @couch = CouchRest::Server.new
+    # @couch.define_available_database(:default, "tech-blog")
+    #
+    def define_available_database(reference, db_name, create_unless_exists = true)
+      available_databases[reference.to_sym] = create_unless_exists ? database!(db_name) : database(db_name)
+    end
+  
+    # Checks that a database is set as available
+    #
+    # Example:
+    #
+    # @couch.available_database?(:default)
+    #
+    def available_database?(ref_or_name)
+      ref_or_name.is_a?(Symbol) ? available_databases.keys.include?(ref_or_name) : available_databases.values.map{|db| db.name}.include?(ref_or_name)
+    end
+  
+    def default_database=(name, create_unless_exists = true)
+      define_available_database(:default, name, create_unless_exists = true)
+    end
+    
+    def default_database
+      available_databases[:default]
+    end
+  
+    # Lists all databases on the server
+    def databases
+      CouchRest.get "#{@uri}/_all_dbs"
+    end
+  
+    # Returns a CouchRest::Database for the given name
+    def database(name)
+      CouchRest::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
+      CouchRest.get "#{@uri}/"
+    end
+
+    # Create a database
+    def create_db(name)
+      CouchRest.put "#{@uri}/#{name}"
+      database(name)
+    end
+
+    # Restart the CouchDB instance
+    def restart!
+      CouchRest.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 = CouchRest.get("#{@uri}/_uuids?count=#{count}")["uuids"]
+      end
+      @uuids.pop
+    end
+
+  end
+end

data/lib/couchrest/core/view.rb

@@ -0,0 +1,4 @@
+module CouchRest
+  class View
+  end
+end

data/lib/couchrest/helper/pager.rb

@@ -0,0 +1,103 @@
+module CouchRest
+  class Pager
+    attr_accessor :db
+    def initialize db
+      @db = db
+    end
+    
+    def all_docs(limit=100, &block)
+      startkey = nil
+      oldend = nil
+      
+      while docrows = request_all_docs(limit+1, startkey)        
+        startkey = docrows.last['key']
+        docrows.pop if docrows.length > limit
+        if oldend == startkey
+          break
+        end
+        yield(docrows)
+        oldend = startkey
+      end
+    end
+    
+    def key_reduce(view, limit=2000, firstkey = nil, lastkey = nil, &block)
+      # start with no keys
+      startkey = firstkey
+      # lastprocessedkey = nil
+      keepgoing = true
+      
+      while keepgoing && viewrows = request_view(view, limit, startkey)
+        startkey = viewrows.first['key']
+        endkey = viewrows.last['key']
+
+        if (startkey == endkey)
+          # we need to rerequest to get a bigger page
+          # so we know we have all the rows for that key
+          viewrows = @db.view(view, :key => startkey)['rows']
+          # we need to do an offset thing to find the next startkey
+          # otherwise we just get stuck
+          lastdocid = viewrows.last['id']
+          fornextloop = @db.view(view, :startkey => startkey, :startkey_docid => lastdocid, :limit => 2)['rows']
+
+          newendkey = fornextloop.last['key']
+          if (newendkey == endkey)
+            keepgoing = false
+          else
+            startkey = newendkey
+          end
+          rows = viewrows
+        else
+          rows = []
+          for r in viewrows
+            if (lastkey && r['key'] == lastkey)
+              keepgoing = false
+              break
+            end
+            break if (r['key'] == endkey)
+            rows << r
+          end   
+          startkey = endkey
+        end
+        
+        key = :begin
+        values = []
+
+        rows.each do |r|
+          if key != r['key']
+            # we're on a new key, yield the old first and then reset
+            yield(key, values) if key != :begin
+            key = r['key']
+            values = []
+          end
+          # keep accumulating
+          values << r['value']
+        end
+        yield(key, values)
+
+      end
+    end
+
+    private
+    
+    def request_all_docs limit, startkey = nil
+      opts = {}
+      opts[:limit] = limit if limit
+      opts[:startkey] = startkey if startkey      
+      results = @db.documents(opts)
+      rows = results['rows']
+      rows unless rows.length == 0
+    end
+
+    def request_view view, limit = nil, startkey = nil, endkey = nil
+      opts = {}
+      opts[:limit] = limit if limit
+      opts[:startkey] = startkey if startkey
+      opts[:endkey] = endkey if endkey
+      
+      results = @db.view(view, opts)
+      rows = results['rows']
+      rows unless rows.length == 0
+    end
+
+  end
+end

data/lib/couchrest/helper/streamer.rb

@@ -0,0 +1,44 @@
+module CouchRest
+  class Streamer
+    attr_accessor :db
+    def initialize db
+      @db = db
+    end
+    
+    # Stream a view, yielding one row at a time. Shells out to <tt>curl</tt> to keep RAM usage low when you have millions of rows.
+    def view name, params = nil, &block
+      urlst = /^_/.match(name) ? "#{@db.root}/#{name}" : "#{@db.root}/_view/#{name}"
+      url = CouchRest.paramify_url urlst, params
+      # puts "stream #{url}"
+      first = nil
+      IO.popen("curl --silent #{url}") do |view|
+        first = view.gets # discard header
+        while line = view.gets 
+          row = parse_line(line)
+          block.call row
+        end
+      end
+      parse_first(first)
+    end
+    
+    private
+    
+    def parse_line line
+      return nil unless line
+      if /(\{.*\}),?/.match(line.chomp)
+        JSON.parse($1)
+      end
+    end
+
+    def parse_first first
+      return nil unless first
+      parts = first.split(',')
+      parts.pop
+      line = parts.join(',')
+      JSON.parse("#{line}}")
+    rescue
+      nil
+    end
+    
+  end
+end

data/lib/couchrest/mixins/attachments.rb

@@ -0,0 +1,31 @@
+module CouchRest
+  module Mixins
+    module Attachments
+    
+      # saves an attachment directly to couchdb
+      def put_attachment(name, file, options={})
+        raise ArgumentError, "doc must be saved" unless self.rev
+        raise ArgumentError, "doc.database required to put_attachment" unless database
+        result = database.put_attachment(self, name, file, options)
+        self['_rev'] = result['rev']
+        result['ok']
+      end
+
+      # returns an attachment's data
+      def fetch_attachment(name)
+        raise ArgumentError, "doc must be saved" unless self.rev
+        raise ArgumentError, "doc.database required to put_attachment" unless database
+        database.fetch_attachment(self, name)
+      end
+
+      # deletes an attachment directly from couchdb
+      def delete_attachment(name)
+        raise ArgumentError, "doc.database required to delete_attachment" unless database
+        result = database.delete_attachment(self, name)
+        self['_rev'] = result['rev']
+        result['ok']
+      end
+    
+    end
+  end
+end