divan 0.1.1

data/README

@@ -0,0 +1,3 @@
+Divan, a Ruby CouchDB client for insane people
+
+TODO: README, documentation and other details

data/Rakefile.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'init.rb'
+require 'rake'
+
+task :create_database do
+  if ENV['database']
+    Divan[ENV['database'].to_sym].create unless Divan[ENV['database'].to_sym].exists?
+  else
+    Divan.databases.each do |name, database|
+      database.create unless database.exists?
+    end
+  end
+end
+
+task :create_views do
+  if ENV['database']
+    if ENV['design']
+      Divan[ENV['design'].to_sym].create_views
+    else
+      Divan[ENV['database'].to_sym].create_views
+    end
+  else
+    Divan.databases.each do |name, database|
+      database.create_views
+    end
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "divan"
+    gem.summary = "A Ruby CouchDB Client for insane people"
+    gem.description = "This is a very simple CouchDB client that have few dependencies.\nThis client has a lot of interesting features, for example: easy access to CouchDB revisions.\n"
+    gem.email = "dalthon@aluno.ita.br"
+    gem.homepage = "http://github.com/efqdalton/divan"
+    gem.authors = ["Dalton Pinto"]
+    gem.files.exclude "config"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/init.rb

@@ -0,0 +1,14 @@
+divan_path = File.expand_path('../lib', __FILE__)
+$:.unshift(divan_path) if File.directory?(divan_path) && !$:.include?(divan_path)
+
+require 'restclient'
+require 'json'
+require 'divan.rb'
+
+Divan.load_database_configuration 'config/divan_config.yml'
+
+# Lines below are used for debug purposes only
+class POC < Divan::Models::ProofOfConcept
+  view_by :mod
+  view_by :value
+end

data/lib/divan.rb

@@ -0,0 +1,65 @@
+require 'divan/models/base'
+require 'divan/base'
+require 'divan/database'
+require 'divan/utils'
+require 'yaml'
+
+module Divan
+  @@databases = {}
+
+  def self.Model(database_config_name)
+    Database.model_class(database_config_name)
+  rescue
+    Divan::Models::Base
+  end
+
+  def self.load_database_configuration(config_path)
+    YAML.load(File.read config_path).each do |name, params|
+      @@databases[name.to_sym] = Database.new name, params
+    end
+  end
+
+  def self.[](name)
+    @@databases[name.to_sym]
+  end
+
+  def self.databases
+    @@databases
+  end
+
+  class DatabaseNotFound < RuntimeError
+    attr_reader :database
+    def initialize(database)
+      @database = database
+    end
+  end
+
+  class DatabaseAlreadyCreated < RuntimeError
+    attr_reader :database
+    def initialize(database)
+      @database = database
+    end
+  end
+
+  class DocumentRevisionMissing < RuntimeError
+    attr_reader :document
+    def initialize(document)
+      @document = document
+    end
+  end
+
+  class DocumentNotFound < RuntimeError
+    attr_reader :document
+    def initialize(document)
+      @document = document
+    end
+  end
+
+  class DocumentConflict < RuntimeError
+    attr_reader :new_document, :current_document
+    def initialize(new_document)
+      @new_document = new_document
+      @current_document = new_document.class.find new_document.id
+    end
+  end
+end

data/lib/divan/base.rb

@@ -0,0 +1,195 @@
+module Divan
+  class Base < Models::Base
+    attr_accessor :id, :rev, :attributes, :last_request
+
+    def initialize(opts = {})
+      opts = opts.clone
+      @id  = opts.delete(:id)  || opts.delete(:_id) || Divan::Utils.uuid
+      @rev = opts.delete(:rev) || opts.delete(:_rev)
+      @attributes = opts 
+      @attributes[self.class.type_field.to_sym] = self.class.type_name unless self.class.top_level_model?
+      self.class.properties.each{ |property| @attributes[property] ||= nil }
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    def validate
+      true
+    end
+    alias :"valid?" :validate 
+
+    def database
+      self.class.database
+    end
+
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method[-1..-1] == '='
+        attrib = method[0..-2].to_sym
+        return @attributes[attrib] = args.first
+      end
+      if( @attributes.keys.include?( (attrib = method[0..-1].to_sym) ) )
+        return @attributes[attrib]
+      end
+      raise NoMethodError, "undefined method '#{method}' for #{self}:#{self.class}"
+    end
+
+    def to_s
+      "\#<#{database.name.to_s.split('_').map{|str| "#{str[0..0].upcase}#{str[1..-1]}" }} #{@attributes.inspect.gsub("\\\"", "\"")}>"
+    end
+    alias :inspect :to_s
+
+    protected
+
+    def document_path(params = {})
+      Divan::Utils.formatted_path @id, params
+    end
+
+    def current_document_path(params = {})
+      params[:rev] = @rev if @rev
+      document_path params
+    end
+
+    class << self
+      attr_writer   :type_name, :type_field
+      attr_reader   :view_by_params, :database
+      attr_accessor :model_name
+
+      def inherited(subclass)
+        strs = subclass.name.match(/[^:]*\Z/)[0].split(/([A-Z][^A-Z]*)/)
+        strs.delete ''
+        subclass.model_name = strs.map{ |x| x.downcase }.join('_')
+        if database
+          subclass.database = database
+          subclass.top_level_model! if subclass.database.name == subclass.model_name
+        end
+      end
+
+      def type_name
+        @type_name ||= model_name
+      end
+
+      def type_field
+        @type_field ||= 'divan_doc_type'
+      end
+
+      def top_level_model!(true_or_false = true)
+        @top_level_model = true_or_false
+      end
+
+      def top_level_model?
+        @top_level_model ||= false
+      end
+
+      def properties
+        @properties ||= ( superclass.methods.include? :properties ) ? superclass.properties.clone : []
+      end
+
+      def property(*args)
+        properties.concat args.flatten
+      end
+
+      def database=(database)
+        undefine_views if( !@database.nil? && @database != database )
+        @database = database
+        define_view_all
+        define_views
+        @database
+      end
+
+      def model_name
+        @model_name ||= ( superclass.methods.include? :model_name ) ? superclass.model_name.clone : nil
+      end
+
+      [:before_save, :after_save, :before_create, :after_create, :before_validate, :after_validate].each do |method|
+        define_method method do |param|
+          eval "( @#{method}_callback ||= [] ) << param"
+        end
+
+        define_method "execute_#{method}_callback" do |instance|
+          eval <<-end_txt
+            @#{method}_callback ||= []
+            !!@#{method}_callback.each do |cb|
+              instance.send(cb) or break false if cb.is_a?(Symbol)
+              cb.call(instance) or break false if cb.is_a?(Proc)
+            end
+          end_txt
+        end
+
+      end
+
+      def define_view(param, functions)
+        @views ||= {}
+        @views[param.to_sym] = functions
+      end
+
+      def define_view!(param, functions)
+        database.views[model_name] ||= {}
+        database.views[model_name][param.to_sym] = functions
+      end
+
+      def define_view_all
+        if database && model_name == database.name
+          define_view :all, :map => "function(doc){ if(doc._id.slice(0, 7) != \"_design\"){ emit(null, doc) } }"
+        else
+          define_view :all, :map => "function(doc){ if(doc.#{type_field} == \"#{type_name}\"){ emit(null, doc) } }"
+        end        
+      end
+
+      def query_view(view, key=nil, args={}, special={})
+        if key.is_a? Hash
+          special = args
+          args    = key
+        else
+          special = args
+          args    = {:key => key}
+        end
+
+        args = args.inject({}){ |hash,(k,v)| hash[k] = v.to_json; hash }
+        view_path = Divan::Utils.formatted_path "_design/#{model_name}/_view/#{view}", args.merge(special)
+        last_request = database.client[view_path].get
+        results = JSON.parse last_request, :symbolize_names => true
+        results[:rows].map do |row|
+          obj = self.new row[:value]
+          obj.last_request = last_request 
+          obj
+        end
+      end
+
+      protected
+
+      def view_by(param)
+        @view_by_params ||= []
+        @view_by_params << param
+        define_view! "by_#{param}", :map => "function(doc) { emit(doc.#{param}, doc) }"
+        eval <<-end_txt
+          class << self
+            def all_by_#{param}(key, args={}, special={})
+              query_view :by_#{param}, key, args, special
+            end
+
+            def by_#{param}(key)
+              all_by_#{param}(:key => key, :limit => 1).first
+            end
+          end
+        end_txt
+      end
+
+      def define_views
+        database.views[model_name] ||= {}
+        database.views[model_name].merge! @views if @views
+      end
+
+      def undefine_views
+        database.views[model_name] = nil
+      end
+
+    end
+  end
+end

data/lib/divan/database.rb

@@ -0,0 +1,95 @@
+module Divan
+  module Models; end
+
+  class Database
+    attr_accessor :name, :host, :port, :database, :user, :password, :views
+    def initialize(name, options = {})
+      @name, @user, @password = name, options['user'], options['password']
+#TODO: Add user & password support
+      @host     = options['host'] || 'http://127.0.0.1'
+      @port     = options['port'] || 5984
+      @database = options['database']
+      @views    = {}
+      build_model_class
+    end
+
+    def exists?
+      begin
+        client.get
+        return true
+      rescue RestClient::ResourceNotFound
+        return false
+      end
+    end
+
+    def stats
+      begin
+        JSON.parse client.get, :symbolize_names => true
+      rescue RestClient::ResourceNotFound
+        raise Divan::DatabaseNotFound.new(self), "Database was not found"
+      end
+    end
+
+    def create
+      begin
+        client.put Hash.new
+      rescue RestClient::PreconditionFailed
+        raise Divan::DatabaseAlreadyCreated.new(self), "Database already created"
+      end
+    end
+
+    def delete
+      begin
+        client.delete
+      rescue RestClient::ResourceNotFound
+        raise Divan::DatabaseNotFound.new(self), "Database was not found"
+      end
+    end
+
+    def create_views
+      views.each do |name, views|
+        create_view(name)
+      end
+    end
+
+    def create_view(view_name)
+      if view_doc = model_class.find("_design/#{view_name}")
+        view_doc.views = views[view_name]
+        view_doc.save
+      else
+        model_class.create :id => "_design/#{view_name}", :language => 'javascript', :views => views[view_name]
+      end
+    end
+
+    def [](path, params={})
+      client[ Divan::Utils.formatted_path(path, params) ]
+    end
+
+    def client
+      @client ||= RestClient::Resource.new( basic_url, *([@user, @password].compact) )
+    end
+
+    def model_class
+      @model_class ||= eval model_class_full_name
+    end
+
+    protected
+    def basic_url
+      "#{host}:#{port}/#{database}/"
+    end
+
+    def model_class_full_name
+      "Divan::Models::#{name.to_s.split('_').map{|str| "#{str[0..0].upcase}#{str[1..-1]}" }}"
+    end
+
+    def build_model_class
+      Divan::Base.class_eval "class #{model_class_full_name} < Divan::Base ; end"
+      model_class.database   = self
+      model_class.top_level_model!
+    end
+
+    def self.model_class(name)
+      eval "Divan::Models::#{name.to_s.split('_').map{|str| "#{str[0..0].upcase}#{str[1..-1]}" }}"
+    end
+  end
+end

data/lib/divan/models/base.rb

@@ -0,0 +1,126 @@
+module Divan
+  module Models
+    class Base
+
+      def save
+        self.class.execute_before_validate_callback(self) or return false
+
+        validate or return false
+
+        self.class.execute_after_validate_callback(self)  or return false
+        self.class.execute_before_save_callback(self)     or return false
+
+        execute_save
+
+        self.class.execute_after_save_callback(self)
+        @last_request
+      end
+
+      def delete
+        begin
+          @last_request = database.client[current_document_path].delete
+        rescue RestClient::ResourceNotFound
+          @last_request = nil
+          return @last_request
+        end
+        @rev = JSON.parse(@last_request, :symbolize_names => true )[:rev]
+        @last_request
+      end
+
+      def revision_ids
+        begin
+          @last_request = database.client[document_path :revs_info => true].get
+          JSON.parse(@last_request, :symbolize_names => true )[:_revs_info].find_all{ |hash| hash[:status] == 'available' }.map{ |hash| hash[:rev] }
+        rescue RestClient::ResourceNotFound
+          return []
+        end
+      end
+
+      def revision(index)
+        revision!(index)
+      rescue Divan::Divan::DocumentRevisionNotAvailable
+        nil
+      end
+
+      def revision!(index)
+        r = revision_ids.find{ |rev| rev[0..1].to_i == index}
+        r.nil? and raise Divan::Divan::DocumentRevisionNotAvailable.new(self), "Revision with index #{index} missing"
+        return self if r == @rev
+        self.class.find @id, :rev => r
+      end
+
+      protected
+
+      def execute_save
+        begin
+          save_attrs = @attributes.clone
+          save_attrs[:"_rev"] = @rev if @rev
+          @last_request = database.client[current_document_path].put save_attrs.to_json
+          @rev = JSON.parse(@last_request, :symbolize_names => true )[:rev]
+        rescue RestClient::Conflict
+          raise Divan::DocumentConflict.new(self), "Update race conflict"
+        end
+      end
+
+      class << self
+        def find(id, params = {})
+          begin
+            last_request = database.client[Divan::Utils.formatted_path id, params].get
+          rescue RestClient::ResourceNotFound
+            return nil
+          end
+          attributes = JSON.parse last_request, :symbolize_names => true
+          obj = self.new attributes
+          obj.last_request = last_request
+          obj
+        end
+
+        def find_all(params=nil)
+          query_view :all, params
+        end
+
+        def all
+          find_all
+        end
+
+        def delete_all(params = nil)
+          to_be_deleted = find_all(params).map do |object|
+            {:_id => object.id, :_rev => object.rev, :_deleted => true }
+          end
+          payload = { :docs => to_be_deleted }.to_json
+          database.client['_bulk_docs'].post payload, :content_type => :json, :accept => :json
+          to_be_deleted.size
+        end
+
+        def create(opts = {})
+          raise ArgumentError if( !opts.is_a?(Hash) && !opts.is_a?(Array) )
+          if opts.is_a? Hash
+            single_create opts
+          else
+            bulk_create opts
+          end
+        end
+
+        protected
+
+        def single_create(opts = {})
+          obj = self.new(opts)
+          obj.save
+          obj
+        end
+
+        def bulk_create(opts)
+          payload = { :docs => opts.map do |params|
+            params       = params.clone
+            params[:_id] = params.delete(:id) || Divan::Utils.uuid
+            params[type_field.to_sym] = type_name unless top_level_model?
+            params
+          end }
+          last_request = database.client['_bulk_docs'].post( payload.to_json, :content_type => :json, :accept => :json )
+        end
+
+      end
+
+    end
+  end
+end

data/lib/divan/utils.rb

@@ -0,0 +1,18 @@
+module Divan
+  module Utils
+    def self.uuid
+      values = [ rand(0x0010000), rand(0x0010000), rand(0x0010000), rand(0x0010000),
+                 rand(0x0010000), rand(0x1000000), rand(0x1000000) ]
+      "%04x%04x%04x%04x%04x%06x%06x" % values
+    end
+
+    def self.formatted_path(path = nil, opts = {})
+      if opts.empty?
+        CGI.escape path.to_s
+      else
+        formatted_opts = opts.map{|k,v| "#{CGI.escape k.to_s}=#{URI.encode v.to_s}"}.join('&')
+        "#{path.to_s}?#{formatted_opts}"
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../init.rb"
+require 'test/unit'

data/test/unit/divan.rb

@@ -0,0 +1,198 @@
+require "#{File.dirname(__FILE__)}/../test_helper.rb"
+
+class InvalidatedModel < Divan::Models::ProofOfConcept
+  before_validate :indiferent_callback
+  after_validate  lambda{ |obj| obj != nil }
+  after_validate  :invalidate
+
+  def indiferent_callback
+    true
+  end
+  
+  def invalidate
+    false
+  end
+end
+
+class ViewedModel < Divan::Models::ProofOfConcept
+  view_by :value
+  view_by :mod
+end
+
+class ProofOfConcept < Divan::Models::ProofOfConcept
+  property :first_name
+end
+
+class TestDivan < Test::Unit::TestCase
+  def test_dynamic_model
+    m = Divan::Model(:teste)
+    assert m.class, Divan::Models::Teste
+    assert m.database.name,     'test'
+    assert m.database.host,     '127.0.0.1'
+    assert m.database.port,     12345
+    assert m.database.user,     'admin'
+    assert m.database.password, 'top1secret2pass'
+  end
+
+  def test_get_database_stats
+    database = Divan[:proof_of_concept]
+    assert_equal database.stats[:db_name], 'proof_of_concept'
+  end
+
+  def test_create_and_delete_database
+    database = Divan::Database.new :created_test_database, 'host' => 'http://127.0.0.1', 'database' => 'test_database'
+    delete_lambda = lambda{
+      assert database.delete['ok']
+      assert !database.exists?
+    }
+    create_lambda = lambda{
+      assert database.create['ok']
+      assert_equal database.stats[:db_name], 'test_database'
+    }
+    delete_lambda.call if database.exists?
+    create_lambda.call
+    delete_lambda.call
+  end
+
+  def test_database_not_found
+    database = Divan::Database.new :missing_database, 'host' => 'http://localhost', 'database' => 'mising_database'
+    assert_raise(Divan::DatabaseNotFound){ database.stats }
+    assert_raise(Divan::DatabaseNotFound){ database.delete }
+  end
+
+  def test_database_already_created
+    database = Divan::Database.new :already_created, 'host' => 'http://localhost', 'database' => 'already_created'
+    assert database.create['ok']
+    assert_raise(Divan::DatabaseAlreadyCreated){ database.create }
+    assert database.delete['ok'] # Only to ensure that database is deleted after this test
+  end
+
+  def test_saving_and_retrieving_simple_document_should_work
+    object = ProofOfConcept.new :simple_param  => 'Working well!',
+                                :hashed_params => { :is_a => 'Hash', :hash_size => 2 }
+    assert object.save
+    retrieved_object = ProofOfConcept.find object.id
+    assert retrieved_object
+    assert retrieved_object.rev
+    assert_equal object.id, retrieved_object.id
+    assert_equal object.attributes, retrieved_object.attributes
+    assert retrieved_object.delete['ok']
+    assert_not_equal object.rev, retrieved_object.rev
+  end
+
+  def test_retrieving_non_existent_document_should_return_nil
+    obj = ProofOfConcept.find '0'*32 # Probably this uuid don't exists in database
+    assert_nil obj
+  end  
+
+  def test_updating_document
+    object = ProofOfConcept.new
+    object[:hashed_params] = {:is_a => 'Hash', :hash_size => 2}
+    object[:simple_param]  = 'Working well!'
+    assert object.save
+    retrieved_object = ProofOfConcept.find object.id
+    assert retrieved_object
+    retrieved_object[:updated_attrib] = 'New attribute!'
+    assert retrieved_object.save['ok']
+    object[:lost_race] = 'I\'ll fail!'
+    assert_raise(Divan::DocumentConflict){ object.save }
+  end
+
+  def test_retrieving_deleted_object
+    object = ProofOfConcept.new
+    object[:hashed_params] = {:is_a => 'Hash', :hash_size => 2}
+    object[:simple_param]  = 'Working well!'
+    assert object.save
+    assert object.delete
+    retrieved_object = ProofOfConcept.find object.id
+    assert_nil retrieved_object
+  end
+
+  def test_deleting_document_twice
+    object = ProofOfConcept.new
+    object[:hashed_params] = {:is_a => 'Hash', :hash_size => 2}
+    object[:simple_param]  = 'Working well!'
+    assert object.save
+    assert object.delete
+    assert_nil object.delete
+  end
+
+  def test_save_deleted_document
+    object = ProofOfConcept.new
+    object[:hashed_params] = {:is_a => 'Hash', :hash_size => 2}
+    object[:simple_param]  = 'Working well!'
+    assert object.save
+    assert object.delete
+    assert object.save
+    assert object.delete
+  end
+
+  def test_delete_all_from_database
+    assert ProofOfConcept.delete_all
+    10.times do |n|
+      assert ProofOfConcept.new( :value => n ).save
+    end
+    # assert_equal Divan[:proof_of_concept].views.count, 5
+    assert Divan[:proof_of_concept].create_views
+    assert_equal ProofOfConcept.delete_all(:limit => 6), 6
+    assert_equal ProofOfConcept.all.first.class, ProofOfConcept
+    assert_equal ProofOfConcept.delete_all, 4
+    assert ProofOfConcept.find('_design/proof_of_concept')
+    assert_equal ProofOfConcept.all.count, 0
+  end
+
+  def test_bulk_create
+    assert ProofOfConcept.delete_all
+    params = 10.times.map do |n|
+      {:number => n, :double => 2*n}
+    end
+    assert ProofOfConcept.create params
+    assert_equal ProofOfConcept.delete_all, 10
+  end
+
+  def test_perform_view_by_query
+    assert ViewedModel.delete_all
+    assert Divan[:proof_of_concept].create_views
+    params = 10.times.map do |n|
+      {:mod => (n%2), :value => "#{n} mod 2"}
+    end
+    assert ViewedModel.create params
+    obj = ViewedModel.by_value '5 mod 2'
+    assert obj
+    assert_equal obj.mod, 1
+    assert_equal ViewedModel.all_by_mod(0).count, 5
+    assert_equal ViewedModel.find_all.count, 10
+    assert_equal ViewedModel.delete_all, 10
+  end
+
+  def test_before_validate_callback_avoids_save
+    object = InvalidatedModel.new
+    assert !object.save
+    assert_nil object.rev
+  end
+
+  def test_dynamic_access_to_attributes
+    object = ProofOfConcept.new :dynamic_attribute => 'Working'
+    assert object.dynamic_attribute, 'Working'
+    assert_equal( (object.dynamic_setter = "Well"), 'Well')
+    assert_equal object.dynamic_setter, 'Well'
+  end
+
+  def test_setting_properties
+    object = ProofOfConcept.new
+    assert_nil object.first_name
+    assert_raise(NoMethodError){ object.last_name }
+  end
+
+  def test_top_level_model
+    Divan::Models::ProofOfConcept.delete_all
+    ProofOfConcept.create :test => 123
+    Divan::Models::ProofOfConcept.create :test => 456
+    ViewedModel.create :test => 789
+    assert_equal Divan::Models::ProofOfConcept.find_all.count, 3
+    assert_equal ProofOfConcept.find_all.count, 3
+    assert_equal ViewedModel.find_all.count, 1
+    assert_equal ViewedModel.delete_all, 1
+    assert_equal ProofOfConcept.delete_all, 2
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: divan
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Dalton Pinto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-18 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: |
+  This is a very simple CouchDB client that have few dependencies.
+  This client has a lot of interesting features, for example: easy access to CouchDB revisions.
+
+email: dalthon@aluno.ita.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile.rb
+- VERSION
+- init.rb
+- lib/divan.rb
+- lib/divan/base.rb
+- lib/divan/database.rb
+- lib/divan/models/base.rb
+- lib/divan/utils.rb
+- test/test_helper.rb
+- test/unit/divan.rb
+has_rdoc: true
+homepage: http://github.com/efqdalton/divan
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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 Ruby CouchDB Client for insane people
+test_files: 
+- test/test_helper.rb
+- test/unit/divan.rb