sbdb 0.0.8

data/LICENSE

@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,56 @@
+Dependencies
+============
+
+You need first the [Bdb](http://github.com/DenisKnauf/bdb) and of course [ruby](http://ruby-lang.org).
+
+Download
+========
+
+via git:
+
+	git clone git://github.com/DenisKnauf/sbdb.git
+
+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
+	db = env.open SBDB::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
+
+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) 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.

data/VERSION

@@ -0,0 +1 @@
+0.0.8

data/lib/sbdb.rb

@@ -0,0 +1,19 @@
+require 'bdb'
+require 'sbdb/environment'
+require 'sbdb/db'
+require 'sbdb/cursor'
+require 'sbdb/transaction'
+
+module SBDB
+	CREATE      = Bdb::DB_CREATE
+	AUTO_COMMIT = Bdb::DB_AUTO_COMMIT
+	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
+	alias open_db unknown
+end

data/lib/sbdb/cursor.rb

@@ -0,0 +1,58 @@
+
+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( 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 self.new *p
+			x = super *p
+			return x  unless block_given?
+			begin yield x
+			ensure x.close
+			end
+		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? {|t| t === @db }
+				def get k, v, f
+					l, w = @cursor.get( k, v, f)
+					l.nil? ? nil : [l.unpack('I')[0], w]
+				end
+			end
+		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 = get k, v, f || FIRST
+			return  unless e
+			yield *e
+			yield *e  while e = get( k, v, n)
+			nil
+		end
+	end
+end

data/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( f = nil)  @db.close f || 0  end
+		def cursor( &e)  Cursor.new self, &e  end
+
+		def at k, txn = nil
+			@db.get _txn(txn), k.nil? ? nil : k.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
+			else
+				@db.put _txn(txn), k.nil? ? nil : k.to_s, v.to_s, 0
+			end
+		end
+		
+		def []= k, v
+			put k, v
+		end
+
+		def delete k, txn = nil
+			@db.del _txn(txn), k.to_s
+		end
+		alias del delete
+
+		class << self
+			def new *p, &e
+				x = super *p
+				return x  unless e
+				begin e.call x
+				ensure
+					begin x.sync
+					rescue Object
+						$stderr.puts [$!.class,$!,$!.backtrace].inspect
+					end
+					begin x.close
+					rescue Object
+						$stderr.puts [$!.class,$!,$!.backtrace].inspect
+					end
+				end
+			end
+			alias open new
+		end
+
+		def _txn t
+			t ||= @txn
+			t && t.bdb_object
+		end
+
+		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 = opts[:txn]
+			begin
+				@db.open txn && txn.bdb_object, file, opts[:name], opts[:type], opts[:flags] || 0, opts[:mode] || 0
+			rescue Object
+				close
+				raise $!
+			end
+		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
+
+		def truncate txn = nil
+			@db.truncate _txn(txn)
+		end
+	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)
+		end
+	end
+
+	class Btree < DB
+	end
+	TYPES[DB::BTREE] = Btree
+
+	class Hash < DB
+	end
+	TYPES[DB::HASH] = Hash
+
+	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
+	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
+
+		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

data/lib/sbdb/environment.rb

@@ -0,0 +1,122 @@
+require 'bdb'
+require 'sbdb/weakhash'
+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, *p, &e
+			open Btree, file, *p, &e
+		end 
+		# Opens a Hash in this Environment
+		def hash file, *p, &e
+			open Hash, file, *p, &e
+		end 
+		# Opens a Recno in this Environment
+		def recno file, *p, &e
+			open Recno, file, *p, &e
+		end 
+		# Opens a Queue in this Environment
+		def queue file, *p, &e
+			open Queue, file, *p, &e
+		end 
+		# Opens a DB of unknown type in this Environment
+		def unknown file, *p, &e
+			open Unknown, file, *p, &e
+		end 
+
+		def transaction flags = nil, &e
+			SBDB::Transaction.new self, flags, &e
+		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 = WeakHash.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 = r = super( *args)
+			begin r = yield obj
+			ensure
+				begin obj.close
+				rescue Object
+					$stderr.puts [$!.class,$!,$!.backtrace].inspect
+				end
+			end  if block_given?
+			r
+		end
+
+		# Close the Environment.
+		# First you should close all databases!
+		def close
+			@dbs.each{|k, 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, *p, &e
+			p.push ::Hash.new  unless ::Hash === p.last
+			p.last[:env] = self
+			(type || SBDB::Unkown).new file, *p, &e
+		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, *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
+		end
+	end
+	Env = Environment
+end

data/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

data/lib/sbdb/weakhash.rb

@@ -0,0 +1,61 @@
+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

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: sbdb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 8
+  version: 0.0.8
+platform: ruby
+authors: 
+- Denis Knauf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dk-bdb
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Simple Ruby Berkeley DB wrapper library for bdb.
+email: Denis.Knauf@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+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
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/DenisKnauf/bdb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple Ruby Berkeley DB
+test_files: []
+