odba 1.1.8 → 1.2.0

data/lib/odba/stub.rb

@@ -1,190 +1,203 @@
 #!/usr/bin/env ruby
 #-- Stub -- odba -- 29.04.2004 -- hwyss@ywesee.com rwaltert@ywesee.com mwalder@ywesee.com
 
-require 'yaml'
-require 'odba/odba_error'
+require "yaml"
+require "odba/odba_error"
 
 module ODBA
-	class Stub # :nodoc: all
-		attr_accessor :odba_id, :odba_container
-		def initialize(odba_id, odba_container, receiver)
-			@odba_id = odba_id
-			@odba_container = odba_container
-			@odba_class = receiver.class unless receiver.nil?
+  class Stub # :nodoc: all
+    attr_accessor :odba_id, :odba_container
+    def initialize(odba_id, odba_container, receiver)
+      @odba_id = odba_id
+      @odba_container = odba_container
+      @odba_class = receiver.class unless receiver.nil?
       @receiver_loaded = true
-		end
-		def class
-			@odba_class ||= odba_instance.class
-		end
-		def eql?(other)
-			@odba_id == other.odba_id || odba_instance.eql?(other)
-		end
-		def inspect
-			"#<ODBA::Stub:#{object_id}##@odba_id @odba_class=#@odba_class @odba_container=#{@odba_container.object_id}##{@odba_container.odba_id}>"
-		end
-		def is_a?(klass)
+    end
+
+    def class
+      @odba_class ||= odba_instance.class
+    end
+
+    def eql?(other)
+      @odba_id == other.odba_id || odba_instance.eql?(other)
+    end
+
+    def inspect
+      "#<ODBA::Stub:#{object_id}##{@odba_id} @odba_class=#{@odba_class} @odba_container=#{@odba_container.object_id}##{@odba_container.odba_id}>"
+    end
+
+    def is_a?(klass)
       klass == Stub || klass == Persistable || klass == @odba_class \
-				|| odba_instance.is_a?(klass)
-		end
-		def odba_clear_receiver
-			@receiver = nil
+        || odba_instance.is_a?(klass)
+    end
+
+    def odba_clear_receiver
+      @receiver = nil
       @receiver_loaded = nil
-		end
+    end
+
     def odba_dup
       odba_isolated_stub
     end
-		def odba_isolated_stub
-			Stub.new(@odba_id, nil, nil)
-		end
+
+    def odba_isolated_stub
+      Stub.new(@odba_id, nil, nil)
+    end
+
     def odba_prefetch?
       false
     end
-		def odba_receiver(name=nil)
-      if(@receiver && !@receiver_loaded)
+
+    def odba_receiver(name = nil)
+      if @receiver && !@receiver_loaded
         warn "stub for #{@receiver.class}:#{@odba_id} was saved with receiver"
         @receiver = nil
       end
-			@receiver || begin
-      #begin
-				@receiver = ODBA.cache.fetch(@odba_id, @odba_container)
+      @receiver || begin
+        # begin
+        @receiver = ODBA.cache.fetch(@odba_id, @odba_container)
         @receiver_loaded = true
-				if(@odba_container)
-					@odba_container.odba_replace_stubs(@odba_id, @receiver)
+        if @odba_container
+          @odba_container.odba_replace_stubs(@odba_id, @receiver)
         else
           warn "Potential Memory-Leak: stub for #{@receiver.class}##{@odba_id} was saved without container"
-				end
-				@receiver
-			rescue OdbaError => e
-				puts "OdbaError"
-				puts caller[0..10].join("\n")
-				warn "ODBA::Stub was unable to replace #{@odba_class}##{@odba_id} from #{@odba_container.class}:##{@odba_container.odba_id}. raise OdbaError"
+        end
+        @receiver
+      rescue OdbaError
+        puts "OdbaError"
+        puts caller[0..10].join("\n")
+        warn "ODBA::Stub was unable to replace #{@odba_class}##{@odba_id} from #{@odba_container.class}:##{@odba_container.odba_id}. raise OdbaError"
         raise OdbaError
-			end
-		end
-  alias :odba_instance :odba_receiver
-		# A stub always references a Persistable that has
-		# already been saved.
-		def odba_unsaved?(snapshot_level=nil)
-			false
-		end
-		def to_yaml_properties
-			['@odba_id', '@odba_container']
-		end
-		def to_yaml_type
-			"!ruby/object:ODBA::Stub"
-		end
-		def yaml_initialize(tag, val)
-      if RUBY_VERSION >= '1.9'
-        val.each { |key, value| instance_variable_set(:"@#{key}", value) }
-      else
-        val.each { |key, value| instance_variable_set("@#{key}", value) }
       end
-		end
-		no_override = [
-			"class", "is_a?", "__id__", "__send__", "inspect",
-			"eql?", "nil?", "respond_to?", "object_id",
-			"instance_variables", "instance_variable_get",
-			"instance_variable_set", "==",
-			## methods defined in persistable.rb:Object
-			"odba_id", "odba_instance", "odba_isolated_stub", "odba_prefetch?",
-			## yaml-methods
-			"to_yaml", "taguri", "to_yaml_style", "to_yaml_type",
-			"to_yaml_properties", "yaml_initialize",
-		]
-		NO_OVERRIDE = no_override.collect { |name| name.to_sym }
-    if RUBY_VERSION >= '1.9'
-      no_override = NO_OVERRIDE
-    end
-		override_methods = Object.public_methods - no_override
-		override_methods.each { |method|
-			src = (method[-1] == ?=) ? <<-EOW : <<-EOS
+    end
+    alias_method :odba_instance, :odba_receiver
+    # A stub always references a Persistable that has
+    # already been saved.
+    def odba_unsaved?(snapshot_level = nil)
+      false
+    end
+
+    def to_yaml_properties
+      ["@odba_id", "@odba_container"]
+    end
+
+    def to_yaml_type
+      "!ruby/object:ODBA::Stub"
+    end
+
+    def yaml_initialize(tag, val)
+      val.each { |key, value| instance_variable_set(:"@#{key}", value) }
+    end
+    no_override = [
+      "class", "is_a?", "__id__", "__send__", "inspect",
+      "eql?", "nil?", "respond_to?", "object_id",
+      "instance_variables", "instance_variable_get",
+      "instance_variable_set", "==",
+      ## methods defined in persistable.rb:Object
+      "odba_id", "odba_instance", "odba_isolated_stub", "odba_prefetch?",
+      ## yaml-methods
+      "to_yaml", "taguri", "to_yaml_style", "to_yaml_type",
+      "to_yaml_properties", "yaml_initialize"
+    ]
+    NO_OVERRIDE = no_override.collect { |name| name.to_sym }
+    no_override = NO_OVERRIDE
+    override_methods = Object.public_methods - no_override
+    override_methods.each { |method|
+      src = (method[-1] == "=") ? <<-EOW : <<-EOS
 				def #{method}(args)
 					odba_instance.#{method}(args)
 				end
-			EOW
+      EOW
 				def #{method}(*args)
 					odba_instance.#{method}(*args)
 				end
-			EOS
-			eval src
-		}
-		def method_missing(meth_symbol, *args, &block)
-			if(NO_OVERRIDE.include?(meth_symbol))
-				super
-			else
-				odba_instance.send(meth_symbol, *args, &block)
-			end
-		end
-		def respond_to?(msg_id, *args)
-			case msg_id
-			when :_dump, :marshal_dump
-				false
-			when *NO_OVERRIDE
-				super
-			else
-				odba_instance.respond_to?(msg_id, *args)
-			end
-		end
-		## FIXME
-		#  implement full hash/array access - separate collection stub?
-		def [](*args, &block)
-			if(@odba_class == Hash \
-				&& !ODBA.cache.include?(@odba_id))
-				ODBA.cache.fetch_collection_element(@odba_id, args.first)
-			end || method_missing(:[], *args, &block)
-		end
+      EOS
+      eval src
+    }
+    def method_missing(meth_symbol, *args, &block)
+      if NO_OVERRIDE.include?(meth_symbol)
+        super
+      else
+        odba_instance.send(meth_symbol, *args, &block)
+      end
+    end
+
+    def respond_to?(msg_id, *args)
+      case msg_id
+      when :_dump, :marshal_dump
+        false
+      when *NO_OVERRIDE
+        super
+      else
+        odba_instance.respond_to?(msg_id, *args)
+      end
+    end
+
+    ## FIXME
+    #  implement full hash/array access - separate collection stub?
+    def [](*args, &block)
+      if @odba_class == Hash \
+        && !ODBA.cache.include?(@odba_id)
+        ODBA.cache.fetch_collection_element(@odba_id, args.first)
+      end || method_missing(:[], *args, &block)
+    end
+
     def ==(other)
       @odba_id == other.odba_id || odba_instance == other
     end
-	end
+  end
 end
 
 class Array # :nodoc: all
-	alias :_odba_amp :&
-	def &(stub)
-		self._odba_amp(stub.odba_instance)
-	end
-	alias :_odba_plus :+
-	def +(stub)
-		self._odba_plus(stub.odba_instance)
-	end
-	alias :_odba_minus :-
-	def -(stub)
-		self._odba_minus(stub.odba_instance)
-	end
-	alias :_odba_weight :<=>
-	def <=>(stub)
-		self._odba_weight(stub.odba_instance)
-	end
-	alias :_odba_equal? :==
-	def ==(stub)
-		self._odba_equal?(stub.odba_instance)
-	end
-	alias :_odba_union :|
-	def |(stub)
-		self._odba_union(stub.odba_instance)
-	end
-	['concat', 'replace', 'include?'].each { |method|
-	#['concat', 'replace'].each { |method|
-		eval <<-EOS
-			alias :_odba_#{method} :#{method}
-			def #{method}(stub)
-				self._odba_#{method}(stub.odba_instance)
-			end
-		EOS
-	}
+  alias_method :_odba_amp, :&
+  def &(other)
+    _odba_amp(other.odba_instance)
+  end
+  alias_method :_odba_plus, :+
+  def +(other)
+    _odba_plus(other.odba_instance)
+  end
+  alias_method :_odba_minus, :-
+  def -(other)
+    _odba_minus(other.odba_instance)
+  end
+  alias_method :_odba_weight, :<=>
+  def <=>(other)
+    _odba_weight(other.odba_instance)
+  end
+  alias_method :_odba_equal?, :==
+  def ==(other)
+    _odba_equal?(other.odba_instance)
+  end
+  alias_method :_odba_union, :|
+  def |(other)
+    _odba_union(other.odba_instance)
+  end
+  # Workaround to avoid the following problem
+  # Formatter SimpleCov::Formatter::HTMLFormatter failed with ArgumentError: wrong number of arguments (given 2, expected 1
+  more_methods = ["replace", "include?"]
+  more_methods << "concat" unless defined?(SimpleCov)
+  more_methods.each do |method|
+    eval %(
+      alias :_odba_#{method} :#{method}
+      def #{method}(stub)
+          self._odba_#{method}(stub.odba_instance)
+      end
+    )
+  end
 end
+
 class Hash # :nodoc: all
-	alias :_odba_equal? :==
-	def ==(stub)
-		self._odba_equal?(stub.odba_instance)
-	end
-	['merge', 'merge!', 'replace'].each { |method|
-		eval <<-EOS
-			alias :_odba_#{method} :#{method}
-			def #{method}(stub)
-				self._odba_#{method}(stub.odba_instance)
-			end
-		EOS
-	}
+  alias_method :_odba_equal?, :==
+  def ==(other)
+    _odba_equal?(other.odba_instance)
+  end
+  ["merge", "merge!", "replace"].each { |method|
+    eval %(
+      alias :_odba_#{method} :#{method}
+      def #{method}(stub)
+          self._odba_#{method}(stub.odba_instance)
+      end
+    )
+  }
 end

data/lib/odba/version.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
 class Odba
-    VERSION = '1.1.8'
+  VERSION = '1.2.0'
 end

data/lib/odba.rb

@@ -1,11 +1,11 @@
 #!/usr/bin/env ruby
 
-require 'odba/persistable'
-require 'odba/storage'
-require 'odba/cache'
-require 'odba/stub'
-require 'odba/marshal'
-require 'odba/cache_entry'
-require 'odba/odba_error'
-require 'odba/index'
-require 'odba/odba'
+require "odba/persistable"
+require "odba/storage"
+require "odba/cache"
+require "odba/stub"
+require "odba/marshal"
+require "odba/cache_entry"
+require "odba/odba_error"
+require "odba/index"
+require "odba/odba"

data/odba.gemspec

@@ -9,19 +9,24 @@ Gem::Specification.new do |spec|
   spec.description = "Object Database Access"
   spec.summary     = "Ruby Software for ODDB.org Memory Management"
   spec.homepage    = "https://github.com/zdavatz/odba"
+  spec.metadata["changelog_uri"] = spec.homepage + "/blob/master/History.md"
   spec.license       = "GPL-v2"
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 3.2"
 
+  spec.add_dependency 'observer'
+  spec.add_dependency 'drb'
+  spec.add_dependency 'stringio'
   spec.add_development_dependency 'ydbi',   '>=0.5.7'
   spec.add_development_dependency 'ydbd-pg','>=0.5.7'
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "flexmock"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "flexmock", "2.4.0" # Version 3.0.1 leads to many errors. Do not know why?
   spec.add_development_dependency "test-unit"
-  spec.add_development_dependency "debug_inspector"
+  spec.add_development_dependency "debug"
+  spec.add_development_dependency "simplecov"
 end

data/test/example.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+$: << File.dirname(__FILE__)
+$: << File.expand_path("../lib/", File.dirname(__FILE__))
+require "odba"
+require "odba/connection_pool"
+
+class User
+  attr_accessor :first_name, :last_name
+  include ODBA::Persistable
+  def initialize(first_name, last_name)
+    @first_name = first_name
+    @last_name = last_name
+  end
+
+  def to_s
+    "#{@first_name} #{@last_name}"
+  end
+end
+
+class Example
+  def self.db_setup
+    # connect default storage manager to a relational database  on
+    # our localhost using port 5435 with a user odba_test and an empty password
+    ODBA.storage.dbi = ODBA::ConnectionPool.new("DBI:Pg:dbname=odba_test;host=127.0.0.1;port=5432", "odba_test", "")
+    ODBA.cache.setup
+  end
+
+  def self.show_last_added_user
+    res = ODBA.storage.dbi.select_all("Select count(*) from object;").first.first
+    odba_id = ODBA.storage.dbi.select_one("select odba_id from object order by odba_id desc limit 1;")
+    puts "show_last_added_user: We have  #{res} objects. Highest odba_id is #{odba_id}"
+    first = ODBA.storage.dbi.select_one("select odba_id, name, prefetchable, extent, content from object order by odba_id desc limit 1;")
+    puts "  DB-content is #{first}"
+    puts "  Fetched object for odba_id #{odba_id} is #{ODBA.cache.fetch(odba_id.first)}"
+  end
+end
+
+Example.db_setup
+composer = User.new("Ludwig", "Van Beethoven")
+composer.odba_store
+Example.show_last_added_user
+painter = User.new("Vincent", "Van Gogh")
+painter.odba_store
+scientist = User.new("Albert", "Einstein")
+scientist.odba_store
+Example.show_last_added_user
+

data/test/helper.rb

@@ -0,0 +1,6 @@
+$: << File.dirname(__FILE__)
+$: << File.expand_path("../lib/", File.dirname(__FILE__))
+require "test/unit"
+require "flexmock/test_unit"
+require 'simplecov'
+SimpleCov.start 'test_frameworks'

data/test/suite.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# TestSuite -- yus -- 02.06.2006 -- rwaltert@ywesee.com
+require_relative "helper"
+
+Dir.foreach(File.dirname(__FILE__)) { |file|
+  require file if /^test_.*\.rb$/o.match?(file)
+}

data/test/test_array.rb

@@ -1,48 +1,46 @@
 #!/usr/bin/env ruby
 # TestArray -- odba -- 30.01.2007 -- hwyss@ywesee.com
-
-$: << File.dirname(__FILE__)
-$: << File.expand_path('../lib', File.dirname(__FILE__))
-
-require 'minitest/autorun'
-require 'flexmock/test_unit'
-require 'flexmock'
-require 'odba/persistable'
-require 'odba/stub'
-require 'odba/odba'
+require_relative "helper"
+require "odba/persistable"
+require "odba/stub"
+require "odba/odba"
 
 module ODBA
-  class TestArray < Minitest::Test
-    include FlexMock::TestCase
+  class TestArray < Test::Unit::TestCase
     class ODBAContainerInArrayInArray
-     include ODBA::Persistable
-     attr_accessor	:non_replaceable, :replaceable, :array, :odba_id
+      include ODBA::Persistable
+      attr_accessor	:non_replaceable, :replaceable, :array, :odba_id
     end
+
     class ContainerInArray
       attr_accessor :content
     end
+
     def setup
-      @array = Array.new
+      @array = []
       ODBA.storage = flexmock("storage")
       ODBA.marshaller = flexmock("marshaller_array")
       ODBA.cache = flexmock("cache")
     end
+
     def teardown
       ODBA.storage = nil
       ODBA.marshaller = nil
       ODBA.cache = nil
-      load = File.expand_path(File.join(File.dirname(__FILE__), '../lib/odba/storage.rb'))
+      File.expand_path(File.join(File.dirname(__FILE__), "../lib/odba/storage.rb"))
       super
     end
+
     def test_odba_cut_connection
       remove_obj = Object
       remove_obj.extend(ODBA::Persistable)
-      remove_obj.instance_variable_set('@odba_id', 2)
-      receiver = ODBA::Stub.new(2,self, remove_obj)
-      array = Array.new
+      remove_obj.instance_variable_set(:@odba_id, 2)
+      receiver = ODBA::Stub.new(2, self, remove_obj)
+      array = []
       array.push(receiver)
       assert_equal(0, array.odba_cut_connection(remove_obj).size)
     end
+
     def test_odba_unsaved_neighbors_array
       rep1 = ODBAContainerInArrayInArray.new
       rep2 = ODBAContainerInArrayInArray.new
@@ -51,47 +49,53 @@ module ODBA
       result = @array.odba_unsaved_neighbors(1)
       assert_equal([rep1, rep2], result)
     end
+
     def test_array_replacement
-      replacement = flexmock('replacement')
-      replacement2 = flexmock('replacement2')
-      stub = flexmock('stub')
-      stub2 = flexmock('stub2')
-      foo = flexmock("foo")
+      replacement = flexmock("replacement")
+      replacement2 = flexmock("replacement2")
+      stub = flexmock("stub")
+      stub2 = flexmock("stub2")
+      flexmock("foo")
       @array.push(stub)
       @array.push(stub2)
-      @array.odba_restore([[0,replacement], [1,replacement2]])
+      @array.odba_restore([[0, replacement], [1, replacement2]])
       assert_equal(replacement, @array[0])
       assert_equal(replacement2, @array[1])
     end
+
     def test_odba_replace_persistables_array
       replaceable = flexmock("replaceable")
       replaceable2 = flexmock("replaceable2")
       @array.push(replaceable)
       @array.push(replaceable2)
       @array.odba_replace_persistables
-      #size is 0 because we store empty array in the db
+      # size is 0 because we store empty array in the db
       # content of the array is in the collection table
       assert_equal(0, @array.size)
     end
+
     def test_odba_unsaved_array_true
       val = flexmock("val")
-      @array.instance_variable_set("@odba_persistent", true)
+      @array.instance_variable_set(:@odba_persistent, true)
       @array.push(val)
       val.should_receive(:is_a?).and_return { |klass| true }
       val.should_receive(:odba_unsaved?).and_return { true }
       assert_equal(true, @array.odba_unsaved?)
     end
+
     def test_odba_collection
-      @array.push('foo', 'bar')
-      assert_equal([[0,'foo'], [1, 'bar']], @array.odba_collection)
+      @array.push("foo", "bar")
+      assert_equal([[0, "foo"], [1, "bar"]], @array.odba_collection)
     end
+
     def test_odba_replace
-      modified = ['foo']
+      modified = ["foo"]
       reloaded = modified.dup
-      modified.push('bar')
+      modified.push("bar")
       modified.odba_replace!(reloaded)
       assert_equal(reloaded, modified)
     end
+
     def test_odba_target_ids
       o = ODBAContainerInArrayInArray.new
       o.odba_id = 1
@@ -100,9 +104,10 @@ module ODBA
       q = ODBAContainerInArrayInArray.new
       q.odba_id = 3
       @array.push(p, q)
-      @array.instance_variable_set('@foo', o)
-      assert_equal([1,2,3], @array.odba_target_ids)
+      @array.instance_variable_set(:@foo, o)
+      assert_equal([1, 2, 3], @array.odba_target_ids)
     end
+
     def test_stubize
       item = ODBAContainerInArrayInArray.new
       @array.push(item)