makura 2009.05.27

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,50 @@
+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
+
+  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,66 @@
+require 'pp'
+require 'uri'
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'rest_client'
+require 'json'
+
+module Makura
+  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/version'
+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
+
+  def constant(name, root = Module)
+    name.split('::').inject(root){|s,v| s.const_get(v) }
+  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("_design/#{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

data/lib/makura/design.rb

@@ -0,0 +1,37 @@
+module Makura
+  class Design
+    attr_accessor :database, :name, :language
+    attr_reader :layouts
+
+    def initialize(name, database = nil)
+      @name, @database = name, database
+      @language = 'javascript'
+      @layouts = {}
+    end
+
+    def save
+      hash = to_hash
+      doc = @database[hash['_id']]
+      doc['views'] = hash['views']
+      @database.save(doc)
+    rescue Makura::Error::ResourceNotFound
+      @database.save(to_hash)
+    end
+
+    def [](layout_name)
+      @layouts[layout_name.to_s]
+    end
+
+    def []=(layout_name, layout)
+      @layouts[layout_name.to_s] = layout
+    end
+
+    def to_hash
+      views = {}
+      @layouts.each{|name, layout| views[name] = layout.to_hash }
+      views.delete_if{|k,v| !(v[:map] || v['map']) }
+
+      {'language' => @language, '_id' => "_design/#{@name}", 'views' => views}
+    end
+  end
+end

data/lib/makura/error.rb

@@ -0,0 +1,14 @@
+module Makura
+  # Mother and namespace of all exceptions
+  class Error < ::RuntimeError
+    class ConnectionRefused < Error; end
+    class RequestFailed < Error; end
+    class ResourceNotFound < RequestFailed; end
+    class Conflict < RequestFailed; end
+    class MissingRevision < RequestFailed; end
+    class BadRequest < RequestFailed; end
+    class Authorization < RequestFailed; end
+    class NotFound < RequestFailed; end
+    class FileExists < RequestFailed; end
+  end
+end

data/lib/makura/http_methods.rb

@@ -0,0 +1,19 @@
+module Makura
+  module HTTPMethods
+    def delete(path, params = {})
+      request(:delete, path, params)
+    end
+
+    def get(path, params = {})
+      request(:get, path, params)
+    end
+
+    def post(path, params = {})
+      request(:post, path, params)
+    end
+
+    def put(path, params = {})
+      request(:put, path, params)
+    end
+  end
+end