ninjudd-active_document 0.0.2 → 0.0.3

data/README.rdoc

@@ -0,0 +1,43 @@
+= 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 'active_document'
+
+  class User < ActiveDocument::Base
+    path '/data/bdb'
+    accessor :first_name, :last_name, :username, :email_address
+
+    primary_key :username
+    index_by [:last_name, :first_name]
+    index_by :email_address, :unique => true
+  end
+
+  User.create(
+    :first_name => 'John',
+    :last_name  => 'Stewart',
+    :username   => 'lefty',
+    :email_address => 'john@thedailyshow.com'
+  )
+  
+  User.find('lefty').attributes
+  => {:first_name=>"John", :last_name=>"Stewart", :username=>"lefty", :email_address=>"john@thedailyshow.com"}
+
+== 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/VERSION.yml

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

data/lib/active_document/base.rb

@@ -3,7 +3,7 @@ class ActiveDocument::Base
     if path
       @path = path
     else
-      @path || (base_class? ? DEFAULT_PATH : super)
+      @path || (base_class? ? ActiveDocument::DEFAULT_PATH : super)
     end
   end
 
@@ -13,7 +13,7 @@ class ActiveDocument::Base
       @database_name = database_name
     else
       return nil if self == ActiveDocument::Base
-      @database_name ||= base_class? ? name.underscore.pluralize : super
+      @database_name ||= base_class? ? name.underscore.gsub('/', '-').pluralize : super
     end
   end
   
@@ -38,58 +38,118 @@ class ActiveDocument::Base
     environment.transaction(&block)
   end
 
+  def transaction(&block)
+    self.class.transaction(&block)
+  end
+
   def self.create(*args)
     model = new(*args)
     model.save
     model
   end
 
-  def self.index_by(field, opts = {})
-    field = field.to_sym
+  def self.primary_key(field_or_fields)    
+    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.
+    if field_or_fields.kind_of?(Array) and not respond_to?(field_or_fields.first)
+      define_find_methods(field_or_fields.first, :field => :primary_key, :partial => true) # find_by_field1
+    end
+  end
+
+  def self.index_by(field_or_fields, opts = {})
+    field = define_field_accessor(field_or_fields)
     raise "index on #{field} already exists" if databases[field]
     databases[field] = ActiveDocument::Database.new(opts.merge(:field => field, :model_class => self))    
+    define_find_methods(field) # find_by_field1_and_field2
+
+    # Define shortcuts for partial keys.
+    if field_or_fields.kind_of?(Array) and not respond_to?(field_or_fields.first)
+      define_find_methods(field_or_fields.first, :field => field, :partial => true) # find_by_field1
+    end
   end
-  
+
   def self.databases
-    @databases ||= { :id  => ActiveDocument::Database.new(:model_class => self, :unique => true) }
+    @databases ||= { :primary_key => ActiveDocument::Database.new(:model_class => self, :unique => true) }
   end      
 
   def self.open_database
-    environment.open
-    databases[:id].open # Must be opened first for associate to work.
-    databases.values.each {|database| database.open}
+    unless @database_open
+      environment.open
+      databases[:primary_key].open # Must be opened first for associate to work.
+      databases.values.each {|database| database.open}
+      @database_open = true
+      at_exit { close_database }
+    end
   end
 
   def self.close_database
-    databases.values.each {|database| database.close}
-    environment.close
+    if @database_open
+      databases.values.each {|database| database.close}
+      environment.close
+      @database_open = false
+    end
   end
 
-  def self.database(field = :id)
+  def self.database(field = nil)
+    open_database # Make sure the database is open.
+    field ||= :primary_key
     field = field.to_sym
     database = databases[field]
     database ||= base_class.database(field) unless base_class?
     database
   end
 
+  def database(field = nil)
+    self.class.database(field)
+  end
+
   def self.find_by(field, *keys)
-    opts = keys.last.kind_of?(Hash) ? keys.pop : {}
+    opts = extract_opts(keys)
+    keys << :all if keys.empty?
     database(field).find(keys, opts)
   end
 
   def self.find(key, opts = {})
     doc = database.find([key], opts).first
-    raise ActiveDocument::DocumentNotFound, "Couldn't find #{name} with key #{key}" unless doc
+    raise ActiveDocument::DocumentNotFound, "Couldn't find #{name} with id #{key.inspect}" unless doc
     doc
   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.method_missing(method_name, *args)
-    method_name = method_name.to_s
-    if method_name =~ /^find_by_(\w+)$/
-      field = $1.to_sym
-      return find_by(field, *args) if databases[field]
+  def self.define_find_methods(name, opts = {})
+    field = opts[:field] || name
+
+    (class << self; self; end).instance_eval do
+      define_method("find_by_#{name}") do |*args|
+        merge_opts(args, :limit => 1, :partial => opts[:partial])
+        find_by(field, *args).first
+      end
+
+      define_method("find_all_by_#{name}") do |*args|
+        merge_opts(args, :partial => opts[:partial])
+        find_by(field, *args)
+      end
     end
-    raise NoMethodError, "undefined method `#{method_name}' for #{self}"
   end
 
   def self.timestamps
@@ -107,7 +167,6 @@ class ActiveDocument::Base
   def self.writer(*attrs)
     attrs.each do |attr|
       define_method("#{attr}=") do |value|
-        raise 'cannot modify readonly document' if readonly?
         attributes[attr] = value
       end
     end
@@ -117,7 +176,15 @@ class ActiveDocument::Base
     reader(*attrs)
     writer(*attrs)
   end
-    
+  
+  def self.save_method(method_name)
+    define_method("#{method_name}!") do |*args|
+      value = send(method_name, *args)
+      save
+      value
+    end
+  end
+
   def initialize(attributes = {})
     if attributes.kind_of?(String)
       @attributes, @saved_attributes = Marshal.load(attributes)
@@ -145,20 +212,37 @@ class ActiveDocument::Base
     return false unless @attributes and @saved_attributes
 
     if field
-      attributes[field] != saved_attributes[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 save
     attributes[:updated_at] = Time.now if respond_to?(:updated_at)
     attributes[:created_at] = Time.now if respond_to?(:created_at) and new_record?
+
+    opts = {}
+    if changed?(:primary_key)
+      opts[:create] = true
+      saved.destroy
+    else
+      opts[:create] = new_record?
+    end
+
     @saved_attributes = attributes
     @attributes       = nil
-    self.class.database.save(self)
+    @saved            = nil
+    database.save(self, opts)
+  end
 
-    true
+  def destroy
+    database.delete(self)
   end
 
   def _dump(ignored)
@@ -168,4 +252,14 @@ class ActiveDocument::Base
   def self._load(data)
     new(data)
   end
+
+private
+
+  def self.extract_opts(args)
+    args.last.kind_of?(Hash) ? args.pop : {}
+  end
+
+  def self.merge_opts(args, opts)
+    args << extract_opts(args).merge(opts)
+  end
 end

data/lib/active_document/database.rb

@@ -4,7 +4,6 @@ class ActiveDocument::Database
     @field       = opts[:field]
     @unique      = opts[:unique]
     @suffix      = opts[:suffix] || (@field ? "by_#{@field}" : nil)
-    at_exit { close }
   end
 
   attr_accessor :model_class, :field, :db, :suffix
@@ -31,34 +30,73 @@ class ActiveDocument::Database
 
   def find(keys, opts = {}, &block)
     models = block_given? ? BlockArray.new(block) : []
+    flags  = opts[:modify] ? Bdb::DB_RMW : 0
 
     keys.uniq.each do |key|
-      if key.kind_of?(Range)
+      if opts[:partial] and not key.kind_of?(Range)
+        first = [*key]
+        last  = first + [true]
+        key = first..last
+      end
+
+      if key == :all
+        cursor = db.cursor(transaction, 0)
+        if opts[:reverse]
+          k,v  = cursor.get(nil, nil, Bdb::DB_LAST | flags)          # Start at the last item.
+          iter = lambda {cursor.get(nil, nil, Bdb::DB_PREV | flags)} # Move backward.
+        else
+          k,v  = cursor.get(nil, nil, Bdb::DB_FIRST | flags)         # Start at the first item.
+          iter = lambda {cursor.get(nil, nil, Bdb::DB_NEXT | flags)} # Move forward.
+        end
+
+        while k
+          models << Marshal.load(v)
+          break if opts[:limit] and models.size == opts[:limit]
+          k,v = iter.call
+        end
+        cursor.close
+      elsif key.kind_of?(Range)
         # Fetch a range of keys.
         cursor = db.cursor(transaction, 0)
         first = Tuple.dump(key.first)
-        last  = Tuple.dump(key.last)
-        k,v = cursor.get(first, nil, Bdb::DB_SET_RANGE)
-        while key.exclude_end? ? k < last : k <= last
+        last  = Tuple.dump(key.last)        
+
+        # Return false once we pass the end of the range.
+        cond = key.exclude_end? ? lambda {|k| k < last} : lambda {|k| k <= last}
+
+        if opts[:reverse]
+          # Position the cursor at the end of the range.
+          k,v = cursor.get(last, nil, Bdb::DB_SET_RANGE | flags)
+          while k and not cond.call(k)
+            k,v = iter.call
+          end
+
+          iter = lambda {cursor.get(nil, nil, Bdb::DB_PREV | flags)} # Move backward.
+          cond = lambda {|k| k >= first} # Change the condition to stop when we move past the start.
+        else
+          k,v  = cursor.get(first, nil, Bdb::DB_SET_RANGE | flags)   # Start at the beginning of the range.
+          iter = lambda {cursor.get(nil, nil, Bdb::DB_NEXT | flags)} # Move forward.
+        end
+
+        while k and cond.call(k)
           models << Marshal.load(v)
           break if opts[:limit] and models.size == opts[:limit]
-          k, v = cursor.get(nil, nil, Bdb::DB_NEXT)
-          break unless k
+          k,v = iter.call
         end
         cursor.close
       else
         if unique?
           # There can only be one item for each key.
-          data = db.get(transaction, Tuple.dump(key), nil, 0)
+          data = db.get(transaction, Tuple.dump(key), nil, flags)
           models << Marshal.load(data) if data
         else
           # Have to use a cursor because there may be multiple items with each key.
           cursor = db.cursor(transaction, 0)
-          k,v = cursor.get(Tuple.dump(key), nil, Bdb::DB_SET)
+          k,v = cursor.get(Tuple.dump(key), nil, Bdb::DB_SET | flags)
           while k
             models << Marshal.load(v)
             break if opts[:limit] and models.size == opts[:limit]
-            k,v = cursor.get(nil, nil, Bdb::DB_NEXT_DUP)
+            k,v = cursor.get(nil, nil, Bdb::DB_NEXT_DUP | flags)
           end
           cursor.close
         end
@@ -69,10 +107,18 @@ class ActiveDocument::Database
     block_given? ? nil : models
   end
 
-  def save(model)
-    id   = Tuple.dump(model.id)
-    data = Marshal.dump(model)
-    db.put(nil, id, data, 0)
+  def save(model, opts = {})
+    key   = Tuple.dump(model.primary_key)
+    data  = Marshal.dump(model)
+    flags = opts[:create] ? Bdb::DB_NOOVERWRITE : 0
+    db.put(transaction, key, data, flags)
+  rescue Bdb::DbError => e
+    raise ActiveDocument::DuplicatePrimaryKey, "primary key #{model.primary_key.inspect} already exists"
+  end
+
+  def delete(model)
+    key = Tuple.dump(model.primary_key)
+    db.del(transaction, key, 0)
   end
 
   def open

data/lib/active_document/environment.rb

@@ -1,7 +1,6 @@
 class ActiveDocument::Environment
   def initialize(path)
     @path = path
-    at_exit { close }
   end
 
   attr_reader :path, :env
@@ -13,12 +12,14 @@ class ActiveDocument::Environment
   def open
     if @env.nil?
       @env = Bdb::Env.new(0)
-      env_flags =  Bdb::DB_CREATE    | # Create the environment if it does not already exist.
-                   Bdb::DB_INIT_TXN  | # Initialize transactions
-                   Bdb::DB_INIT_LOCK | # Initialize locking.
-                   Bdb::DB_INIT_LOG  | # Initialize logging
-                   Bdb::DB_INIT_MPOOL  # Initialize the in-memory cache.
-      @env.open(path, env_flags, 0);
+      env_flags =  Bdb::DB_CREATE     | # Create the environment if it does not already exist.
+                   Bdb::DB_INIT_TXN   | # Initialize transactions        
+                   Bdb::DB_INIT_LOCK  | # Initialize locking.
+                   Bdb::DB_INIT_LOG   | # Initialize logging
+                   Bdb::DB_INIT_MPOOL   # Initialize the in-memory cache.
+      @env.cachesize = 10 * 1024 * 1024
+      @env.flags_on = Bdb::DB_TXN_WRITE_NOSYNC
+      @env.open(path, env_flags, 0)
     end
   end
 
@@ -34,7 +35,7 @@ class ActiveDocument::Environment
       parent = @transaction
       @transaction = env.txn_begin(nil, 0)
       begin
-        yield
+        value = yield
         @transaction.commit(0)
       rescue Exception => e
         @transaction.abort
@@ -42,6 +43,7 @@ class ActiveDocument::Environment
       ensure
         @transaction = parent
       end
+      value
     else
       @transaction
     end

data/lib/active_document.rb

@@ -1,6 +1,7 @@
 module ActiveDocument
   class ActiveDocumentError < StandardError; end
   class DocumentNotFound < ActiveDocumentError; end
+  class DuplicatePrimaryKey < ActiveDocumentError; end
 end
 
 require 'bdb'

data/test/active_document_test.rb

@@ -6,20 +6,29 @@ class Foo < ActiveDocument::Base
   path BDB_PATH
   accessor :foo, :bar, :id
 
+  primary_key :id
   index_by :foo
   index_by :bar, :unique => true
 end
 
+class Bar < ActiveDocument::Base
+  path BDB_PATH
+  accessor :foo, :bar
+
+  primary_key [:foo, :bar]
+  index_by :bar
+end
+
 class ActiveDocumentTest < Test::Unit::TestCase
-  context 'with db open' do
+  context 'with foo db open' do
     setup do
       FileUtils.mkdir BDB_PATH
       Foo.open_database
     end
-    
+
     teardown do
       Foo.close_database
-      FileUtils.rmtree BDB_PATH      
+      FileUtils.rmtree BDB_PATH
     end
 
     should 'find in database after save' do
@@ -35,11 +44,46 @@ class ActiveDocumentTest < Test::Unit::TestCase
       end
     end
     
-    should 'find_by_id' do
+    should 'find_by_primary_key' do
       f = Foo.new(:foo => 'BAR', :id => 1)
       f.save
       
-      assert_equal f, Foo.find_by_id(1).first
+      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 '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 secondary indexes' do
@@ -49,9 +93,9 @@ class ActiveDocumentTest < Test::Unit::TestCase
       f2 = Foo.new(:foo => 'BAR', :bar => 'FU', :id => 2)
       f2.save
       
-      assert_equal f1, Foo.find_by_bar('FOO').first
-      assert_equal f2, Foo.find_by_bar('FU').first
-      assert_equal [f1,f2], Foo.find_by_foo('BAR')
+      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')
     end
     
     should 'find by range' do
@@ -59,11 +103,57 @@ class ActiveDocumentTest < Test::Unit::TestCase
         Foo.new(:id => i, :foo => "foo-#{i}").save
       end
       
-      assert_equal (5..17).to_a, Foo.find_by_id(5..17).collect {|f| f.id}
-      assert_equal (5..14).to_a, Foo.find_by_id(5..17, :limit => 10).collect {|f| f.id}
+      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_by_id(1..3, 4, 16..20).collect {|f| f.id}
+      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
   end
+
+  context 'with bar db open' do
+    setup do
+      FileUtils.mkdir BDB_PATH
+      Bar.open_database
+    end
+
+    teardown do
+      Bar.close_database
+      FileUtils.rmtree BDB_PATH
+    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
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ninjudd-active_document
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Justin Balthrop
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-19 00:00:00 -07:00
+date: 2009-08-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -22,6 +22,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- README.rdoc
 - VERSION.yml
 - lib/active_document
 - lib/active_document/base.rb