active_document 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+*.sw?
+.DS_Store
+coverage

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Justin Balthrop
+
+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.rdoc

@@ -0,0 +1,111 @@
+= ActiveDocument
+
+ActiveDocument is a persistent Model store built on Berkeley DB. It was inspired by
+ActiveRecord, and in some cases, it can be used as a drop-in replacement. The performance
+of ActiveDocument can exceed a traditional ORM for many applications, because the database
+is stored locally and all lookups must use a predefined index. Also, attributes do not
+have to be cast after they are read from the database like in ActiveRecord. Instead, Ruby
+objects are stored directly in Berkeley DB and loaded using Marshal, which makes loading
+objects much faster. For more information on the diffences between Berkeley DB and a
+relational Database, see (http://www.oracle.com/database/docs/Berkeley-DB-v-Relational.pdf).
+
+== Usage:
+
+  require 'rubygems'
+  require 'active_document'
+
+  class User < ActiveDocument::Base
+    path '/data/bdb'
+    accessor :first_name, :last_name, :username, :email_address, :tags
+
+    primary_key :username
+    index_by [:last_name, :first_name]
+    index_by :email_address, :unique => true
+    index_by :tags, :multi_key => true
+  end
+
+  User.create(
+    :first_name => 'John',
+    :last_name  => 'Stewart',
+    :username   => 'lefty',
+    :email_address => 'john@thedailyshow.com',
+    :tags => [:funny, :liberal]
+  )
+
+  User.create(
+    :first_name => 'Martha',
+    :last_name  => 'Stewart',
+    :username   => 'helen',
+    :email_address => 'martha@marthastewart.com',
+    :tags => [:conservative, :convict]
+  )
+
+  User.create(
+    :first_name => 'Stephen',
+    :last_name  => 'Colbert',
+    :username   => 'steve',
+    :email_address => 'steve@thereport.com',
+    :tags => [:conservative, :funny]
+  )
+  
+  User.find('lefty').attributes
+  => {"username"=>"lefty", "last_name"=>"Stewart", "email_address"=>"john@thedailyshow.com", "first_name"=>"John"}
+
+  User.find_by_email_address("john@thedailyshow.com").username
+  => "lefty"
+
+  User.find_all_by_last_name("Stewart").collect {|u| u.first_name}
+  => ["John", "Martha"]
+
+  User.find_all_by_tag(:funny).collect {|u| u.username}
+  => ["lefty", "steve"]
+
+=== Complex finds:
+
+Any find can take multiple keys, a key range, or multiple key ranges.
+
+  User.create(
+    :first_name => 'Will',
+    :last_name  => 'Smith',
+    :username   => 'legend',
+    :email_address => 'will@smith.com',
+    :tags => [:actor, :rapper]
+  )
+
+  User.find_all_by_last_name("Stewart", "Smith").collect {|u| u.username}
+  => ["lefty", "helen", "legend"]
+
+  User.find_all_by_last_name("Smith".."Stuart").collect {|u| u.username}
+  => ["legend", "lefty", "helen"]
+
+  User.find_all_by_last_name("Smith".."Stuart", "Colbert").collect {|u| u.username}
+  => ["legend", "lefty", "helen", "steve"]
+
+  User.find_all_by_last_name("Aardvark".."Daisy", "Smith".."Stuart").collect {|u| u.username}
+  => ["steve", "legend", "lefty", "helen"]
+
+=== Limit and Offset:
+
+Any find can also take :limit, :offset, :page, and :per_page as options. These can be used for paginating large lists.
+
+  User.find_all_by_username(:limit => 2).collect {|u| u.username}
+  => ["helen", "lefty"]
+
+  User.find_all_by_username(:limit => 2, :offset => 2).collect {|u| u.username}
+  => ["legend", "steve"]
+
+  User.find_all_by_username(:per_page => 2, :page => 1).collect {|u| u.username}
+  => ["helen", "lefty"]
+
+  User.find_all_by_username(:per_page => 2, :page => 2).collect {|u| u.username}
+  => ["legend", "steve"]
+
+== Install:
+
+  sudo gem install ninjudd-bdb -s http://gems.github.com
+  sudo gem install ninjudd-tuple -s http://gems.github.com
+  sudo gem install ninjudd-active_document -s http://gems.github.com
+
+== License:
+
+Copyright (c) 2009 Justin Balthrop, Geni.com; Published under The MIT License, see LICENSE

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "active_document"
+    s.summary = %Q{Schemaless models in Berkeley DB}
+    s.email = "code@justinbalthrop.com"
+    s.homepage = "http://github.com/ninjudd/active_document"
+    s.description = "Schemaless models in Berkeley DB."
+    s.authors = ["Justin Balthrop"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'active_document'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.verbose = true
+  end
+rescue LoadError
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 0
+:major: 0

data/active_document.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{active_document}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Justin Balthrop"]
+  s.date = %q{2009-11-19}
+  s.description = %q{Schemaless models in Berkeley DB.}
+  s.email = %q{code@justinbalthrop.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "active_document.gemspec",
+     "examples/foo.rb",
+     "examples/photo.rb",
+     "lib/active_document.rb",
+     "lib/active_document/base.rb",
+     "test/.gitignore",
+     "test/active_document_test.rb",
+     "test/deadlock_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ninjudd/active_document}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Schemaless models in Berkeley DB}
+  s.test_files = [
+    "test/active_document_test.rb",
+     "test/deadlock_test.rb",
+     "test/test_helper.rb",
+     "examples/foo.rb",
+     "examples/photo.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/examples/foo.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'active_document'
+
+class Foo < ActiveDocument::Base
+  path '/tmp/data'
+
+  reader :roo
+  writer :woo
+  accessor :foo, :bar, :key
+end

data/examples/photo.rb

@@ -0,0 +1,9 @@
+require 'active_document'
+
+class Photo < ActiveDocument::Base
+  path '/var/data'
+
+  accessor :id, :tagged_ids, :user_id, :description
+
+  index_by :tagged_ids  
+end

data/lib/active_document.rb

@@ -0,0 +1,9 @@
+module ActiveDocument
+  class DocumentNotFound    < StandardError; end
+  class DuplicatePrimaryKey < StandardError; end
+end
+
+require 'bdb/database'
+require 'bdb/partitioned_database'
+require 'active_support'
+require 'active_document/base'

data/lib/active_document/base.rb

@@ -0,0 +1,390 @@
+class ActiveDocument::Base
+  def self.path(path = nil)    
+    @path = path if path
+    @path ||= (self == ActiveDocument::Base ? nil : ActiveDocument::Base.path)
+  end
+
+  def self.path=(path)
+    @path = path
+  end
+
+  def self.database_name(database_name = nil)
+    if database_name
+      raise 'cannot modify database_name after db has been initialized' if @database_name
+      @database_name = database_name
+    else
+      return if self == ActiveDocument::Base 
+      @database_name ||= name.underscore.gsub('/', '-').pluralize
+    end
+  end
+
+  def self.database
+    @database
+  end
+
+  def database
+    self.class.database
+  end
+
+  def self.transaction(&block)
+    database.transaction(&block)
+  end
+
+  def transaction(&block)
+    self.class.transaction(&block)
+  end
+
+  def self.checkpoint(opts = {})
+    database.checkpoint(opts)
+  end
+
+  def self.create(*args)
+    model = new(*args)
+    model.save
+    model
+  end
+
+  def self.primary_key(field_or_fields, opts = {})
+    raise 'primary key already defined' if @database
+
+    if @partition_by = opts[:partition_by]
+      @database = Bdb::PartitionedDatabase.new(database_name, :path  => path, :partition_by => @partition_by)
+      (class << self; self; end).instance_eval do
+        alias_method opts[:partition_by].to_s.pluralize, :partitions
+        alias_method "with_#{opts[:partition_by]}", :with_partition
+        alias_method "with_each_#{opts[:partition_by]}", :with_each_partition
+      end
+    else
+      @database = Bdb::Database.new(database_name, :path => path)
+    end
+
+    field = define_field_accessor(field_or_fields)
+    define_find_methods(field, :field => :primary_key) # find_by_field1_and_field2
+    
+    define_field_accessor(field_or_fields, :primary_key)
+    define_find_methods(:primary_key) # find_by_primary_key
+
+    # Define shortcuts for partial keys.
+    define_partial_shortcuts(field_or_fields, :primary_key)
+  end
+
+  def self.partitions
+    database.partitions
+  end
+
+  def self.with_partition(partition, &block)
+    database.with_partition(partition, &block)
+  end
+
+  def self.with_each_partition(&block)
+    database.partitions.each do |partition|
+      database.with_partition(partition, &block)
+    end
+  end
+
+  def self.partition_by
+    @partition_by
+  end
+
+  def partition_by
+    self.class.partition_by
+  end
+
+  def partition
+    send(partition_by) if partition_by
+  end
+
+  def self.index_by(field_or_fields, opts = {})
+    raise "cannot have a multi_key index on an aggregate key" if opts[:multi_key] and field_or_fields.kind_of?(Array)
+
+    field = define_field_accessor(field_or_fields)
+    database.index_by(field, opts)
+
+    field_name = opts[:multi_key] ? field.to_s.singularize : field
+    define_find_methods(field_name, :field => field) # find_by_field1_and_field2
+
+    # Define shortcuts for partial keys.
+    define_partial_shortcuts(field_or_fields, field)
+  end
+
+  def self.close_environment
+    # Will close all databases in the environment.
+    environment.close
+  end
+
+  def self.find_by(field, *args)
+    opts = extract_opts(args)
+    opts[:field] = field
+    args << :all if args.empty?
+    args << opts
+    database.get(*args)
+  end
+
+  def self.find(key, opts = {})
+    doc = database.get(key, opts).first
+    raise ActiveDocument::DocumentNotFound, "Couldn't find #{name} with id #{key.inspect}" unless doc
+    doc
+  end
+  
+  def self.count(field, key)
+    database.count(field, key)
+  end
+
+  def self.define_field_accessor(field_or_fields, field = nil)    
+    if field_or_fields.kind_of?(Array)
+      field ||= field_or_fields.join('_and_').to_sym
+      define_method(field) do
+        field_or_fields.collect {|f| self.send(f)}.flatten
+      end
+    elsif field
+      define_method(field) do
+        self.send(field_or_fields)
+      end
+    else
+      field = field_or_fields.to_sym
+    end
+    field
+  end
+
+  def self.define_find_methods(name, config = {})
+    field = config[:field] || name
+
+    (class << self; self; end).instance_eval do
+      define_method("find_by_#{name}") do |*args|
+        modify_opts(args) do |opts|
+          opts[:limit] = 1
+          opts[:partial] ||= config[:partial]
+        end
+        find_by(field, *args).first
+      end
+
+      define_method("find_all_by_#{name}") do |*args|
+        modify_opts(args) do |opts|
+          opts[:partial] ||= config[:partial]
+        end
+        find_by(field, *args)
+      end
+    end
+  end
+
+  def self.define_partial_shortcuts(fields, primary_field)
+    return unless fields.kind_of?(Array)
+
+    (fields.size - 1).times do |i|
+      name = fields[0..i].join('_and_')
+      next if respond_to?("find_by_#{name}")
+      define_find_methods(name, :field => primary_field, :partial => true)
+    end
+  end
+
+  def self.timestamps
+    reader(:created_at, :updated_at, :deleted_at)
+  end
+
+  def self.defaults(defaults = {})
+    @defaults ||= {}
+    @defaults.merge!(defaults)
+  end
+
+  def self.default(attr, default)
+    defaults[attr] = default
+  end
+
+  def self.reader(*attrs)
+    attrs.each do |attr|
+      define_method(attr) do
+        read_attribute(attr)
+      end
+    end
+  end
+
+  def self.bool_reader(*attrs)
+    attrs.each do |attr|
+      define_method(attr) do
+        !!read_attribute(attr)
+      end
+
+      define_method("#{attr}?") do
+        !!read_attribute(attr)
+      end
+    end
+  end
+
+  def self.writer(*attrs)
+    attrs.each do |attr|
+      define_method("#{attr}=") do |value|
+        attributes[attr] = value
+      end
+    end
+  end
+
+  def self.accessor(*attrs)
+    reader(*attrs)
+    writer(*attrs)
+  end
+
+  def self.bool_accessor(*attrs)
+    bool_reader(*attrs)
+    writer(*attrs)
+  end
+  
+  def self.save_method(method_name)
+    define_method("#{method_name}!") do |*args|
+      transaction do 
+        value = send(method_name, *args)
+        save
+        value
+      end
+    end
+  end
+
+  def initialize(attributes = {}, saved_attributes = nil)
+    @attributes       = HashWithIndifferentAccess.new(attributes)       if attributes
+    @saved_attributes = HashWithIndifferentAccess.new(saved_attributes) if saved_attributes
+
+    # Initialize defaults if this is a new record.
+    if @saved_attributes.nil?
+      self.class.defaults.each do |attr, default|
+        next if @attributes.has_key?(attr)
+        @attributes[attr] = default.is_a?(Proc) ? default.bind(self).call : default.dup
+      end
+    end
+
+    # Set the partition field in case we are in a with_partition block.
+    if partition_by and partition.nil?
+      set_method = "#{partition_by}="
+      self.send(set_method, database.partition) if respond_to?(set_method)
+    end
+  end
+
+  attr_reader :saved_attributes
+  alias locator_key bdb_locator_key
+
+  def attributes
+    @attributes ||= Marshal.load(Marshal.dump(saved_attributes))
+  end
+
+  def read_attribute(attr)
+    if @attributes.nil?
+      saved_attributes[attr]
+    else
+      attributes[attr]
+    end
+  end
+
+  save_method :update_attributes
+  def update_attributes(attrs = {})
+    attrs.each do |field, value|
+      self.send("#{field}=", value)
+    end
+  end
+
+  def to_json(*args)
+    attributes.to_json(*args)
+  end
+
+  def ==(other)
+    return false unless other.class == self.class
+    attributes == other.attributes
+  end
+
+  def new_record?
+    @saved_attributes.nil?
+  end
+
+  def changed?(field = nil)
+    return false unless @attributes and @saved_attributes
+
+    if field
+      send(field) != saved.send(field)
+    else
+      attributes != saved_attributes
+    end
+  end
+
+  def saved
+    raise 'no saved attributes for new record' if new_record?
+    @saved ||= self.class.new(saved_attributes)
+  end
+  
+  def clone(changed_attributes = {})
+    cloned_attributes = Marshal.load(Marshal.dump(attributes))
+    uncloned_fields.each do |attr|
+      cloned_attributes.delete(attr)
+    end
+    cloned_attributes.merge!(changed_attributes)
+    self.class.new(cloned_attributes)
+  end
+
+  def self.uncloned_fields(*attrs)
+    if attrs.empty?
+      @uncloned_fields ||= [:created_at, :updated_at, :deleted_at]
+    else
+      uncloned_fields.concat(attrs)
+    end
+  end
+
+  def save(opts = {})
+    time = opts[:updated_at] || Time.now
+    attributes[:updated_at] = time   if respond_to?(:updated_at)
+    attributes[:created_at] ||= time if respond_to?(:created_at) and new_record?
+
+    opts = {}
+    if changed?(:primary_key) or (partition_by and changed?(partition_by))
+      opts[:create] = true
+      saved.destroy
+    else
+      opts[:create] = new_record?
+    end
+
+    @saved_attributes = attributes
+    @attributes       = nil
+    @saved            = nil
+    database.set(primary_key, self, opts)
+  rescue Bdb::DbError => e
+    raise(ActiveDocument::DuplicatePrimaryKey, e) if e.code == Bdb::DB_KEYEXIST
+    raise(e)
+  end
+
+  def destroy
+    database.delete(primary_key)
+  end
+
+  save_method :delete
+  def delete
+    raise 'cannot delete a record without deleted_at attribute' unless respond_to?(:deleted_at)
+    saved_attributes[:deleted_at] = Time.now
+  end
+
+  save_method :undelete
+  def undelete
+    raise 'cannot undelete a record without deleted_at attribute' unless respond_to?(:deleted_at)
+    saved_attributes.delete(:deleted_at)
+  end
+
+  def deleted?
+    respond_to?(:deleted_at) and not deleted_at.nil?
+  end
+
+  def _dump(ignored)
+    attributes       = @attributes.to_hash       if @attributes
+    saved_attributes = @saved_attributes.to_hash if @saved_attributes
+    Marshal.dump([attributes, saved_attributes])
+  end
+
+  def self._load(data)
+    new(*Marshal.load(data))
+  end
+
+private
+
+  def self.extract_opts(args)
+    args.last.kind_of?(Hash) ? args.pop : {}
+  end
+
+  def self.modify_opts(args)
+    opts = extract_opts(args)
+    yield(opts)
+    args << opts
+  end
+end

data/test/.gitignore

@@ -0,0 +1 @@
+tmp

data/test/active_document_test.rb

@@ -0,0 +1,417 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+ActiveDocument::Base.path = File.dirname(__FILE__) + '/tmp'
+FileUtils.rmtree ActiveDocument::Base.path
+FileUtils.mkdir  ActiveDocument::Base.path
+
+class Foo < ActiveDocument::Base
+  accessor :foo, :bar, :id
+
+  primary_key :id
+  index_by :foo, :multi_key => true
+  index_by :bar, :unique => true
+end
+
+class Bar < ActiveDocument::Base
+  accessor :foo, :bar
+
+  primary_key [:foo, :bar]
+  index_by :bar
+  index_by :foo
+end
+
+class Baz < ActiveDocument::Base
+  accessor :foo, :bar, :baz
+
+  primary_key [:foo, :bar], :partition_by => :baz
+  index_by :bar
+end
+
+class User < ActiveDocument::Base
+  accessor :first_name, :last_name, :username, :email_address, :tags
+  timestamps
+  defaults :tags => []
+
+  primary_key :username
+  index_by [:last_name, :first_name]
+  index_by :email_address, :unique => true
+  index_by :tags, :multi_key => true
+end
+
+class View < ActiveDocument::Base
+  reader :profile_id, :user_id, :count
+  timestamps
+
+  primary_key [:profile_id, :user_id]
+  index_by [:user_id,    :updated_at]
+  index_by [:profile_id, :updated_at]
+  
+  save_method :increment
+  def increment
+    attributes[:count] += 1
+  end
+
+  def self.increment!(profile_id, user_id)
+    transaction do
+      view = find_by_primary_key([profile_id, user_id]) #, :modify => true)
+      if view
+        view.increment!
+      else
+        view = create(:profile_id => profile_id, :user_id => user_id, :count => 1)
+      end
+    end    
+  end
+end
+
+class ActiveDocumentTest < Test::Unit::TestCase
+  context 'with empty foo db' do
+    setup do
+      Foo.database.truncate!
+    end
+
+    should 'find in database after save' do
+      f = Foo.new(:foo => 'BAR', :id => 1)
+      f.save
+      
+      assert_equal f, Foo.find(1)
+    end
+    
+    should 'raise exception if not found' do
+      assert_raises(ActiveDocument::DocumentNotFound) do
+        Foo.find(7)
+      end
+    end
+    
+    should 'find_by_primary_key' do
+      f = Foo.new(:foo => 'BAR', :id => 1)
+      f.save
+      
+      assert_equal f, Foo.find_by_primary_key(1)
+      assert_equal f, Foo.find_by_id(1)
+    end
+
+    should 'destroy' do
+      f = Foo.new(:foo => 'BAR', :id => 1)
+      f.save
+      
+      assert_equal f, Foo.find_by_id(1)
+
+      f.destroy
+
+      assert_equal nil, Foo.find_by_id(1)
+    end
+
+    should 'change primary key' do
+      f = Foo.new(:foo => 'BAR', :id => 1)
+      f.save
+      
+      assert_equal f, Foo.find_by_id(1)
+
+      f.id = 2
+      f.save
+
+      assert_equal nil, Foo.find_by_id(1)
+      assert_equal 2,   Foo.find_by_id(2).id
+    end
+    
+    should 'find by secondary indexes' do
+      f1 = Foo.new(:foo => ['BAR', 'BAZ'], :bar => 'FOO', :id => 1)
+      f1.save
+      
+      f2 = Foo.new(:foo => 'BAR', :bar => 'FU', :id => 2)
+      f2.save
+      
+      assert_equal f1,      Foo.find_by_bar('FOO')
+      assert_equal f2,      Foo.find_by_bar('FU')
+      assert_equal [f1,f2], Foo.find_all_by_foo('BAR')
+      assert_equal [f1],    Foo.find_all_by_foo('BAZ')
+    end
+    
+    should 'find by range' do
+      (1..20).each do |i|
+        Foo.new(:id => i, :foo => "foo-#{i}").save
+      end
+      
+      assert_equal (5..17).to_a, Foo.find_all_by_id(5..17).collect {|f| f.id}
+      assert_equal (5..14).to_a, Foo.find_all_by_id(5..17, :limit => 10).collect {|f| f.id}
+
+      # Mixed keys and ranges.
+      assert_equal (1..4).to_a + (16..20).to_a, Foo.find_all_by_id(1..3, 4, 16..20).collect {|f| f.id}
+    end
+
+    should 'find all' do
+      (1..20).each do |i|
+        Foo.new(:id => i, :foo => "foo-#{i}").save
+      end
+      
+      assert_equal (1..20).to_a, Foo.find_all_by_id.collect {|f| f.id}
+      assert_equal 1, Foo.find_by_id.id # First
+    end
+
+    should 'find with reverse' do
+      (1..20).each do |i|
+        Foo.new(:id => i, :foo => "foo-#{i}").save
+      end
+      
+      assert_equal (1..20).to_a.reverse, Foo.find_all_by_id(:reverse => true).collect {|f| f.id}
+      assert_equal (5..17).to_a.reverse, Foo.find_all_by_id(5..17, :reverse => true).collect {|f| f.id}
+      assert_equal 20, Foo.find_by_id(:reverse => true).id # Last
+    end
+
+    should 'find with limit and offset' do
+      (1..100).each do |i|
+        Foo.new(:id => i, :bar => i + 42, :foo => i % 20).save
+      end
+
+      assert_equal [5, 5, 5, 5, 6, 6, 6],
+        Foo.find_all_by_foo(5..14, :limit => 7, :offset => 1).collect {|f| f.foo}
+
+      assert_equal [6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8],
+        Foo.find_all_by_foo(6..14, :limit => 11, :offset => 3).collect {|f| f.foo}
+
+      assert_equal [8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11],
+        Foo.find_all_by_foo(8..14, :limit => 16, :offset => 4).collect {|f| f.foo}
+
+      assert_equal [12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14],
+        Foo.find_all_by_foo(12..14, :offset => 0).collect {|f| f.foo}
+    end
+
+    should 'add locator_key to models' do
+      Foo.new(:id => 1, :foo => [1, 2, 3]).save
+      Foo.new(:id => 2, :foo => [4, 5, 6]).save
+      Foo.new(:id => 3, :foo => [6, 7, 8]).save
+
+      Foo.find_all_by_foo(2..4).each_with_index do |foo, i|
+        assert_equal [i + 2], foo.locator_key
+      end
+
+      Foo.find_all_by_foo(6).each do |foo|
+        assert_equal [6], foo.locator_key
+      end
+
+      i = 1
+      Foo.find_all_by_foo.each do |foo|
+        key = i > 6 ? [i - 1] : [i]
+        assert_equal key, foo.locator_key
+        i += 1
+      end
+    end
+  end
+
+  context 'with empty bar db' do
+    setup do
+      Bar.database.truncate!
+    end
+
+    should 'not overwrite existing model' do
+      b1 = Bar.new(:foo => 'foo', :bar => 'bar')
+      b1.save
+      
+      assert_raises(ActiveDocument::DuplicatePrimaryKey) do
+        b2 = Bar.new(:foo => 'foo', :bar => 'bar')
+        b2.save
+      end
+    end
+
+    should 'find_by_primary_key and find by id fields' do
+      100.times do |i|
+        100.times do |j|
+          b = Bar.new(:foo => i, :bar => j)
+          b.save
+        end
+      end
+
+      assert_equal [5, 5],   Bar.find_by_primary_key([5, 5]).primary_key
+      assert_equal [52, 52], Bar.find_by_foo_and_bar([52, 52]).foo_and_bar
+      assert_equal (0..99).collect {|i| [42, i]}, Bar.find_all_by_foo(42).collect {|b| b.primary_key}
+      assert_equal (0..99).collect {|i| [i, 52]}, Bar.find_all_by_bar(52).collect {|b| b.primary_key}
+    end
+
+    should 'count' do
+      (1..21).each do |i|
+        Bar.new(:foo => i % 7, :bar => i % 3).save
+      end
+      
+      assert_equal 1, Bar.count(:primary_key, [6,2])
+      assert_equal 0, Bar.count(:primary_key, [2,6])
+
+      3.times {|i| assert_equal 7, Bar.count(:bar, i)}
+      assert_equal 0, Bar.count(:bar, 3)
+
+      7.times {|i| assert_equal 3, Bar.count(:foo, i)}
+      assert_equal 0, Bar.count(:foo, 7)
+    end
+  end
+
+  context 'with empty baz db' do
+    setup do
+      Baz.database.truncate!
+    end
+
+    should 'partition_by baz' do
+      b1 = Baz.new(:foo => 'foo', :bar => 'bar', :baz => 1)
+      b1.save
+
+      b2 = Baz.new(:foo => 'foo', :bar => 'bar', :baz => 2)
+      b2.save
+
+      assert_equal b1, Baz.find(['foo','bar'], :baz => 1)
+      assert_equal b2, Baz.find(['foo','bar'], :baz => 2)
+    end
+
+    should 'find and save with partition' do
+      10.times do |i|
+        Baz.with_baz(i) do
+          assert_equal nil, Baz.find_by_primary_key(['foo','bar'])
+
+          b = Baz.new(:foo => 'foo', :bar => 'bar')
+          b.save
+
+          assert_equal i, b.baz
+          assert_equal b, Baz.find(['foo','bar'])
+        end
+      end
+      assert_equal (0...10).collect {|i| i.to_s}, Baz.partitions
+    end
+  end
+
+  context 'with empty user db' do
+    setup do
+      User.database.truncate!
+
+      @john = User.create(
+        :first_name => 'John',
+        :last_name  => 'Stewart',
+        :username   => 'lefty',
+        :email_address => 'john@thedailyshow.com',
+        :tags => [:funny, :liberal]
+      )
+
+      @martha = User.create(
+        :first_name => 'Martha',
+        :last_name  => 'Stewart',
+        :username   => 'helen',
+        :email_address => 'martha@marthastewart.com',
+        :tags => [:conservative, :convict]
+      )
+
+      @steve = User.create(
+        :first_name => 'Stephen',
+        :last_name  => 'Colbert',
+        :username   => 'steve',
+        :email_address => 'stephen@thereport.com',
+        :tags => [:conservative, :funny]
+      )
+
+      @will = User.create(
+        :first_name => 'Will',
+        :last_name  => 'Smith',
+        :username   => 'legend',
+        :email_address => 'will@smith.com',
+        :tags => [:actor, :rapper]
+      )
+    end
+    
+    should 'initialize defaults' do
+      user = User.create
+      assert_equal [], user.tags
+    end
+
+    should 'find_all_by_username' do
+      assert_equal ['helen', 'lefty', 'legend', 'steve'], User.find_all_by_username.collect {|u| u.username}
+    end
+
+    should 'find_all_by_last_name_and_first_name' do
+      assert_equal ['steve', 'legend', 'lefty', 'helen'], User.find_all_by_last_name_and_first_name.collect {|u| u.username}
+    end
+
+    should 'find_all_by_last_name' do
+      assert_equal ['John', 'Martha'], User.find_all_by_last_name('Stewart').collect {|u| u.first_name}
+      assert_equal ['Stephen', 'Will', 'John', 'Martha'], User.find_all_by_last_name.collect {|u| u.first_name}
+    end
+
+    should 'find_all_by_tag' do
+      assert_equal ['lefty', 'steve'], User.find_all_by_tag(:funny).collect {|u| u.username}
+    end
+
+    should 'find with keys' do
+      assert_equal ['lefty', 'helen', 'legend'],
+        User.find_all_by_last_name("Stewart", "Smith").collect {|u| u.username}
+    end
+
+    should 'find with range' do
+      assert_equal ['legend', 'lefty', 'helen'],
+        User.find_all_by_last_name("Smith".."Stuart").collect {|u| u.username}
+    end
+
+    should 'find with range and key' do
+      assert_equal ['legend', 'lefty', 'helen', 'steve'],
+        User.find_all_by_last_name("Smith".."Stuart", "Colbert").collect {|u| u.username}
+    end
+
+    should 'find with ranges' do
+      assert_equal ['steve', 'legend', 'lefty', 'helen'],
+        User.find_all_by_last_name("Aardvark".."Daisy", "Smith".."Stuart").collect {|u| u.username}
+    end
+
+    should 'find with limit' do
+      assert_equal ["helen", "lefty"], User.find_all_by_username(:limit => 2).collect {|u| u.username}
+    end
+
+    should 'find with limit and offset' do
+      assert_equal ["legend", "steve"], User.find_all_by_username(:limit => 2, :offset => 2).collect {|u| u.username}
+    end
+
+    should 'find with group' do
+      expected = [[["Colbert", "Stephen"], 1],
+                  [["Smith", "Will"],      1],
+                  [["Stewart", "John"],    1],
+                  [["Stewart", "Martha"],  1]]
+
+      assert_equal expected, User.find_all_by_last_name(:all, :group => true).collect {|k,v| [k,v.size]}
+      assert_equal expected, User.find_all_by_last_name(:all, :group => 2   ).collect {|k,v| [k,v.size]}
+
+      expected = [[["Colbert"], 1],
+                  [["Smith"],   1],
+                  [["Stewart"], 2]]
+
+      assert_equal expected, User.find_all_by_last_name(:all, :group => 1   ).collect {|k,v| [k,v.size]}
+    end
+
+    should 'find with page' do
+      assert_equal ["helen", "lefty"],  User.find_all_by_username(:per_page => 2, :page => 1).collect {|u| u.username}
+      assert_equal ["legend", "steve"], User.find_all_by_username(:per_page => 2, :page => 2).collect {|u| u.username}
+      assert_equal ["helen", "lefty"],  User.find_all_by_username(:limit => 2, :page => 1).collect {|u| u.username}
+      assert_equal ["legend", "steve"], User.find_all_by_username(:limit => 2, :page => 2).collect {|u| u.username}
+    end
+
+    should "mark deleted but don't destroy record" do
+      assert !@martha.deleted?
+      assert !User.find_by_username('helen').deleted?
+
+      @martha.delete!
+
+      assert @martha.deleted?
+      assert User.find_by_username('helen').deleted?
+    end
+  end
+
+  context 'with empty views db' do
+    setup do
+      View.database.truncate!
+    end
+
+    N = 10000
+    P = 1
+    U = 1
+
+    should 'increment views randomly without corrupting secondary index' do
+      N.times do
+        profile_id = rand(P)
+        user_id    = rand(U)
+        View.increment!(profile_id, user_id)
+      end
+      assert true
+    end
+  end
+end

data/test/deadlock_test.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+ActiveDocument.default_path = File.dirname(__FILE__) + '/tmp'
+ActiveDocument.env_config :cache_size => 1 * 1024 * 1024
+ActiveDocument.db_config  :page_size => 512
+
+class Foo < ActiveDocument::Base
+  accessor :bar, :id
+
+  primary_key :id
+end
+
+class DeadlockTest < Test::Unit::TestCase
+  context 'with empty and closed environment' do
+    setup do
+      FileUtils.rmtree Foo.path
+      FileUtils.mkdir  Foo.path
+      Foo.close_environment
+    end
+
+    N = 5000 # total number of records
+    R = 10   # number of readers
+    W = 10   # number of writers
+    T = 20   # reads per transaction
+    L = 100  # logging frequency
+
+    should 'detect deadlock' do
+      pids = []
+
+      W.times do |n|
+        pids << fork(&writer)
+      end
+
+      sleep(1)
+
+      R.times do
+        pids << fork(&reader)
+      end
+
+      # Make sure that all processes finish with no errors.
+      pids.each do |pid|
+        Process.wait(pid)
+        assert_equal status, $?.exitstatus
+      end
+    end
+
+    C = 10
+    should 'detect unclosed resources' do
+      threads = []
+
+      threads << Thread.new do
+        C.times do
+          sleep(10)
+
+          pid = fork do
+            cursor = Foo.database.db.cursor(nil, 0)
+            cursor.get(nil, nil, Bdb::DB_FIRST)
+            exit!(1)
+          end
+          puts "\n====simulating exit with unclosed resources ===="
+          Process.wait(pid)
+          assert_equal 1, $?.exitstatus
+        end
+      end
+
+      threads << Thread.new do
+        C.times do
+          pid = fork(&writer(1000))
+          Process.wait(pid)
+          assert [0,9].include?($?.exitstatus)
+        end
+      end
+
+      sleep(3)
+
+      threads << Thread.new do
+        C.times do
+          pid = fork(&reader(1000))
+          Process.wait(pid)
+          assert [0,9].include?($?.exitstatus)
+        end
+      end
+      
+      threads.each {|t| t.join}
+    end
+  end
+
+  def reader(n = N)
+    lambda do
+      T.times do
+        (1...n).to_a.shuffle.each_slice(T) do |ids|
+          Foo.transaction do
+            ids.each {|id| Foo.find_by_id(id)}
+          end
+          log('r')
+        end
+      end
+      Foo.close_environment
+    end
+  end
+
+  def writer(n = N)
+    lambda do
+      (1...n).to_a.shuffle.each_with_index do |id, i|
+        Foo.transaction do
+          begin
+            Foo.create(:id => id, :bar => "bar" * 1000 + "anne #{rand}")
+          rescue ActiveDocument::DuplicatePrimaryKey => e
+            Foo.find_by_id(id).destroy
+            retry
+          end
+        end
+        log('w')
+      end
+      Foo.close_environment
+    end
+  end
+
+  def log(action)
+    @count ||= Hash.new(0)
+    if @count[action] % L == 0
+      print action.to_s
+      $stdout.flush
+    end
+    @count[action] += 1
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'pp'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'active_document'

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: active_document
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Justin Balthrop
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Schemaless models in Berkeley DB.
+email: code@justinbalthrop.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- active_document.gemspec
+- examples/foo.rb
+- examples/photo.rb
+- lib/active_document.rb
+- lib/active_document/base.rb
+- test/.gitignore
+- test/active_document_test.rb
+- test/deadlock_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ninjudd/active_document
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Schemaless models in Berkeley DB
+test_files: 
+- test/active_document_test.rb
+- test/deadlock_test.rb
+- test/test_helper.rb
+- examples/foo.rb
+- examples/photo.rb