lmdb 0.6.5 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d6a2b5d9eb4d0c1a93c0d807bb890ad33bd7eafe6e55d7a132796096296f078
-  data.tar.gz: 9ef7004f7734571bebb5352a99287f1de65e3392c7490d089de959c5a3502a68
+  metadata.gz: 79e94aae1eb049c37cc44abdde80712dd5c8fa900d1ec2b68c33b773862f4e1a
+  data.tar.gz: ccf377de1e2e910c81459fad2fe0bce8eb831ca40e3f95fc311ef7ccd3eb1e57
 SHA512:
-  metadata.gz: bf624d2a0e988a764d1cbdd23c30fe48d249d79f855aa5cc3bb3c3c079474edc59df57a68a47aa85b723d4dc6e28621f01c529d1f09efa948d66205e392e485c
-  data.tar.gz: a659a1329886ffd36f6c901c9db4fb64f3f463bf085d17115b2a7b2bda9bf5cf365d5ab90850043395a66566a20d56c3548fa56997563ef714a91a5c3f764202
+  metadata.gz: 0e3d55b2b4486caea098bb175b6ae4aeff87d770010ce4359c003e1707e6089da204a1f6f62fd0bf1e300170e0954b6245dc6fd3d9e951211d87f0b94cf958e8
+  data.tar.gz: 96e68bf724dfc2f47a5bfd72dbc5fcda8ede5e8b7edc69e1cb2e55f5c6230997bd319e04d47bbea8aaca39c5d0e322f70e37b2f9d0cb8f5e991b50ca7df51469

data/README.md

@@ -1,8 +1,5 @@
 # LMDB
 
-[![Gittip donate button](http://img.shields.io/gittip/bevry.png)](https://www.gittip.com/min4d/ "Donate weekly to this project using Gittip")
-[![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=min4d&url=https://github.com/minad/lmdb&title=LMDB&language=&tags=github&category=software)
-
 Ruby bindings for the amazing [OpenLDAP's Lightning Memory-Mapped Database (LMDB)](https://www.symas.com/lmdb/).
 
 ## Installation
@@ -15,12 +12,9 @@ gem install lmdb
 
 ## Links
 
-* Source: <http://github.com/minad/lmdb>
-* Bugs:   <http://github.com/minad/lmdb/issues>
-* Tests and benchmarks: <http://travis-ci.org/minad/lmdb>
-* API documentation:
-    * Latest Gem: <http://rubydoc.info/gems/lmdb/frames>
-    * GitHub master: <http://rubydoc.info/github/minad/lmdb/master/frames>
+* Source: <http://github.com/doriantaylor/rb-lmdb>
+* Bugs:   <http://github.com/doriantaylor/rb-lmdb/issues>
+* API documentation: <http://rubydoc.info/gems/lmdb/>
 
 ## API
 
@@ -42,12 +36,16 @@ end
 env.close
 ```
 
-If you want to have a simpler interface to LMDB databases please consider using [Moneta](https://github.com/minad/moneta). The Moneta gem provides an LMDB adapter which uses this gem.
+## Moneta
+
+If you want to have a simpler interface to LMDB databases please
+consider using [Moneta](https://github.com/minad/moneta). The Moneta
+gem provides an LMDB adapter which uses this gem.
 
 ## License (MIT)
 
 ```
-Copyright (c) 2013 Daniel Mendler
+Copyright ©2013 Daniel Mendler (later changes ©2025 Dorian Taylor)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/ext/lmdb_ext/lmdb_ext.c

@@ -936,7 +936,7 @@ static VALUE environment_databases(VALUE self) {
         char *intern_db_name;
         MDB_dbi db;
         VALUE db_name;
-        
+
         if (memchr(key.mv_data, '\0', key.mv_size))
             continue;
 

data/lib/lmdb/database.rb

@@ -84,10 +84,10 @@ module LMDB
       maybe_txn true do
       # env.transaction do
         cursor do |c|
-          method = :set
-          while rec = c.send(method, key)
-            method = :next_range
-            yield rec[1]
+          rec = c.set key
+          while rec
+            yield rec.last
+            rec = c.next_range key
           end
         end
       end
@@ -134,24 +134,65 @@ module LMDB
       ret
     end
 
+    # Conditionally put a value into the database.
+    #
+    # @param key [#to_s] The key of the record
+    # @param value [#to_s, nil] the (optional) value
+    # @param options [Hash] options
+    #
+    # @see #put
+    #
+    # @return [void]
+    #
+    def put?(key, value = nil, **options)
+      flags = {}
+      flags[dupsort? ? :nodupdata : :nooverwrite] = true
+      begin
+        put key, value, **options.merge(flags)
+      rescue LMDB::Error::KEYEXIST
+        nil
+      end
+    end
+
     # Delete the key (and optional value pair) if it exists; do not
     # complain about missing keys.
-    # @param key [#to_s] The key.
-    # @param value [#to_s] The optional value.
+    # @param key [#to_s] The key of the record
+    # @param value [#to_s, nil] The optional value
+    #
+    # @see #delete
+    #
+    # @return [void]
+    #
     def delete?(key, value = nil)
-      delete key, value if has? key, value
+      begin
+        delete key, value
+      rescue LMDB::Error::NOTFOUND
+        nil
+      end
     end
 
+    # Return how many records there are in this database.
+    #
     # @return the number of records in this database
     def size
       stat[:entries]
     end
 
+    #
+    # @return whether the database is empty
+    def empty?
+      stat[:entries] == 0
+    end
+
     private
 
     # having trouble with read-only transactions embedded in
     # read-write for some reason; can't pin it down to test it yet so
     # going to do this (djt; 2020-02-10)
+    #
+    # 2025-11-14: this miiiigght no longer be necessary?? like as of
+    # whenever i implemented that short-circuiting code
+    #
     def maybe_txn(readonly, &block)
       if t = env.active_txn
         # warn "reusing #{t.readonly? ? 'read-only ' : ''}txn #{t.inspect}"

data/lib/lmdb/version.rb

@@ -1,3 +1,3 @@
 module LMDB
-  VERSION = '0.6.5'.freeze
+  VERSION = '0.6.7'.freeze
 end

data/spec/lmdb_spec.rb

@@ -40,8 +40,8 @@ describe LMDB do
         env = LMDB::Environment.new(path, nosync: true, mode: 0777,
           maxreaders: 777, mapsize: 111111, maxdbs: 666)
         env.should be_instance_of(described_class)
-        env.info[:maxreaders].should == 777
-        env.info[:mapsize].should == 111111
+        env.info[:maxreaders].should eq(777)
+        env.info[:mapsize].should eq(111111)
         env.flags.should include(:nosync)
         env.close
 
@@ -74,7 +74,7 @@ describe LMDB do
     it 'should set mapsize' do
       size_before = env.info[:mapsize]
       env.mapsize = size_before * 2
-      env.info[:mapsize].should == size_before * 2
+      env.info[:mapsize].should eq(size_before * 2)
     end
 
     it 'should copy' do
@@ -108,7 +108,7 @@ describe LMDB do
       it 'returns list of named databases' do
         db1 = subject.database 'db1', create: true
         db2 = subject.database 'db2', create: true
-        subject.databases.should == ['db1', 'db2']
+        subject.databases.should eq(['db1', 'db2'])
       end
 
       it 'returns list of named databases when there are non-database kes in the main db' do
@@ -117,7 +117,7 @@ describe LMDB do
         subject.database 'db1', create: true
         subject.database 'db2', create: true
 
-        subject.databases.should == ['db1', 'db2']
+        subject.databases.should eq(['db1', 'db2'])
       end
     end
 
@@ -125,71 +125,71 @@ describe LMDB do
       subject { env }
 
       it 'should create transactions' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         subject.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           txn.should be_instance_of(described_class)
           txn.abort
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
       end
 
       it 'should create read-only transactions' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         subject.transaction(true) do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           txn.should be_instance_of(described_class)
           txn.abort
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
       end
 
       it 'can create child transactions' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         env.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           env.transaction do |ctxn|
-            subject.active_txn.should == ctxn
+            subject.active_txn.should eq(ctxn)
             ctxn.abort
-            subject.active_txn.should == txn
+            subject.active_txn.should eq(txn)
           end
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
         end
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
       end
 
       it 'should support aborting parent transaction' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         env.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           env.transaction do |ctxn|
-            subject.active_txn.should == ctxn
+            subject.active_txn.should eq(ctxn)
             db['key'] = 'value'
             txn.abort
-            subject.active_txn.should == nil
+            subject.active_txn.should be_nil
           end
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        db['key'].should be(nil)
-        subject.active_txn.should == nil
+        db['key'].should be_nil
+        subject.active_txn.should be_nil
       end
 
       it 'should support comitting parent transaction' do
-        subject.active_txn.should == nil
+        subject.active_txn.should be_nil
         env.transaction do |txn|
-          subject.active_txn.should == txn
+          subject.active_txn.should eq(txn)
           env.transaction do |ctxn|
-            subject.active_txn.should == ctxn
+            subject.active_txn.should eq(ctxn)
             db['key'] = 'value'
             txn.commit
-            subject.active_txn.should == nil
+            subject.active_txn.should be_nil
           end
-          subject.active_txn.should == nil
+          subject.active_txn.should be_nil
         end
-        db['key'].should == 'value'
-        subject.active_txn.should == nil
+        db['key'].should eq('value')
+        subject.active_txn.should be_nil
       end
 
       it 'should get environment' do
@@ -197,7 +197,7 @@ describe LMDB do
         env.transaction do |txn|
           env2 = txn.env
         end
-        env2.should == env
+        env2.should eq(env)
       end
     end
   end
@@ -207,8 +207,8 @@ describe LMDB do
 
     it 'should return flags' do
       subject.flags.should be_instance_of(Hash)
-      subject.dupsort?.should == false
-      subject.dupfixed?.should == false
+      subject.dupsort?.should be_falsy
+      subject.dupfixed?.should be_falsy
     end
 
     it 'should support named databases' do
@@ -222,19 +222,22 @@ describe LMDB do
       db1['key'] = '2'
       db2['key'] = '3'
 
-      main['key'].should == '1'
-      db1['key'].should == '2'
-      db2['key'].should == '3'
+      main['key'].should eq(?1)
+      db1['key'].should  eq(?2)
+      db2['key'].should  eq(?3)
     end
 
     it 'should get/put data' do
       subject.get('cat').should be_nil
       subject.put('cat', 'garfield').should be_nil
-      subject.get('cat').should == 'garfield'
+      subject.get('cat').should eq('garfield')
 
       # check for key-value pairs on non-dupsort database
-      subject.has?('cat', 'garfield').should == true
-      subject.has?('cat', 'heathcliff').should == false
+      subject.has?('cat', 'garfield').should be_truthy
+      subject.has?('cat', 'heathcliff').should be_falsy
+
+      subject.put?('dog', 'odie')
+      subject.has?('dog', 'odie').should be_truthy
     end
 
     it 'should delete by key' do
@@ -255,7 +258,7 @@ describe LMDB do
 
     it 'stores key/values in same transaction' do
       db.put('key', 'value').should be_nil
-      db.get('key').should == 'value'
+      db.get('key').should eq('value')
     end
 
     it 'stores key/values in different transactions' do
@@ -268,10 +271,10 @@ describe LMDB do
       end
 
       env.transaction do
-        db.get('key').should == 'value'
-        db.get('key2').should == 'value2'
+        db.get('key').should eq('value')
+        db.get('key2').should eq('value2')
         env.transaction do
-          db.get('key3').should == 'value3'
+          db.get('key3').should eq('value3')
         end
       end
     end
@@ -281,22 +284,22 @@ describe LMDB do
     end
 
     it 'should return size' do
-      db.size.should == 0
+      db.size.should eq(0)
       db.put('key', 'value')
-      db.size.should == 1
+      db.size.should eq(1)
       db.put('key2', 'value2')
-      db.size.should == 2
+      db.size.should eq(2)
     end
 
     it 'should be enumerable' do
       db['k1'] = 'v1'
       db['k2'] = 'v2'
-      db.to_a.should == [['k1', 'v1'], ['k2', 'v2']]
+      db.to_a.should eq([['k1', 'v1'], ['k2', 'v2']])
     end
 
     it 'should have shortcuts' do
       db['key'] = 'value'
-      db['key'].should == 'value'
+      db['key'].should eq('value')
     end
 
     it 'should store binary' do
@@ -304,15 +307,15 @@ describe LMDB do
       bin2 = "\xAAx\BB\xCC2"
       db[bin1] = bin2
       db['key'] = bin2
-      db[bin1].should == bin2
-      db['key'].should == bin2
+      db[bin1].should eq(bin2)
+      db['key'].should eq(bin2)
     end
 
     it 'should get environment' do
       main = env.database
       db1 = env.database('db1', create: true)
-      main.env.should == env
-      db1.env.should == env
+      main.env.should eq(env)
+      db1.env.should eq(env)
     end
 
     it 'should iterate over/list keys' do
@@ -330,38 +333,38 @@ describe LMDB do
 
     it 'should get first key/value' do
       db.cursor do |c|
-        c.first.should == ['key1', 'value1']
+        c.first.should eq(['key1', 'value1'])
       end
     end
 
     it 'should get last key/value' do
       db.cursor do |c|
-        c.last.should == ['key2', 'value2']
+        c.last.should eq(['key2', 'value2'])
       end
     end
 
     it 'should get next key/value' do
       db.cursor do |c|
         c.first
-        c.next.should == ['key2', 'value2']
+        c.next.should eq(['key2', 'value2'])
       end
     end
 
     it 'should seek to key' do
       db.cursor do |c|
-        c.set('key1').should == ['key1', 'value1']
+        c.set('key1').should eq(['key1', 'value1'])
       end
     end
 
     it 'should seek to closest key' do
       db.cursor do |c|
-        c.set_range('key0').should == ['key1', 'value1']
+        c.set_range('key0').should eq(['key1', 'value1'])
       end
     end
 
     it 'should seek to key with nuls' do
       db.cursor do |c|
-        c.set_range('\x00').should == ['key1', 'value1']
+        c.set_range('\x00').should eq(['key1', 'value1'])
       end
     end
 
@@ -369,8 +372,8 @@ describe LMDB do
       db.cursor do |c|
         db.put('key0', 'value0')
         c.first
-        c.next_range('key1').should == ['key1', 'value1']
-        c.next_range('key1').should == nil
+        c.next_range('key1').should eq(['key1', 'value1'])
+        c.next_range('key1').should be_nil
       end
     end
 
@@ -378,32 +381,35 @@ describe LMDB do
       dupdb = env.database 'dupsort', create: true, dupsort: true
 
       # check flag while we're at it
-      dupdb.flags[:dupsort].should == true
-      dupdb.dupsort?.should == true
-      dupdb.dupfixed?.should == false
+      dupdb.flags[:dupsort].should be_truthy
+      dupdb.dupsort?.should be_truthy
+      dupdb.dupfixed?.should be_falsy
 
       # add the no-op keyword to trigger a complaint from ruby 2.7
       dupdb.put 'key1', 'value1', nodupdata: false
       dupdb.put 'key1', 'value2'
       dupdb.put 'key2', 'value3'
       dupdb.cursor do |c|
-        c.set('key1', 'value2').should == ['key1', 'value2']
-        c.set('key1', 'value1').should == ['key1', 'value1']
-        c.set('key1', 'value3').should == nil
+        c.set('key1', 'value2').should eq(['key1', 'value2'])
+        c.set('key1', 'value1').should eq(['key1', 'value1'])
+        c.set('key1', 'value3').should be_nil
       end
 
+      # this should do nothing
+      dupdb.put?('key1', 'value1', nodupdata: true).should be_nil
+
       # this is basically an extended test of `cursor.set key, val`
-      dupdb.has?('key1', 'value1').should == true
-      dupdb.has?('key1', 'value2').should == true
-      dupdb.has?('key1', 'value0').should == false
+      dupdb.has?('key1', 'value1').should be_truthy
+      dupdb.has?('key1', 'value2').should be_truthy
+      dupdb.has?('key1', 'value0').should be_falsy
 
       # match the contents of key1
-      dupdb.each_value('key1').to_a.sort.should == ['value1', 'value2']
+      dupdb.each_value('key1').to_a.sort.should eq(['value1', 'value2'])
 
       # we should have two entries for key1
-      dupdb.cardinality('key1').should == 2
+      dupdb.cardinality('key1').should eq(2)
 
-      dupdb.each_key.to_a.sort.should == ['key1', 'key2']
+      dupdb.each_key.to_a.sort.should eq(['key1', 'key2'])
 
       # XXX move this or whatever
       env.transaction do |t|
@@ -430,7 +436,7 @@ describe LMDB do
     it 'should get database' do
       db2 = nil
       env.transaction { c = db.cursor; db2 = c.database }
-      db2.should == db
+      db2.should eq(db)
     end
 
     it 'should nest a read-only txn in a read-write' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lmdb
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.6.7
 platform: ruby
 authors:
 - Daniel Mendler
 - Dorian Taylor
 bindir: bin
 cert_chain: []
-date: 2025-05-07 00:00:00.000000000 Z
+date: 2025-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake