rod 0.7.1 → 0.7.2

data/lib/rod/property/singular_association.rb

@@ -0,0 +1,139 @@
+require 'rod/property/base'
+
+module Rod
+  module Property
+    # This class defines the +has_one+ (singular association) property.
+    # A +has_one+ property has to define its +name+.
+    class SingularAssociation < Base
+      # Creates new singular association associated with +klass+,
+      # with given +name+ and +options+.
+      # Valid options are:
+      # * +:class_name+ - the name of the class (as String) associated
+      #   with this class
+      # * +:polymorphic+ - if set to +true+ the association is polymorphic (allows to access
+      #   objects of different classes via this association).
+      def initialize(klass,name,options={})
+        super(klass,name,options)
+      end
+
+      # Predicate indicating that this property is a field.
+      def field?
+        false
+      end
+
+      # Predicate indicating that this property is an association.
+      def association?
+        true
+      end
+
+      # Predicate indicating that this property is a singular association.
+      def singular?
+        true
+      end
+
+      # Predicate indicating that this property is not a plural association.
+      def plural?
+        false
+      end
+
+      # Predicate indicating that this property is polymorphic.
+      def polymorphic?
+        @options[:polymorphic]
+      end
+
+      # Returns the metadata of the association in form of a hash.
+      def metadata
+        @options.dup
+      end
+
+      # Converts the association to fields in a C struct.
+      def to_c_struct
+        result = "  #{c_type(:ulong)} #{@name};\n"
+        if polymorphic?
+          result += "  #{c_type(:ulong)} #{@name}__class;\n"
+        end
+        result
+      end
+
+      # Defines the accessor of the association's constituents
+      # (C struct field/fields that hold the association data).
+      def define_c_accessors(builder)
+        field_reader(@name,@klass.struct_name,c_type(:ulong),builder)
+        field_writer(@name,@klass.struct_name,c_type(:ulong),builder)
+        if polymorphic?
+          field_reader("#{@name}__class",@klass.struct_name,c_type(:ulong),builder)
+          field_writer("#{@name}__class",@klass.struct_name,c_type(:ulong),builder)
+        end
+      end
+
+      # Make the C accessors private.
+      def seal_c_accessors
+        @klass.send(:private,"_#{@name}")
+        @klass.send(:private,"_#{@name}=")
+      end
+
+      # Defines the getter of the Ruby class which corresponds to this association.
+      def define_getter
+        # optimization
+        name = @name.to_s
+        property = self
+        class_name =
+          if @options[:class_name]
+            @options[:class_name]
+          else
+            "#{@klass.scope_name}::#{name.camelcase}"
+          end
+        klass = options[:polymorphic] ? nil : class_name.constantize
+        @klass.send(:define_method,name) do
+          value = instance_variable_get("@#{name}")
+          if value.nil?
+            return nil if self.new?
+            rod_id = send("_#{name}",@rod_id)
+            # the indices are shifted by 1, to leave 0 for nil
+            if rod_id == 0
+              value = nil
+            else
+              if property.polymorphic?
+                klass = Model.get_class(send("_#{name}__class",@rod_id))
+              end
+              value = klass.find_by_rod_id(rod_id)
+            end
+            # avoid change tracking
+            instance_variable_set("@#{name}",value)
+          end
+          value
+        end
+      end
+
+      # Defines the settor of the Ruby class which corresponds to this association.
+      def define_setter
+        # optimization
+        name = @name.to_s
+        @klass.send(:define_method,"#{name}=") do |value|
+          old_value = send(name)
+          send("#{name}_will_change!") unless old_value == value
+          instance_variable_set("@#{name}", value)
+          value
+        end
+      end
+
+      # Returns the memory layout of the C struct fields that
+      # correspond to this association.
+      def layout
+        unless polymorphic?
+          "#{@name}[value:#{sizeof(:ulong)}]"
+        else
+          "#{@name}[value:#{sizeof(:ulong)}+" +
+            "class:#{sizeof(:ulong)}]"
+        end
+      end
+
+      protected
+      # Check if the property has valid options.
+      # An exceptions is raised if they are not.
+      def check_options(options)
+        #TODO implement
+      end
+    end
+  end
+end

data/rod.gemspec

@@ -11,8 +11,8 @@ Gem::Specification.new do |s|
   s.authors = ['Aleksander Pohl']
   s.email   = ["apohllo@o2.pl"]
   s.homepage    = "http://github.com/apohllo/rod"
-  s.summary = "Ruby object database"
-  s.description = "Ruby object database is designed for large amount of data, whose structure rarely changes."
+  s.summary = "Ruby Object Database"
+  s.description = "Ruby Object Database is designed for large amounts of data, whose structure rarely changes."
 
   s.rubyforge_project = "rod"
   s.rdoc_options = ["--main", "README.rdoc"]
@@ -24,10 +24,12 @@ Gem::Specification.new do |s|
 
   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("activemodel", ["~> 3.2.2"])
   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("mocha", "~> 0.9.8")
   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"])
+  s.add_development_dependency("minitest", "~> 2.7.0")
 end

data/spec/berkeley/database.rb

@@ -0,0 +1,83 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'rod'
+
+describe Rod::Berkeley::Database do
+  describe "a database" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_db", :create => true, :cache => true)
+      @database = Rod::Berkeley::Database.new(environment)
+    end
+
+    after do
+      @database.close
+      @database.environment.close
+    end
+
+    it "should not be in opened state befor being opened" do
+      @database.opened?.must_equal false
+    end
+
+    it "should allow to open itself" do
+      proc {@database.open("db1.db", :hash, :create => true, :truncate => true)}.must_be_silent
+    end
+
+    it "should be in opened state after being opened" do
+      @database.open("db1.db", :hash, :create => true, :truncate => true)
+      @database.opened?.must_equal true
+    end
+
+    it "should not allow to open itself twice" do
+      @database.open("db1.db", :hash, :create => true, :truncate => true)
+      proc {@database.open("db1.db", :hash, :create => true, :truncate => true)}.must_raise Rod::DatabaseError
+    end
+
+    it "should allow to close itself" do
+      proc {@database.close}.must_be_silent
+    end
+
+    it "should not be in opened state after being closed" do
+      @database.open("db1.db", :hash, :create => true, :truncate => true)
+      @database.close
+      @database.opened?.must_equal false
+    end
+  end
+
+  describe "a hash database with transactions enabled" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_txn", :create => true, :cache => true, :transactions => true,
+                      :logging => true, :locking => true)
+      @database = Rod::Berkeley::Database.new(environment)
+      @database.open("db1.db", :hash, :create => true, :auto_commit => true)
+    end
+
+    after do
+      @database.close
+      @database.environment.close
+    end
+
+    it "should allow to add data with transactional protection" do
+      transaction = Rod::Berkeley::Transaction.new(@database.environment)
+      transaction.begin
+      @database.put("Ruby","Matz",transaction)
+      transaction.commit
+
+      transaction.reset
+      transaction.begin
+      @database.get("Ruby").must_equal "Matz"
+      transaction.commit
+
+      transaction.reset
+      transaction.begin
+      @database.put("Ruby","Matsumoto San",transaction)
+      transaction.abort
+
+      transaction.reset
+      transaction.begin
+      @database.get("Ruby").must_equal "Matz"
+      transaction.commit
+    end
+  end
+end

data/spec/berkeley/environment.rb

@@ -0,0 +1,58 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'rod'
+
+describe Rod::Berkeley::Environment do
+  describe "an environment" do
+    before do
+      @environment = Rod::Berkeley::Environment.new
+    end
+
+    after do
+      @environment.close
+    end
+
+    it "should not be in opened state before being opened" do
+      @environment.opened?.must_equal false
+    end
+
+    it "should allow to open itself" do
+      proc {@environment.open("tmp/env", :create => true)}.must_be_silent
+    end
+
+    it "should not allow to open it twice" do
+      @environment.open("tmp/env", :create => true)
+      proc {@environment.open("tmp/env")}.must_raise Rod::DatabaseError
+    end
+
+    it "should be in opened state after being opened" do
+      @environment.open("tmp/env", :create => true)
+      @environment.opened?.must_equal true
+    end
+
+    it "should not be in opened state after being closed" do
+      @environment.open("tmp/env", :create => true)
+      @environment.close
+      @environment.opened?.must_equal false
+    end
+  end
+
+  describe "an opened environment" do
+    before do
+      @environment = Rod::Berkeley::Environment.new
+      @environment.open("tmp/env", :create => true)
+    end
+
+    after do
+      @environment.close
+    end
+
+    it "should be in opened state" do
+      @environment.opened?.must_equal true
+    end
+
+    it "should allow to close it" do
+      proc {@environment.close}.must_be_silent
+    end
+  end
+end

data/spec/berkeley/sequence.rb

@@ -0,0 +1,101 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'rod'
+
+describe Rod::Berkeley::Sequence do
+  describe "a sequence" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_seq", :create => true, :cache => true)
+      database = Rod::Berkeley::Database.new(environment)
+      database.open("db1.db", :hash, :create => true, :truncate => true)
+      @sequence = Rod::Berkeley::Sequence.new(database)
+    end
+
+    after do
+      @sequence.close
+      @sequence.database.close
+      @sequence.database.environment.close
+    end
+
+    it "should allow to open itself with 'sequence' as the key" do
+      proc {@sequence.open("sequence", nil, :create => true)}.must_be_silent
+    end
+
+    it "should allow to close itself" do
+      @sequence.open("sequence", nil, :create => true)
+      proc {@sequence.close}.must_be_silent
+    end
+  end
+
+  describe "an opened sequence" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_seq", :create => true, :cache => true)
+      database = Rod::Berkeley::Database.new(environment)
+      database.open("db1.db", :hash, :create => true, :truncate => true)
+      @sequence = Rod::Berkeley::Sequence.new(database)
+      @sequence.open("sequence", nil, :create => true)
+    end
+
+    after do
+      @sequence.close
+      @sequence.database.close
+      @sequence.database.environment.close
+    end
+
+    it "should return 1 as its first value" do
+      @sequence.next.must_equal 1
+    end
+
+    it "should return 3 as the second value with delta set to 2" do
+      @sequence.next(nil,:delta => 2)
+      @sequence.next.must_equal 3
+    end
+  end
+
+  describe "an opened sequence with large cache" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_seq_txn", :create => true, :cache => true,
+                      :transactions => true, :logging => true, :locking => true)
+      database = Rod::Berkeley::Database.new(environment)
+      database.open("db1.db", :hash, :create => true, :auto_commit => true)
+      @sequence = Rod::Berkeley::Sequence.new(database)
+      @sequence.open("sequence", nil, :create => true, :cache_size => 1000)
+    end
+
+    after do
+      @sequence.close
+      @sequence.database.close
+      @sequence.database.environment.close
+    end
+
+    it "should retrive 100 000 values fast" do
+      100_000.times{ @sequence.next}
+    end
+  end
+
+  describe "an opened sequence with small cache" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_seq_txn", :create => true, :cache => true,
+                      :transactions => true, :logging => true, :locking => true)
+      database = Rod::Berkeley::Database.new(environment)
+      database.open("db1.db", :hash, :create => true, :auto_commit => true)
+      @sequence = Rod::Berkeley::Sequence.new(database)
+      @sequence.open("sequence", nil, :create => true)
+    end
+
+    after do
+      @sequence.close
+      @sequence.database.close
+      @sequence.database.environment.close
+    end
+
+    it "should retrive 100 000 values fast is syncing is disabled" do
+      100_000.times{ @sequence.next(nil, :no_sync => true)}
+    end
+  end
+
+end

data/spec/berkeley/transaction.rb

@@ -0,0 +1,92 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'rod'
+
+describe Rod::Berkeley::Transaction do
+  describe "a transaction" do
+    before do
+      environment = Rod::Berkeley::Environment.new
+      environment.open("tmp/env_txn", :create => true, :cache => true, :transactions => true,
+                      :logging => true, :locking => true)
+      @transaction = Rod::Berkeley::Transaction.new(environment)
+    end
+
+    after do
+      @transaction.finish
+      @transaction.environment.close
+    end
+
+    it "should not be in started state after creation" do
+      @transaction.started?.must_equal false
+    end
+
+    it "should not be in finished state after creation" do
+      @transaction.finished?.must_equal false
+    end
+
+    it "should allow to start itself" do
+      proc {@transaction.begin}.must_be_silent
+    end
+
+    it "should allow to start itself in no_sync mode" do
+      proc {@transaction.begin(:no_sync => true)}.must_be_silent
+    end
+
+    it "should allow to start itself in sync mode" do
+      proc {@transaction.begin(:sync => true)}.must_be_silent
+    end
+
+    it "should allow to start itself in write_no_sync mode" do
+      proc {@transaction.begin(:write_no_sync => true)}.must_be_silent
+    end
+
+    it "should be in started state after being started" do
+      @transaction.begin
+      @transaction.started?.must_equal true
+    end
+
+    it "should not be in finished state after being started" do
+      @transaction.begin
+      @transaction.finished?.must_equal false
+    end
+
+    it "should be in started state after being committed" do
+      @transaction.begin
+      @transaction.commit
+      @transaction.started?.must_equal true
+    end
+
+    it "should be in finished state after being committed" do
+      @transaction.begin
+      @transaction.commit
+      @transaction.finished?.must_equal true
+    end
+
+    it "should be in started state after being aborted" do
+      @transaction.begin
+      @transaction.abort
+      @transaction.started?.must_equal true
+    end
+
+    it "should be in finished state after being aborted" do
+      @transaction.begin
+      @transaction.abort
+      @transaction.finished?.must_equal true
+    end
+
+    it "should allow to reset itself before being started" do
+      proc {@transaction.reset}.must_be_silent
+    end
+
+    it "should allow to reset itself after being finished" do
+      @transaction.begin
+      @transaction.abort
+      proc {@transaction.reset}.must_be_silent
+    end
+
+    it "should not allow to reset itself before being finished" do
+      @transaction.begin
+      proc {@transaction.reset}.must_raise Rod::DatabaseError
+    end
+  end
+end