rod 0.6.1 → 0.6.2

data/rod.gemspec

@@ -4,24 +4,27 @@ require 'rod/constants'
 Gem::Specification.new do |s|
   s.name = "rod"
   s.version = Rod::VERSION
-  s.date = "#{Time.now}"
+  s.date = "#{Time.now.strftime("%Y-%m-%d")}"
+  # TODO set to Linux/MacOSX and Ruby 1.9
+  s.platform    = Gem::Platform::RUBY
+  s.authors = ['Aleksander Pohl']
+  s.email   = ["apohllo@o2.pl"]
+  s.homepage    = "http://github.com/apohllo/rod"
   s.summary = "Ruby object database"
-  s.email = "apohllo@o2.pl"
-  #s.homepage = "http://wierzba.wzks.uj.edu.pl/~mag/dilp"
   s.description = "Ruby object database is designed for large amount of data, whose structure rarely changes."
+
+  s.rubyforge_project = "rod"
+  s.rdoc_options = ["--main", "README.rdoc"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_path = "lib"
-  s.has_rdoc = true
-  s.authors = ['Aleksander Pohl', 'Piotr Gurgul', 'Marcin Sieniek']
-  s.files = ["Rakefile", "rod.gemspec", 'lib/rod.rb', 'README',
-    'changelog.txt', 'Gemfile'] + Dir.glob("lib/**/*")
-  #s.test_files = Dir.glob("{test,spect}/**/*")
-  #s.rdoc_options = ["--main", "README.txt"]
-  #s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+
   s.add_dependency("RubyInline", [">= 3.8.3","< 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_development_dependency("mocha", [">= 0.9.8","< 1.0.0"])
-  s.add_development_dependency("cucumber", [">= 0.9.4","< 0.10.0"])
+  s.add_development_dependency("cucumber", "~> 1.0.0")
   s.add_development_dependency("rspec", [">= 2.2.0","< 2.3.0"])
 end
-

data/tests/check_strings.rb

@@ -0,0 +1,10 @@
+$:.unshift("tests")
+require 'structures'
+require 'validate_read_on_create'
+
+Rod::Database.development_mode = true
+RodTest::Database.instance.open_database("tmp/read_write")
+MAGNITUDO.times do |index|
+  validate(index,RodTest::MyStruct[index])
+end
+RodTest::Database.instance.close_database

data/tests/class_compatibility_create.rb

@@ -0,0 +1,14 @@
+$:.unshift("lib")
+require 'rod'
+
+Rod::Database.development_mode = true
+class TestDatabase < Rod::Database
+end
+
+class TestClass < Rod::Model
+  field :test, :string
+  database_class TestDatabase
+end
+
+TestDatabase.instance.create_database("tmp/class_compatibility")
+TestDatabase.instance.close_database

data/tests/class_compatibility_verify.rb

@@ -0,0 +1,18 @@
+$:.unshift("lib")
+require 'rod'
+
+Rod::Database.development_mode = true
+class TestDatabase < Rod::Database
+end
+
+class TestClass < Rod::Model
+  field :test, :integer
+  database_class TestDatabase
+end
+
+begin
+  TestDatabase.instance.open_database("tmp/class_compatibility")
+  raise "Should raise an error"
+rescue Rod::IncompatibleVersion => ex
+  # ok, this should be thrown
+end

data/tests/eff1_test.rb

@@ -0,0 +1,60 @@
+$:.unshift("lib")
+require 'rod'
+
+module RodTest
+  class Model < Rod::Model
+  end
+
+  %w{A B C D E}.each do |letter|
+    klass = Class.new(Model) do
+      10.times do |i|
+        field "a#{i}".to_sym, :ulong
+      end
+
+    end
+    const_set("#{letter}Struct",klass)
+    klass.send(:build_structure)
+  end
+
+  class EffectivenessTest
+
+		MAGNITUDE = 100000
+    FILENAME = "tmp/eff1"
+
+		def setup
+			Model.create_database(FILENAME)
+      @structs = {}
+      %w{A B C D E}.each do |letter|
+        @structs[letter.to_sym] = []
+        (MAGNITUDE).times do |i|
+          @structs[letter.to_sym][i] = RodTest.const_get("#{letter}Struct").new
+          10.times do |j|
+            @structs[letter.to_sym][i].send("a#{j}=",j)
+          end
+        end
+      end
+		end
+
+		def main
+      start_t = Time.now.to_f
+      %w{A B C D E}.each do |letter|
+        (MAGNITUDE / 2).times {|i| @structs[letter.to_sym][i].store }
+      end
+      %w{A B C D E}.each do |letter|
+        (MAGNITUDE / 2).times {|i| @structs[letter.to_sym][MAGNITUDE/2 + i].store }
+      end
+      end_t = Time.now.to_f
+      puts "Storing the objects in the DB took #{end_t - start_t} seconds"
+
+      start_t = Time.now.to_f
+			Model.close_database
+      end_t = Time.now.to_f
+
+      puts "Closing the DB took #{end_t - start_t} seconds"
+		end
+	end
+end
+
+e = RodTest::EffectivenessTest.new
+e.setup
+e.main

data/tests/eff2_test.rb

@@ -0,0 +1,61 @@
+$:.unshift("lib")
+require 'rod'
+
+module RodTest
+  class Model < Rod::Model
+  end
+
+  %w{E D C B A}.each do |letter|
+    klass = Class.new(Model) do
+      10.times do |i|
+        field "a#{i}".to_sym, :ulong
+      end
+
+    end
+    const_set("#{letter}Struct",klass)
+    klass.send(:build_structure)
+  end
+
+  class EffectivenessTest
+
+		MAGNITUDE = 100000
+    FILENAME = "tmp/eff2"
+
+		def setup
+      @structs = {}
+      %w{A B C D E}.each do |letter|
+        @structs[letter.to_sym] = []
+        (MAGNITUDE).times do |i|
+          @structs[letter.to_sym][i] = RodTest.const_get("#{letter}Struct").new
+          10.times do |j|
+            @structs[letter.to_sym][i].send("a#{j}=",j)
+          end
+        end
+      end
+		end
+
+		def main
+      start_t = Time.now.to_f
+			Model.create_database(FILENAME)
+      %w{A B C D E}.each do |letter|
+        (MAGNITUDE / 2).times {|i| @structs[letter.to_sym][i].store }
+      end
+      %w{A B C D E}.each do |letter|
+        (MAGNITUDE / 2).times {|i| @structs[letter.to_sym][MAGNITUDE/2 + i].store }
+      end
+      end_t = Time.now.to_f
+      puts "Storing the objects in the DB took #{end_t - start_t} seconds"
+
+      start_t = Time.now.to_f
+			Model.close_database
+      end_t = Time.now.to_f
+
+      puts "Closing the DB took #{end_t - start_t} seconds"
+		end
+	end
+
+end
+
+e = RodTest::EffectivenessTest.new
+e.setup
+e.main

data/tests/full_runs.rb

@@ -0,0 +1,68 @@
+$:.unshift("tests")
+$:.unshift("lib")
+require 'structures'
+require 'rod'
+require 'test/unit'
+
+module RodTest
+	class FullRuns < Test::Unit::TestCase
+
+		MAGNITUDE = 10000
+		def setup
+			@test_filename = "tmp/noncontinuous_pages"
+			Model.create_database(@test_filename)
+			@hs = []
+			(MAGNITUDE).times do |i|
+			  @hs[i] = HisStruct.new
+			  @hs[i].inde = i
+			end
+
+			@ys = []
+			(MAGNITUDE).times do |i|
+			  @ys[i] = YourStruct.new
+			  @ys[i].counter = 10
+			  @ys[i].his_structs = @hs[i*10...(i+1)*10]
+			end
+
+			@ms = []
+			(MAGNITUDE * 10).times do |i|
+			  @ms[i] = MyStruct.new
+			  @ms[i].count = 10 * i
+			  @ms[i].precision = 0.1 * i
+			  @ms[i].identifier = i
+			  @ms[i].your_struct = @ys[i]
+			  @ms[i].title = "title_#{i}"
+			  @ms[i].body = "body_#{i}"
+			end
+		end
+
+
+		def test_noncontinuous_pages
+
+			#creation
+			(0..2).each do |j|
+				@ms.each_index do |i|
+					@ms[i].store if i % 3 == j
+				end
+				@ys.each_index do |i|
+					@ys[i].store if i % 3 == j
+				end
+				@hs.each_index do |i|
+					@hs[i].store if i % 3 == j
+				end
+			end
+			Model.close_database
+
+			# verification
+			Model.open_database(@test_filename)
+			assert MyStruct.count == @ms.count,
+        "MyStruct: should be #{@ms.count}, was #{MyStruct.count}!"
+			assert YourStruct.count == @ys.count,
+        "YourStruct: should be #{@ys.count}, was #{YourStruct.count}!"
+			assert HisStruct.count == @hs.count,
+        "HisStruct: should be #{@hs.count}, was #{HisStruct.count}!"
+			Model.close_database
+		end
+	end
+end
+

data/tests/generate_classes_create.rb

@@ -0,0 +1,25 @@
+$:.unshift("lib")
+require 'rod'
+require File.join(".",File.dirname(__FILE__),"generate_classes_model")
+
+Rod::Database.development_mode = true
+
+
+Database.instance.create_database("tmp/generate_classes")
+
+files = 10.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
+
+Database.instance.close_database

data/tests/generate_classes_model.rb

@@ -0,0 +1,23 @@
+require 'rod'
+
+class Database < Rod::Database
+end
+
+class Model < Rod::Model
+  database_class Database
+end
+
+class User < Model
+  field :name, :string, :index => :flat
+  has_one :account, :index => :flat
+  has_many :files, :index => :flat, :class_name => "UserFile"
+end
+
+class Account < Model
+  field :login, :string
+end
+
+class UserFile < Model
+  field :data, :string
+end
+

data/tests/generate_classes_rewrite.rb

@@ -0,0 +1,7 @@
+$:.unshift("lib")
+require 'rod'
+require File.join(".",File.dirname(__FILE__),"generate_classes_model")
+
+Rod::Database.development_mode = true
+Database.instance.open_database("tmp/generate_classes",:readonly => false)
+Database.instance.close_database

data/tests/generate_classes_verify.rb

@@ -0,0 +1,46 @@
+$:.unshift("lib")
+require 'rod'
+require 'rspec/expectations'
+
+module RodTest
+end
+
+Rod::Database.development_mode = true
+
+Rod::Database.instance.open_database("tmp/generate_classes",:generate => RodTest)
+
+user = RodTest::User[0]
+user = RodTest::User.find_by_name("John")
+user.should_not == nil
+user.name.should == "John"
+user.account.should_not == nil
+user.account.should == RodTest::Account[0]
+user.files.size.should == 3
+
+account = RodTest::Account[0]
+account.login.should == "john"
+RodTest::User.find_all_by_account(account).size.should == 1
+RodTest::User.find_all_by_account(account)[0].should == user
+RodTest::User.find_by_account(account).should_not == nil
+user.account.should == account
+
+user = RodTest::User.find_by_name("Amanda")
+user.should_not == nil
+user.name.should == "Amanda"
+user.account.should_not == nil
+user.files.size.should == 5
+
+account = RodTest::Account[1]
+account.login.should == "amanda"
+RodTest::User.find_by_account(account).should_not == nil
+user.account.should == account
+
+file = RodTest::UserFile[0]
+file.data.should == "0 data"
+
+RodTest::UserFile.each{|f| f.data.should_not == nil}
+users = RodTest::User.find_all_by_files(file)
+users.size.should == 2
+users[1].should == user
+
+Rod::Database.instance.close_database

data/tests/load_struct.rb

@@ -0,0 +1,24 @@
+$:.unshift("tests")
+require 'structures'
+
+puts "-- Load sample structures test --"
+
+Rod::Database.development_mode = true
+RodTest::Database.instance.open_database("tmp/abc")
+RodTest::Database.instance.print_layout
+puts RodTest::MyStruct.count
+puts RodTest::YourStruct.count
+puts RodTest::HisStruct.count
+index = 0
+RodTest::MyStruct.each do |object|
+  index += 1
+  puts index if index % 1000 == 0
+  object.to_s
+end
+RodTest::YourStruct.each do |object|
+    object.to_s
+end
+
+puts RodTest::MyStruct.find_by_title("title_10")
+
+RodTest::Database.instance.close_database

data/tests/migration_create.rb

@@ -0,0 +1,25 @@
+$:.unshift("lib")
+require 'rod'
+require File.join(".",File.dirname(__FILE__),"migration_model1")
+
+Rod::Database.development_mode = true
+
+
+Database.instance.create_database("tmp/migration")
+
+files = 10.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
+
+Database.instance.close_database

data/tests/migration_migrate.rb

@@ -0,0 +1,22 @@
+$:.unshift("lib")
+require 'rod'
+require File.join(".",File.dirname(__FILE__),"migration_model2")
+require 'rspec/expectations'
+
+$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
+
+user = User[1]
+user.accounts << Account[1]
+user.store
+
+Database.instance.close_database
+
+test(?f,"tmp/migration/#{Rod::DATABASE_FILE}#{Rod::LEGACY_DATA_SUFFIX}").should == true