dispaaro-couch 0.1

data/.gitignore

@@ -0,0 +1,11 @@
+coverage
+test.sqlite3*
+*.pid
+*.lck
+pkg
+test/tmp/*
+test/log
+*.gemspec
+
+
+.DS_Store

data/Rakefile

@@ -0,0 +1,15 @@
+load "#{File.dirname __FILE__}/vex/gem.rake"
+
+task :default => :test
+
+task :test do
+  sh "ruby test/test.rb"
+end
+
+task :rcov do
+  sh "cd test; rcov -o ../coverage -x gems -x ^test.rb test.rb"
+end
+
+task :rdoc do
+  sh "rdoc -o doc/rdoc"
+end

data/gem.yml

@@ -0,0 +1,13 @@
+name: "dispaaro-couch"
+version: "0.1"
+summary: "A CouchDB handler"
+description: "Yet another CouchDB handler"
+homepage: http://github.com/radiospiel/dispaaro-couch  
+author: radiospiel
+email: eno@open-lab.org  
+dependencies:
+  - etest
+  # - nokogiri
+  # - sanitize
+  # - htmlentities
+  # - json

data/lib/couch.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'dlog'
+require 'vex'
+
+module Couch
+  def self.database
+    Thread.current[:database]
+  end
+
+  def self.database=(database)
+    Thread.current[:database] = database
+  end
+
+  def self.connect(host, port, db, recreate=false)
+    self.database = Database.new host, port, db, recreate
+  end
+
+  def self.disconnect
+    Thread.current[:database] = nil
+  end
+end
+
+load "#{File.dirname(__FILE__)}/couch/extras.rb"
+
+load "#{File.dirname(__FILE__)}/couch/log.rb"
+load "#{File.dirname(__FILE__)}/couch/database.rb"
+load "#{File.dirname(__FILE__)}/couch/document.rb"
+load "#{File.dirname(__FILE__)}/couch/server.rb"
+load "#{File.dirname(__FILE__)}/couch/error.rb"
+load "#{File.dirname(__FILE__)}/couch/view.rb"
+load "#{File.dirname(__FILE__)}/couch/doc_view.rb"

data/lib/couch/database.rb

@@ -0,0 +1,137 @@
+require 'uuid'
+
+class Couch::Database
+  include Couch::Log
+
+  def memoized_views
+    @memoized_views ||= {}
+  end
+
+  def initialize(host, port, db, recreate = false)
+    @server = Couch::Server.new host, port
+    @db = db
+
+    if recreate
+      Couch::Error.ignore { @server.delete("/#{db}") }
+      @server.put("/#{db}/", "")
+    else
+      Couch::Error.ignore { @server.put("/#{db}/", "") }
+    end
+  end
+
+  # -- forward HTTP methods to server object.
+
+  def get(url)
+    @server.get("/#{@db}/#{url}")
+  end
+
+  def post(url, data)
+    @server.post("/#{@db}/#{url}", data)
+  end
+
+  def put(url, data)
+    @server.put("/#{@db}/#{url}", data)
+  end
+
+  def delete(url)
+    @server.delete("/#{@db}/#{url}")
+  end
+
+  # -- document CRUD methods
+
+  module Base
+    def create(doc)
+      raise unless doc.new_record?
+
+      doc.id ||= UUID.new.generate
+
+      r = put(doc.id, doc)
+      doc.send :update_rev, r[:rev]
+    end
+
+    #
+    # read couch document from server
+    def read(id)
+      r = get(id)
+      Couch::Document.instantiate r
+    end
+
+    def update(doc)
+      r = put(doc.id, doc)
+      doc.send :update_rev, r[:rev]
+    end
+
+    def destroy(doc)
+      delete("#{doc.id}?rev=#{doc.rev}")
+    end
+  end
+
+  include Base
+  
+  # -- document bulk methods
+  
+  module Bulk
+    def self.included(klass)
+      klass.send :protected, :do_bulked
+    end
+    
+    def create(doc)
+      return super unless @bulk
+      
+      raise unless doc.new_record?
+      doc.id ||= UUID.new.generate
+
+      @bulk << doc
+    end
+
+    def read(id)
+      flush
+      super
+    end
+
+    def update(doc)
+      flush
+      super
+    end
+
+    def destroy(doc)
+      flush
+      super
+    end
+    
+    def async(&block)
+      if @bulk
+        yield
+      else
+        do_bulked(&block)
+      end
+    end
+    
+    def do_bulked(&block)
+      @bulk = []
+      yield
+      flush
+    ensure
+      @bulk = nil
+    end
+    
+    def flush
+      return unless @bulk
+      bulk = @bulk
+      @bulk = nil
+      
+      docs_by_id = {}
+      bulk.each do |doc|
+        docs_by_id[doc.id] = doc
+      end
+
+      post("_bulk_docs", :docs => bulk).
+        each do |rev_data|
+          id, rev = rev_data[:id], rev_data[:rev]
+          docs_by_id[id].send :update_rev, rev
+        end
+    end
+  end
+  
+  include Bulk
+end

data/lib/couch/doc_view.rb

@@ -0,0 +1,77 @@
+class Couch::DocView < Couch::View
+  def self.find_or_create(klass, opts)
+    name = name_for(klass, opts)
+
+    database.memoized_views[name] ||= begin
+      Couch::DocView.find(name) ||
+      Couch::DocView.create(klass, name, opts)
+    end
+  end
+  
+  def self.create(klass, name, opts = {})
+    map = <<-JS
+      function(doc) { 
+        if(doc.type == #{klass.name.to_json}) { emit(#{key_expression(opts[:keys])}, 1); }
+      }
+    JS
+
+    reduce = "_sum" if opts[:mode] == :count
+
+    super name, :map => map, :reduce => reduce
+  end
+
+  private
+
+  def self.name_for(klass, opts)
+    mode = opts[:mode]
+    keys = opts[:keys]
+
+    name = klass.to_s + ":#{mode}"
+    return name if keys.empty?
+    
+    "#{name}_by_" + keys.map(&:to_s).join("_")
+  end
+  
+  def self.key_expression(keys)
+    case keys.length
+    when 0 then 1
+    when 1 then "doc.#{keys.first}"
+    else        "[" + keys.map {|k| "doc.#{k}"}.join(", ") + "]"
+    end
+  end
+end
+
+module Couch::DocExtensions
+  def view(mode, *keys)
+    Couch::DocView.find_or_create(self, :mode => mode, :keys => keys)
+  end
+
+  #
+  # conditions might be empty, or might contain 
+  # :key => required value(s) entries
+  def count(conditions = {})
+    case conditions.length
+    when 0
+      r = view(:count, *conditions.keys).all
+      r.inject(0) do |sum, row| sum + row[:value] end
+    when 1
+      startkey = endkey = conditions.values.first
+      r = view(:count, *conditions.keys).all(Couch::DocExtensions.condition_keys(conditions.values.first))
+      r.inject(0) do |sum, row| sum + row[:value] end
+    else
+      raise "More than one key is currently not supported"
+    end
+  end
+
+  def self.condition_keys(v)
+    case v
+    when Range
+      { :startkey => v.first, :endkey => v.last }
+    else
+      { :startkey => v, :endkey => v }
+    end
+  end
+end
+
+
+Couch::Document.extend Couch::DocExtensions

data/lib/couch/document.rb

@@ -0,0 +1,140 @@
+class Couch::Document
+  include Couch::Log
+
+  def self.database
+    Couch.database
+  end
+
+  def database
+    self.class.database
+  end
+
+  def self.async(&block)
+    database.async(&block)
+  end
+  
+  def self.create(*args)
+    new(*args).save
+  end
+
+  # instantiate a Couch::Document from a Hash.
+  def self.instantiate(data, target = nil)
+    target_type_name = data[:type] || raise("Missing document type in #{data.inspect}")
+
+    if target.nil?
+      target_klass = target_type_name.constantize
+      target = target_klass.new(data)
+    elsif target.class.name != target_type_name
+      raise "Type mismatch #{target.class.name} vs #{target_type_name}"
+      target.update data
+    end
+    target
+  end
+
+  def self.find(id)
+    database.read(id)
+  rescue Couch::Error404
+    nil
+  end
+
+  attr :attributes
+  
+  def initialize(data = {}, dont_change = true)
+    @attributes = data.dup
+    self.id = @attributes.delete(:id) if @attributes[:id]
+
+    @attributes[:type] = self.class.name
+  end
+  
+  def dup
+    other = super
+    other.instance_variable_set "@attributes", attributes.dup
+    other.instance_variable_set "@original", @original.dup
+    other
+  end
+  
+  def type; attributes[:type]; end
+  
+  def id; @attributes[:_id]; end
+  def id=(id); @attributes[:_id] = id; end
+
+  def rev; @attributes[:_rev]; end
+
+  def to_hash
+    r = @attributes.dup
+    
+    r.delete :_id
+    r.delete :_rev
+    r.delete :type
+    r
+  end
+
+  #
+  #
+
+  def new_record?
+    rev.nil?
+  end
+
+  def reload
+    raise if new_record?
+
+    @attributes = database.read(self.id).attributes
+    @original = attributes.dup
+    self
+  end
+  
+  def save
+    if new_record?
+      database.create self
+    elsif changed?
+      database.update self
+    end
+    
+    @original = attributes.dup
+    self
+  end
+  
+  def changed?
+    @original != @attributes
+  end
+  
+  def destroy
+    database.destroy self
+    self
+  end
+  
+  def inspect
+    "<#{self.class.name}[#{self.id}] #{attributes.inspect}>"
+  end
+  
+  private
+  
+  def update_rev(rev)
+    attributes[:_rev] = rev
+  end
+  
+  public
+  
+  def to_json
+    attributes.to_json
+  end
+
+  def update(attributes)
+    self.attributes.update attributes
+  end
+  
+  private
+  
+  def method_missing(sym, *args)
+    if block_given?
+      super
+    elsif args.length == 0 && attributes.key?(sym)
+      attributes[sym]
+    elsif args.length == 1 && sym.to_s =~ /(.+)=$/
+      attributes[$1.to_sym] = args.first
+    else
+      super
+    end
+  end
+end

data/lib/couch/error.rb

@@ -0,0 +1,27 @@
+class Couch::Error < RuntimeError
+  def initialize(options); @options = options; end
+
+  def to_s; @options.inspect; end
+  def inspect; @options.inspect; end
+
+  def self.ignore(&block)
+    yield
+  rescue Couch::Error
+    dlog.warn $!
+    nil
+  end
+end
+
+class Couch::Error404 < Couch::Error
+end
+
+class Couch::Error
+  def self.raise(options)
+    case options[:code].to_s
+    when "404"
+      super Couch::Error404, options
+    else
+      super Couch::Error, options
+    end
+  end
+end

data/lib/couch/extras.rb

@@ -0,0 +1,12 @@
+class Object
+  def define_instance_method(sym, *args, &block)
+    if args.empty?
+      singleton_class.send(:define_method, sym, &block)
+    else
+      invalid_argument! if block_given?
+      r = args.first
+      singleton_class.send(:define_method, sym) do r end
+    end
+    self
+  end
+end

data/lib/couch/log.rb

@@ -0,0 +1,8 @@
+module Couch::Log
+  QUIET = false 
+  # QUIET = true
+
+  if QUIET
+    # def dlog(*args); end
+  end
+end

data/lib/couch/server.rb

@@ -0,0 +1,40 @@
+require 'yajl'
+require 'yajl/json_gem'
+require 'net/http'
+
+class Couch::Server
+  include Couch::Log
+
+  def initialize(host, port)
+    @host, @port = host, port
+  end
+
+  def delete(uri);      request Net::HTTP::Delete.new(uri); end
+  def get(uri);         request Net::HTTP::Get.new(uri); end
+  def put(uri, json);   request Net::HTTP::Put.new(uri), json; end
+  def post(uri, json);  request Net::HTTP::Post.new(uri), json; end
+
+  private
+  
+  def request(request, body=nil)
+    if body
+      request["content-type"] = "application/json"
+      request.body = body.to_json
+    end
+
+    r = benchslow "[#{request.method}] #{request.path}" do
+      Net::HTTP.start(@host, @port) { |http| http.request(request) }
+    end
+    
+    body = Yajl::Parser.new(:symbolize_keys => true).parse(r.body)
+    # dlog "-->", body
+    
+    return body if r.kind_of?(Net::HTTPSuccess)
+
+    Couch::Error.raise :code => r.code, 
+      :message => r.message, 
+      :method => request.method,
+      :uri => request.path,
+      :body => body
+  end
+end

data/lib/couch/view.rb

@@ -0,0 +1,72 @@
+class Couch::View < Couch::Document
+  DUMMY_NAME = "foo"
+
+  def self.find(name)
+    super("_design/#{name}")
+  end
+  
+  # -- create a view --------------------------------------------------
+  
+  def self.create(name, opts)
+    map = opts[:map] || raise("Missing map function")
+    reduce = opts[:reduce]
+
+    super :id => "_design/#{name}",
+      :views => { DUMMY_NAME => { 
+        :map => map,
+        :reduce => reduce
+      } }
+  end
+
+  def map
+    view[:map]
+  end
+
+  def map=(map)
+    update :views => { DUMMY_NAME => { 
+      :map => map,
+      :reduce => reduce
+    } }
+  end
+  
+  def reduce
+    view[:reduce]
+  end
+  
+  def reduce=(reduce)
+    update :views => { DUMMY_NAME => { 
+      :map => map,
+      :reduce => reduce
+    } }
+  end
+  
+  private
+  
+  def view
+    views[DUMMY_NAME]
+  end
+  
+  # -- query the view -------------------------------------------------
+
+  public
+
+  def all(opts = {})
+    opts = opts.to_a.inject({}) do |h, (k,v)|
+      h.update k => Yajl::Encoder.encode(v)
+    end 
+    
+    r = Couch.database.get CGI.url_for("#{id}/_view/#{DUMMY_NAME}", opts)
+    r[:rows].
+      define_instance_method(:offset, r[:offset]).
+      define_instance_method(:total_rows, r[:total_rows])
+  end
+  
+  def total_rows(opts = nil)
+    if opts.nil?
+      r = Couch.database.get CGI.url_for("#{id}/_view/#{DUMMY_NAME}")
+      r[:total_rows]
+    else
+      all(opts).length
+    end
+  end
+end

data/script/console

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+# Start a console that initializes the gem
+#
+require "irb"
+require "rubygems"
+
+begin
+  require 'wirble'
+  Wirble.init
+  Wirble.colorize
+rescue LoadError
+  STDERR.puts "To enable colorized and tab completed run 'gem install wirble'"
+end
+
+$: << "#{File.dirname(__FILE__)}/../lib"
+require "#{File.dirname(__FILE__)}/../init.rb"
+
+IRB.start

data/script/rebuild

@@ -0,0 +1,7 @@
+#!/bin/sh
+rake default build_gemspec package || exit 1 
+echo "============================================="
+echo "I built the gem for you. To upload, run "
+echo
+echo "gem push $(ls -d pkg/*.gem | tail -n 1)"
+

data/script/watchr

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'fsevent'   # This comes from ruby-fsevent
+require 'yaml'
+
+case ARGV.length
+when 0
+  if File.exists?(".watchr.yml")
+    STDERR.puts "Reloading config"
+    args = YAML.load File.read(".watchr.yml") 
+  end
+when 1
+  nil
+else
+  File.open(".watchr.yml", "w") do |f|
+    f.write ARGV.to_yaml
+  end 
+  args = ARGV
+end
+
+if !args
+  STDERR.puts "watchr dir ruby-parameter ruby-parameter ruby-parameter ..."
+  abort
+end
+
+dirs = args.shift.split(",")
+$args = args.dup
+
+STDERR.puts "Watching #{dirs.join(",")}"
+
+class PrintChange < FSEvent
+  def on_change(directories)
+    if !directories
+      STDERR.print "Initial run: "
+    else
+      STDERR.print "\n\n\nDetected change in: #{directories.first}: "
+    end
+
+    STDERR.puts $args.join(" ")
+    STDERR.puts "=" * 80
+    system *$args
+  end
+end
+
+printer = PrintChange.new
+printer.on_change nil
+printer.watch_directories dirs
+printer.start

data/test/couch.json

@@ -0,0 +1,5 @@
+{
+  "host": "localhost", 
+  "port": "5984",
+  "database": "fooxy"
+}

data/test/couch/basic_test.rb

@@ -0,0 +1,67 @@
+load File.dirname(__FILE__) + "/../couch_test_helper.rb"
+
+class BasicTest < Couch::TestCase
+
+  def test_create
+    post = Post.create(:body => "Post #1")
+    assert_equal({:body => "Post #1"}, post.to_hash)
+    assert !post.new_record?
+  end
+
+  def test_attributes
+    post = Post.new(:body => "Post #1")
+
+    assert_equal("Post #1", post.body)
+    post.body = "body"
+    assert_equal("body", post.body)
+  end
+
+  def test_basic
+    post = Post.new(:body => "Post #1")
+    assert_equal({:body => "Post #1"}, post.to_hash)
+    assert post.new_record?
+
+    post.save
+    assert_equal("Post #1", post.body)
+
+    assert_not_nil(post.rev)
+    assert !post.new_record?
+
+    dup = post.dup
+
+    rev1 = post.rev
+    post.save
+    assert_equal(rev1, post.rev)
+
+    post.update(:body => "Post #2")
+    assert !post.new_record?
+    post.save
+    assert_not_equal(rev1, post.rev)
+
+    post.reload
+    assert_equal(post.to_hash, { :body => "Post #2" })
+
+    assert_equal(dup.to_hash, { :body => "Post #1" })
+    assert_equal(rev1, dup.rev)
+
+    assert_equal({ :body => "Post #1" }, dup.to_hash)
+    dup.reload
+    assert_equal({ :body => "Post #2" }, dup.to_hash)
+    assert_equal(post.rev, dup.rev)
+  end
+
+  def test_named_object
+    post = Post.new(:id => "test", :body => "view")
+    assert_equal("test", post.id)
+    post.save
+    assert_equal("test", post.id)
+  end
+
+  def test_named_object_w_create
+    post = Post.create(:id => "test", :body => "view")
+    assert_equal("test", post.id)
+    post.save
+    assert_equal("test", post.id)
+  end
+
+end

data/test/couch/bulk_test.rb

@@ -0,0 +1,51 @@
+load File.dirname(__FILE__) + "/../couch_test_helper.rb"
+
+class BulkTest < Couch::TestCase
+  attr :view
+  
+  def setup
+    super
+    
+    @view = Couch::View.create "types", :map => MAP_ONE
+
+    assert_equal(0, view.total_rows)
+    assert_equal(0, view.all.offset)
+  end
+  
+  def do_test_cnt(cnt)
+    post = nil 
+
+    benchmark "=== writing #{cnt} objects" do
+      Post.async do 
+        (1..cnt).each do |i| post = Post.create(:body => "Post ##{i}") end
+      end
+    end
+
+    assert !post.new_record?
+  
+    benchmark("Querying view") do assert_equal(cnt, view.total_rows) end
+    benchmark("Requerying view") do assert_equal(cnt, view.total_rows) end
+
+    view.map = MAP_TWICE
+    view.save
+
+    benchmark("Querying view") do assert_equal(2 * cnt, view.total_rows) end
+    benchmark("Requerying view") do assert_equal(2 * cnt, view.total_rows) end
+
+    post.destroy
+
+    benchmark("Requerying view") do assert_equal(2 * (cnt - 1), view.total_rows) end
+
+    benchmark("Count via Post.count") do assert_equal(cnt - 1, Post.count) end
+    benchmark("Recount via Post.count") do assert_equal(cnt - 1, Post.count) end
+  end
+
+  COUNTS = [ 10, 100, 1000, 10000, 100000 ]
+  COUNTS = [ 10, 100  ]
+  
+  COUNTS.each do |i|
+    define_method "test_view_#{i}" do 
+      do_test_cnt i
+    end
+  end 
+end

data/test/couch/doc_view_test.rb

@@ -0,0 +1,55 @@
+load File.dirname(__FILE__) + "/../couch_test_helper.rb"
+
+class DocViewTest < Couch::TestCase
+  def test_wo_args
+    p1 = Post.create(:body => "Post ##{1}")
+    assert_equal(1, Post.count)
+
+    p2 = Post.create(:body => "Post ##{2}")
+    assert_equal(2, Post.count)
+
+    p3 = Post.create(:body => "Post ##{3}")
+    assert_equal(3, Post.count)
+  
+    p3.destroy
+    assert_equal(2, Post.count)
+  end
+
+  def test_with_one_arg
+    Post.create(:body => "Post ##{1}", :number => 1)
+    assert_equal(0, Post.count(:number => 0))
+
+    Post.create(:body => "Post ##{1}", :number => 1)
+
+    assert_equal(0, Post.count(:number => 0))
+    assert_equal(2, Post.count(:number => 1))
+    assert_equal(0, Post.count(:number => 2))
+    
+    
+    p2 = Post.create(:body => "Post ##{2}", :number => 2)
+
+    assert_equal(0, Post.count(:number => 0))
+    assert_equal(2, Post.count(:number => 1))
+    assert_equal(1, Post.count(:number => 2))
+    
+    p3 = Post.create(:body => "Post ##{3}", :number => 1)
+    assert_equal(0, Post.count(:number => 0))
+    assert_equal(3, Post.count(:number => 1))
+    assert_equal(1, Post.count(:number => 2))
+      
+    p2.destroy
+    assert_equal(0, Post.count(:number => 0))
+    assert_equal(3, Post.count(:number => 1))
+    assert_equal(0, Post.count(:number => 2))
+  end
+
+  def test_with_range_condition
+    Post.create(:body => "Post ##{1}", :number => 1)
+    Post.create(:body => "Post ##{1}", :number => 1)
+    Post.create(:body => "Post ##{1}", :number => 2)
+
+    assert_equal(0, Post.count(:number => 0..0.5))
+    assert_equal(2, Post.count(:number => -1..1))
+    assert_equal(3, Post.count(:number => -3..100))
+  end
+end

data/test/couch/post.rb

@@ -0,0 +1,3 @@
+
+class Post < Couch::Document
+end

data/test/couch/view_test.rb

@@ -0,0 +1,60 @@
+load File.dirname(__FILE__) + "/../couch_test_helper.rb"
+
+class ViewTest < Couch::TestCase
+  def test_none
+    view = Couch::View.create "none", :map => MAP_NONE
+    assert_equal(0, view.total_rows)
+    Post.create(:body => "Post ##{1}")
+    assert_equal(0, view.total_rows)
+
+    view.map = MAP_ONE
+    view.save
+    assert_equal(1, view.total_rows)
+  end
+
+  def test_one
+    view = Couch::View.create "to_self", :map => MAP_ONE
+    assert_equal(0, view.total_rows)
+    Post.create(:body => "Post ##{1}")
+    assert_equal(1, view.total_rows)
+  end
+
+  def test_start_end_key
+    view = Couch::View.create "to_self", :map => MAP_ONE
+    assert_equal(0, view.total_rows)
+    Post.create(:body => "Post ##{1}")
+    assert_equal(1, view.total_rows)
+
+    assert_equal(1, view.total_rows(:startkey => "p", :endkey => "q"))
+    assert_equal(0, view.total_rows(:startkey => "q", :endkey => "r"))
+  end
+  
+  def test_view
+    view = Couch::View.create "types", :map => MAP_ONE
+
+    assert_equal(0, view.total_rows)
+    assert_equal(0, view.all.offset)
+
+    post = nil 
+    
+    benchmark "writing #{COUNT} objects" do
+      (1..COUNT).each do |i|
+        post = Post.create(:body => "Post ##{i}")
+        assert !post.new_record?
+      end
+    end
+
+    assert_equal(COUNT, view.total_rows)
+    assert_equal(COUNT, view.total_rows)
+
+    view.map = MAP_TWICE
+    view.save
+
+    assert_equal(2 * COUNT, view.total_rows)
+    assert_equal(2 * COUNT, view.total_rows)
+
+    post.destroy
+    
+    assert_equal(2 * (COUNT - 1), view.total_rows)
+  end
+end

data/test/couch_test_helper.rb

@@ -0,0 +1,31 @@
+unless defined?(Couch::TestCase)
+
+require File.dirname(__FILE__) + "/test_helper"
+require File.dirname(__FILE__) + "/../lib/couch"
+
+require File.dirname(__FILE__) + "/couch/post"
+
+CONFIG = JSON.parse(File.read(File.dirname(__FILE__) + "/couch.json"))
+dlog "Using couchdb config", CONFIG
+
+class Couch::TestCase < BaseTestCase
+  MAP_ONE = "function(post) { if(post.type) { emit(post.type); } }"
+  MAP_TWICE = "function(post) { if(post.type) { emit(1); emit(2); } }"
+  MAP_NONE = "function(post) { }"
+  
+  COUNT = 10
+  
+  def setup
+    host = CONFIG["host"]
+    port = CONFIG["port"] || 5984
+    database = CONFIG["database"]
+    
+    Couch.connect(host, port, database, true)
+  end
+
+  def teardown
+    Couch.disconnect
+  end
+end
+
+end

data/test/test.rb

@@ -0,0 +1,14 @@
+#require "rubygems"
+#require "etest"
+
+#$: << File.dirname(__FILE__) + "/../lib"
+#require 'couch'
+
+Dir.glob(File.dirname(__FILE__) + "/couch/*_test.rb").each do |file|
+  load file
+end
+
+LOGFILE = "log/test.log"
+
+#Etest.autorun
+

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+unless defined?(BaseTestCase)
+
+require "rubygems"
+require "ruby-debug"
+
+# Use test/unit
+#
+# require "test/unit"
+# 
+# class BaseTestCase < Test::Unit::TestCase
+#   def test_dummy
+#     # or else test unit cries out loud-
+#   end
+# end
+
+require "minitest/unit"
+require 'minitest/autorun'
+
+class BaseTestCase < MiniTest::Unit::TestCase
+  def assert_not_nil(object, message = nil)
+    assert !object.nil?, message || "Should not be nil"
+  end
+
+  def assert_not_equal(unexpected, actual, message = nil)
+    assert unexpected != actual, message || "#{actual.inspect} should not equal #{unexpected.inspect}"
+  end
+end
+
+end
+

data/vex/gem.rake

@@ -0,0 +1,36 @@
+def sys(*args)
+  STDERR.puts "#{args.join(" ")}"
+  system *args
+end
+
+namespace :gem do
+  task :build => :spec do
+    options = []
+    sys "gem build .gemspec #{options.join(" ")} && mkdir -p pkg && mv *.gem pkg"
+  end
+
+  task :spec do
+    File.open ".gemspec", "w" do |file|
+      file.write <<-TXT
+      require "vex/gem"
+      Gem.spec File.dirname(__FILE__)
+TXT
+    end
+  end
+  
+  task :install => :build do
+    file = Dir.glob("pkg/*.gem").sort.last
+    sys "gem install #{file}"
+  end
+  
+  task :push => :build do
+    file = Dir.glob("pkg/*.gem").sort.last
+    puts "To push the gem to gemcutter please run"
+    puts
+    puts "\tgem push #{file}"
+  end
+end
+
+desc "Build gem"
+# task :gem => %w(test gem:install)
+task :gem => %w(gem:install gem:push)

data/vex/gem.rb

@@ -0,0 +1,95 @@
+module Gem
+  (class << self; self; end).class_eval do
+    def default_attributes
+      %w(name version date files executables)
+    end
+    
+    def set_root(root)
+      @root = File.expand_path(root)
+      @name = File.basename(@root)
+      @conf ||= YAML.load File.read("#{@root}/gem.yml")
+      @attributes ||= (default_attributes + @conf.keys.map(&:to_s)).uniq
+    end
+    
+    # attr_reader :root, :conf, :attributes, 
+    attr_reader :name
+
+    def attribute(name)
+      if @conf.key?(name) && !%w(dependencies).include?(name)
+        @conf[name]
+      else
+        self.send(name)
+      end
+    end
+
+    #
+    # create a new Gem::Specification object for this gem.
+    def spec(root)
+      self.set_root root
+    
+      Gem::Specification.new do |s|
+        @attributes.each do |attr|
+          v = attribute(attr)
+          next if v.nil?
+          
+          log attr, v
+          
+          s.send attr + "=", v
+        end
+        
+        %w(pre_uninstall post_install).each do |hook|
+          next unless File.exists?("#{root}/hooks/#{hook}.rb")
+          log hook, "yes"
+          Gem.send(hook) {
+            load "hooks/#{hook}.rb"
+          }
+        end
+      end
+    end
+    
+    def log(attr, v)
+      v = case attr
+      when "files" then "#{v.length} files"
+      else              v.inspect
+      end
+      
+      STDERR.puts "#{"%20s" % attr}:\t#{v}"
+    end
+    
+    def dependencies
+      return nil unless @conf["dependencies"]
+
+      @conf["dependencies"].map do |d|
+        Gem::Dependency.new d, ">= 0"
+      end
+    end
+    
+    def head(file)
+      File.open(file) do |f|
+        f.readline
+      end
+    end
+    
+    def executables
+      r = Dir.glob("#{@root}/bin/**/*").map do |file|
+        next unless head(file) =~ /^#!/
+        file[@root.length + 5 .. -1]
+      end.compact
+      
+      return nil if r.empty?
+      r
+    end
+
+    #
+    # get files from git
+    def files
+      r = `git ls-files`.split("\n")
+    end
+
+    #
+    # return the date
+    def date
+      Date.today.to_s
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: dispaaro-couch
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- radiospiel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: etest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Yet another CouchDB handler
+email: eno@open-lab.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- gem.yml
+- lib/couch.rb
+- lib/couch/database.rb
+- lib/couch/doc_view.rb
+- lib/couch/document.rb
+- lib/couch/error.rb
+- lib/couch/extras.rb
+- lib/couch/log.rb
+- lib/couch/server.rb
+- lib/couch/view.rb
+- script/console
+- script/rebuild
+- script/watchr
+- test/couch.json
+- test/couch/basic_test.rb
+- test/couch/bulk_test.rb
+- test/couch/doc_view_test.rb
+- test/couch/post.rb
+- test/couch/view_test.rb
+- test/couch_test_helper.rb
+- test/test.rb
+- test/test_helper.rb
+- vex/gem.rake
+- vex/gem.rb
+has_rdoc: true
+homepage: http://github.com/radiospiel/dispaaro-couch
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A CouchDB handler
+test_files: []
+