ninjudd-active_document 0.0.2

data/VERSION.yml

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

data/lib/active_document/base.rb

@@ -0,0 +1,171 @@
+class ActiveDocument::Base
+  def self.path(path = nil)
+    if path
+      @path = path
+    else
+      @path || (base_class? ? DEFAULT_PATH : super)
+    end
+  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 nil if self == ActiveDocument::Base
+      @database_name ||= base_class? ? name.underscore.pluralize : super
+    end
+  end
+  
+  def self.base_class?
+    self == base_class
+  end
+
+  def self.base_class(klass = self)
+    if klass == ActiveDocument::Base or klass.superclass == ActiveDocument::Base
+      klass
+    else
+      base_class(klass.superclass)
+    end
+  end
+
+  @@environment = {}
+  def self.environment
+    @@environment[path] ||= ActiveDocument::Environment.new(path)
+  end
+
+  def self.transaction(&block)
+    environment.transaction(&block)
+  end
+
+  def self.create(*args)
+    model = new(*args)
+    model.save
+    model
+  end
+
+  def self.index_by(field, opts = {})
+    field = field.to_sym
+    raise "index on #{field} already exists" if databases[field]
+    databases[field] = ActiveDocument::Database.new(opts.merge(:field => field, :model_class => self))    
+  end
+  
+  def self.databases
+    @databases ||= { :id  => 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}
+  end
+
+  def self.close_database
+    databases.values.each {|database| database.close}
+    environment.close
+  end
+
+  def self.database(field = :id)
+    field = field.to_sym
+    database = databases[field]
+    database ||= base_class.database(field) unless base_class?
+    database
+  end
+
+  def self.find_by(field, *keys)
+    opts = keys.last.kind_of?(Hash) ? keys.pop : {}
+    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
+    doc
+  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]
+    end
+    raise NoMethodError, "undefined method `#{method_name}' for #{self}"
+  end
+
+  def self.timestamps
+    reader(:created_at, :updated_at)
+  end
+
+  def self.reader(*attrs)
+    attrs.each do |attr|
+      define_method(attr) do
+        attributes[attr]
+      end
+    end
+  end
+
+  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
+  end
+
+  def self.accessor(*attrs)
+    reader(*attrs)
+    writer(*attrs)
+  end
+    
+  def initialize(attributes = {})
+    if attributes.kind_of?(String)
+      @attributes, @saved_attributes = Marshal.load(attributes)
+    else
+      @attributes = attributes
+    end
+  end
+
+  attr_reader :saved_attributes
+
+  def attributes
+    @attributes ||= Marshal.load(Marshal.dump(saved_attributes))
+  end
+
+  def ==(other)
+    return false if other.nil?
+    attributes == other.attributes
+  end
+
+  def new_record?
+    @saved_attributes.nil?
+  end
+
+  def changed?(field = nil)
+    return false unless @attributes and @saved_attributes
+
+    if field
+      attributes[field] != saved_attributes[field]
+    else
+      attributes != saved_attributes
+    end
+  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?
+    @saved_attributes = attributes
+    @attributes       = nil
+    self.class.database.save(self)
+
+    true
+  end
+
+  def _dump(ignored)
+    Marshal.dump([@attributes, @saved_attributes])
+  end
+
+  def self._load(data)
+    new(data)
+  end
+end

data/lib/active_document/database.rb

@@ -0,0 +1,124 @@
+class ActiveDocument::Database
+  def initialize(opts)
+    @model_class = opts[:model_class]
+    @field       = opts[:field]
+    @unique      = opts[:unique]
+    @suffix      = opts[:suffix] || (@field ? "by_#{@field}" : nil)
+    at_exit { close }
+  end
+
+  attr_accessor :model_class, :field, :db, :suffix
+
+  def unique?
+    @unique
+  end
+  
+  def environment
+    model_class.environment
+  end
+
+  def primary_db
+    model_class.database.db if field
+  end
+  
+  def name
+    @name ||= [model_class.database_name, suffix].compact.join('_')
+  end
+
+  def transaction
+    environment.transaction
+  end
+
+  def find(keys, opts = {}, &block)
+    models = block_given? ? BlockArray.new(block) : []
+
+    keys.uniq.each do |key|
+      if 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
+          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
+        end
+        cursor.close
+      else
+        if unique?
+          # There can only be one item for each key.
+          data = db.get(transaction, Tuple.dump(key), nil, 0)
+          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)
+          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)
+          end
+          cursor.close
+        end
+      end
+      break if opts[:limit] and models.size == opts[:limit]
+    end
+
+    block_given? ? nil : models
+  end
+
+  def save(model)
+    id   = Tuple.dump(model.id)
+    data = Marshal.dump(model)
+    db.put(nil, id, data, 0)
+  end
+
+  def open
+    if @db.nil?
+      @db = environment.db
+      @db.flags = Bdb::DB_DUPSORT unless unique?
+      @db.open(nil, name, nil, Bdb::Db::BTREE, Bdb::DB_CREATE | Bdb::DB_AUTO_COMMIT, 0)
+      
+      if primary_db
+        index_callback = lambda do |db, key, data|
+          model = Marshal.load(data)
+          return unless model.kind_of?(model_class)
+          
+          index_key = model.send(field)
+          if index_key.kind_of?(Array)
+            # Index multiple keys. If the key is an array, you must wrap it with an outer array.
+            index_key.collect {|k| Tuple.dump(k)}
+          elsif index_key
+            # Index a single key.
+            Tuple.dump(index_key)
+          end
+        end
+        
+        primary_db.associate(nil, @db, 0, index_callback)
+      end
+    end
+  end
+
+  def close
+    if @db
+      @db.close(0)
+      @db = nil
+    end
+  end
+end
+
+# This allows us to support a block in find without changing the syntax.
+class BlockArray
+  def initialize(block)
+    @block = block
+    @size  = 0
+  end
+  attr_reader :size
+  
+  def <<(item)
+    @size += 1
+    @block.call(item)
+  end
+end

data/lib/active_document/environment.rb

@@ -0,0 +1,49 @@
+class ActiveDocument::Environment
+  def initialize(path)
+    @path = path
+    at_exit { close }
+  end
+
+  attr_reader :path, :env
+
+  def db
+    env.db
+  end
+
+  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);
+    end
+  end
+
+  def close
+    if @env
+      @env.close
+      @env = nil
+    end
+  end
+
+  def transaction
+    if block_given?
+      parent = @transaction
+      @transaction = env.txn_begin(nil, 0)
+      begin
+        yield
+        @transaction.commit(0)
+      rescue Exception => e
+        @transaction.abort
+        raise e
+      ensure
+        @transaction = parent
+      end
+    else
+      @transaction
+    end
+  end
+end

data/lib/active_document.rb

@@ -0,0 +1,11 @@
+module ActiveDocument
+  class ActiveDocumentError < StandardError; end
+  class DocumentNotFound < ActiveDocumentError; end
+end
+
+require 'bdb'
+require 'tuple'
+require 'active_support/inflector'
+require 'active_document/database'
+require 'active_document/environment'
+require 'active_document/base'

data/test/active_document_test.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+BDB_PATH = File.dirname(__FILE__) + '/tmp'
+
+class Foo < ActiveDocument::Base
+  path BDB_PATH
+  accessor :foo, :bar, :id
+
+  index_by :foo
+  index_by :bar, :unique => true
+end
+
+class ActiveDocumentTest < Test::Unit::TestCase
+  context 'with db open' do
+    setup do
+      FileUtils.mkdir BDB_PATH
+      Foo.open_database
+    end
+    
+    teardown do
+      Foo.close_database
+      FileUtils.rmtree BDB_PATH      
+    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_id' do
+      f = Foo.new(:foo => 'BAR', :id => 1)
+      f.save
+      
+      assert_equal f, Foo.find_by_id(1).first
+    end
+    
+    should 'find by secondary indexes' do
+      f1 = Foo.new(:foo => 'BAR', :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').first
+      assert_equal f2, Foo.find_by_bar('FU').first
+      assert_equal [f1,f2], Foo.find_by_foo('BAR')
+    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_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}
+
+      # 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}
+    end
+  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,62 @@
+--- !ruby/object:Gem::Specification 
+name: ninjudd-active_document
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Justin Balthrop
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-19 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: justin@geni.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/active_document
+- lib/active_document/base.rb
+- lib/active_document/database.rb
+- lib/active_document/environment.rb
+- lib/active_document.rb
+- test/active_document_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ninjudd/active_document
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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: 2
+summary: TODO
+test_files: []
+