Bump version to 0.0.12.2

.gitignore

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

README

@@ -1,56 +0,0 @@
-= Dependencies
-
-== Bdb
-
-Your need first this library:
-
-http://github.com/DenisKnauf/bdb
-
-= Download
-
-via git:
-
-	git clone git://github.com/DenisKnauf/sbdb.git
-
-= Installation
-
-	gem build sbdb.gemspec
-	gem install sbdb-*.gem
-
-= Usage
-
-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', 'mynewdb', 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
-
-SBDB::DB#each uses a SBDB::Cursor:
-
-	cursor = db.cursor
-	cursor.each {|k,v| puts "#{k}: ${v}" }
-
-<strong>Don't forget to close everything, you've opened!</strong>
-
-	cursor.close
-	db.close
-	env.close
-
-But you can use a <em>lambda</em> to ensure to close everything:
-
-	SBDB::Env.new( 'newenv', SBDB::CREATE) do |env|
-		env.open SBDB::Btree, 'newdb.db', 'mynewdb', SBDB::CREATE do |db|
-			db.to_hash
-		end
-	end
-
-SBDB::DB#to_hash creates a cursor and close it later.

README.md

@@ -0,0 +1,61 @@
+Dependencies
+============
+
+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/ruby-bdb/sbdb
+
+Install
+=======
+
+	gem build sbdb.gemspec
+	gem install sbdb-*.gem
+
+Usage
+=====
+
+First, open environment and database
+
+	require 'sbdb'
+	Dir.mkdir 'newenv'  rescue Errno::EEXIST
+	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" } # => ["key => value"]
+	db.count    # => 1
+	db.each {|k,v| puts "#{k}: #{v}" }
+
+`SBDB::DB#each` uses a `SBDB::Cursor`:
+
+	cursor = db.cursor
+	cursor.each {|k,v| puts "#{k}: #{v}" }
+
+**Don't forget to close everything, you've opened!**
+
+	cursor.close
+	db.close
+	env.close
+
+But you can use a *lambda* to ensure to close everything:
+
+	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.
+
+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", "VERSION", "lib/**/*.rb", "test/**/*.rb"]
-    gem.require_paths = ["lib"]
-		gem.add_dependency '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.6
+0.0.12.2

lib/sbdb.rb

@@ -1,7 +1,9 @@
 require 'bdb'
+require 'ref'
 require 'sbdb/environment'
 require 'sbdb/db'
 require 'sbdb/cursor'
+require 'sbdb/transaction'
 
 module SBDB
 	CREATE      = Bdb::DB_CREATE
@@ -9,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

@@ -2,6 +2,7 @@ require 'bdb'
 require 'sbdb/cursor'
 
 module SBDB
+	TYPES = []
 	class DB
 		UNKNOWN = Bdb::Db::UNKNOWN
 		BTREE = Bdb::Db::BTREE
@@ -13,117 +14,143 @@ module SBDB
 		CONSUME_WAIT = Bdb::DB_CONSUME_WAIT
 
 		attr_reader :home
+		attr_accessor :txn
 		include Enumerable
 		def bdb_object()  @db  end
 		def sync()  @db.sync  end
-		def close( f = nil)  @db.close f || 0  end
-		def []( k)  @db.get nil, k.nil? ? nil : k.to_s, nil, 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 []= k, v
-			if v.nil?
-				@db.del nil, k.to_s, 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 key, val, txn = nil
+			if val.nil?
+				@db.del _txn(txn), key.to_s, 0
 			else
-				@db.put nil, 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 []= key, val
+			put key, val
+		end
+
+		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
-					x.sync
-					x.close
-				end
+					SBDB::raise_barrier &obj.method(:sync)
+					SBDB::raise_barrier &obj.method(:close)
+				end  if exe
+				ret
 			end
 			alias open new
 		end
 
-		def initialize file, name = nil, type = nil, flags = nil, mode = nil, txn = nil, env = nil
-			flags ||= 0
-			type ||= UNKNOWN
-			type = BTREE  if type == UNKNOWN and (flags & CREATE) == CREATE
-			@home, @db = env, env ? env.bdb_object.db : Bdb::Db.new
-			begin @db.open txn, file, name, type, flags, mode || 0
-			rescue 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
+			#type = BTREE  if type == UNKNOWN and (flags & CREATE) == CREATE
+			@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 = 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 => 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
+			@db.truncate _txn(txn)
 		end
 	end
 
 	class Unknown < DB
-		def self.new file, name, *p, &e
-			db = super file, name, UNKNOWN, *p[2..-1]
-			case db.bdb_object.get_type
-			when BTREE  then Btree.new file, name, *p
-			when HASH   then Hash.new  file, name *p
-			when RECNO  then Recno.new file, name, *p
-			when QUEUE  then Queue.new file, name, *p
-			else super file, name, UNKNOWN, *p, &e
-			end
-		ensure db.close
+		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
 
 	class Btree < DB
-		def self.new file, name = nil, *p, &e
-			super file, name, BTREE, *p, &e
-		end
 	end
+	TYPES[DB::BTREE] = Btree
 
 	class Hash < DB
-		def self.new file, name = nil, *p, &e
-			super file, name, HASH, *p, &e
+	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 self.new file, name = nil, *p, &e
-			super file, name, RECNO, *p, &e
-		end
-
-		def [] k
-			super [k].pack('I')
-		end
-
-		def []= k, v
-			super [k].pack('I'), v
-		end
+		include Arrayisch
 	end
 	Array = Recno
+	TYPES[DB::RECNO] = Recno
 
 	class Queue < DB
-		def self.new file, name = nil, *p, &e
-			super file, name, QUEUE, *p, &e
-		end
-
-		def [] k
-			super [k].pack('I')
-		end
-
-		def []= k, v
-			super [k].pack('I'), v
-		end
-
-		def unshift
-			get nil, nil, nil, Bdb::DB_CONSUME
+		include Arrayisch
+		def unshift txn = nil
+			@db.get _txn(txn), "\0\0\0\0", nil, Bdb::DB_CONSUME
 		end
 	end
+	TYPES[DB::QUEUE] = Queue
 end

lib/sbdb/environment.rb

@@ -1,6 +1,6 @@
 require 'bdb'
-require 'sbdb/weakhash'
 require 'sbdb/db'
+require 'sbdb/transaction'
 
 module SBDB
 	# Environments are for storing one or more databases and are important
@@ -17,50 +17,72 @@ module SBDB
 		PRIVATE    = Bdb::DB_PRIVATE
 		SYSTEM_MEM = Bdb::DB_SYSTEM_MEM
 		TXN_NOSYNC = Bdb::DB_TXN_NOSYNC
+		LOG_DIRECT = Bdb::DB_LOG_DIRECT
+		LOG_DSYNC  = Bdb::DB_LOG_DSYNC
+		LOG_AUTO_REMOVE = Bdb::DB_LOG_AUTO_REMOVE
+		LOG_IN_MEMORY = Bdb::DB_LOG_IN_MEMORY
+		LOG_ZERO   = Bdb::DB_LOG_ZERO
 
 		# returns the Bdb-object.
 		def bdb_object()  @env  end
 		# Opens a Btree in this Environment
-		def btree file, name = nil, flags = nil, mode = nil, txn = nil, &e
-			Btree.new file, name, flags, mode, txn, self, &e
+		def btree file, *ps, &exe
+			open Btree, file, *ps, &exe
 		end 
 		# Opens a Hash in this Environment
-		def hash file, name = nil, flags = nil, mode = nil, txn = nil, &e
-			Hash.new file, name, flags, mode, txn, self, &e
+		def hash file, *ps, &exe
+			open Hash, file, *ps, &exe
 		end 
 		# Opens a Recno in this Environment
-		def recno file, name = nil, flags = nil, mode = nil, txn = nil, &e
-			Recno.new file, name, flags, mode, txn, self, &e
+		def recno file, *ps, &exe
+			open Recno, file, *ps, &exe
 		end 
 		# Opens a Queue in this Environment
-		def queue file, name = nil, flags = nil, mode = nil, txn = nil, &e
-			Queue.new file, name, flags, mode, txn, self, &e
+		def queue file, *ps, &exe
+			open Queue, file, *ps, &exe
 		end 
 		# Opens a DB of unknown type in this Environment
-		def unknown file, name = nil, flags = nil, mode = nil, txn = nil, &e
-			Unknown.new file, name, flags, mode, txn, self, &e
+		def unknown file, *ps, &exe
+			open Unknown, file, *ps, &exe
 		end 
 
-		def initialize dir = nil, flags = nil, mode = nil
-			@dbs, @env = WeakHash.new, Bdb::Env.new( 0)
-			begin @env.open dir || '.', flags || INIT_TRANSACTION | CREATE, mode || 0
+		def transaction flg = nil, &exe
+			SBDB::Transaction.new self, flg, &exe
+		end
+		alias txn transaction
+
+		# args:
+		#   args[0] => dir
+		#   args[1] => flags
+		#   args[3] => mode
+		# possible options (via Hash):
+		#	  :dir, :flags, :mode, :log_config
+		def initialize *args
+			opts = ::Hash === args.last ? args.pop : {}
+			opts = {:dir => args[0], :flags => args[1], :mode => args[2]}.update opts
+			@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]
+			begin @env.open opts[:dir]||'.', opts[:flags]|| INIT_TRANSACTION|CREATE, opts[:mode]||0
 			rescue Object
 				close
 				raise
 			end
+		end
 
-			return self  unless block_given?
-
-			begin yield self
-			ensure close
-			end
-			nil
+		def self.new *args
+			obj = ret = super( *args)
+			begin ret = yield obj
+			ensure SBDB::raise_barrier &obj.method(:close)
+			end  if block_given?
+			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
 
@@ -70,8 +92,10 @@ module SBDB
 
 		# Opens a Database.
 		# see SBDB::DB, SBDB::Btree, SBDB::Hash, SBDB::Recno, SBDB::Queue
-		def open type, file, name = nil, flags = nil, mode = nil, txn = nil, &e
-			(type || SBDB::Unkown).new file, name, flags, mode, txn, self, &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
@@ -80,8 +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, name = nil, type = nil, flags = nil, mode = nil, &e
-			@dbs[ [file, name, flags | CREATE]] ||= (type || SBDB::Unkown).new file, name, flags, mode, nil, self, &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/transaction.rb

@@ -0,0 +1,42 @@
+require 'sbdb'
+require 'bdb'
+
+module SBDB
+	class Transaction
+		NOSYNC = Bdb::DB_TXN_NOSYNC
+		SYNC = Bdb::DB_TXN_SYNC
+		NOWAIT = Bdb::DB_TXN_NOWAIT
+		WRITE_NOSYNC = Bdb::DB_TXN_WRITE_NOSYNC
+		SNAPSHOT = Bdb::DB_TXN_SNAPSHOT
+		READ_COMMITED = Bdb::DB_READ_COMMITTED
+		READ_UNCOMMITED = Bdb::DB_READ_UNCOMMITTED
+
+		def bdb_object()  @txn  end
+
+		def self.new *p, &e
+			r = obj = super( *p)
+			begin
+				r = e.call obj
+			rescue Object
+				obj.abort
+				raise $!
+			ensure
+				obj.commit
+			end  if e
+			r
+		end
+
+		def initialize env, flags = nil, parent = nil
+			@txn = env.bdb_object.txn_begin parent, flags || 0
+		end
+
+		def commit flags = nil
+			@txn.commit flags || 0
+		end
+
+		def abort
+			@txn.abort
+		end
+	end
+	TXN = Transaction
+end

lib/sbdb/weakhash.rb

@@ -1,63 +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|
-			if @key_map.has_key? key_id
-				@cache.delete @key_map[key_id]
-			end
-		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,47 +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.6"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Denis Knauf"]
-  s.date = %q{2010-02-05}
-  s.description = %q{Simple Ruby Berkeley DB wrapper library for bdb.}
-  s.email = %q{Denis.Knauf@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README"
-  ]
-  s.files = [
-    "README",
-     "VERSION",
-     "lib/sbdb.rb",
-     "lib/sbdb/cursor.rb",
-     "lib/sbdb/db.rb",
-     "lib/sbdb/environment.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.5}
-  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<bdb>, [">= 0"])
-    else
-      s.add_dependency(%q<bdb>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<bdb>, [">= 0"])
-  end
-end
-