couchdb-client 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in couchrb.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Gimi Liang
+
+MIT License
+
+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 OR COPYRIGHT HOLDERS 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,47 @@
+# Couchdb-client
+
+'couchdb-client' is a pure ruby, easy to use CouchDB client library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'couchdb-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install couchdb-client
+
+## Usage
+
+    require 'couchdb-client'
+
+    client = CouchDB.connect :host => 'localhost', :port => 5984 # => CouchDB::Client instance
+
+    db = client['some_database'] # => CouchDB::Database
+
+    doc = db.put 'key' => 'value'
+
+    doc = db.get 'xxx' # => CouchDB::Document instance w/ _id 'xxx'
+
+    doc.update!(:some_field => 'new_value')
+    # or
+    db.put doc.update('some_field' => 'new_value')
+
+    doc.delete!
+    # or
+    db.delete doc._id
+
+    db.exists? 'xxx'
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/couchdb-client.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/couchdb/client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Gimi Liang"]
+  gem.email         = ["liang.gimi@gmail.com"]
+  gem.description   = %q{A pure Ruby CouchDB client.}
+  gem.summary       = %q{A pure Ruby CouchDB client.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "couchdb-client"
+  gem.require_paths = ["lib"]
+  gem.version       = CouchDB::Client::VERSION
+
+  gem.add_dependency 'json',       ['~> 1.7.5']
+  gem.add_dependency 'httparty',   ['~> 0.8.3']
+end

data/lib/couchdb/client/version.rb

@@ -0,0 +1,5 @@
+module CouchDB
+  class Client
+    VERSION = "1.0.0"
+  end
+end

data/lib/couchdb/client.rb

@@ -0,0 +1,77 @@
+module CouchDB
+  class Client
+    def self.default_options
+      {:host => 'localhost', :port => 5984}
+    end
+
+    def initialize(options = {})
+      options = self.class.default_options.merge normalize_options(options)
+      @connection = establish_connection options
+    end
+
+    def all_dbs
+      get '_all_dbs'
+    end
+
+    # Public: Get a Database with the given name.
+    def db(name, doc_class = Document)
+      DataBase.new self, name, doc_class
+    end
+    
+    alias [] db
+
+    def get(path)
+      send_http_request :get, path
+    end
+
+    def put(path, options = {})
+      send_http_request :put, path, {:headers => {'Content-Type' => 'application/json'}}.merge!(options)
+    end
+
+    def post(path, options = {})
+      send_http_request :post, path, {:headers => {'Content-Type' => 'application/json'}}.merge!(options)
+    end
+
+    def delete(path, options = {})
+      send_http_request :delete, path, options
+    end
+
+    def head(path, options = {})
+      send_http_request :head, path, options
+    end
+
+    private
+
+    attr_reader :connection
+
+    def normalize_options(options)
+      options.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
+    end
+
+    def establish_connection(options)
+       class << self; self end.tap { |singleton_class|
+        singleton_class.send :include, HTTParty
+        singleton_class.base_uri base_uri_from_options(options)
+       }
+    end
+
+    def base_uri_from_options(options)
+      scheme = options[:ssl] ? 'https' : 'http'
+      "#{scheme}://#{options[:host]}".tap { |uri|
+        uri << ":#{options[:port]}" if options[:port]
+      }
+    end
+
+    def send_http_request(verb, path, options = {})
+      CouchDB.debug { "[CouchDB] Request: #{verb} /#{path} #{options.inspect}" }
+      resp = connection.send(verb, "/#{path}", options)
+      CouchDB.debug { "[CouchDB] Response: #{resp.code} #{resp.body.inspect}" }
+      if resp.code < 300
+        JSON.load resp.body
+      else
+        raise HTTPError, resp
+      end
+    end
+  end
+
+end

data/lib/couchdb/database.rb

@@ -0,0 +1,99 @@
+module CouchDB
+  class DataBase
+    attr_reader :name
+
+    def initialize(client, name, doc_class = Document)
+      raise ArgumentError, "doc_class must be a Document." unless doc_class <= Document
+
+      @client = client
+      @name = name
+      @doc_class = doc_class
+    end
+
+    def set_doc_class(doc_class)
+      raise ArgumentError, "doc_class must be a Document." unless doc_class <= Document
+
+      @doc_class = doc_class
+    end
+
+    # Create or update a document.
+    def create!
+      client.put name
+    end
+
+    def ensure_exist!
+      create!
+    rescue HTTPError => e
+      raise e unless e.code == 419
+    end
+
+    def delete!
+      client.delete name
+    end
+
+    def all_docs(options = nil)
+      client.get path_for('_all_docs')
+    end
+
+    def new_doc(data)
+      doc_class.new self, data
+    end
+
+    # Public: retrieve a document by its _id. Also see `find`.
+    def get(_id)
+      new_doc client.get(path_for(_id))
+    end
+
+    # Public: retrieve a document by its _id.
+    #
+    # This method is similar to the `get` method, the only difference is
+    # `get` will raise CouchDB::HTTPError when CouchDB returns errors,
+    # while `find` will only return nil. Which means `get` gives you
+    # a more flexible way to handle errors.
+    def find(_id)
+      get _id
+    rescue HTTPError => e
+      nil
+    end
+
+    # Public: put a hash-ish into the database.
+    #
+    # This method can be used to create and update a document.
+    def put(data)
+      data = new_doc data
+      raise InvalidObject.new(data) unless data.valid?
+
+      resp =
+        if id = data.delete('_id')
+          client.put path_for(id), :body => encode(data)
+        else
+          client.post name, :body => encode(data)
+        end
+
+      data.merge! '_id' => resp['id'], '_rev' => resp['rev']
+    end
+
+    def delete(_id, _rev)
+      client.delete path_for(_id), :query => {'rev' => _rev}
+    end
+
+    # Public: is there a document whose id is _id?
+    def exist?(_id)
+      client.head path_for(_id)
+    rescue CouchDB::HTTPError
+      raise $! unless $!.code == 404
+    end
+
+    private
+
+    attr_reader :client, :doc_class
+
+    def path_for(_id)
+      "#{name}/#{_id}"
+    end
+
+    def encode(document)
+      JSON.fast_generate document
+    end
+  end
+end

data/lib/couchdb/document.rb

@@ -0,0 +1,54 @@
+module CouchDB
+  class Document < JSONObject
+    class << self
+      alias fixed_schema!   fixed_structure!
+      alias fixed_schema?   fixed_structure?
+      alias dynamic_schema! dynamic_structure!
+      alias dynamic_schema? dynamic_structure?
+    end
+
+    property :_id,  :string
+    property :_rev, :string
+
+    attr_reader :db
+
+    def initialize(db, attributes = nil)
+      super attributes
+      @db = db
+      send :after_initialize if respond_to?(:after_initialize)
+    end
+
+    def _rev
+      self['_rev']
+    end
+
+    alias rev _rev
+
+    def _id
+      self['_id']
+    end
+
+    alias id _id
+
+    def new_record?
+      _id.nil?
+    end
+
+    def save
+      send :before_save if respond_to?(:before_save)
+      replace db.put(self)
+    end
+
+    def update!(attributes)
+      send :before_update if respond_to?(:before_update)
+      update attributes
+      save
+    end
+
+    def delete!
+      raise InvalidOperation, "Can not delete a document without _id or _rev." unless id and rev
+      send :before_delete if respond_to?(:before_delete)
+      db.delete id, rev
+    end
+  end
+end

data/lib/couchdb/errors.rb

@@ -0,0 +1,89 @@
+module CouchDB
+  class Error < RuntimeError; end
+
+  class InvalidOperation < Error; end
+
+  class PropertyError < Error
+    attr_reader :name
+
+    def initialize(name, msg = nil)
+      @name = name
+      msg ||= "Property error: #{name}"
+      super msg
+    end
+
+    def to_hash
+      {:property => name, :error => 'error'}
+    end
+  end
+
+  class UndefinedProperty < PropertyError
+    def initialize(name)
+      super name, "Property #{name.inspect} is not defined."
+    end
+
+    def to_hash
+      {:property => name, :error => 'undefined'}
+    end
+  end
+
+  class MissingProperty < PropertyError
+    def initialize(name)
+      super name, "Property #{name.inspect} is required, but not given."
+    end
+
+    def to_hash
+      {:property => name, :error => 'missing'}
+    end
+  end
+
+  class InvalidValue < PropertyError
+    attr_accessor :value, :reason
+
+    def initialize(name, value, reason = nil)
+      @value, @reason = value, reason
+      super name, "#{value.inspect} is not a valid value for #{name} (#{reason})."
+    end
+
+    def to_hash
+      {:property => name, :value => value, :error => 'invalid'}
+    end
+  end
+
+  class InvalidObject < Error
+    attr_reader :errors
+
+    def initialize(json_object)
+      @errors = json_object.errors.inject({}) { |h, (name, error)|
+        h[name] = case error
+                  when PropertyError
+                    error.to_hash.tap { |hash| hash.delete :property }
+                  else
+                    {:error => 'unknown'}
+                  end
+        h
+      }
+
+      super "#{json_object} is invalid."
+    end
+
+    def to_hash
+      @errors
+    end
+
+    def to_json
+      JSON.fast_generate @errors
+    end
+  end
+
+  class HTTPError < Error
+    attr_reader :code, :body
+
+    def initialize(response)
+      @code = response.code
+      @body = JSON.parse response.body if response.body
+
+      super @body ? @body['reason'] : @code
+    end
+  end
+end

data/lib/couchdb/json_object.rb

@@ -0,0 +1,188 @@
+module CouchDB
+  # Public: The Ruby class that represents the JSON Object.
+  #         All properties (keys) in a JSONObject are strings.
+  #         (even strings are not the best hash key in Ruby)
+  class JSONObject < Hash
+    # Private: The propety definition object.
+    class Property
+      BuiltinTypes = {
+        :string => lambda { |v| v.to_s },
+        :int    => lambda { |v| Integer(v) },
+        :float  => lambda { |v| Float(v) },
+        :bool   => lambda { |v| !!v },
+        :array  => lambda { |v| Array(v) },
+        :hash   => lambda { |v| v.to_hash },
+        :object => JSONObject
+      }
+
+      attr_reader :name, :default
+
+      def initialize(name, type, options = {}, &blk)
+        @name = name
+
+        if type.is_a?(Symbol)
+          raise ArgumentError, "Unknow property type #{type.inspect}." unless BuiltinTypes.has_key?(type)
+          type = BuiltinTypes[type] 
+        end
+        type = Class.new JSONObject, &blk if type == JSONObject
+
+        @convertor =
+          if type.respond_to?(:call)
+            type
+          elsif convert_method = [:convert, :new].detect { |m| type.respond_to? m }
+            type.method convert_method
+          else
+            raise ArgumentError, "Property type should has :convert, :call or :new method."
+          end
+
+        @required  = options[:required]
+        @default   = options[:default]
+        @validator = options[:validate]
+      end
+
+      def required?
+        @required
+      end
+
+      def has_default?
+        !@default.nil?
+      end
+
+      def convert(value)
+        @convertor.call value
+      rescue
+        raise $!.is_a?(InvalidValue) ? $! : InvalidValue.new(name, value, $!.message)
+      end
+
+      def valid_value?(value)
+        @validator.nil? or value.nil? or @validator.call(value)
+      end
+    end # Property
+
+    # Public: Make this object become a fixed struture object, which means
+    #         all properties of this object have to be declared (using the
+    #         `property` method) before being used.
+    def self.fixed_structure!
+      @fixed_structure = true
+    end
+
+    # Public: Make this object a dynamic struture object, which means
+    #         its properties are dynamic (just like a Hash).
+    def self.dynamic_structure!
+      @fixed_structure = false
+    end
+
+    def self.fixed_structure?
+      @fixed_structure
+    end
+
+    def self.dynamic_structure?
+      not fixed_structure?
+    end
+
+    # Public: Properties will inherit from the parent class.
+    def self.properties
+      @properties ||= {}.tap { |h| h.merge! superclass.properties if superclass < JSONObject }
+    end
+
+    def self.property(name, type = :string, options = {}, &blk)
+      name = name.to_s
+      properties[name] = Property.new(name, type, options, &blk)
+    end
+
+    # Public: lookup a property definition by its name.
+    def self.lookup(property_name)
+      properties[property_name.to_s]
+    end
+
+    attr_reader :errors
+
+    def initialize(data = nil)
+      replace data if data
+      set_defaults
+      @errors = {}
+    end
+
+    def []=(name, value)
+      super name.to_s, convert_value(name, value)
+    end
+
+    def store(name, value)
+      super name.to_s, convert_value(name, value)
+    end
+
+    def update(data)
+      super convert_hash(data)
+    end
+
+    def merge!(data)
+      super convert_hash(data)
+    end
+
+    def merge(data)
+      super convert_hash(data)
+    end
+
+    def replace(data)
+      super convert_hash(data)
+    end
+
+    def valid?
+      validate!
+      errors.empty?
+    end
+
+    def validate!
+      errors.clear
+
+      properties.each { |k, property|
+        if property.required? and self[k].nil?
+          errors[k] = MissingProperty.new(k)
+          next
+        end
+
+        if not property.valid_value?(self[k])
+          errors[k] = InvalidValue.new(k, self[k])
+        end
+      }
+    end
+
+    def inspect
+      "#{self.class.name}#{super}"
+    end
+
+    private
+
+    def properties
+      self.class.properties
+    end
+
+    def fixed_structure?
+      self.class.fixed_structure?
+    end
+
+    def dynamic_structure?
+      self.class.dynamic_structure?
+    end
+
+    def convert_value(property_name, value)
+      unless value.nil?
+        property = self.class.lookup property_name
+        raise UndefinedProperty.new(property_name) if fixed_structure? && property.nil?
+        value = property.convert(value) if property
+      end
+
+      value
+    end
+
+    def convert_hash(hash)
+      Hash[hash.map { |k, v| [k.to_s, convert_value(k, v)] }]
+    end
+
+    def set_defaults
+      properties.values.each { |property|
+        self[property.name] = property.default if self[property.name].nil? and property.has_default?
+      }
+    end
+  end
+end

data/lib/couchdb/model.rb

@@ -0,0 +1,111 @@
+module CouchDB
+  class Model
+    # call-seq
+    #   establish_connection options
+    #
+    # call-seq
+    #   establish_connection client
+    def self.establish_connection(options_or_client)
+      @connection = options_or_client
+      @connection = Client.new connection unless connection.is_a?(Client)
+    end
+
+    def self.connection
+      @connection || superclass <= Model && superclass.connection || nil
+    end
+
+    def self.db
+      @db ||= connection && connection[db_name, doc_class]
+    end
+
+    def self.set_db_name(name)
+      @db_name = name
+    end
+
+    def self.db_name
+      @db_name || superclass <= Model && superclass.db_name || nil
+    end
+
+    def self.set_doc_class(doc_class)
+      raise ArgumentError, "Not a Document." unless doc_class <= Document
+      return if @doc_class == doc_class
+      @doc_class = doc_class
+      @db = nil
+    end
+
+    def self.doc_class
+      @doc_class || superclass <= Model && superclass.doc_class || Document
+    end
+
+    def self.find(id)
+      doc = db.find(id)
+      new doc if doc
+    end
+
+    attr_reader :doc
+
+    def initialize(attributes = nil)
+      @doc = self.class.db.new_doc attributes
+    end
+
+    def [](attribute)
+      @doc[attribute]
+    end
+
+    def []=(attribute, value)
+      @doc[attribute] = value
+    end
+
+    def read(chained_keys, splitter = '.')
+      chained_keys.split(splitter).inject(@doc) { |value, key|
+        value = value.respond_to?(key) ? value.send(key) : value[key]
+        break if value.nil?
+        value
+      }
+    end
+
+    def _id
+      @doc._id
+    end
+
+    alias id _id
+
+    def _rev
+      @doc._rev
+    end
+
+    alias rev _rev
+
+    def new_record?
+      @doc.new_record?
+    end
+
+    def update(attributes)
+      @doc.update! attributes
+    end
+
+    def save
+      @doc.save
+    end
+
+    def delete
+      @doc.delete!
+      freeze
+    end
+
+    def to_hash
+      @doc.to_hash
+    end
+
+    def to_json
+      JSON.fast_generate @doc
+    end
+
+    private
+
+    def freeze
+      super
+      @doc.freeze
+    end
+  end
+end

data/lib/couchdb-client.rb

@@ -0,0 +1 @@
+require 'couchdb'

data/lib/couchdb.rb

@@ -0,0 +1,35 @@
+require 'json'
+require 'httparty'
+
+module CouchDB
+  require 'couchdb/errors'
+
+  require 'couchdb/client'
+  require 'couchdb/database'
+  require 'couchdb/json_object'
+  require 'couchdb/document'
+
+  require 'couchdb/model'
+
+  class << self
+    # Public: A sugar method for creating a Client instance.
+    def connect(options = {})
+      Client.new options
+    end
+
+    def logger
+      @logger ||= begin
+                    require 'logger'
+                    Logger.new($stdout).tap { |logger| logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO }
+                  end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def debug
+      logger.debug yield if logger.debug?
+    end
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+class ClientTest < CouchDB::TestCase
+  def test_get_all_dbs
+    assert_includes client.all_dbs, 'couchdb-client_test_fixtures'
+  end
+
+  def test_get_all_documents
+    resp = db.all_docs
+
+    assert_equal resp['total_rows'], resp['rows'].size
+  end
+
+  def test_create_documents
+    doc = db.put :type => 'human', :name => 'Gimi'
+
+    assert_kind_of CouchDB::Document, doc
+    assert doc.id
+    assert doc.rev
+  end
+
+  def test_get_documents
+    doc  = db.put :type => 'human', :name => 'Gimi'
+    doc2 = db.get doc.id
+
+    assert_kind_of CouchDB::Document, doc2
+    assert_equal doc.id, doc2.id
+    assert_equal doc.rev, doc2.rev
+    assert_equal doc.values_at('type', 'name'), doc2.values_at('type', 'name')
+  end
+
+  def test_update_documents
+    doc = db.put :type => 'human', :name => 'Gimi'
+    rev = doc.rev
+    doc.update! :name => 'GimiL'
+
+    assert_equal 'GimiL', doc['name']
+    refute_equal rev, doc.rev
+  end
+
+  def test_delete_documents
+    doc = db.put :type => 'human', :name => 'Gimi'
+    doc.delete!
+    assert_raises CouchDB::HTTPError do
+      db.get doc.id
+    end
+  end
+end

data/test/database_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+class DatabaseTest < CouchDB::TestCase
+  def test_default_doc_class
+    doc = db.put :type => 'person', :name => 'Gimi'
+    assert_instance_of CouchDB::Document, doc
+  end
+
+  def test_custom_doc_class
+    db = client.db(db_name, TestDoc)
+
+    assert_raises CouchDB::InvalidObject do
+      db.put :key => 'value'
+    end
+
+    doc = db.put :name => 'Gimi'
+    assert_instance_of TestDoc, doc
+    assert_equal 'person', doc['type']
+  end
+
+  def test_exist
+    refute db.exist?('non_exist_id')
+  end
+
+  class TestDoc < CouchDB::Document
+    property :type, :string, :default  => 'person'
+    property :name, :string, :required => true
+  end
+end

data/test/json_object_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class JSONObjectTest < MiniTest::Unit::TestCase
+  def test_keys_are_strings
+    o = CouchDB::JSONObject.new
+    o[:key] = 'some_value'
+    assert_equal 'some_value', o['key']
+
+    o = CouchDB::JSONObject.new :key => 'some_value'
+    assert_equal 'some_value', o['key']
+  end
+
+  def test_builtin_type_converter
+    skip
+  end
+
+  def test_dynamic_structure
+    o = CouchDB::JSONObject.new
+    o[:key] = 'some_value'
+    assert o.valid?
+  end
+
+  def test_fixed_structure
+    o = Class.new(CouchDB::JSONObject) do
+      fixed_structure!
+
+      property :valid_key
+    end.new
+
+    assert o['valid_key'] = 'some_value'
+    assert_raises CouchDB::UndefinedProperty do
+      o['invalid_key'] = 'some_value'
+    end
+  end
+
+  def test_required_property
+    o = Class.new(CouchDB::JSONObject) do
+      property :required_key, :string, :required => true
+    end.new
+
+    refute o.valid?
+    assert_instance_of CouchDB::MissingProperty, o.errors['required_key']
+
+    o[:required_key] = 'some_value'
+    assert o.valid?
+  end
+
+  def test_property_validation
+    o = Class.new(CouchDB::JSONObject) do
+      property :key, :string, :validate => lambda { |v| %w[hello world].include? v }
+    end.new
+
+    o[:key] = 'hello'
+    assert o.valid?
+
+    o[:key] = 'hell'
+    refute o.valid?
+    assert_instance_of CouchDB::InvalidValue, o.errors['key']
+  end
+
+  def test_property_inherent
+    parent = Class.new CouchDB::JSONObject do
+      fixed_structure!
+
+      property :name, :string, :required => true
+    end
+
+    child = Class.new parent do
+      property :parent, :string, :required => true
+    end
+
+    p = parent.new :name => 'Gimi'
+    assert p.valid?
+
+    c = child.new :parent => 'Gimi'
+    refute c.valid?
+    assert_instance_of CouchDB::MissingProperty, c.errors['name']
+  end
+end

data/test/model_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class ModelTest < CouchDB::TestCase
+  def setup
+    super
+    CouchDB::Model.establish_connection client
+  end
+
+  def test_read_method
+    model = Class.new(CouchDB::Model) do
+      set_doc_class Class.new(CouchDB::Document) {
+        property :key_one, :object do
+          property :inner_key, :string
+        end
+
+        property :key_two, :object do
+          def foo
+            'foo'
+          end
+        end
+      }
+    end
+
+    model.set_db_name db_name
+
+    sth = model.new :key_one => {:inner_key => 'inner_value'}, :key_two => {}
+
+    assert_equal 'inner_value', sth.read('key_one.inner_key')
+    assert_equal 'foo', sth.read('key_two.foo')
+  end
+end

data/test/test_all.rb

@@ -0,0 +1 @@
+Dir[File.expand_path('../*_test.rb', __FILE__)].each { |test_case| require test_case }

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+
+require 'bundler'
+Bundler.setup
+
+require 'couchdb-client'
+require 'minitest/autorun'
+
+class CouchDB::TestCase < MiniTest::Unit::TestCase
+  attr_reader :client, :db
+
+  def setup
+    super
+
+    @client = CouchDB.connect
+    @db = @client[db_name]
+    @db.ensure_exist!
+  end
+
+  def teardown
+    db.delete!
+  end
+
+  private
+
+  def db_name
+    @db_name ||= 'couchdb-client_test_fixtures'
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: couchdb-client
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Gimi Liang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-12 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 7
+        - 5
+        version: 1.7.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 8
+        - 3
+        version: 0.8.3
+  type: :runtime
+  version_requirements: *id002
+description: A pure Ruby CouchDB client.
+email: 
+- liang.gimi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- couchdb-client.gemspec
+- lib/couchdb-client.rb
+- lib/couchdb.rb
+- lib/couchdb/client.rb
+- lib/couchdb/client/version.rb
+- lib/couchdb/database.rb
+- lib/couchdb/document.rb
+- lib/couchdb/errors.rb
+- lib/couchdb/json_object.rb
+- lib/couchdb/model.rb
+- test/client_test.rb
+- test/database_test.rb
+- test/json_object_test.rb
+- test/model_test.rb
+- test/test_all.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+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.9.5
+signing_key: 
+specification_version: 3
+summary: A pure Ruby CouchDB client.
+test_files: 
+- test/client_test.rb
+- test/database_test.rb
+- test/json_object_test.rb
+- test/model_test.rb
+- test/test_all.rb
+- test/test_helper.rb