jchris-couchrest 0.2.2 → 0.7.99

data/README

@@ -0,0 +1,39 @@
+Couchrest is a loose port of the couch.js library from CouchDB’s Futon admin interface, which I find to be concise, clear, and well designed.
+
+I prefer to stay close to the metal, especially when the metal is as clean and simple as CouchDB’s HTTP API. The main thing Couchrest does for you is manage the Ruby <=> JSON serialization, and point your actions (database creation, document CRUD, view creation and queries, etc) at the appropriate API endpoints.
+
+The core of Couchrest is Heroku’s excellent REST Client Ruby HTTP wrapper. REST Client takes all the nastyness of Net::HTTP and gives is a pretty face, while still giving you more control than Open-URI. I recommend it anytime you’re interfacing with a well-defined API. (We use it for Grabb.it’s Tumblr integration, and it works like a charm.)
+
+The most complete source of documentation are the spec files. To ensure that your environment is setup for successful CouchRest operation, from the project root directory run `autotest` or `spec spec` (requires RSpec and optionally ZenTest for autotest support). 
+
+Quick Start:
+
+@cr = CouchRest.new("http://localhost:5984")
+@db = @cr.create_db('couchrest-test')
+response = @db.save({:key => 'value', 'another key' => 'another value'})
+doc = @db.get(response['id'])
+puts doc.inspect
+
+
+Bulk Save:
+
+@db.bulk_save([
+    {"wild" => "and random"},
+    {"mild" => "yet local"},
+    {"another" => ["set","of","keys"]}
+  ])
+puts @db.documents.inspect # returns ids and revs of the current docs
+
+Creating and Querying Views:
+
+@db.save({
+  "_id" => "_design/first", 
+  :views => {
+    :test => {
+      :map => "function(doc){for(var w in doc){ if(!w.match(/^_/))emit(w,doc[w])}}"
+      }
+    }
+  })
+puts @db.view('first/test')['rows'].inspect 
+
+

data/Rakefile

@@ -1,66 +1,15 @@
 require 'rake'
-require "rake/rdoctask"
-require 'rake/gempackagetask'
-require File.join(File.expand_path(File.dirname(__FILE__)),'lib','couchrest')
-
-
-begin
-  require 'spec/rake/spectask'
-rescue LoadError
-  puts <<-EOS
-To use rspec for testing you must install rspec gem:
-    gem install rspec
-EOS
-  exit(0)
-end
-
-spec = Gem::Specification.new do |s|
-  s.name = "couchrest"
-  s.version = CouchRest::VERSION
-  s.date = "2008-11-22"
-  s.summary = "Lean and RESTful interface to CouchDB."
-  s.email = "jchris@apache.org"
-  s.homepage = "http://github.com/jchris/couchrest"
-  s.description = "CouchRest provides a simple interface on top of CouchDB's RESTful HTTP API, as well as including some utility scripts for managing views and attachments."
-  s.has_rdoc = true
-  s.authors = ["J. Chris Anderson", "Matt Aimonetti"]
-  s.files = %w( LICENSE README.md Rakefile THANKS.md ) + 
-    Dir["{examples,lib,spec,utils}/**/*"] - 
-    Dir["spec/tmp"]
-  s.extra_rdoc_files = %w( README.md LICENSE THANKS.md )
-  s.require_path = "lib"
-  s.add_dependency("json", ">= 1.1.2")
-  s.add_dependency("rest-client", ">= 0.5")
-  s.add_dependency("mime-types", ">= 1.15")
-end
-
-
-desc "create .gemspec file (useful for github)"
-task :gemspec do
-  filename = "#{spec.name}.gemspec"
-  File.open(filename, "w") do |f|
-    f.puts spec.to_ruby
-  end
-end
+require 'spec/rake/spectask'
 
 desc "Run all specs"
 Spec::Rake::SpecTask.new('spec') do |t|
-	t.spec_files = FileList['spec/**/*_spec.rb']
+	t.spec_files = FileList['spec/*_spec.rb']
 end
 
 desc "Print specdocs"
 Spec::Rake::SpecTask.new(:doc) do |t|
-	t.spec_opts = ["--format", "specdoc"]
+	t.spec_opts = ["--format", "specdoc", "--dry-run"]
 	t.spec_files = FileList['spec/*_spec.rb']
 end
 
-desc "Generate the rdoc"
-Rake::RDocTask.new do |rdoc|
-  files = ["README.rdoc", "LICENSE", "lib/**/*.rb"]
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README.rdoc"
-  rdoc.title = "CouchRest: Ruby CouchDB, close to the metal"
-end
-
-desc "Run the rspec"
 task :default => :spec

data/lib/couchrest.rb

@@ -1,183 +1,61 @@
-# 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"
-gem 'json'
 require 'json'
-gem 'rest-client'
 require 'rest_client'
 
-$:.unshift File.dirname(__FILE__) unless
-  $:.include?(File.dirname(__FILE__)) ||
-  $:.include?(File.expand_path(File.dirname(__FILE__)))
-  
-$COUCHREST_DEBUG ||= false
-  
-require 'couchrest/monkeypatches'
+require File.dirname(__FILE__) + '/database'
 
-# = CouchDB, close to the metal
-module CouchRest
-  VERSION    = '0.2.2' unless self.const_defined?("VERSION")
+class CouchRest
+  attr_accessor :uri
+  def initialize server = 'http://localhost:5984'
+    @uri = server
+  end
   
-  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'
+  # list all databases on the server
+  def databases
+    CouchRest.get "#{@uri}/_all_dbs"
+  end
   
-  autoload :ExtendedDocument,     'couchrest/more/extended_document'
-  autoload :CastedModel,          'couchrest/more/casted_model'
+  def database name
+    CouchRest::Database.new(@uri, name)
+  end
   
-  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
+  # get the welcome message
+  def info
+    CouchRest.get "#{@uri}/"
+  end
 
-    # 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
-    
-    # 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
+  # restart the couchdb instance
+  def restart!
+    CouchRest.post "#{@uri}/_restart"
+  end
+  
+  # create a database
+  def create_db name
+    CouchRest.put "#{@uri}/#{name}"
+    database name
+  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])
+  class << self
+    def put uri, doc = nil
+      payload = doc.to_json if doc
+      JSON.parse(RestClient.put(uri, payload))
     end
   
-    def database url
-      parsed = parse url
-      cr = CouchRest.new(parsed[:host])
-      cr.database(parsed[:database])
+    def get uri
+      JSON.parse(RestClient.get(uri), :max_nesting => false)
     end
     
-    def put(uri, doc = nil)
-      payload = doc.to_json if doc
-      begin
-        JSON.parse(RestClient.put(uri, payload))
-      rescue Exception => e
-        if $COUCHREST_DEBUG == true
-          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 $COUCHREST_DEBUG == true
-          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 $COUCHREST_DEBUG == true
-          raise "Error while sending a POST request #{uri}\npayload: #{payload.inspect}\n#{e}"
-        else
-          raise e
-        end
-      end
+      JSON.parse(RestClient.post(uri, payload))
     end
-  
+    
     def delete uri
       JSON.parse(RestClient.delete(uri))
     end
     
-    def copy uri, destination
-      JSON.parse(RestClient.copy(uri, {'Destination' => destination}))
-    end
-    
-    def move uri, destination
-      JSON.parse(RestClient.move(uri, {'Destination' => destination}))
-    end
-  
-    def paramify_url url, params = {}
-      if params && !params.empty?
+    def paramify_url url, params = nil
+      if params
         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)}"
@@ -186,5 +64,5 @@ module CouchRest
       end
       url
     end
-  end # class << self
-end
+  end  
+end

data/lib/database.rb

@@ -0,0 +1,83 @@
+require 'cgi'
+require "base64"
+require File.dirname(__FILE__) + '/couchrest'
+
+class CouchRest
+  class Database
+    attr_accessor :host, :name
+    def initialize host, name
+      @name = name
+      @host = host
+      @root = "#{host}/#{name}"
+    end
+    
+    def documents params = nil
+      url = CouchRest.paramify_url "#{@root}/_all_docs", params
+      CouchRest.get url  
+    end
+  
+    def temp_view funcs, params = nil
+      url = CouchRest.paramify_url "#{@root}/_temp_view", params
+      JSON.parse(RestClient.post(url, funcs.to_json, {"Content-Type" => 'application/json'}))
+    end
+  
+    def view name, params = nil
+      url = CouchRest.paramify_url "#{@root}/_view/#{name}", params
+      CouchRest.get url
+    end
+
+    # experimental
+    def search params = nil
+      url = CouchRest.paramify_url "#{@root}/_search", params
+      CouchRest.get url
+    end
+  
+    def get id
+      slug = CGI.escape(id) 
+      CouchRest.get "#{@root}/#{slug}"
+    end
+    
+    def fetch_attachment doc, name
+      doc = CGI.escape(doc)
+      name = CGI.escape(name)
+      RestClient.get "#{@root}/#{doc}/#{name}"
+    end
+    
+    # PUT or POST depending on presence of _id attribute
+    def save doc
+      if doc['_attachments']
+        doc['_attachments'] = encode_attachments(doc['_attachments'])
+      end
+      if doc['_id']
+        slug = CGI.escape(doc['_id'])
+        CouchRest.put "#{@root}/#{slug}", doc
+      else
+        CouchRest.post "#{@root}", doc
+      end
+    end
+    
+    def bulk_save docs
+      CouchRest.post "#{@root}/_bulk_docs", {:docs => docs}
+    end
+    
+    def delete doc
+      slug = CGI.escape(doc['_id'])
+      CouchRest.delete "#{@root}/#{slug}?rev=#{doc['_rev']}"
+    end
+    
+    def delete!
+      CouchRest.delete @root
+    end
+    private
+    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/script/couchdir

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+unless ARGV.length >= 2
+  puts "usage: couchdir path/to/directory db-name"
+  exit
+end
+
+dirname = ARGV[0].sub(/\/$/,'')
+dbname = ARGV[1]
+
+  
+
+puts "Shoving #{dirname} into #{dbname}."
+
+require File.expand_path(File.dirname(__FILE__)) + '/../couchrest'
+require 'fileutils'
+
+cr = CouchRest.new("http://localhost:5984")
+@db = cr.database(dbname)
+
+@content_types = {
+  "html"       => "text/html",
+  "htm"        => "text/html",
+  "png"        => "image/png",
+  "css"        => "text/css"
+}
+
+files = Dir.glob(File.join(dirname,"**","*"))
+attachments = {}
+files.each do |filename|
+  content = open(filename).read
+  aname = filename.split('/')
+  aname.shift
+  aname = aname.join('/')
+  attachments[aname] = {
+    "data" => content,
+    "content_type" => @content_types[aname.split('.').last]
+  }
+end
+
+puts attachments.keys.inspect
+
+doc = @db.get(dirname) rescue nil
+
+# puts "get: #{doc.inspect}"
+
+if doc
+  doc["_attachments"] = attachments
+else
+  doc = {
+    "_id" => dirname,
+    "_attachments" => attachments
+  }
+end
+
+# puts "saving: #{doc.inspect}"
+@db.save(doc)
+puts "saved"