rod 0.6.2 → 0.6.3

data/lib/rod/reference_updater.rb

@@ -0,0 +1,85 @@
+require 'rod/exception'
+
+module Rod
+  # This class provides the set of reference updaters, that is objects
+  # used to break down the process of data storage into separate steps.
+  # If there is an object A which reference object B, there might be two
+  # cases: object A is stored *before* object B is stored or *after* the object
+  # B is stored. In the first case, the id of the object B is not know, so
+  # it might be updated only after the object is stored. If the object B
+  # stored the reference to object A (to update its reference to the object
+  # B), then the object A could not be GC'ed until object B is stored.
+  # For large nets of objects, this would result in large non-GCable collections
+  # of objects. The reference updater splits the reference of object B to A
+  # and allows for GC of A, even thou B is not yet stored.
+  class ReferenceUpdater
+    # Singular reference updater holds the +rod_id+ and +class_id+ of the
+    # object that has to be updated and the name of the
+    # +property+ of the reference to be updated.
+    class SingularUpdater
+      def initialize(database,rod_id,class_id,property)
+        @database = database
+        @rod_id = rod_id
+        @class_id = class_id
+        @property = property
+      end
+
+      # Updates the id of the referenced +object+.
+      def update(object)
+        referee = Model.get_class(@class_id).find_by_rod_id(@rod_id)
+        referee.update_singular_association(@property,object)
+      end
+    end
+
+    # Plural reference updater holds the +collection+ proxy
+    # that includes the reference to be updated and its +index+
+    # within that collection.
+    class PluralUpdater
+      def initialize(database,collection,index)
+        @database = database
+        @collection = collection
+        @index = index
+      end
+
+      # Updates the id of the referenced +object+.
+      def update(object)
+        @collection.send(:update_reference_id,object.rod_id,@index)
+      end
+    end
+
+    # This updater is used when there is an index of Rod objects
+    # and one of its keys is an object which is not yet stored.
+    # The key of the index is set to the rod_id, when the object
+    # is stored.
+    class IndexUpdater
+      # The updater is initialized with the +index+ to be updated.
+      def initialize(index)
+        @index = index
+      end
+
+      # Updates the index by providing the object with the updated +rod_id+.
+      def update(object)
+        @index.key_persisted(object)
+      end
+    end
+
+    # Creates singular reference updater of for the +property+
+    # of the +object+ that belongs to the +database+.
+    def self.for_singular(object,property,database)
+      SingularUpdater.new(database,object.rod_id,object.class.name_hash,property)
+    end
+
+    # Creates plural reference updater for given
+    # +collection+ proxy with given +index+.
+    def self.for_plural(collection,index,database)
+      PluralUpdater.new(database,collection,index)
+    end
+
+    # Creates reference updater for an index. It is used
+    # when the indexed plural association includes objects
+    # that are not yet persisted.
+    def self.for_index(index)
+      IndexUpdater.new(index)
+    end
+  end
+end

data/lib/rod/utils.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'fileutils'
+
+module Rod
+  module Utils
+    # Removes single file.
+    def remove_file(file_name)
+      if test(?f,file_name)
+        File.delete(file_name)
+        puts "Removing #{file_name}" if $ROD_DEBUG
+      end
+    end
+
+    # Remove all files matching the +pattern+.
+    # If +skip+ given, the file with the given name is not deleted.
+    def remove_files(pattern,skip=nil)
+      Dir.glob(pattern).each do |file_name|
+        remove_file(file_name) unless file_name == skip
+      end
+    end
+
+    # Removes all files which are similar (i.e. are generated
+    # by RubyInline for the same class) to +name+
+    # excluding the file with exactly the name given.
+    def remove_files_but(name)
+      remove_files(name.sub(INLINE_PATTERN_RE,"*"),name)
+    end
+  end
+end

data/rod.gemspec

@@ -5,6 +5,7 @@ Gem::Specification.new do |s|
   s.name = "rod"
   s.version = Rod::VERSION
   s.date = "#{Time.now.strftime("%Y-%m-%d")}"
+  s.required_ruby_version = '>= 1.9.2'
   # TODO set to Linux/MacOSX and Ruby 1.9
   s.platform    = Gem::Platform::RUBY
   s.authors = ['Aleksander Pohl']
@@ -21,10 +22,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_path = "lib"
 
-  s.add_dependency("RubyInline", [">= 3.8.3","< 4.0.0"])
+  s.add_dependency("RubyInline", [">= 3.10.0","< 4.0.0"])
   s.add_dependency("english", [">= 0.5.0","< 0.6.0"])
   s.add_dependency("activemodel", [">= 3.0.7","< 3.1.0"])
+  s.add_dependency("bsearch", [">= 1.5.0","< 1.6.0"])
   s.add_development_dependency("mocha", [">= 0.9.8","< 1.0.0"])
   s.add_development_dependency("cucumber", "~> 1.0.0")
   s.add_development_dependency("rspec", [">= 2.2.0","< 2.3.0"])
+  s.add_development_dependency("rake", [">= 0.9.0","< 1.0.0"])
 end

data/tests/migration_create.rb

@@ -7,19 +7,40 @@ Rod::Database.development_mode = true
 
 Database.instance.create_database("tmp/migration")
 
-files = 10.times.map{|i| UserFile.new(:data => "#{i} data")}
+count = (ARGV[0] || 10).to_i
+puts "Count in migration test: #{count}"
+
+files = count.times.map{|i| UserFile.new(:data => "#{i} data")}
 files.each{|f| f.store}
 
-account = Account.new(:login => "john")
-account.store
-user = User.new(:name => "John", :account => account,
-                :files => [files[0],files[1],files[2]])
-user.store
-
-account = Account.new(:login => "amanda")
-account.store
-user = User.new(:name => "Amanda", :account => account,
-                :files => [files[0],files[4],files[5],nil,files[6]])
-user.store
+users = []
+count.times do |index|
+  account = Account.new(:login => "john#{index}",
+                        :nick => "j#{index}")
+  account.store
+  user1 = User.new(:name => "John#{index}",
+                  :surname => "Smith#{index}",
+                  :account => account,
+                  :mother => users[index-1],
+                  :father => users[index-2],
+                  :friends => [users[index-3],users[index-4]],
+                  :files => [files[index],files[index + 1],files[index + 2]])
+  user1.store
+
+  account = Account.new(:login => "amanda#{index}",
+                        :nick => "a#{index}")
+  account.store
+  user2 = User.new(:name => "Amanda#{index}",
+                   :surname => "Amanda#{index}",
+                   :account => account,
+                   :mother => users[index-1],
+                   :father => users[index-2],
+                   :friends => [users[index-5],users[index-6]],
+                   :files => [files[index],files[index+4],files[index+5],
+                     nil,files[index+6]])
+  user2.store
+  users << user1
+  users << user2
+end
 
 Database.instance.close_database

data/tests/migration_migrate.rb

@@ -3,19 +3,36 @@ require 'rod'
 require File.join(".",File.dirname(__FILE__),"migration_model2")
 require 'rspec/expectations'
 
-$ROD_DEBUG = true
+#$ROD_DEBUG = true
 Rod::Database.development_mode = true
 
 Database.instance.open_database("tmp/migration", :migrate => true,
                                :readonly => false)
 
-user = User[0]
-user.accounts << Account[0]
-user.store
+count = (ARGV[0] || 10).to_i
+count.times do |index|
+  account1 = Account[index * 2]
+  account1.password = "pass#{index * 2}"
+  account1.store
+  file = UserFile[index]
+  file.name = "file#{index}"
+  file.store
+  user = User[index*2]
+  user.age = index
+  user.file = file
+  user.accounts << account1
+  user.store
 
-user = User[1]
-user.accounts << Account[1]
-user.store
+  account2 = Account[index * 2 + 1]
+  account2.password = "pass#{index * 2 + 1}"
+  account2.store
+  user = User[index*2 + 1]
+  user.age = index * 2
+  user.file = file
+  user.accounts << account1
+  user.accounts << account2
+  user.store
+end
 
 Database.instance.close_database
 

data/tests/migration_model1.rb

@@ -11,13 +11,18 @@ class User < Model
   field :name, :string, :index => :flat
   field :surname, :string
   has_one :account, :index => :flat
+  has_one :mother, :class_name => "User"
+  has_one :father, :class_name => "User"
   has_many :files, :index => :flat, :class_name => "UserFile"
+  has_many :friends, :class_name => "User"
 end
 
 class Account < Model
   field :login, :string
+  field :nick, :string
 end
 
 class UserFile < Model
   field :data, :string
+  field :path, :string
 end

data/tests/migration_model2.rb

@@ -8,20 +8,56 @@ class Model < Rod::Model
 end
 
 class User < Model
+  # present
   field :name, :string, :index => :flat
+
+  # removed
+  # field :surname, :string
+
+  # added
   field :age, :integer
+
+  # present
   has_one :account, :index => :flat
+
+  # removed
+  # has_one :mother, :class_name => "User"
+
+  # removed
+  # has_one :father, :class_name => "User"
+
+  # added
+  has_one :file, :class_name => "UserFile"
+
+  # present
   has_many :files, :index => :flat, :class_name => "UserFile"
+
+  # added
   has_many :accounts, :index => :flat
+
+  # removed
+  # has_many :friends, :class_name => "User"
 end
 
 class Account < Model
+  # present
   field :login, :string
+
+  # removed
+  # field :nick, :string
+
+  # added
   field :password, :string
 end
 
 class UserFile < Model
+  # present
   field :data, :string
+
+  # removed
+  # field :path, :string
+
+  # added
   field :name, :string, :index => :flat
 end
 

data/tests/migration_verify.rb

@@ -7,50 +7,57 @@ Rod::Database.development_mode = true
 
 Database.instance.open_database("tmp/migration")
 
-user = User[0]
-user.should_not == nil
-user = User.find_by_name("John")
-user.should_not == nil
-user.name.should == "John"
-user.age.should == 0
-user.account.should_not == nil
-user.account.should == Account[0]
-user.files.size.should == 3
-user.accounts.size.should == 1
-user.accounts[0].should == user.account
-
-account = Account[0]
-account.login.should == "john"
-account.password.should == ""
-User.find_all_by_account(account).size.should == 1
-User.find_all_by_account(account)[0].should == user
-User.find_by_account(account).should_not == nil
-user.account.should == account
-
-user = User.find_by_name("Amanda")
-user.should_not == nil
-user.name.should == "Amanda"
-user.age.should == 0
-user.account.should_not == nil
-user.files.size.should == 5
-user.accounts.size.should == 1
-user.accounts[0].should == user.account
-
-account = Account[1]
-account.login.should == "amanda"
-account.password.should == ""
-User.find_by_account(account).should_not == nil
-user.account.should == account
-
-file = UserFile[0]
-file.data.should == "0 data"
-
-UserFile.each do |file|
+count = (ARGV[0] || 10).to_i
+count.times do |index|
+  user1 = User[index*2]
+  user1.should_not == nil
+  user = User.find_by_name("John#{index}")
+  user1.should == user
+  user1.name.should == "John#{index}"
+  user1.age.should == index
+  user1.account.should_not == nil
+  user1.account.should == Account[index * 2]
+  user1.account.login.should == "john#{index}"
+  user1.account.password.should == "pass#{index * 2}"
+  User.find_all_by_account(user1.account).size.should == 1
+  User.find_all_by_account(user1.account)[0].should == user
+  User.find_by_account(user1.account).should_not == nil
+  user1.files.size.should == 3
+  user1.files[0].data.should == "#{index} data"
+  user1.files[0].name.should == "file#{index}"
+  user1.accounts.size.should == 1
+  user1.accounts[0].should == user1.account
+
+  user2 = User[index*2+1]
+  user2.should_not == nil
+  user = User.find_by_name("Amanda#{index}")
+  user2.should == user
+  user2.name.should == "Amanda#{index}"
+  user2.age.should == index * 2
+  user2.account.should_not == nil
+  user2.account.should == Account[index * 2 + 1]
+  user2.account.password.should == "pass#{index * 2 + 1}"
+  User.find_by_account(user2.account).should == user2
+  user2.files.size.should == 5
+  user2.files[0].data.should == "#{index} data"
+  user2.files[0].name.should == "file#{index}"
+  user2.files[3].data.should == nil unless user2.files[3].nil?
+  user2.accounts.size.should == 2
+  user2.accounts[0].should == user1.account
+  user2.accounts[1].should == user2.account
+end
+
+
+UserFile.each.with_index do |file,index|
   file.data.should_not == nil
-  file.name.should == ""
+  file.data.should == "#{index} data"
+  file.name.should_not == nil
+  file.name.should == "file#{index}"
 end
-users = User.find_all_by_files(file)
+
+users = User.find_all_by_files(UserFile[0])
 users.size.should == 2
-users[1].should == user
+users[0].should == User[0]
+users[1].should == User[1]
 
 Database.instance.close_database

data/tests/missing_class_create.rb

@@ -0,0 +1,21 @@
+$:.unshift("lib")
+require 'rod'
+
+class User < Rod::Model
+  database_class Rod::Database
+  field :name, :string
+end
+
+class Item < Rod::Model
+  database_class Rod::Database
+  field :name, :string
+end
+
+Rod::Database.development_mode = true
+
+Rod::Database.instance.create_database("tmp/missing_class")
+user = User.new(:name => "John")
+user.store
+item = Item.new(:name => "hammer")
+item.store
+Rod::Database.instance.close_database

data/tests/missing_class_verify.rb

@@ -0,0 +1,20 @@
+$:.unshift("lib")
+require 'rod'
+require 'rspec/expectations'
+include RSpec::Matchers
+
+class User < Rod::Model
+  database_class Rod::Database
+  field :name, :string
+end
+
+# This class is missing in the runtime
+#class Item < Rod::Model
+#  database_class Rod::Database
+#  field :name
+#end
+
+Rod::Database.development_mode = true
+
+(lambda {Rod::Database.instance.open_database("tmp/missing_class")}).
+  should raise_error(Rod::DatabaseError)