norr-couchrest 0.30

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/history.txt

@@ -0,0 +1,19 @@
+== 0.30
+ 
+* Major enhancements
+ 
+  * Added support for pagination (John Wood)
+  * Improved performance when initializing documents with timestamps (Matt Aimonetti)
+ 
+* Minor enhancements
+ 
+  * Extended the API to retrieve an attachment URI (Matt Aimonetti)
+  * Bug fix: default value should be able to be set as false (Alexander Uvarov)
+  * Bug fix: validates_is_numeric should be able to properly validate a Float instance (Rob Kaufman)
+  * Bug fix: fixed the Timeout implementation (Seth Falcon)
+  
+  
+---
+
+Unfortunately, before 0.30 we did not keep a track of the modifications made to CouchRest.
+You can see the full commit history on GitHub: http://github.com/mattetti/couchrest/commits/master/

data/lib/couchrest.rb

@@ -0,0 +1,198 @@
+# 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 'rubygems'
+begin
+  require 'json'
+rescue LoadError
+  raise "You need install and require your own json compatible library since couchrest rest couldn't load the json/json_pure gem" unless Kernel.const_defined?("JSON")
+end
+require 'rest_client'
+
+$:.unshift File.dirname(__FILE__) unless
+  $:.include?(File.dirname(__FILE__)) ||
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+    
+require 'couchrest/monkeypatches'
+
+# = CouchDB, close to the metal
+module CouchRest
+  VERSION    = '0.30' unless self.const_defined?("VERSION")
+  
+  autoload :Server,       'couchrest/core/server'
+  autoload :Database,     'couchrest/core/database'
+  autoload :Response,     'couchrest/core/response'
+  autoload :Document,     'couchrest/core/document'
+  autoload :Design,       'couchrest/core/design'
+  autoload :View,         'couchrest/core/view'
+  autoload :Model,        'couchrest/core/model'
+  autoload :Pager,        'couchrest/helper/pager'
+  autoload :FileManager,  'couchrest/helper/file_manager'
+  autoload :Streamer,     'couchrest/helper/streamer'
+  autoload :Upgrade,      'couchrest/helper/upgrade'
+  
+  autoload :ExtendedDocument,     'couchrest/more/extended_document'
+  autoload :CastedModel,          'couchrest/more/casted_model'
+  
+  require File.join(File.dirname(__FILE__), 'couchrest', 'mixins')
+  
+  # The CouchRest 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
+
+    # extracted from Extlib
+    #
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # @example
+    # "Module".constantize #=> Module
+    # "Class".constantize #=> Class
+    def constantize(camel_cased_word)
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+    
+    # extracted from Extlib
+    #    
+    # Capitalizes the first word and turns underscores into spaces and strips _id.
+    # Like titleize, this is meant for creating pretty output.
+    #
+    # @example
+    #   "employee_salary" #=> "Employee salary"
+    #   "author_id" #=> "Author"
+    def humanize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+    
+    # 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 /^http:\/\/(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /^http:\/\/(.*)\/(.*)/
+        host = $1
+        db = $2
+      when /^http:\/\/(.*)/
+        host = $1
+      when /(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /(.*)\/(.*)/
+        host = $1
+        db = $2
+      else
+        db = url
+      end
+
+      db = nil if db && db.empty?
+
+      {
+        :host => host || "127.0.0.1:5984",
+        :database => db,
+        :doc => docid
+      }
+    end
+
+    # set proxy for RestClient to use
+    def proxy url
+      RestClient.proxy = url
+    end
+
+    # 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 = CouchRest.new(parsed[:host])
+      cr.database!(parsed[:database])
+    end
+  
+    def database url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database(parsed[:database])
+    end
+    
+    def put(uri, doc = nil)
+      payload = doc.to_json if doc
+      begin
+        JSON.parse(RestClient.put(uri, payload))
+      rescue Exception => e
+        if $DEBUG
+          raise "Error while sending a PUT request #{uri}\npayload: #{payload.inspect}\n#{e}"
+        else
+          raise e
+        end
+      end
+    end
+
+    def get(uri)
+      begin
+        JSON.parse(RestClient.get(uri), :max_nesting => false)
+      rescue => e
+        if $DEBUG
+          raise "Error while sending a GET request #{uri}\n: #{e}"
+        else
+          raise e
+        end
+      end
+    end
+  
+    def post uri, doc = nil
+      payload = doc.to_json if doc
+      begin
+        JSON.parse(RestClient.post(uri, payload))
+      rescue Exception => e
+        if $DEBUG
+          raise "Error while sending a POST request #{uri}\npayload: #{payload.inspect}\n#{e}"
+        else
+          raise e
+        end
+      end
+    end
+  
+    def delete uri
+      JSON.parse(RestClient.delete(uri))
+    end
+    
+    def copy uri, destination
+      JSON.parse(RestClient.copy(uri, {'Destination' => destination}))
+    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/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