couchbase-model 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+test/CouchbaseMock.jar

data/.travis.yml

@@ -0,0 +1,11 @@
+before_install:
+  - wget -O- http://packages.couchbase.com/ubuntu/couchbase.key | sudo apt-key add -
+  - echo deb http://packages.couchbase.com/ubuntu lucid lucid/main | sudo tee /etc/apt/sources.list.d/couchbase.list
+  - sudo apt-get update
+  - sudo apt-get -y install libevent-dev libvbucket-dev libcouchbase-dev
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree

data/.yardopts

@@ -0,0 +1,5 @@
+--protected
+--no-private
+-
+README.markdown
+HISTORY.markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in couchbase-model.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,51 @@
+# Couchbase Model [![Build Status](https://secure.travis-ci.org/avsej/ruby-couchbase-model.png?branch=master)](http://travis-ci.org/avsej/ruby-couchbase-model)
+
+This library allows to declare models for [couchbase gem][1]. Here are example:
+
+    require 'couchbase/model'
+
+    class Post < Couchbase::Model
+      attribute :title
+      attribute :body
+      attribute :draft
+    end
+
+    p = Post.new(:id => 'hello-world',
+                 :title => 'Hello world',
+                 :draft => true)
+    p.save
+    p = Post.find('hello-world')
+    p.body = "Once upon the times...."
+    p.save
+    p.update(:draft => false)
+    Post.bucket.get('hello-world')  #=> {"title"=>"Hello world", "draft"=>false,
+                                    #    "body"=>"Once upon the times...."}
+
+You can also let the library generate the unique identifier for you:
+
+    p = Post.create(:title => 'How to generate ID',
+                    :body => 'Open up the editor...')
+    p.id        #=> "74f43c3116e788d09853226603000809"
+
+There are several algorithms available. By default it use `:sequential`
+algorithm, but you can change it to more suitable one for you:
+
+    class Post < Couchbase::Model
+      attribute :title
+      attribute :body
+      attribute :draft
+
+      uuid_algorithm :random
+    end
+
+You can define connection options on per model basis:
+
+    class Post < Couchbase::Model
+      attribute :title
+      attribute :body
+      attribute :draft
+
+      connect :port => 80, :bucket => 'blog'
+    end
+
+[1]: https://github.com/couchbase/couchbase-ruby-client/

data/Rakefile

@@ -0,0 +1,22 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'bundler/gem_tasks'
+
+Dir['tasks/*.rake'].sort.each { |f| load f }
+
+task :default => :test

data/couchbase-model.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "couchbase/model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "couchbase-model"
+  s.version     = Couchbase::Model::VERSION
+  s.authors     = ["Sergey Avseyev"]
+  s.email       = ["sergey.avseyev@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Declarative interface to Couchbase}
+  s.description = %q{ORM-like interface allows you to persist your models to Couchbase}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'couchbase', '~> 1.1.0'
+
+  s.add_development_dependency 'rake', '~> 0.8.7'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rdiscount'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency RUBY_VERSION =~ /^1\.9/ ? 'ruby-debug19' : 'ruby-debug'
+end

data/lib/couchbase-model.rb

@@ -0,0 +1,18 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'couchbase/model'

data/lib/couchbase/model.rb

@@ -0,0 +1,332 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'couchbase'
+require 'couchbase/model/version'
+require 'couchbase/model/uuid'
+
+module Couchbase
+
+  class Error::MissingId < Error::Base; end
+
+  # Declarative layer for Couchbase gem
+  #
+  #  require 'couchbase/model'
+  #
+  #  class Post < Couchbase::Model
+  #    attribute :title
+  #    attribute :body
+  #    attribute :draft
+  #  end
+  #
+  #  p = Post.new(:id => 'hello-world',
+  #               :title => 'Hello world',
+  #               :draft => true)
+  #  p.save
+  #  p = Post.find('hello-world')
+  #  p.body = "Once upon the times...."
+  #  p.save
+  #  p.update(:draft => false)
+  #  Post.bucket.get('hello-world')  #=> {"title"=>"Hello world", "draft"=>false,
+  #                                  #    "body"=>"Once upon the times...."}
+  #
+  # You can also let the library generate the unique identifier for you:
+  #
+  #  p = Post.create(:title => 'How to generate ID',
+  #                  :body => 'Open up the editor...')
+  #  p.id        #=> "74f43c3116e788d09853226603000809"
+  #
+  # There are several algorithms available. By default it use `:sequential`
+  # algorithm, but you can change it to more suitable one for you:
+  #
+  #  class Post < Couchbase::Model
+  #    attribute :title
+  #    attribute :body
+  #    attribute :draft
+  #
+  #    uuid_algorithm :random
+  #  end
+  #
+  # You can define connection options on per model basis:
+  #
+  #  class Post < Couchbase::Model
+  #    attribute :title
+  #    attribute :body
+  #    attribute :draft
+  #
+  #    connect :port => 80, :bucket => 'blog'
+  #  end
+  class Model
+    # Each model must have identifier
+    attr_accessor :id
+
+    # @private Container for all attributes of all subclasses
+    @@attributes = ::Hash.new {|hash, key| hash[key] = []}
+
+    # Use custom connection options
+    #
+    # @param [String, Hash, Array] options for establishing connection.
+    #
+    # @see Couchbase::Bucket#initialize
+    #
+    # @example Choose specific bucket
+    #   class Post < Couchbase::Model
+    #     connect :bucket => 'posts'
+    #     ...
+    #   end
+    def self.connect(*options)
+      self.bucket = Couchbase.connect(*options)
+    end
+
+    # Choose the UUID generation algorithms
+    #
+    # @param [Symbol] algorithm (:sequential) one of the available
+    #   algorithms.
+    #
+    # @see Couchbase::UUID#next
+    #
+    # @example Select :random UUID generation algorithm
+    #   class Post < Couchbase::Model
+    #     uuid_algorithm :random
+    #     ...
+    #   end
+    def self.uuid_algorithm(algorithm)
+      self.thread_storage[:uuid_algorithm] = algorithm
+    end
+
+    # Defines an attribute for the model
+    #
+    # @param [Symbol, String] name name of the attribute
+    #
+    # @example Define some attributes for a model
+    #  class Post < Couchbase::Model
+    #    attribute :title
+    #    attribute :body
+    #    attribute :published_at
+    #  end
+    #
+    #  post = Post.new(:title => 'Hello world',
+    #                  :body => 'This is the first example...',
+    #                  :published_at => Time.now)
+    def self.attribute(name)
+      define_method(name) do
+        @_attributes[name]
+      end
+      define_method(:"#{name}=") do |value|
+        @_attributes[name] = value
+      end
+      attributes << name unless attributes.include?(name)
+    end
+
+    # Find the model using +id+ attribute
+    #
+    # @param [String, Symbol] id model identificator
+    # @return [Couchbase::Model] an instance of the model
+    #
+    # @example Find model using +id+
+    #   post = Post.find('the-id')
+    def self.find(id)
+      if id && (obj = bucket.get(id))
+        new({:id => id}.merge(obj))
+      end
+    end
+
+    # Create the model with given attributes
+    #
+    # @param [Hash] args attribute-value pairs for the object
+    # @return [Couchbase::Model] an instance of the model
+    def self.create(*args)
+      new(*args).create
+    end
+
+    # Constructor for all subclasses of Couchbase::Model, which optionally
+    # takes a Hash of attribute value pairs.
+    #
+    # @param [Hash] attrs attribute-value pairs
+    def initialize(attrs = {})
+      @id = nil
+      @_attributes = ::Hash.new
+      update_attributes(attrs)
+    end
+
+    # Create this model and assign new id if necessary
+    #
+    # @return [Couchbase::Model] newly created object
+    #
+    # @raise [Couchbase::Error::KeyExists] if model with the same +id+
+    #   exists in the bucket
+    #
+    # @example Create the instance of the Post model
+    #   p = Post.new(:title => 'Hello world', :draft => true)
+    #   p.create
+    def create
+      @id ||= Couchbase::Model::UUID.generator.next(1, model.thread_storage[:uuid_algorithm])
+      model.bucket.add(@id, attributes)
+      self
+    end
+
+    # Create or update this object based on the state of #new?.
+    #
+    # @return [Couchbase::Model] The saved object
+    #
+    # @example Update the Post model
+    #   p = Post.find('hello-world')
+    #   p.draft = false
+    #   p.save
+    def save
+      return create if new?
+      model.bucket.set(@id, attributes)
+      self
+    end
+
+    # Update this object, optionally accepting new attributes.
+    #
+    # @param [Hash] attrs Attribute value pairs to use for the updated
+    #               version
+    # @return [Couchbase::Model] The updated object
+    def update(attrs)
+      update_attributes(attrs)
+      save
+    end
+
+    # Delete this object from the bucket
+    #
+    # @note This method will reset +id+ attribute
+    #
+    # @return [Couchbase::Model] Returns a reference of itself.
+    #
+    # @example Delete the Post model
+    #   p = Post.find('hello-world')
+    #   p.delete
+    def delete
+      raise Couchbase::Error::MissingId, "missing id attribute" unless @id
+      model.bucket.delete(@id)
+      @id = nil
+      self
+    end
+
+    # Check if the record have +id+ attribute
+    #
+    # @return [true, false] Whether or not this object has an id.
+    #
+    # @note +true+ doesn't mean that record exists in the database
+    #
+    # @see Couchbase::Model#exists?
+    def new?
+      !@id
+    end
+
+    # Check if the key exists in the bucket
+    #
+    # @param [String, Symbol] id the record identifier
+    # @return [true, false] Whether or not the object with given +id+
+    #   presented in the bucket.
+    def self.exists?(id)
+      !!bucket.get(id, :quiet => true)
+    end
+
+    # Check if this model exists in the bucket.
+    #
+    # @return [true, false] Whether or not this object presented in the
+    #   bucket.
+    def exists?
+      model.exists?(@id)
+    end
+
+    # All the defined attributes within a class.
+    #
+    # @see Model.attribute
+    def self.attributes
+      @@attributes[self]
+    end
+
+    # All the attributes of the current instance
+    #
+    # @return [Hash]
+    def attributes
+      @_attributes
+    end
+
+    # Update all attributes without persisting the changes.
+    #
+    # @param [Hash] attrs attribute-value pairs.
+    def update_attributes(attrs)
+      if id = attrs.delete(:id)
+        @id = id
+      end
+      attrs.each do |key, value|
+        send(:"#{key}=", value)
+      end
+    end
+
+    # Reload all the model attributes from the bucket
+    #
+    # @return [Model] the latest model state
+    #
+    # @raise [Error::MissingId] for records without +id+
+    #   attribute
+    def reload
+      raise Couchbase::Error::MissingId, "missing id attribute" unless @id
+      attrs = model.find(@id).attributes
+      update_attributes(attrs)
+      self
+    end
+
+    # @private The thread local storage for model specific stuff
+    def self.thread_storage
+      Couchbase.thread_storage[self] ||= {:uuid_algorithm => :sequential}
+    end
+
+    # @private Fetch the current connection
+    def self.bucket
+      self.thread_storage[:bucket] ||= Couchbase.bucket
+    end
+
+    # @private Set the current connection
+    #
+    # @param [Bucket] connection the connection instance
+    def self.bucket=(connection)
+      self.thread_storage[:bucket] = connection
+    end
+
+    # @private Get model class
+    def model
+      self.class
+    end
+
+    # @private Wrap the hash to the model class
+    #
+    # @param [Model, Hash] the Couchbase::Model subclass or the
+    #   attribute-value pairs
+    def self.wrap(object)
+      object.class == self ? object : new(object)
+    end
+
+    # @private Returns a string containing a human-readable representation
+    # of the record.
+    def inspect
+      attrs = model.attributes.sort.map do |attr|
+        [attr, @_attributes[attr].inspect]
+      end
+      sprintf("#<%s:%s %s>",
+              model, new? ? "?" : id,
+              attrs.map{|a| a.join("=")}.join(" "))
+    end
+
+  end
+
+end

data/lib/couchbase/model/uuid.rb

@@ -0,0 +1,103 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'thread'
+
+module Couchbase
+
+  class Model
+
+    # Generator of CouchDB specfic UUIDs. This is the ruby implementation of
+    # couch_uuids.erl from couchdb distribution. It is threadsafe.
+
+    class UUID
+      # Get default UUID generator. You can create your own if you like.
+      def self.generator
+        @generator ||= UUID.new
+      end
+
+      # Initialize generator.
+      #
+      # @param [Fixnum] seed seed for pseudorandom number generator.
+      def initialize(seed = nil)
+        seed ? srand(seed) : srand
+        @prefix, _ = rand_bytes(13).unpack("H26")
+        @inc = rand(0xfff) + 1
+        @lock = Mutex.new
+      end
+
+      # Generate list of UUIDs.
+      #
+      # @param [Fixnum] count number of UUIDs you need
+      #
+      # @param [Symbol] algorithm Algorithm to use. Known algorithms:
+      #   [:random]
+      #     128 bits of random awesome. All awesome, all the time.
+      #   [:sequential]
+      #     Monotonically increasing ids with random increments.  First 26 hex
+      #     characters are random. Last 6 increment in random amounts until an
+      #     overflow occurs. On overflow, the random prefix is regenerated and
+      #     the process starts over.
+      #   [:utc_random]
+      #     Time since Jan 1, 1970 UTC with microseconds. First 14 characters
+      #     are the time in hex. Last 18 are random.
+      #
+      # @return [String, Array] single string value or array of strings. Where
+      #   each value represents 128-bit number written in hexadecimal format.
+      def next(count = 1, algorithm = :sequential)
+        raise ArgumentError, "count should be a positive number" unless count > 0
+        uuids = case algorithm
+                when :random
+                  rand_bytes(16 * count).unpack("H32" * count)
+                when :utc_random
+                  now = Time.now.utc
+                  prefix = "%014x" % [now.to_i * 1_000_000 + now.usec]
+                  rand_bytes(9 * count).unpack("H18" * count).map do |tail|
+                    "#{prefix}#{tail}"
+                  end
+                when :sequential
+                  (1..count).map{ next_seq }
+                else
+                  raise ArgumentError, "Unknown algorithm #{algo}. Should be one :sequential, :random or :utc_random"
+                end
+        uuids.size == 1 ? uuids[0] : uuids
+      end
+
+      private
+
+      def next_seq
+        @lock.synchronize do
+          if @inc >= 0xfff000
+            @prefix, _ = rand_bytes(13).unpack("H26")
+            @inc = rand(0xfff) + 1
+          end
+          @inc += rand(0xfff) + 1
+          "%s%06x" % [@prefix, @inc]
+        end
+      end
+
+      def rand_bytes(count)
+        bytes = ""
+        count.times { bytes << rand(256) }
+        bytes
+      end
+
+    end
+
+  end
+
+end

data/lib/couchbase/model/version.rb

@@ -0,0 +1,26 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Couchbase
+
+  class Model
+
+    VERSION = "0.0.1"
+
+  end
+
+end

data/tasks/doc.rake

@@ -0,0 +1,25 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'rake/clean'
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+YARD::Rake::YardocTask.new do |t|
+  t.options = %w(--protected --no-private)
+  t.files.push('-', 'README.markdown', 'HISTORY.markdown')
+end

data/tasks/test.rake

@@ -0,0 +1,35 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'rake/testtask'
+require 'rake/clean'
+
+rule 'test/CouchbaseMock.jar' do |task|
+  jar_path = "0.5-SNAPSHOT/CouchbaseMock-0.5-20120222.060643-15.jar"
+  sh %{wget -q -O test/CouchbaseMock.jar http://files.couchbase.com/maven2/org/couchbase/mock/CouchbaseMock/#{jar_path}}
+end
+
+CLOBBER << 'test/CouchbaseMock.jar'
+
+Rake::TestTask.new do |test|
+  test.libs << "test" << "."
+  test.ruby_opts << "-rruby-debug" if ENV['DEBUG']
+  test.pattern = 'test/test_*.rb'
+  test.options = '--verbose'
+end
+
+Rake::Task['test'].prerequisites.unshift('test/CouchbaseMock.jar')

data/tasks/util.rake

@@ -0,0 +1,21 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+desc 'Start an irb session and load the library.'
+task :console  do
+  exec "irb -I lib -rruby-debug -rcouchbase-model"
+end

data/test/setup.rb

@@ -0,0 +1,168 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'minitest/autorun'
+require 'couchbase'
+require 'couchbase/model'
+
+require 'socket'
+require 'open-uri'
+
+class CouchbaseServer
+  attr_accessor :host, :port, :num_nodes, :buckets_spec
+
+  def real?
+    true
+  end
+
+  def initialize(params = {})
+    @host, @port = ENV['COUCHBASE_SERVER'].split(':')
+    @port = @port.to_i
+
+    if @host.nil? || @host.empty? || @port == 0
+      raise ArgumentError, "Check COUCHBASE_SERVER variable. It should be hostname:port"
+    end
+
+    @config = Yajl::Parser.parse(open("http://#{@host}:#{@port}/pools/default"))
+    @num_nodes = @config["nodes"].size
+    @buckets_spec = params[:buckets_spec] || "default:"  # "default:,protected:secret,cache::memcache"
+  end
+
+  def start
+    # flush all buckets
+    @buckets_spec.split(',') do |bucket|
+      name, password, _ = bucket.split(':')
+      connection = Couchbase.new(:hostname => @host,
+                                 :port => @port,
+                                 :username => name,
+                                 :bucket => name,
+                                 :password => password)
+      connection.flush
+    end
+  end
+  def stop; end
+end
+
+class CouchbaseMock
+  Monitor = Struct.new(:pid, :client, :socket, :port)
+
+  attr_accessor :host, :port, :buckets_spec, :num_nodes, :num_vbuckets
+
+  def real?
+    false
+  end
+
+  def initialize(params = {})
+    @host = "127.0.0.1"
+    @port = 0
+    @num_nodes = 10
+    @num_vbuckets = 4096
+    @buckets_spec = "default:"  # "default:,protected:secret,cache::memcache"
+    params.each do |key, value|
+      send("#{key}=", value)
+    end
+    yield self if block_given?
+    if @num_vbuckets < 1 || (@num_vbuckets & (@num_vbuckets - 1) != 0)
+      raise ArgumentError, "Number of vbuckets should be a power of two and greater than zero"
+    end
+  end
+
+  def start
+    @monitor = Monitor.new
+    @monitor.socket = TCPServer.new(nil, 0)
+    @monitor.socket.listen(10)
+    _, @monitor.port, _, _ = @monitor.socket.addr
+    trap("CLD") do
+      puts "CouchbaseMock.jar died unexpectedly during startup"
+      exit(1)
+    end
+    @monitor.pid = fork
+    if @monitor.pid.nil?
+      rc = exec(command_line("--harakiri-monitor=:#{@monitor.port}"))
+    else
+      trap("CLD", "SIG_DFL")
+      @monitor.client, _ = @monitor.socket.accept
+      @port = @monitor.client.recv(100).to_i
+    end
+  end
+
+  def stop
+    @monitor.client.close
+    @monitor.socket.close
+    Process.kill("TERM", @monitor.pid)
+    Process.wait(@monitor.pid)
+  end
+
+  def failover_node(index, bucket = "default")
+    @monitor.client.send("failover,#{index},#{bucket}", 0)
+  end
+
+  def respawn_node(index, bucket = "default")
+    @monitor.client.send("respawn,#{index},#{bucket}", 0)
+  end
+
+  protected
+
+  def command_line(extra = nil)
+    cmd = "java -jar #{File.dirname(__FILE__)}/CouchbaseMock.jar"
+    cmd << " --host #{@host}" if @host
+    cmd << " --port #{@port}" if @port
+    cmd << " --nodes #{@num_nodes}" if @num_nodes
+    cmd << " --vbuckets #{@num_vbuckets}" if @num_vbuckets
+    cmd << " --buckets #{@buckets_spec}" if @buckets_spec
+    cmd << " #{extra}"
+    cmd
+  end
+end
+
+class MiniTest::Unit::TestCase
+
+  def start_mock(params = {})
+    mock = nil
+    if ENV['COUCHBASE_SERVER']
+      mock = CouchbaseServer.new(params)
+      if (params[:port] && mock.port != params[:port]) ||
+        (params[:host] && mock.host != params[:host]) ||
+        mock.buckets_spec != "default:"
+        skip("Unable to configure real cluster. Requested config is: #{params.inspect}")
+      end
+    else
+      mock = CouchbaseMock.new(params)
+    end
+    mock.start
+    mock
+  end
+
+  def stop_mock(mock)
+    assert(mock)
+    mock.stop
+  end
+
+  def with_mock(params = {})
+    mock = nil
+    if block_given?
+      mock = start_mock(params)
+      yield mock
+    end
+  ensure
+    stop_mock(mock) if mock
+  end
+
+  def uniq_id(*suffixes)
+    [caller.first[/.*[` ](.*)'/, 1], suffixes].join("_")
+  end
+end

data/test/test_model.rb

@@ -0,0 +1,114 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011, 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require File.join(File.dirname(__FILE__), 'setup')
+
+class Post < Couchbase::Model
+  attribute :title
+  attribute :body
+end
+
+class TestModel < MiniTest::Unit::TestCase
+
+  def setup
+    @mock = start_mock
+    Post.bucket = Couchbase.connect(:hostname => @mock.host,
+                                    :port => @mock.port)
+  end
+
+  def teardown
+    stop_mock(@mock)
+  end
+
+  def test_assigns_attributes_from_the_hash
+    post = Post.new(:title => "Hello, world")
+    assert_equal "Hello, world", post.title
+    refute post.body
+    refute post.id
+  end
+
+  def test_assings_id_and_saves_the_object
+    post = Post.create(:title => "Hello, world")
+    assert post.id
+  end
+
+  def test_updates_attributes
+    post = Post.create(:title => "Hello, world")
+    post.update(:body => "This is my first example")
+    assert_equal "This is my first example", post.body
+  end
+
+  def test_refreshes_the_attributes_with_reload_method
+    orig = Post.create(:title => "Hello, world")
+    double = Post.find(orig.id)
+    double.update(:title => "Good bye, world")
+    orig.reload
+    assert_equal "Good bye, world", orig.title
+  end
+
+  def test_doesnt_raise_if_the_attribute_redefined
+    eval <<-EOC
+      class RefinedPost < Couchbase::Model
+        attribute :title
+        attribute :title
+      end
+    EOC
+  end
+
+  def test_allows_arbitrary_ids
+    Post.create(:id => uniq_id, :title => "Foo")
+    assert_equal "Foo", Post.find(uniq_id).title
+  end
+
+  def test_returns_an_instance_of_post
+    Post.bucket.set(uniq_id, {:title => 'foo'})
+    assert Post.find(uniq_id).kind_of?(Post)
+    assert_equal uniq_id, Post.find(uniq_id).id
+    assert_equal "foo", Post.find(uniq_id).title
+  end
+
+  def test_changes_its_attributes
+    post = Post.create(:title => "Hello, world")
+    post.title = "Good bye, world"
+    post.save.reload
+    assert_equal "Good bye, world", post.title
+  end
+
+  def test_assings_a_new_id_to_each_record
+    post1 = Post.create
+    post2 = Post.create
+
+    refute post1.new?
+    refute post2.new?
+    refute_equal post1.id, post2.id
+  end
+
+  def test_deletes_an_existent_model
+    post = Post.create(:id => uniq_id)
+    assert post.delete
+    refute Post.bucket.get(uniq_id)
+  end
+
+  def test_fails_to_delete_model_without_id
+    post = Post.new(:title => "Hello")
+    refute post.id
+    assert_raises Couchbase::Error::MissingId do
+      post.delete
+    end
+  end
+
+end

data/test/test_uuid.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'setup')
+
+class TestUUID < MiniTest::Unit::TestCase
+
+  def test_it_can_generate_10k_unique_ids
+    random = Couchbase::Model::UUID.new.next(10_000, :random)
+    assert_equal 10_000, random.uniq.size
+
+    utc_random = Couchbase::Model::UUID.new.next(10_000, :utc_random)
+    assert_equal 10_000, utc_random.uniq.size
+
+    sequential = Couchbase::Model::UUID.new.next(10_000, :sequential)
+    assert_equal 10_000, sequential.uniq.size
+  end
+
+  def test_it_produces_monotonically_increasing_ids
+    utc_random = Couchbase::Model::UUID.new
+    assert utc_random.next(1, :utc_random) < utc_random.next(1, :utc_random)
+
+    sequential = Couchbase::Model::UUID.new
+    assert sequential.next(1, :sequential) < sequential.next(1, :sequential)
+  end
+
+  def test_it_roll_over
+    generator = Couchbase::Model::UUID.new
+    prefix = generator.next[0, 26]
+    n = 0
+    n += 1 while prefix == generator.next[0, 26]
+    assert(n >= 5000 && n <= 11000)
+  end
+
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: couchbase-model
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sergey Avseyev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: couchbase
+  requirement: &8647480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *8647480
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &8646760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *8646760
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &8575100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8575100
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &8574240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8574240
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &8573480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8573480
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &8572660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8572660
+description: ORM-like interface allows you to persist your models to Couchbase
+email:
+- sergey.avseyev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- .yardopts
+- Gemfile
+- README.markdown
+- Rakefile
+- couchbase-model.gemspec
+- lib/couchbase-model.rb
+- lib/couchbase/model.rb
+- lib/couchbase/model/uuid.rb
+- lib/couchbase/model/version.rb
+- tasks/doc.rake
+- tasks/test.rake
+- tasks/util.rake
+- test/setup.rb
+- test/test_model.rb
+- test/test_uuid.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Declarative interface to Couchbase
+test_files:
+- test/setup.rb
+- test/test_model.rb
+- test/test_uuid.rb