Bump version to 0.0.12.2

.gitignore

@@ -0,0 +1,5 @@
+pkg
+*.gem
+*.gemspec
+rdoc
+*.rbc

README.md

@@ -1,14 +1,14 @@
 Dependencies
 ============
 
-You need first the [Bdb](http://github.com/DenisKnauf/bdb) and of course [ruby](http://ruby-lang.org).
+You need first the [Bdb](http://github.com/ruby-bdb/bdb) and of course [ruby](http://ruby-lang.org).
 
 Download
 ========
 
 via git:
 
-	git clone git://github.com/DenisKnauf/sbdb.git
+	git clone git://github.com/ruby-bdb/sbdb
 
 Install
 =======
@@ -23,21 +23,22 @@ First, open environment and database
 
 	require 'sbdb'
 	Dir.mkdir 'newenv'  rescue Errno::EEXIST
-	env = SBDB::Env.new 'newenv', SBDB::CREATE
-	db = env.open SBDB::Btree, 'newdb.db', :flags => SBDB::CREATE
+	env = SBDB::Env.new 'newenv', SBDB::CREATE | SBDB::Env::INIT_TRANSACTION
+	db = env.btree 'newdb.db', :flags => SBDB::CREATE
 
 It works nearly like a Ruby-Hash:
 
 	db['key'] = 'value'
-	db['key']		# => 'value'
-	db.to_hash		# => {'key'=>'value'}
-	db.map {|k, v| [k, v].join ' => '}		# => ["key => value"]
-	db.count		# => 1
+	db['key']   # => 'value'
+	db.to_hash  # => {'key'=>'value'}
+	db.map {|k, v| "k => v" } # => ["key => value"]
+	db.count    # => 1
+	db.each {|k,v| puts "#{k}: #{v}" }
 
-SBDB::DB#each uses a SBDB::Cursor:
+`SBDB::DB#each` uses a `SBDB::Cursor`:
 
 	cursor = db.cursor
-	cursor.each {|k,v| puts "#{k}: ${v}" }
+	cursor.each {|k,v| puts "#{k}: #{v}" }
 
 **Don't forget to close everything, you've opened!**
 
@@ -47,10 +48,14 @@ SBDB::DB#each uses a SBDB::Cursor:
 
 But you can use a *lambda* to ensure to close everything:
 
-	SBDB::Env.new( 'newenv', SBDB::CREATE) do |env|
+	SBDB::Env.new( 'newenv', SBDB::CREATE | SBDB::Env::INIT_TRANSACTION) do |env|
 		env.open SBDB::Btree, 'newdb.db', :flags => SBDB::CREATE do |db|
 			db.to_hash
 		end
 	end
 
-SBDB::DB#to_hash creates a cursor and close it later.
+`SBDB::DB#to_hash` creates a cursor and close it later.
+
+Tip:
+
+	Signal.trap 'EXIT', env.method( :close)

Rakefile

@@ -1,4 +1,6 @@
 require 'rubygems'
+require 'rdoc/task'
+require 'rake/testtask'
 require 'rake'
 
 begin
@@ -8,18 +10,18 @@ begin
     gem.summary = %Q{Simple Ruby Berkeley DB}
     gem.description = %Q{Simple Ruby Berkeley DB wrapper library for bdb.}
     gem.email = "Denis.Knauf@gmail.com"
-    gem.homepage = "http://github.com/DenisKnauf/bdb"
+    gem.homepage = "http://github.com/ruby-bdb/sbdb"
     gem.authors = ["Denis Knauf"]
-    gem.files = ["README.md", "VERSION", "lib/**/*.rb", "test/**/*.rb"]
-    gem.require_paths = ["lib"]
-		gem.add_dependency 'dk-bdb'
+    gem.files = %w[AUTHORS README.md VERSION lib/**/*.rb test/**/*.rb]
+    gem.require_paths = %w[lib]
+		gem.add_dependency 'bdb', '>= 0.2.6.5'
+		gem.add_dependency 'ref'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test' << 'ext'
   test.pattern = 'test/**/*_test.rb'
@@ -43,7 +45,6 @@ task :test => :check_dependencies
 
 task :default => :test
 
-require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
   if File.exist?('VERSION')
     version = File.read('VERSION')

VERSION

@@ -1 +1 @@
-0.0.8
+0.0.12.2

lib/sbdb.rb

@@ -1,4 +1,5 @@
 require 'bdb'
+require 'ref'
 require 'sbdb/environment'
 require 'sbdb/db'
 require 'sbdb/cursor'
@@ -10,10 +11,16 @@ module SBDB
 	RDONLY      = Bdb::DB_RDONLY
 	READONLY    = RDONLY
 
-	def btree( *p)   Btree.new *p   end
-	def hash( *p)    Hash.new *p    end
-	def recno( *p)   Recno.new *p   end
-	def queue( *p)   Queue.new *p   end 
-	def unknown( *p) Unknown.new *p end
+	def btree( *ps)   Btree.new *ps   end
+	def hash( *ps)    Hash.new *ps    end
+	def recno( *ps)   Recno.new *ps   end
+	def queue( *ps)   Queue.new *ps   end 
+	def unknown( *ps) Unknown.new *ps end
 	alias open_db unknown
+
+	def self.raise_barrier *ps, &e
+		e.call *ps
+	rescue Object
+		$stderr.puts [$!.class,$!,$!.backtrace].inspect
+	end
 end

lib/sbdb/cursor.rb

@@ -10,21 +10,37 @@ module SBDB
 		attr_reader :db
 
 		include Enumerable
-		def bdb_object()  @cursor  end
-		def close()  @cursor.close  end
-		def get( k, v, f)  @cursor.get( k, v, f)  end
-		def count()  @cursor.count  end
-		def first( k = nil, v = nil)  get k, v, FIRST  end
-		def last(  k = nil, v = nil)  get k, v, LAST   end 
-		def next(  k = nil, v = nil)  get k, v, NEXT   end 
-		def prev(  k = nil, v = nil)  get k, v, PREV   end
+		def bdb_object
+			@cursor
+		end
+		def close
+			@cursor.close
+		end
+		def get key, val, flg
+			@cursor.get key, val, flg
+		end
+		def count
+			@cursor.count
+		end
+		def first key = nil, val = nil
+			get key, val, FIRST
+		end
+		def last key = nil, val = nil
+			get key, val, LAST
+		end 
+		def next key = nil, val = nil
+			get key, val, NEXT
+		end 
+		def prev key = nil, val = nil
+			get key, val, PREV
+		end
 
-		def self.new *p
-			x = super *p
-			return x  unless block_given?
-			begin yield x
-			ensure x.close
-			end
+		def self.new *ps
+			ret = obj = super( *ps)
+			begin ret = yield obj
+			ensure obj.close
+			end  if block_given?
+			ret
 		end
 
 		def initialize ref
@@ -33,25 +49,25 @@ module SBDB
 				when Bdb::Db::Cursor  then [ref]
 				else [ref.bdb_object.cursor( nil, 0), ref]
 				end
-			if [Recno, Queue].any? {|t| t === @db }
-				def get k, v, f
-					l, w = @cursor.get( k, v, f)
-					l.nil? ? nil : [l.unpack('I')[0], w]
+			if [Recno, Queue].any? {|dbt| dbt === @db }
+				def get *ps
+					key, val = @cursor.get( *ps)
+					key.nil? ? nil : [key.unpack('I')[0], val]
 				end
 			end
 		end
 
-		def reverse k = nil, v = nil, &e
-			each k, v, LAST, PREV, &e
+		def reverse key = nil, val = nil, &exe
+			each key, val, LAST, PREV, &exe
 		end
 
-		def each k = nil, v = nil, f = nil, n = nil
-			return Enumerator.new( self, :each, k, v, f, n)  unless block_given?
-			n ||= NEXT
-			e = get k, v, f || FIRST
-			return  unless e
-			yield *e
-			yield *e  while e = get( k, v, n)
+		def each key = nil, val = nil, flg = nil, nxt = nil
+			return Enumerator.new( self, :each, key, val, flg, nxt)  unless block_given?
+			nxt ||= NEXT
+			ent = get key, val, flg || FIRST
+			return  unless ent
+			yield *ent
+			yield *ent  while ent = get( key, val, nxt)
 			nil
 		end
 	end

lib/sbdb/db.rb

@@ -18,57 +18,63 @@ module SBDB
 		include Enumerable
 		def bdb_object()  @db  end
 		def sync()  @db.sync  end
-		def close( f = nil)  @db.close f || 0  end
-		def cursor( &e)  Cursor.new self, &e  end
+		def close( flg = nil)  @db.close flg || 0  end
+		def cursor( &exe)  Cursor.new self, &exe  end
 
-		def at k, txn = nil
-			@db.get _txn(txn), k.nil? ? nil : k.to_s, nil, 0
+		def at key, txn = nil
+			@db.get _txn(txn), key.nil? ? nil : key.to_s, nil, 0
 		rescue Bdb::KeyEmpty
 			return nil
 		end
 		alias [] at
 
-		def put k, v, txn = nil
-			if v.nil?
-				@db.del _txn(txn), k.to_s, 0
+		def put key, val, txn = nil
+			if val.nil?
+				@db.del _txn(txn), key.to_s, 0
 			else
-				@db.put _txn(txn), k.nil? ? nil : k.to_s, v.to_s, 0
+				@db.put _txn(txn), key.nil? ? nil : key.to_s, val.to_s, 0
 			end
 		end
-		
-		def []= k, v
-			put k, v
+
+		def []= key, val
+			put key, val
 		end
 
-		def delete k, txn = nil
-			@db.del _txn(txn), k.to_s
+		def delete key, txn = nil
+			@db.del _txn(txn), key.to_s
 		end
 		alias del delete
 
 		class << self
-			def new *p, &e
-				x = super *p
-				return x  unless e
-				begin e.call x
+			def new *ps, &exe
+				ret = obj = super( *ps)
+				begin ret = exe.call obj
 				ensure
-					begin x.sync
-					rescue Object
-						$stderr.puts [$!.class,$!,$!.backtrace].inspect
-					end
-					begin x.close
-					rescue Object
-						$stderr.puts [$!.class,$!,$!.backtrace].inspect
-					end
-				end
+					SBDB::raise_barrier &obj.method(:sync)
+					SBDB::raise_barrier &obj.method(:close)
+				end  if exe
+				ret
 			end
 			alias open new
 		end
 
-		def _txn t
-			t ||= @txn
-			t && t.bdb_object
+		def _txn txn
+			txn ||= @txn
+			txn && txn.bdb_object
 		end
 
+		def transaction flg = nil, &exe
+			block_given? ? home.transaction( flg, &exe) : home.transaction( flg)
+		end
+
+		# Arguments:
+		# * file
+		# * name
+		# * type
+		# * flags
+		# * mode
+		# * env
+		# or: **file**, **opts**. *opts* must be a *::Hash* with keys like above, excluded *file*.
 		def initialize file, *args
 			opts = ::Hash === args.last ? args.pop : {}
 			opts = {:name => args[0], :type => args[1], :flags => args[2], :mode => args[3], :env => args[4]}.update opts
@@ -76,27 +82,28 @@ module SBDB
 			@home, @db = opts[:env], opts[:env] ? opts[:env].bdb_object.db : Bdb::Db.new
 			opts[:type] = TYPES.index(self.class) || UNKNOWN
 			@db.re_len = opts[:re_len]  if opts[:re_len]
-			txn = opts[:txn]
+			@txn = nil
+			txn = opts[:txn]  # First is the global txn, second only for open.
 			begin
 				@db.open txn && txn.bdb_object, file, opts[:name], opts[:type], opts[:flags] || 0, opts[:mode] || 0
-			rescue Object
+			rescue Object => exc
 				close
-				raise $!
+				raise exc
 			end
 		end
 
-		def each k = nil, v = nil, &e
-			cursor{|c|c.each k, v, &e}
+		def each key = nil, val = nil, &exe
+			cursor {|c| c.each key, val, &exe }
 		end
 
-		def reverse k = nil, v = nil, &e
-			cursor{|c|c.reverse k, v, &e}
+		def reverse key = nil, val = nil, &exe
+			cursor {|c| c.reverse key, val, &exe }
 		end
 
-		def to_hash k = nil, v = nil
-			h = {}
-			each( k, v) {|k, v| h[ k] = v }
-			h
+		def to_hash key = nil, val = nil
+			ht = {}
+			each key, val, &ht.method( :[]=)
+			ht
 		end
 
 		def truncate txn = nil
@@ -105,9 +112,9 @@ module SBDB
 	end
 
 	class Unknown < DB
-		def self.new file, *p, &e
-			dbt = super( file, *p) {|db| db.bdb_object.get_type }
-			TYPES[dbt] ? TYPES[dbt].new( file, *p, &e) : super( file, *p, &e)
+		def self.new file, *ps, &exe
+			dbt = super( file, *ps) {|db| db.bdb_object.get_type }
+			TYPES[dbt] ? TYPES[dbt].new( file, *ps, &exe) : super( file, *ps, &exe)
 		end
 	end
 
@@ -119,38 +126,31 @@ module SBDB
 	end
 	TYPES[DB::HASH] = Hash
 
+	module Arrayisch
+		def [] key
+			super [key].pack('I')
+		end
+
+		def []= key, val
+			super [key].pack('I'), val
+		end
+
+		def push val, txn = nil
+			@db.put _txn(txn), "\0\0\0\0", val, Bdb::DB_APPEND
+		end
+	end
+
 	class Recno < DB
-		def [] k
-			super [k].pack('I')
-		end
-
-		def []= k, v
-			super [k].pack('I'), v
-		end
-
-		def push v, txn = nil
-			@db.put _txn(txn), "\0\0\0\0", v, Bdb::DB_APPEND
-		end
+		include Arrayisch
 	end
 	Array = Recno
 	TYPES[DB::RECNO] = Recno
 
 	class Queue < DB
-		def [] k
-			super [k].pack('I')
-		end
-
-		def []= k, v
-			super [k].pack('I'), v
-		end
-
+		include Arrayisch
 		def unshift txn = nil
 			@db.get _txn(txn), "\0\0\0\0", nil, Bdb::DB_CONSUME
 		end
-
-		def push v, txn = nil
-			@db.put _txn(txn), "\0\0\0\0", v, Bdb::DB_APPEND
-		end
 	end
 	TYPES[DB::QUEUE] = Queue
 end

lib/sbdb/environment.rb

@@ -1,5 +1,4 @@
 require 'bdb'
-require 'sbdb/weakhash'
 require 'sbdb/db'
 require 'sbdb/transaction'
 
@@ -27,28 +26,28 @@ module SBDB
 		# returns the Bdb-object.
 		def bdb_object()  @env  end
 		# Opens a Btree in this Environment
-		def btree file, *p, &e
-			open Btree, file, *p, &e
+		def btree file, *ps, &exe
+			open Btree, file, *ps, &exe
 		end 
 		# Opens a Hash in this Environment
-		def hash file, *p, &e
-			open Hash, file, *p, &e
+		def hash file, *ps, &exe
+			open Hash, file, *ps, &exe
 		end 
 		# Opens a Recno in this Environment
-		def recno file, *p, &e
-			open Recno, file, *p, &e
+		def recno file, *ps, &exe
+			open Recno, file, *ps, &exe
 		end 
 		# Opens a Queue in this Environment
-		def queue file, *p, &e
-			open Queue, file, *p, &e
+		def queue file, *ps, &exe
+			open Queue, file, *ps, &exe
 		end 
 		# Opens a DB of unknown type in this Environment
-		def unknown file, *p, &e
-			open Unknown, file, *p, &e
+		def unknown file, *ps, &exe
+			open Unknown, file, *ps, &exe
 		end 
 
-		def transaction flags = nil, &e
-			SBDB::Transaction.new self, flags, &e
+		def transaction flg = nil, &exe
+			SBDB::Transaction.new self, flg, &exe
 		end
 		alias txn transaction
 
@@ -61,7 +60,7 @@ module SBDB
 		def initialize *args
 			opts = ::Hash === args.last ? args.pop : {}
 			opts = {:dir => args[0], :flags => args[1], :mode => args[2]}.update opts
-			@dbs, @env = WeakHash.new, Bdb::Env.new( 0)
+			@dbs, @env = Ref::WeakValueMap.new, Bdb::Env.new( 0)
 			@env.log_config opts[:log_config], 1  if opts[:log_config]
 			@env.lg_bsize = opts[:lg_bsize]  if opts[:lg_bsize]
 			@env.lg_max = opts[:lg_max]  if opts[:lg_max]
@@ -73,21 +72,17 @@ module SBDB
 		end
 
 		def self.new *args
-			obj = r = super( *args)
-			begin r = yield obj
-			ensure
-				begin obj.close
-				rescue Object
-					$stderr.puts [$!.class,$!,$!.backtrace].inspect
-				end
+			obj = ret = super( *args)
+			begin ret = yield obj
+			ensure SBDB::raise_barrier &obj.method(:close)
 			end  if block_given?
-			r
+			ret
 		end
 
 		# Close the Environment.
 		# First you should close all databases!
 		def close
-			@dbs.each{|k, db|db.close}
+			@dbs.each{|key, db|db.close}
 			@env.close
 		end
 
@@ -97,10 +92,10 @@ module SBDB
 
 		# Opens a Database.
 		# see SBDB::DB, SBDB::Btree, SBDB::Hash, SBDB::Recno, SBDB::Queue
-		def open type, file, *p, &e
-			p.push ::Hash.new  unless ::Hash === p.last
-			p.last[:env] = self
-			(type || SBDB::Unkown).new file, *p, &e
+		def open type, file, *ps, &exe
+			ps.push ::Hash.new  unless ::Hash === ps.last
+			ps.last[:env] = self
+			(type || SBDB::Unkown).new file, *ps, &exe
 		end
 		alias db open
 		alias open_db open
@@ -109,13 +104,12 @@ module SBDB
 		# it returns the old instance.
 		# If you use this, never use close. It's possible somebody else use it too.
 		# The Databases, which are opened, will close, if the Environment will close.
-		def [] file, *p, &e
-			p.push ::Hash.new  unless ::Hash === p.last
-			p.last[:env] = self
-			name = String === p[0] ? p[0] : p.last[:name]
-			flags = Fixnum === p[1] ? p[1] : p.last[:flags]
-			type = Fixnum === p[2] ? p[2] : p.last[:type]
-			@dbs[ [file, name, flags | CREATE]] ||= (type || SBDB::Unknown).new file, *p, &e
+		def [] file, *ps, &exe
+			opts = ::Hash === ps.last ? ps.pop : {}
+			opts[:env] = self
+			name, type, flg = ps[0] || opts[:name], ps[1] || opts[:type], ps[2] || opts[:flags]
+			ps.push opts
+			@dbs[ [file, name, flg | CREATE]] ||= (type || SBDB::Unknown).new file, *ps, &exe
 		end
 	end
 	Env = Environment

lib/sbdb/weakhash.rb

@@ -1,61 +0,0 @@
-module SBDB
-
-# See http://eigenclass.org/hiki/deferred-finalizers-in-Ruby
-# Not threadsafe.
-
-class WeakHash
-	attr_reader :cache
-	def initialize cache = ::Hash.new
-		@cache = cache
-		@key_map = {}
-		@rev_cache = ::Hash.new{|h,k| h[k] = {}}
-		@reclaim_value = lambda do |value_id| 
-			if @rev_cache.has_key? value_id
-				@rev_cache[value_id].each_key{|key| @cache.delete key}
-				@rev_cache.delete value_id
-			end
-		end
-		@reclaim_key = lambda do |key_id|
-			@cache.delete @key_map.delete(key_id)  if @key_map.has_key? key_id
-		end
-	end
-
-	def []= key, value
-		case key
-		when Fixnum, Symbol, true, false
-			key2 = key
-		else
-			key2 = key.dup
-		end
-		@rev_cache[value.object_id][key2] = true
-		@cache[key2] = value.object_id
-		@key_map[key.object_id] = key2
-
-		ObjectSpace.define_finalizer(value, @reclaim_value)
-		ObjectSpace.define_finalizer(key, @reclaim_key)
-		value
-	end
-
-	def [] key
-		value_id = @cache[key]
-		return ObjectSpace._id2ref( value_id)  unless value_id.nil?
-		nil
-	rescue RangeError
-		nil
-	end
-
-	def each &e
-		@cache.each do |k, vid|
-			unless vid.nil?
-				obj = begin
-						ObjectSpace._id2ref vid
-					rescue RangeError
-						next
-					end
-				yield k, obj
-			end
-		end
-	end
-end
-
-end

sbdb.gemspec

@@ -1,48 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{sbdb}
-  s.version = "0.0.8"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Denis Knauf"]
-  s.date = %q{2010-03-11}
-  s.description = %q{Simple Ruby Berkeley DB wrapper library for bdb.}
-  s.email = %q{Denis.Knauf@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md"
-  ]
-  s.files = [
-    "README.md",
-     "VERSION",
-     "lib/sbdb.rb",
-     "lib/sbdb/cursor.rb",
-     "lib/sbdb/db.rb",
-     "lib/sbdb/environment.rb",
-     "lib/sbdb/transaction.rb",
-     "lib/sbdb/weakhash.rb"
-  ]
-  s.homepage = %q{http://github.com/DenisKnauf/bdb}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Simple Ruby Berkeley DB}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<dk-bdb>, [">= 0"])
-    else
-      s.add_dependency(%q<dk-bdb>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<dk-bdb>, [">= 0"])
-  end
-end
-