odb 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Loren Segal
+
+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,5 @@
+= ODB
+
+A Ruby Object Database
+
+Loren Segal © 2009

data/Rakefile

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/lib/odb'
+require 'rubygems'
+require 'rake/gempackagetask'
+
+WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
+SUDO = WINDOWS ? '' : 'sudo'
+
+task :default => :specs
+
+load 'odb.gemspec'
+Rake::GemPackageTask.new(SPEC) do |pkg|
+  pkg.gem_spec = SPEC
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Install the gem locally"
+task :install => :gem do 
+  sh "#{SUDO} gem install pkg/#{SPEC.name}-#{SPEC.version}.gem --local --no-rdoc --no-ri"
+  sh "rm -rf pkg/odb-#{SPEC.version}" unless ENV['KEEP_FILES']
+end
+
+begin
+  require 'spec'
+  require 'spec/rake/spectask'
+
+  desc "Run all specs"
+  Spec::Rake::SpecTask.new("specs") do |t|
+    $DEBUG = true if ENV['DEBUG']
+    t.spec_opts = ["--format", "specdoc", "--colour"]
+    t.spec_opts += ["--require", File.join(File.dirname(__FILE__), 'spec', 'spec_helper')]
+    t.spec_files = Dir["spec/**/*_spec.rb"].sort
+  
+    if ENV['RCOV']
+      hide = '_spec\.rb$,spec_helper\.rb$,ruby_lex\.rb$,autoload\.rb$'
+      hide += ',legacy\/.+_handler,html_syntax_highlight_helper18\.rb$' if RUBY19
+      hide += ',ruby_parser\.rb$,ast_node\.rb$,handlers\/ruby\/[^\/]+\.rb$,html_syntax_highlight_helper\.rb$' if RUBY18
+      t.rcov = true 
+      t.rcov_opts = ['-x', hide]
+    end
+  end
+  task :spec => :specs
+rescue LoadError
+  warn "warn: RSpec tests not available. `gem install rspec` to enable them."
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  warn "warn: YARD is not available. `gem install yard` to enable documentation generation"
+end

data/lib/odb.rb

@@ -0,0 +1,236 @@
+require 'set'
+require 'fileutils'
+
+module ODB
+  def self.new(store = nil)
+    Database.new(store || HashStore.new)
+  end
+  
+  module Persistent
+  end
+  
+  class Database
+    attr_accessor :store
+    
+    class << self
+      attr_accessor :current
+    end
+    
+    def initialize(store)
+      self.store = store
+      self.store.db = self
+      self.class.current = self unless self.class.current
+    end
+    
+    def transaction(&block)
+      Transaction.new(self, &block)
+    end
+  end
+  
+  class DataStore
+    attr_reader :name, :key_cache
+    attr_accessor :db
+    
+    def initialize(name)
+      @name = name
+      @key_cache = {}
+      @object_map = {}
+    end
+    
+    def read(key)
+      key = key_cache[key] if Symbol === key
+      if oid = @object_map[key]
+        ObjectSpace._id2ref(oid)
+      else
+        obj = read_object(key)
+        @object_map[key] = obj.object_id
+        obj
+      end
+    end
+    
+    def write(key, value)
+      if Symbol === key
+        key = (key_cache[key] = value.object_id) 
+        @object_map[key] = value.object_id
+        return
+      end
+      @object_map[key] = value.object_id
+      write_object(key, value)
+    end
+    
+    def [](key) read(key) end
+    def []=(key, value) write(key, value) end
+
+    def after_commit; end
+      
+    protected
+    
+    def read_object(key) raise NotImplementedError end
+    def write_object(key, value) raise NotImplementedError end
+  end
+  
+  class Transaction
+    attr_accessor :objects
+
+    def self.transactions
+      Thread.current['__odb_transactions'] ||= []
+    end
+    
+    def self.current
+      transactions.last
+    end
+    
+    def initialize(db = ODB.current, &block)
+      @objects = Set.new
+      @db = db
+      transaction(&block) if block_given?
+    end
+    
+    def transaction(&block)
+      objects_before = persistent_objects
+      self.class.transactions << self
+      yield
+      self.objects << (persistent_objects - objects_before)
+      commit
+      self.class.transactions.pop
+    end
+    
+    def commit
+      self.objects = objects.to_a
+      while objects.size > 0
+        object = objects.pop
+        @db.store[object.object_id] = object
+      end
+      @db.store.after_commit
+    end
+    
+    def persistent_objects
+      ObjectSpace.each_object(Persistent).to_a
+    end
+  end
+  
+  class FileStore < DataStore
+    def initialize(name)
+      super(name)
+      FileUtils.mkdir_p(name)
+      if File.file?(resource("__key_cache"))
+        @key_cache = Marshal.load(IO.read(resource("__key_cache")))
+      end
+    end
+    
+    def after_commit
+      File.open(resource("__key_cache"), "wb") do |file|
+        file.write(Marshal.dump(key_cache))
+      end
+    end
+
+    protected
+    
+    def resource(key)
+      File.join(name, key.to_s)
+    end
+
+    def read_object(key)
+      Marshal.load(IO.read(resource(key))).__deserialize__
+    end
+    
+    def write_object(key, value)
+      resource = resource(key)
+      FileUtils.mkdir_p(File.dirname(resource))
+      File.open(resource, "wb") do |file|
+        file.write(Marshal.dump(value.__serialize__))
+      end
+    end
+  end
+  
+  class HashStore < DataStore
+    def initialize
+      super(nil)
+      @store = {}
+    end
+    
+    def read_object(key)
+      @store[key].__deserialize__(db)
+    end
+    
+    def write_object(key, value)
+      @store[key] = value.__serialize__
+    end
+  end
+end
+
+class Object
+  def __serialize__(transaction = ODB::Transaction.current)
+    obj = {:class => self.class, :ivars => {}}
+    instance_variables.each do |ivar|
+      subobj = instance_variable_get(ivar)
+      transaction.objects << subobj unless Fixnum === subobj
+      obj[:ivars][ivar[1..-1]] = Fixnum === subobj ? subobj.__serialize__ : subobj.object_id
+    end
+    obj
+  end
+end
+
+class String
+  def __serialize__(transaction = nil)
+    super().update(:value => self)
+  end
+end
+
+class Array
+  def __serialize__(transaction = ODB::Transaction.current)
+    obj = super
+    obj[:type] = :array
+    obj[:items] = map do |item|
+      transaction.objects << item 
+      item.object_id
+    end
+    obj
+  end
+end
+
+class Fixnum
+  def __serialize__(transaction = nil)
+    {:class => Fixnum, :value => self}
+  end
+end
+
+class Float
+  def __serialize__(transaction = nil)
+    super().update(:value => self)
+  end
+end
+
+class Hash
+  def __serialize__(transaction = ODB::Transaction.current)
+    obj = super
+    obj[:type] = :hash
+    obj[:items] = map do |k, v|
+      transaction.objects.push(k.object_id, v.object_id)
+      [k.object_id, v.object_id]
+    end
+    obj
+  end
+  
+  def __deserialize__(db = ODB::Database.current)
+    object = self[:value] ? self[:value] : self[:class].allocate
+    self[:ivars].each do |ivar, value|
+      object.instance_variable_set("@#{ivar}", Hash === value ? value[:value] : db.store[value])
+    end
+    case self[:type]
+    when :array
+      object.replace(self[:list].map {|item| db.store[item] })
+    when :hash
+      self[:list].each do |values|
+        object[db.store[values[0]]] = object[db.store[values[1]]]
+      end
+    end
+    object
+  end
+end
+
+class NilClass
+  def __deserialize__(db = nil)
+    nil
+  end
+end

data/spec/persistence_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../lib/odb"
+
+class Post
+  include ODB::Persistent
+  attr_accessor :title, :author, :comment
+end
+
+class Comment
+  def initialize
+    @name = 1
+    @value = 2.5
+  end
+end
+
+describe ODB::Persistent do
+  it "should save a post" do
+    db = ODB.new
+    post = Post.new.tap {|p| p.title = "x"; p.author = "Joe"; p.comment = Comment.new }
+    db.transaction do
+      db.store[:post] = post
+      db.store[:comment] = post.comment
+    end
+
+    db.store[:post].should == post
+    db.store[:post].comment.object_id.should == db.store[:comment].object_id
+  end
+end
+

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: odb
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Loren Segal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-25 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lsegal@soen.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/odb.rb
+- spec/persistence_spec.rb
+- LICENSE
+- README.rdoc
+- Rakefile
+has_rdoc: yard
+homepage: http://gnuu.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: odb
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An Object Oriented Database for Ruby
+test_files: []
+