careo-makura 0.1

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2008 Michael Fellinger <m.fellinger@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Makura
+
+Makura is a Ruby wrapper around the CouchDB REST API.
+
+It doesn't provide a lot of bells and whistles, but aims to be as close to the
+original API as possible, while taking advantage of Ruby's expressive power.
+
+Most ideas for this have been gathered while trying other libraries such as
+CouchObject, CouchRest, and RelaxDB.
+
+It does so with almost no modification of ruby libraries and makes it simple
+to switch the HTTP library used by changing one method.
+Eventually Makura will be using an evented http library to provide better
+performance.
+
+We are using the json library, which adds following methods:
+To Kernel: #j, #jj, #JSON
+To Object and most core classes: #to_json
+To String: #to_json_raw_object, #to_json, #to_json_raw
+
+## Dependencies
+
+* CouchDB - 0.9 trunk (rev 725909 and higher)
+* rest-client
+* rack
+* json
+
+## Features
+
+* Simple Models, the CouchDB way and without magic.
+* Free choice of inheritance, just include the Makura::Model module.
+* Smart interpretation of returned JSON.
+* Direct mapping of javascript files to map/reduce functions for views.
+* CouchDB specific error reporting, no meaningless HTTP status code.
+* Live update of views during runtime.
+* Easy configuration, possibility to use different servers and databases each
+  model.
+
+## Usage
+
+See the /example/blog.rb

data/bin/makura

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'makura'
+
+Makura::Model.database = ARGV.shift
+DB = Makura::Model.database
+
+puts "Your database is assigned to DB"
+
+require 'irb'
+IRB.start

data/example/blog.rb

@@ -0,0 +1,53 @@
+require 'makura'
+
+# Setting up everything
+
+# Makura::Model.server = 'http://localhost:5984'
+Makura::Model.database = 'mydb'
+
+class Post
+  include Makura::Model
+
+  properties :title, :text, :tags
+  belongs_to :author
+
+  layout :all
+
+  validates(:title){ presence and length :within => (3..100) }
+  validates(:text){ presence }
+
+  save # submit design docs to CouchDB
+end
+
+class Author
+  include Makura::Model
+
+  property :name
+
+  layout :posts, :reduce => :sum_length
+  layout :all
+
+  save
+end
+
+class Comment
+  include Makura::Model
+
+  property :text
+end
+
+# And here it goes.
+
+author = Author.new('name' => 'Michael Fellinger')
+author.save
+
+post = Post.new(
+  :title => 'Hello, World!',
+  :text => 'This is my first post',
+  :author => author)
+post.save
+
+Post.view(:all).each do |post|
+  p post
+  p post.author
+end

data/example/couch/map/author_all.js

@@ -0,0 +1,5 @@
+function(doc){
+  if(doc.type == 'Author'){
+    emit(doc._id, doc);
+  }
+}

data/example/couch/map/author_posts.js

@@ -0,0 +1,5 @@
+function(doc){
+  if(doc.type == 'Post' && doc.user){
+    emit(doc.user, doc);
+  }
+}

data/example/couch/map/post_all.js

@@ -0,0 +1,5 @@
+function(doc){
+  if(doc.type == 'Post'){
+    emit(doc._id, doc);
+  }
+}

data/example/couch/map/post_comments.js

@@ -0,0 +1,5 @@
+function(doc){
+  if(doc.type == 'Comment'){
+    emit(doc._id, doc);
+  }
+}

data/example/couch/reduce/sum_length.js

@@ -0,0 +1,7 @@
+function(keys, values, rereduce){
+  if(rereduce){
+    return sum(values);
+  } else {
+    return values.length;
+  }
+}

data/lib/makura.rb

@@ -0,0 +1,62 @@
+require 'pp'
+require 'uri'
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'rest_client'
+require 'json'
+
+module Makura
+  VERSION = '2008.01.15'
+  ROOT = File.expand_path(File.dirname(__FILE__))
+end
+
+unless $LOAD_PATH.any?{|lp| File.expand_path(lp) == Makura::ROOT }
+  $LOAD_PATH.unshift(Makura::ROOT)
+end
+
+require 'makura/error'
+require 'makura/http_methods'
+require 'makura/server'
+require 'makura/database'
+require 'makura/uuid_cache'
+require 'makura/model'
+require 'makura/design'
+require 'makura/layout'
+
+module Makura
+  CHARS = (48..128).map{|c| c.chr}.grep(/[[:alnum:]]/)
+  MOD = CHARS.size
+
+  module_function
+
+  # From Rack
+  def escape(s)
+    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+      '%'+$1.unpack('H2'*$1.size).join('%').upcase
+    }.tr(' ', '+')
+  end
+
+  def pretty_from_md5(md5)
+    id = md5.to_i(16)
+    o = []
+    while id > 0
+      id, r = id.divmod(MOD)
+      o.unshift CHARS[r]
+    end
+    o.join
+  end
+
+  def pretty_to_md5(id)
+    i = 0
+    id.scan(/./) do |c|
+      i = i * MOD + CHARS.index(c)
+    end
+    i.to_s(16)
+  end
+end
+
+Sofa = Makura # be backwards compatible

data/lib/makura/database.rb

@@ -0,0 +1,216 @@
+module Makura
+  class Database
+    include HTTPMethods
+    attr_accessor :server, :name
+
+    # Initialize instance of Database and create if it doesn't exist yet.
+    # To prevent automatic creation, pass false as 3rd parameter
+    #
+    # Usage:
+    #   server = Makura::Server.new
+    #   # #<URI::HTTP:0xb7788234 URL:http://localhost:5984>
+    #   database = Makura::Database.new(server, 'foo')
+    #   # #<Makura::Database 'http://localhost:5984/foo'>
+
+    def initialize(server, name, auto_create = true)
+      @server, @name = server, name
+      create if auto_create
+    end
+
+    # Create the database if it doesn't exist already.
+    #
+    # Usage:
+    #   server = Makura::Server.new
+    #   # #<URI::HTTP:0xb76a4a98 URL:http://localhost:5984>
+    #
+    #   database = Makura::Database.new(server, 'foo', false)
+    #   # #<Makura::Database 'http://localhost:5984/foo'>
+    #
+    #   database.create
+    #   # {"update_seq"=>0, "doc_count"=>0, "purge_seq"=>0, "disk_size"=>4096,
+    #   #  "compact_running"=>false, "db_name"=>"foo", "doc_del_count"=>0}
+
+    def create
+      info
+    rescue Error::ResourceNotFound
+      put("/", :payload => '')
+    end
+
+    # Will delete document in the CouchDB corresponding to given +doc+.
+    # Use #destroy to delete the database itself.
+    # Use #delete! to automatically rescue exceptions on conflicts.
+    #
+    # Possible variations (User is a Makura::Model) are:
+    #
+    #   # deleting based on explicit _id and :rev option.
+    #   database.delete('manveru', :rev => 123134)
+    #
+    #   # deleting based on a Hash
+    #   database.delete('_id' => 'manveru', '_rev' => 123134)
+    #
+    #   user = User.new(:name => 'manveru')
+    #   user.save
+    #   database.delete(user)
+    #
+    # Usage when deleting document:
+    #   doc = database.save('name' => 'manveru', 'time' => Time.now)
+    #   # {"rev"=>"484030692", "id"=>"67e086087d5b7e7196b5c99174b0b66c", "ok"=>true}
+    #
+    #   database[doc['id']]
+    #   # {"name"=>"manveru", "_rev"=>"484030692",
+    #      "time"=>"Sat Nov 22 16:37:50 +0900 2008",
+    #      "_id"=>"67e086087d5b7e7196b5c99174b0b66c"}
+    #
+    #   database.delete(doc['id'], :rev => doc['rev'])
+    #   # {"rev"=>"2034883605", "id"=>"67e086087d5b7e7196b5c99174b0b66c", "ok"=>true}
+    #
+    #   database[doc['id']]
+    #   RestClient::ResourceNotFound: RestClient::ResourceNotFound
+    #
+    #   database.delete(doc['id'], :rev => doc['rev'])
+    #   Makura::RequestFailed: {"reason"=>"Document update conflict.", "error"=>"conflict"}
+
+    def delete(doc, opts = {})
+      case doc
+      when Makura::Model
+        doc_id, doc_rev = doc._id, doc._rev
+      when Hash
+        doc_id  = doc['_id']  || doc['id']  || doc[:_id]  || doc[:id]
+        doc_rev = doc['_rev'] || doc['rev'] || doc[:_rev] || doc[:rev]
+      else
+        doc_id = doc
+      end
+
+      raise(ArgumentError, "document _id wasn't passed") unless doc_id
+
+      doc_id = Makura.escape(doc_id)
+      opts[:rev] ||= doc_rev if doc_rev
+
+      request(:delete, doc_id.to_s, opts)
+    end
+
+    def delete!(doc, opts = {})
+      delete(doc, opts)
+    rescue Error::Conflict, Error::ResourceNotFound
+    end
+
+    # Delete the database itself.
+    #
+    # Usage:
+    #   database.destroy
+    #   # {"ok"=>true}
+    #   database.info
+    #   # RestClient::ResourceNotFound: RestClient::ResourceNotFound
+
+    def destroy(opts = {})
+      request(:delete, '/', opts)
+    end
+
+    def destroy!(opts = {})
+      destroy(opts)
+    rescue Error::ResourceNotFound
+    end
+
+    def info
+      get('/')
+    end
+
+    def all_docs(params = {})
+      get('_all_docs')
+    end
+    alias documents all_docs
+
+    def [](id, rev = nil)
+      id = Makura.escape(id)
+      if rev
+        get(id, :rev => rev)
+      else
+        get(id)
+      end
+    end
+
+    def []=(id, doc)
+      id = Makura.escape(id)
+      put(id, :payload => prepare_doc(doc))
+    end
+
+    def temp_view(params = {})
+      params[:payload] = functions = {}
+      functions[:map] = params.delete(:map) if params[:map]
+      functions[:reduce] = params.delete(:reduce) if params[:reduce]
+      params['Content-Type'] = 'application/json'
+
+      post('_temp_view', params)
+    end
+
+    def view(layout, params = {})
+      get("_view/#{layout}", params)
+    end
+
+    def save(doc)
+      if id = doc['_id']
+        id = Makura.escape(id)
+        put(id, :payload => prepare_doc(doc))
+      else
+        id = doc['_id'] = @server.next_uuid
+        id = Makura.escape(id)
+        put(id, :payload => prepare_doc(doc))
+      end
+    end
+
+    # NOTE:
+    #   * Seems like we don't even need to check _id, CouchDB will assign it.
+    #     But in order to use our own uuids we still do it.
+    def bulk_docs(docs)
+      docs.each{|doc| doc['_id'] ||= @server.next_uuid }
+      post("_bulk_docs", :payload => {:docs => docs})
+    end
+    alias bulk_save bulk_docs
+
+    def get_attachment(doc, file_id)
+      doc_id = doc.respond_to?(:_id) ? doc._id : doc.to_str
+      file_id, doc_id = Makura.escape(file_id), Makura.escape(doc_id)
+
+      get("#{doc_id}/#{file_id}", :raw => true)
+    end
+
+    # PUT an attachment directly to CouchDB
+    def put_attachment(doc, file_id, file, options = {})
+      doc_id, file_id = Makura.escape(doc._id), Makura.escape(file_id)
+
+      options[:payload] = file
+      options[:raw] = true
+      options[:rev] = doc._rev if doc._rev
+
+      put("#{doc_id}/#{file_id}", options)
+    end
+
+    def prepare_doc(doc)
+      if attachments = doc['_attachments']
+        doc['_attachments'] = encode_attachments(attachments)
+      end
+
+      return doc
+    end
+
+    def request(method, path, params = {})
+      @server.send(:request, method, "/#{name}/#{path}", params)
+    end
+
+    def encode_attachments(attachments)
+      attachments.each do |key, value|
+        next if value['stub']
+        value['data'] = base64(value['data'])
+      end
+      attachments
+    end
+
+    def base64(data)
+      [data.to_s].pack('m').delete("\n")
+    end
+
+    def inspect
+      "#<Makura::Database '#{@server.uri(name)}'>"
+    end
+  end
+end