lmdb 0.1.0 → 0.2.0

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: lmdb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Mendler
-- Black Square Media
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -61,6 +60,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - CHANGES
 - CONTRIBUTORS
 - Gemfile
@@ -77,16 +77,13 @@ files:
 - ext/lmdb_ext/liblmdb/midl.c
 - ext/lmdb_ext/liblmdb/midl.h
 - ext/lmdb_ext/lmdb_ext.c
+- ext/lmdb_ext/lmdb_ext.h
+- ext/lmdb_ext/prototypes.sh
 - lib/lmdb.rb
-- lib/lmdb/database.rb
-- lib/lmdb/environment.rb
 - lmdb.gemspec
-- spec/lmdb/database_spec.rb
-- spec/lmdb/environment_spec.rb
-- spec/lmdb/lmdb_ext_spec.rb
+- spec/helper.rb
 - spec/lmdb_spec.rb
-- spec/spec_helper.rb
-homepage: https://github.com/minad/mdb
+homepage: https://github.com/minad/lmdb
 licenses:
 - MIT
 metadata: {}
@@ -111,8 +108,5 @@ signing_key:
 specification_version: 4
 summary: Ruby bindings to Lightning MDB
 test_files:
-- spec/lmdb/database_spec.rb
-- spec/lmdb/environment_spec.rb
-- spec/lmdb/lmdb_ext_spec.rb
+- spec/helper.rb
 - spec/lmdb_spec.rb
-- spec/spec_helper.rb

data/lib/lmdb/database.rb

@@ -1,66 +0,0 @@
-class LMDB::Database
-
-  class << self
-    private :new
-  end
-
-  # @attr_reader [String] name
-  attr_reader :name
-
-  # @attr_reader [LMDB::Environment] env
-  attr_reader :env
-
-  # @param [LMDB::Environment] env
-  # @param [String] name the DB name
-  def initialize(env, name)
-    @env  = env
-    @name = name.to_s
-  end
-
-  # Closes the DB, doesn't fail if already closed
-  def close
-    raw.close if loaded?
-  end
-
-  # Reads a key
-  # @param [String] key
-  def get(key)
-    ensure_db!
-    rtxn {|txn| raw.get(txn, key) }
-  rescue LMDB::Ext::Error::NOTFOUND
-  end
-  alias_method :[], :get
-
-  # Sets a key to a new value
-  # @param [String] key
-  # @param [String] value
-  def set(key, value)
-    ensure_db!
-    rtxn {|txn| raw.put(txn, key, value) }
-  end
-  alias_method :put, :set
-  alias_method :[]=, :set
-
-  private
-
-    def raw
-      @raw ||= rtxn {|txn| renv.open(txn, name, LMDB::CREATE) }
-    end
-
-    def renv
-      @renv ||= env.send(:raw)
-    end
-
-    def rtxn(&block)
-      env.send(:rtxn, &block)
-    end
-
-    def loaded?
-      !!@raw
-    end
-
-    def ensure_db!
-      raw unless loaded?
-    end
-
-end

data/lib/lmdb/environment.rb

@@ -1,135 +0,0 @@
-class LMDB::Environment
-
-  DEFAULT_OPTS = {
-    path: ".",
-    mode: 0755,
-    max_size: (2**28-1), # 4G
-    # max_size: 1_000_000,
-    max_dbs: 16,
-    max_readers: 126,
-    sub_dirs: true,
-    read_only: false,
-    mmap: false,
-    sync: true,
-    meta_sync: false
-  }.freeze
-
-  INFO_MAP = {
-    mapaddr:    :address,
-    mapsize:    :max_size,
-    last_pgno:  :last_page,
-    last_txnid: :last_transaction_id,
-    maxreaders: :maxreaders,
-    numreaders: :readers
-  }.freeze
-
-  STAT_MAP = {
-    psize:          :page_size,
-    depth:          :depth,
-    branch_pages:   :branch_pages,
-    leaf_pages:     :leaf_pages,
-    overflow_pages: :overflow_pages,
-    entries:        :entries
-  }.freeze
-
-  # @attr_reader [String] path environment path
-  attr_reader :path
-
-  # Constructor, opens an environment
-  #
-  # @param [Hash] opts options
-  # @option opts [String] :path
-  #   the environment path, defaults to current path
-  # @option opts [String] :mode
-  #   the file mode, defaults to 0755
-  # @option opts [Integer] :max_size
-  #   the maximum environment size in bytes, defaults to 4G
-  # @option opts [Integer] :max_dbs
-  #   the maximum number of databases, defaults to 16
-  # @option opts [Integer] :max_readers
-  #   the maximum number of readers, defaults to 126
-  # @option opts [Boolean] :sub_dirs
-  #   allow subdirectories, defaults to true
-  # @option opts [Boolean] :read_only
-  #   open in read-only mode, defaults to false
-  # @option opts [Boolean] :mmap
-  #   use memory map, faster, but less durable, incompatible with nested transactions, defaults to false
-  # @option opts [Boolean] :sync
-  #   flushes system buffers at the end of a transaction; slower, but more durable, defaults to true
-  # @option opts [Boolean] :meta_sync
-  #   flush system buffers on every write and not only at the end of a transaction; slower, but more durable, defaults to false
-  # @raises [LMDB::Error] on errors
-  def initialize(opts = {})
-    opts  = DEFAULT_OPTS.merge(opts)
-    @path = opts[:path].to_s
-    @raw  = LMDB::Ext::Environment.open path, parse(opts)
-  end
-
-  # Manually sync the environment
-  #
-  # @param [Hash] opts options
-  # @option opts [Boolean] :force force sync, default false
-  # @return [Boolean] true if successful
-  # @raises [LMDB::Error] on errors
-  def sync(opts = {})
-    @raw.sync !!opts[:force]
-    true
-  end
-
-  # @return [Hash] environment info & stats
-  def info
-    info, stat = @raw.info, @raw.stat
-    hash = {}
-    INFO_MAP.each {|m, f| hash[f] = info.send(m) }
-    STAT_MAP.each {|m, f| hash[f] = stat.send(m) }
-    hash
-  end
-
-  # TODO: Thread-safe global transactions
-  #
-  # Executes a transaction
-  # @yield a transaction
-  # @yieldparam [LMDB::Transaction] txn the transaction instance
-  # def transaction(&block)
-  #   LMDB::Transaction.send(:new, self, &block)
-  # end
-
-  # Opens a database
-  # @param [String] name
-  # @return [LMDB::Database] the database
-  def database(name)
-    LMDB::Database.send(:new, self, name)
-  end
-  alias_method :db, :database
-
-  # @return [String] introspection
-  def inspect
-    "#<#{self.class.name} @path=#{path.inspect}>"
-  end
-
-  private
-
-    def raw
-      @raw
-    end
-
-    def rtxn(&block)
-      @raw.transaction(&block)
-    end
-
-    def parse(opts)
-      flags = 0
-      flags |= LMDB::NOSUBDIR   unless opts[:sub_dirs]
-      flags |= LMDB::RDONLY     if opts[:read_only]
-      flags |= LMDB::WRITEMAP   if opts[:mmap]
-      flags |= LMDB::NOSYNC     unless opts[:sync]
-      flags |= LMDB::NOMETASYNC unless opts[:meta_sync]
-
-      { flags: flags,
-        mode: opts[:mode],
-        maxreaders: opts[:max_readers].to_i,
-        mapsize: opts[:max_size].to_i,
-        maxdbs: opts[:max_dbs].to_i }
-    end
-
-end

data/spec/lmdb/database_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe LMDB::Database do
-
-  subject    { env.db(:pets) }
-  after      { subject.close }
-
-  its(:name) { should == "pets" }
-  its(:env)  { should == env }
-
-  it 'should get/set data' do
-    subject.get("cat").should be_nil
-    subject.set("cat", "garfield").should be_nil
-    subject.get("cat").should == "garfield"
-  end
-
-  it 'should get/set data' do
-    subject.get("cat").should be_nil
-    subject.set("cat", "garfield").should be_nil
-    subject.get("cat").should == "garfield"
-  end
-
-end

data/spec/lmdb/environment_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe LMDB::Environment do
-
-  subject    { env }
-
-  it  { should be_instance_of(described_class) }
-  its(:path) { should be_instance_of(String) }
-  its(:info) { should be_instance_of(Hash) }
-  its("info.keys") { should =~ [:address, :branch_pages, :depth, :entries, :last_page, :last_transaction_id, :leaf_pages, :max_size, :maxreaders, :overflow_pages, :page_size, :readers] }
-
-  it 'should sync' do
-    subject.sync.should be(true)
-    subject.sync(force: true).should be(true)
-  end
-
-  it 'should open databases' do
-    subject.database(:pets).should be_instance_of(LMDB::Database)
-    subject.db(:pets).should be_instance_of(LMDB::Database)
-  end
-
-end

data/spec/lmdb/lmdb_ext_spec.rb

@@ -1,253 +0,0 @@
-require 'spec_helper'
-
-shared_examples "an environment" do
-  describe 'open' do
-    it 'returns environment' do
-      env = subject.open(path)
-      env.should be_instance_of(described_class::Environment)
-      env.close
-    end
-
-    it 'accepts block' do
-      subject.open(path) do |env|
-        env.should be_instance_of(described_class::Environment)
-        42
-      end.should == 42
-    end
-
-    it 'accepts options' do
-      env = subject.open(path, :flags => LMDB::NOSYNC, :mode => 0777, :maxreaders => 777, :mapsize => 111111, :maxdbs => 666)
-      env.should be_instance_of(described_class::Environment)
-      env.info.maxreaders.should == 777
-      env.info.mapsize.should == 111111
-      env.close
-    end
-  end
-end
-
-describe LMDB::Ext do
-
-  let(:env)  { LMDB::Ext.open(path) }
-  after      { env.close }
-
-  it_behaves_like "an environment" do
-    subject { LMDB::Ext }
-  end
-
-  describe "Stat" do
-    subject { env.stat }
-
-    it { should be_instance_of(described_class::Stat) }
-    its(:psize) { should be_instance_of(Fixnum) }
-    its(:depth) { should be_instance_of(Fixnum) }
-    its(:branch_pages) { should be_instance_of(Fixnum) }
-    its(:leaf_pages) { should be_instance_of(Fixnum) }
-    its(:overflow_pages) { should be_instance_of(Fixnum) }
-    its(:entries) { should be_instance_of(Fixnum) }
-  end
-
-  describe "Info" do
-    subject { env.info }
-
-    it { should be_instance_of(described_class::Info) }
-    its(:mapaddr) { should be_instance_of(Fixnum) }
-    its(:mapsize) { should be_instance_of(Fixnum) }
-    its(:last_pgno) { should be_instance_of(Fixnum) }
-    its(:last_txnid) { should be_instance_of(Fixnum) }
-    its(:maxreaders) { should be_instance_of(Fixnum) }
-    its(:numreaders) { should be_instance_of(Fixnum) }
-  end
-
-  describe "Environment" do
-    it_behaves_like "an environment" do
-      subject { described_class::Environment }
-    end
-
-    subject { env }
-
-    its(:path)  { should == path }
-    its(:flags) { should == 0 }
-
-    it 'should copy' do
-      target = mkpath('copy')
-      subject.copy(target).should be_nil
-    end
-
-    it 'should sync' do
-      subject.sync.should be_nil
-    end
-
-    it 'should force-sync' do
-      subject.sync(true).should be_nil
-    end
-
-    it 'should accept custom flags' do
-      (subject.flags = LMDB::NOSYNC).should == LMDB::NOSYNC
-      subject.flags.should == LMDB::NOSYNC
-
-      (subject.flags = 0).should == 0
-      subject.flags.should == 0
-    end
-
-    it 'should create transactions' do
-      txn = subject.transaction
-      txn.should be_instance_of(described_class::Transaction)
-      txn.parent.should be_nil
-      txn.environment.should == subject
-      txn.abort
-    end
-
-    it 'should create read-only transactions' do
-      txn = subject.transaction(true)
-      txn.should be_instance_of(described_class::Transaction)
-      txn.abort
-    end
-
-    it 'should create transactions blocks' do
-      subject.transaction do |txn|
-        txn.should be_instance_of(described_class::Transaction)
-        txn.environment.should == subject
-        txn.parent.should be_nil
-      end
-    end
-  end
-
-  describe "Transaction" do
-    subject { env.transaction }
-    after   { subject.abort rescue nil }
-
-    its(:environment) { should == env }
-    its(:parent) { should be_nil }
-
-    it 'can create child transactions' do
-      txn = subject.transaction
-      txn.should be_instance_of(described_class::Transaction)
-      txn.parent.should == subject
-      txn.environment.should == env
-      txn.abort
-    end
-
-    it 'can create block transactions' do
-      subject.transaction do |txn|
-        txn.should be_instance_of(described_class::Transaction)
-        txn.parent.should == subject
-      end
-    end
-  end
-
-  describe "Database" do
-
-    subject do
-      env.transaction do |txn|
-        env.open(txn, 'db', LMDB::CREATE)
-      end
-    end
-    let!(:db) { subject }
-    after     { subject.close rescue nil }
-
-    it 'stores key/values in same transaction' do
-      env.transaction do |txn|
-        db.put(txn, 'key', 'value').should be_nil
-        db.get(txn, 'key').should == 'value'
-      end
-    end
-
-    it 'stores key/values in different transactions' do
-      env.transaction do |txn|
-        db.put(txn, 'key', 'value').should be_nil
-      end
-
-      env.transaction do |txn|
-        db.get(txn, 'key').should == 'value'
-      end
-    end
-
-    it 'should return cursor' do
-      env.transaction do |txn|
-        cursor = db.cursor(txn)
-        cursor.should be_instance_of(described_class::Cursor)
-        cursor.close
-      end
-    end
-
-    it 'should return stat' do
-      env.transaction do |txn|
-        db.stat(txn).should be_instance_of(described_class::Stat)
-      end
-    end
-
-    it 'should close' do
-      db.close.should be_nil
-      -> { db.close }.should raise_error(LMDB::Ext::Error, /closed/)
-    end
-
-    it "should be correctly GC'd", segfault: true do
-      db = env.transaction {|t| env.open(t, 'db', LMDB::CREATE) }
-      db = nil
-      GC.start
-      db = env.transaction {|t| env.open(t, 'db', LMDB::CREATE) }
-    end
-
-  end
-
-  describe "Cursor" do
-
-    let! :db do
-      env.transaction {|txn| env.open(txn, 'db', LMDB::CREATE) }
-    end
-
-    before do
-      env.transaction do |txn|
-        db.put(txn, 'key1', 'value1')
-        db.put(txn, 'key2', 'value2')
-      end
-    end
-
-    after do
-      db.close
-    end
-
-    def with_cursor
-      env.transaction do |txn|
-        cursor = db.cursor(txn)
-        begin
-          yield cursor
-        ensure
-          cursor.close
-        end
-      end
-    end
-
-    it 'should get next key/value' do
-      with_cursor do |c|
-        c.first.should == ['key1', 'value1']
-      end
-    end
-
-    it 'should get next key/value' do
-      with_cursor do |c|
-        c.first
-        c.next.should == ['key2', 'value2']
-      end
-    end
-
-    it 'should seek to key' do
-      with_cursor do |c|
-        c.set('key1').should == ['key1', 'value1']
-      end
-    end
-
-    it 'should seek to closest key' do
-      with_cursor do |c|
-        c.set_range('key0').should == ['key1', 'value1']
-      end
-    end
-
-    it 'should seek to key with nuls' do
-      with_cursor do |c|
-        c.set_range("\x00").should == ['key1', 'value1']
-      end
-    end
-
-  end
-end