mattetti-couchrest 0.2

data/examples/word_count/markov

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__)) + '/../../couchrest'
+
+cr = CouchRest.new("http://127.0.0.1:5984")
+@db = cr.database('word-count-example')
+@word_memoizer = {}
+
+def probable_follower_for(word)
+  @word_memoizer[word] ||= @db.view('markov/chain-reduce', :startkey => [word,nil], :endkey => [word,{}],:group_level => 2)
+  
+  # puts
+  # puts "search #{word} #{wprobs[word]['rows'].length}"
+  # @word_memoizer[word]['rows'].sort_by{|r|r['value']}.each{|r|puts [r['value'],r['key']].inspect}
+  
+  rows = @word_memoizer[word]['rows'].select{|r|(r['key'][1]!='')}.sort_by{|r|r['value']}
+  row = rows[(-1*[rows.length,5].min)..-1].sort_by{rand}[0]
+  row ? row['key'][1] : nil
+end
+
+
+word = ARGV[0]
+words = [word]
+
+while word
+  $stdout.print ' ' if words.length > 1
+  $stdout.print word
+  $stdout.flush
+  word = probable_follower_for(word)
+  words << word
+end
+
+$stdout.print '.'
+$stdout.flush
+puts
+
+# `say #{words.join(' ')}`
+

data/examples/word_count/views/books/chunked-map.js

@@ -0,0 +1,3 @@
+function(doc) {
+  doc.title && doc.chunk && emit([doc.title, doc.chunk],null);
+}

data/examples/word_count/views/books/united-map.js

@@ -0,0 +1 @@
+function(doc){if(doc.text && doc.text.match(/united/))  emit([doc.title, doc.chunk],null)}

data/examples/word_count/views/markov/chain-map.js

@@ -0,0 +1,6 @@
+function(doc){
+  var words = doc.text.split(/\W/).filter(function(w) {return w.length > 0}).map(function(w){return w.toLowerCase()});
+  for (var i = 0, l = words.length; i < l; i++) {
+    emit(words.slice(i,4),doc.title);
+  }
+}

data/examples/word_count/views/markov/chain-reduce.js

@@ -0,0 +1,7 @@
+function(key,vs,c){
+  if (c) {
+    return sum(vs);
+  } else {
+    return vs.length;
+  }
+}

data/examples/word_count/views/word_count/count-map.js

@@ -0,0 +1,6 @@
+function(doc){
+  var words = doc.text.split(/\W/).map(function(w){return w.toLowerCase()});
+  words.forEach(function(word){
+    if (word.length > 0) emit([word,doc.title],1);
+  });
+}

data/examples/word_count/views/word_count/count-reduce.js

@@ -0,0 +1,3 @@
+function(key,values){
+  return sum(values);
+}

data/examples/word_count/word_count.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'couchrest'
+
+couch = CouchRest.new("http://127.0.0.1:5984")
+db = couch.database('word-count-example')
+db.delete! rescue nil
+db = couch.create_db('word-count-example')
+
+books = {
+  'outline-of-science.txt' => 'http://www.gutenberg.org/files/20417/20417.txt',
+  'ulysses.txt' => 'http://www.gutenberg.org/dirs/etext03/ulyss12.txt',
+  'america.txt' => 'http://www.gutenberg.org/files/16960/16960.txt',
+  'da-vinci.txt' => 'http://www.gutenberg.org/dirs/etext04/7ldv110.txt'
+}
+
+books.each do |file, url|
+  pathfile = File.join(File.dirname(__FILE__),file)
+  `curl #{url} > #{pathfile}` unless File.exists?(pathfile)  
+end
+
+
+books.keys.each do |book|
+  title = book.split('.')[0]
+  puts title
+  File.open(File.join(File.dirname(__FILE__),book),'r') do |file|
+    lines = []
+    chunk = 0
+    while line = file.gets
+      lines << line
+      if lines.length > 10
+        db.save({
+          :title => title,
+          :chunk => chunk, 
+          :text => lines.join('')
+        })
+        chunk += 1
+        puts chunk
+        lines = []
+      end
+    end
+  end
+end
+
+# puts "The books have been stored in your CouchDB. To initiate the MapReduce process, visit http://127.0.0.1:5984/_utils/ in your browser and click 'word-count-example', then select view 'words' or 'count'. The process could take about 15 minutes on an average MacBook."
+
+

data/examples/word_count/word_count_query.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'couchrest'
+
+couch = CouchRest.new("http://127.0.0.1:5984")
+db = couch.database('word-count-example')
+
+puts "Now that we've parsed all those books into CouchDB, the queries we can run are incredibly flexible."
+puts "\nThe simplest query we can run is the total word count for all words in all documents:"
+puts "this will take a few minutes the first time. if it times out, just rerun this script in a few few minutes."
+puts db.view('word_count/words').inspect
+
+puts "\nWe can also narrow the query down to just one word, across all documents. Here is the count for 'flight' in all three books:"
+
+word = 'flight'
+params = {
+  :startkey => [word], 
+  :endkey => [word,{}]
+  }
+
+puts db.view('word_count/words',params).inspect
+
+puts "\nWe scope the query using startkey and endkey params to take advantage of CouchDB's collation ordering. Here are the params for the last query:"
+puts params.inspect
+
+puts "\nWe can also count words on a per-title basis."
+
+title = 'da-vinci'
+params = {
+  :key => [word, title]
+  }
+  
+puts db.view('word_count/words',params).inspect
+
+
+puts "\nHere are the params for 'flight' in the da-vinci book:"
+puts params.inspect
+puts
+puts 'The url looks like this:'
+puts 'http://127.0.0.1:5984/word-count-example/_view/word_count/count?key=["flight","da-vinci"]'
+puts "\nTry dropping that in your browser..."

data/examples/word_count/word_count_views.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'couchrest'
+
+couch = CouchRest.new("http://127.0.0.1:5984")
+db = couch.database('word-count-example')
+
+word_count = {
+  :map => 'function(doc){
+    var words = doc.text.split(/\W/);
+    words.forEach(function(word){
+      if (word.length > 0) emit([word,doc.title],1);
+    });
+  }',
+  :reduce => 'function(key,combine){
+    return sum(combine);
+  }'
+}
+
+db.delete db.get("_design/word_count") rescue nil
+
+db.save({
+  "_id" => "_design/word_count",
+  :views => {
+    :words => word_count
+  }
+})

data/lib/couchrest/commands/generate.rb

@@ -0,0 +1,71 @@
+require 'fileutils'
+
+module CouchRest
+  module Commands
+    module Generate
+
+      def self.run(options)
+        directory    = options[:directory]
+        design_names = options[:trailing_args]
+
+        FileUtils.mkdir_p(directory)
+        filename = File.join(directory, "lib.js")
+        self.write(filename, <<-FUNC)
+        // Put global functions here.
+        // Include in your views with
+        //
+        //   //include-lib
+        FUNC
+
+        design_names.each do |design_name|
+          subdirectory = File.join(directory, design_name)
+          FileUtils.mkdir_p(subdirectory)
+          filename = File.join(subdirectory, "sample-map.js")
+          self.write(filename, <<-FUNC)
+          function(doc) {
+            // Keys is first letter of _id
+            emit(doc._id[0], doc);
+          }
+          FUNC
+
+          filename = File.join(subdirectory, "sample-reduce.js")
+          self.write(filename, <<-FUNC)
+          function(keys, values) {
+            // Count the number of keys starting with this letter
+            return values.length;
+          }
+          FUNC
+
+          filename = File.join(subdirectory, "lib.js")
+          self.write(filename, <<-FUNC)
+          // Put functions specific to '#{design_name}' here.
+          // Include in your views with
+          //
+          //   //include-lib
+          FUNC
+        end
+      end
+
+      def self.help
+        helpstring = <<-GEN
+
+        Usage: couchview generate directory design1 design2 design3 ...
+
+        Couchview will create directories and example views for the design documents you specify.
+
+        GEN
+        helpstring.gsub(/^        /, '')
+      end
+
+      def self.write(filename, contents)
+        puts "Writing #{filename}"
+        File.open(filename, "w") do |f|
+          # Remove leading spaces
+          contents.gsub!(/^        (  )?/, '')
+          f.write contents
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/commands/push.rb

@@ -0,0 +1,103 @@
+module CouchRest
+
+  module Commands
+
+    module Push
+
+      def self.run(options)
+        directory = options[:directory]
+        database  = options[:trailing_args].first
+        
+        fm      = CouchRest::FileManager.new(database)
+        fm.loud = options[:loud]
+
+        if options[:loud]
+          puts "Pushing views from directory #{directory} to database #{fm.db}"
+        end
+
+        fm.push_views(directory)
+      end
+
+      def self.help
+        helpstring = <<-GEN
+
+        == Pushing views with Couchview ==
+
+        Usage: couchview push directory dbname
+
+        Couchview expects a specific filesystem layout for your CouchDB views (see
+        example below). It also supports advanced features like inlining of library
+        code (so you can keep DRY) as well as avoiding unnecessary document
+        modification.
+
+        Couchview also solves a problem with CouchDB's view API, which only provides
+        access to the final reduce side of any views which have both a map and a
+        reduce function defined. The intermediate map results are often useful for
+        development and production. CouchDB is smart enough to reuse map indexes for
+        functions duplicated across views within the same design document.
+
+        For views with a reduce function defined, Couchview creates both a reduce view
+        and a map-only view, so that you can browse and query the map side as well as
+        the reduction, with no performance penalty.
+
+        == Example ==
+
+        couchview push foo-project/bar-views baz-database
+
+        This will push the views defined in foo-project/bar-views into a database
+        called baz-database. Couchview expects the views to be defined in files with
+        names like:
+
+        foo-project/bar-views/my-design/viewname-map.js
+        foo-project/bar-views/my-design/viewname-reduce.js
+        foo-project/bar-views/my-design/noreduce-map.js
+
+        Pushed to => http://127.0.0.1:5984/baz-database/_design/my-design
+
+        And the design document:
+        {
+          "views" : {
+            "viewname-map" : {
+              "map" : "### contents of view-name-map.js ###"
+            },
+            "viewname-reduce" : {
+              "map" : "### contents of view-name-map.js ###",
+              "reduce" : "### contents of view-name-reduce.js ###"
+            },
+            "noreduce-map" : {
+              "map" : "### contents of noreduce-map.js ###"
+            }
+          }
+        }
+
+        Couchview will create a design document for each subdirectory of the views
+        directory specified on the command line.
+
+        == Library Inlining ==
+
+        Couchview can optionally inline library code into your views so you only have
+        to maintain it in one place. It looks for any files named lib.* in your
+        design-doc directory (for doc specific libs) and in the parent views directory
+        (for project global libs). These libraries are only inserted into views which
+        include the text
+
+        // !include lib
+
+        or
+
+        # !include lib
+
+        Couchview is a result of scratching my own itch. I'd be happy to make it more
+        general, so please contact me at jchris@grabb.it if you'd like to see anything
+        added or changed.
+
+        GEN
+        helpstring.gsub(/^        /, '')
+      end
+
+    end
+
+
+  end
+
+end

data/lib/couchrest/core/database.rb

@@ -0,0 +1,313 @@
+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 = 50
+    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)
+      url = CouchRest.paramify_url "#{@uri}/_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("#{@uri}/#{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(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