Bump version to 0.0.12.2

.gitignore

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

README

@@ -1,66 +0,0 @@
-Bdb
-===
-
-Your need first this library:
-
-http://github.com/DenisKnauf/bdb
-
-Download
-========
-
-via git:
-
-	git clone git://github.com/DenisKnauf/sbdb.git
-
-Installation
-============
-
-	gem install sbdb-*.gem
-
-or: 
-
-	gem install sbdb --source http://github.com/DenisKnauf/sbdb/raw/master/sbdb-0.0.5.gem
-
-Documentation
-=============
-
-Doesn't exist yet.
-
-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}" }
-
-Don't forget to close everything, you opened!
-
-	cursor.close
-	db.close
-	env.close
-
-But you can use a *lambda* 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.5
+0.0.12.2

lib/sbdb.rb

@@ -1,246 +1,26 @@
 require 'bdb'
+require 'ref'
+require 'sbdb/environment'
+require 'sbdb/db'
+require 'sbdb/cursor'
+require 'sbdb/transaction'
 
 module SBDB
-	CREATE = Bdb::DB_CREATE
+	CREATE      = Bdb::DB_CREATE
 	AUTO_COMMIT = Bdb::DB_AUTO_COMMIT
-	INIT_TXN = Bdb::DB_INIT_TXN
-	INIT_LOCK = Bdb::DB_INIT_LOCK
-	INIT_LOG = Bdb::DB_INIT_LOG
-	INIT_MPOOL = Bdb::DB_INIT_MPOOL
+	RDONLY      = Bdb::DB_RDONLY
+	READONLY    = RDONLY
 
-	class Environment
-		def bdb_object
-			@env
-		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 initialize dir, flags = nil, mode = nil
-			flags ||= INIT_TXN | INIT_LOCK | INIT_LOG | INIT_MPOOL | CREATE
-			mode ||= 0
-			@env = Bdb::Env.new 0
-			begin @env.open dir, flags, mode
-			rescue Object
-				close
-				raise
-			end
-
-			return self  unless block_given?
-
-			begin yield self
-			ensure close
-			end
-			nil
-		end
-
-		def close
-			@env.close
-		end
-
-		class << self
-			alias open new
-		end
-
-		def open type, *p, &e
-			p[5] = self
-			type.new *p, &e
-		end
-		alias db open
-		alias open_db open
-	end
-	Env = Environment
-
-	class DB
-		UNKNOWN = Bdb::Db::UNKNOWN
-		BTREE = Bdb::Db::BTREE
-		HASH = Bdb::Db::HASH
-		QUEUE = Bdb::Db::QUEUE
-		ARRAY = RECNO = Bdb::Db::RECNO
-
-		attr_reader :home
-
-		include Enumerable
-		def bdb_object
-			@db
-		end
-
-		class << self
-			def new *p, &e
-				x = super *p
-				return x  unless e
-				begin e.call x
-				ensure
-					x.sync
-					x.close
-				end
-			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
-			mode ||= 0
-			@home = env
-			@db = env ? env.bdb_object.db : Bdb::Db.new
-			begin @db.open txn, file, name, type, flags, mode
-			rescue Object
-				close
-				raise $!
-			end
-		end
-
-		def sync
-			@db.sync
-		end
-
-		def close f = nil
-			@db.close f || 0
-		end
-
-		def [] k
-			@db.get nil, k, nil, 0
-		end
-
-		def []= k, v
-			@db.put nil, k, v, 0
-		end
-
-		def cursor &e
-			Cursor.new self, &e
-		end
-
-		def each k = nil, v = nil, &e
-			cursor{|c|c.each k, v, &e}
-		end
-
-		def reverse k = nil, v = nil, &e
-			cursor{|c|c.reverse k, v, &e}
-		end
-
-		def to_hash k = nil, v = nil
-			h = {}
-			each( k, v) {|k, v| h[ k] = v }
-			h
-		end
-	end
-
-	class Cursor
-		NEXT = Bdb::DB_NEXT
-		FIRST = Bdb::DB_FIRST
-		LAST = Bdb::DB_LAST
-		PREV = Bdb::DB_PREV
-		SET = Bdb::DB_SET
-
-		attr_reader :db
-
-		include Enumerable
-		def bdb_object
-			@cursor
-		end
-
-		def self.new *p
-			x = super *p
-			return x  unless block_given?
-			begin yield x
-			ensure x.close
-			end
-		end
-
-		def initialize ref
-			obj = ref.bdb_object
-			@cursor, @db = *if Cursor === ref
-					[obj.dup, ref.db]
-				else [obj.cursor( nil, 0), ref]
-				end
-		end
-
-		def close
-			@cursor.close
-		end
-
-		def get k, v, f
-			@cursor.get k, v, f
-		end
-
-		def count
-			@cursor.count
-		end
-
-		def reverse k = nil, v = nil, &e
-			each k, v, LAST, PREV, &e
-		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 = @cursor.get k, v, f || FIRST
-			return  unless e
-			yield *e
-			yield *e  while e = @cursor.get( k, v, n)
-			nil
-		end
-
-		def first k = nil, v = nil
-			@cursor.get k, v, FIRST
-		end
-
-		def last k = nil, v = nil
-			@cursor.get k, v, LAST
-		end
-
-		def next k = nil, v = nil
-			@cursor.get k, v, NEXT
-		end
-
-		def prev k = nil, v = nil
-			@cursor.get k, v, PREV
-		end
-	end
-
-	class Unknown < DB
-		def self.new *p, &e
-			super *p[0...2], UNKNOWN, *p[2..-1], &e
-		end
-	end
-
-	class Btree < DB
-		def self.new *p, &e
-			super *p[0...2], BTREE, *p[2..-1], &e
-		end
-	end
-
-	class Hash < DB
-		def self.new *p, &e
-			super *p[0...2], HASH, *p[2..-1], &e
-		end
-	end
-
-	class Recno < DB
-		def self.new *p, &e
-			super *p[0...2], RECNO, *p[2..-1], &e
-		end
-
-		def [] k
-			super [k].pack('N')
-		end
-
-		def []= k, v
-			super [k].pack('N'), v
-		end
-	end
-	Array = Recno
-
-	class Queue < DB
-		def self.new *p, &e
-			super *p[0...2], QUEUE, *p[2..-1], &e
-		end
-
-		def [] k
-			super [k].pack('N')
-		end
-
-		def []= k, v
-			super [k].pack('N'), v
-		end
+	def self.raise_barrier *ps, &e
+		e.call *ps
+	rescue Object
+		$stderr.puts [$!.class,$!,$!.backtrace].inspect
 	end
 end

lib/sbdb/cursor.rb

@@ -0,0 +1,74 @@
+
+module SBDB
+	class Cursor
+		NEXT  = Bdb::DB_NEXT
+		FIRST = Bdb::DB_FIRST
+		LAST  = Bdb::DB_LAST
+		PREV  = Bdb::DB_PREV
+		SET   = Bdb::DB_SET
+
+		attr_reader :db
+
+		include Enumerable
+		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 *ps
+			ret = obj = super( *ps)
+			begin ret = yield obj
+			ensure obj.close
+			end  if block_given?
+			ret
+		end
+
+		def initialize ref
+			@cursor, @db = *case ref
+				when Cursor  then [ref.bdb_object.dup, ref.db]
+				when Bdb::Db::Cursor  then [ref]
+				else [ref.bdb_object.cursor( nil, 0), ref]
+				end
+			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 key = nil, val = nil, &exe
+			each key, val, LAST, PREV, &exe
+		end
+
+		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
+end

lib/sbdb/db.rb

@@ -0,0 +1,156 @@
+require 'bdb'
+require 'sbdb/cursor'
+
+module SBDB
+	TYPES = []
+	class DB
+		UNKNOWN = Bdb::Db::UNKNOWN
+		BTREE = Bdb::Db::BTREE
+		HASH = Bdb::Db::HASH
+		QUEUE = Bdb::Db::QUEUE
+		ARRAY = RECNO = Bdb::Db::RECNO
+		RDONLY = READLONY = Bdb::DB_RDONLY
+		CONSUME = Bdb::DB_CONSUME
+		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( flg = nil)  @db.close flg || 0  end
+		def cursor( &exe)  Cursor.new self, &exe  end
+
+		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 _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 *ps, &exe
+				ret = obj = super( *ps)
+				begin ret = exe.call obj
+				ensure
+					SBDB::raise_barrier &obj.method(:sync)
+					SBDB::raise_barrier &obj.method(:close)
+				end  if exe
+				ret
+			end
+			alias open new
+		end
+
+		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 exc
+			end
+		end
+
+		def each key = nil, val = nil, &exe
+			cursor {|c| c.each key, val, &exe }
+		end
+
+		def reverse key = nil, val = nil, &exe
+			cursor {|c| c.reverse key, val, &exe }
+		end
+
+		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, *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
+	end
+	TYPES[DB::BTREE] = Btree
+
+	class Hash < DB
+	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
+		include Arrayisch
+	end
+	Array = Recno
+	TYPES[DB::RECNO] = Recno
+
+	class Queue < DB
+		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

@@ -0,0 +1,116 @@
+require 'bdb'
+require 'sbdb/db'
+require 'sbdb/transaction'
+
+module SBDB
+	# Environments are for storing one or more databases and are important
+	# if you want to work with more than one process on one database.
+	# You needn't use Environment,  but it's usefull.
+	class Environment
+		INIT_TXN   = Bdb::DB_INIT_TXN
+		INIT_LOCK  = Bdb::DB_INIT_LOCK
+		INIT_LOG   = Bdb::DB_INIT_LOG
+		INIT_MPOOL = Bdb::DB_INIT_MPOOL
+		INIT_TRANSACTION = INIT_TXN | INIT_LOCK | INIT_LOG | INIT_MPOOL
+		LOCKDOWN   = Bdb::DB_LOCKDOWN
+		NOMMAP     = Bdb::DB_NOMMAP
+		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, *ps, &exe
+			open Btree, file, *ps, &exe
+		end 
+		# Opens a Hash in this Environment
+		def hash file, *ps, &exe
+			open Hash, file, *ps, &exe
+		end 
+		# Opens a Recno in this Environment
+		def recno file, *ps, &exe
+			open Recno, file, *ps, &exe
+		end 
+		# Opens a Queue in this Environment
+		def queue file, *ps, &exe
+			open Queue, file, *ps, &exe
+		end 
+		# Opens a DB of unknown type in this Environment
+		def unknown file, *ps, &exe
+			open Unknown, file, *ps, &exe
+		end 
+
+		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
+
+		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{|key, db|db.close}
+			@env.close
+		end
+
+		class << self
+			alias open new
+		end
+
+		# Opens a Database.
+		# see SBDB::DB, SBDB::Btree, SBDB::Hash, SBDB::Recno, SBDB::Queue
+		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
+
+		# Returns the DB like open, but if it's already opened,
+		# 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, *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
+end

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

sbdb.gemspec

@@ -1,39 +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.5"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Denis Knauf"]
-  s.date = %q{2010-01-29}
-  s.description = %q{Simple Ruby Berkeley DB wrapper library for bdb.}
-  s.email = %q{Denis.Knauf@gmail.com}
-  s.extra_rdoc_files = [
-    "README"
-  ]
-  s.files = [
-    "README",
-     "VERSION",
-     "lib/sbdb.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
-    else
-    end
-  else
-  end
-end
-