btree 0.0.0 → 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a5640c8a1cddfdfb4f56acbc605aaa5722ab154605f133a8dfa8b089cc32e1c
+  data.tar.gz: edf0f1348d367ddacb3337d42df137201064c981b5becc84ab6a0b1368990217
+SHA512:
+  metadata.gz: a7ded3fe792d31605f5a115402419f819c0bebfc72d38ac50fac86300bd595b871be8d73a19d538a75445a76579b327bdc2884f38e5606f94ca8761df976a26d
+  data.tar.gz: 0cee704dabf324cddfab2e6edac454fe7698cfdd8b936f013969aec0b4b22e75ef6ac2ca272ab2d04313b0bdd5b1b6d35ce0d4e54f5eb6d6789988c95d64121e

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+# Runtime dependencies come from btree.gemspec, which declares none.
+gemspec
+
+# shoulda-context supplies the context/should DSL the tests use. The shoulda
+# meta-gem would also pull in shoulda-matchers, whose only purpose is Rails
+# model assertions this project has no use for, and which drags in the whole
+# activesupport tree behind it.
+group :development, :test do
+  gem "rake", "~> 13"
+  gem "minitest", "~> 6.0"
+  gem "shoulda-context", "~> 2.0"
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    btree (1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    drb (2.2.3)
+    minitest (6.0.6)
+      drb (~> 2.0)
+      prism (~> 1.5)
+    prism (1.9.0)
+    rake (13.4.2)
+    shoulda-context (2.0.0)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  btree!
+  minitest (~> 6.0)
+  rake (~> 13)
+  shoulda-context (~> 2.0)
+
+CHECKSUMS
+  btree (1.0.1)
+  drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  shoulda-context (2.0.0) sha256=7adf45342cd800f507d2a053658cb1cce2884b616b26004d39684b912ea32c34
+
+BUNDLED WITH
+  4.0.17

data/History.txt

@@ -1,3 +1,22 @@
+== 1.0.1 / 2026-07-23
+
+* 2 bug fixes
+  * Range queries now visit every subtree that can contain an in-range key.
+    Previously the descent stopped at the first key at or above the range end,
+    so values held in later subtrees were silently omitted from the result.
+  * Inserting a key that a node split had promoted into an internal node now
+    raises "Duplicate key". Previously the duplicate check ran only at the
+    leaf, so such a key was descended past and inserted a second time, leaving
+    one copy unreachable in a subtree.
+
+* 1 minor enhancement
+  * Nodes locate keys by a hybrid linear/binary search, scanning small nodes
+    and using bsearch on large ones.
+
+== 1.0.0 / 2017-11-09
+
+* Initial gem release.
+
 == 0.0.0 / 2010-12-20
 
 * 1 major enhancement

data/README.md

@@ -1,5 +1,5 @@
-Ruby-BTree
-==========
+btree
+=====
 
 Pure ruby implementation of a btree as described in Introduction to Algorithms by 
 Cormen, Leiserson, Rivest and Stein, Chapter 18.

data/Rakefile

@@ -1,18 +1,177 @@
+require 'rake/testtask'
+require 'rake/clean'
+require 'rubygems/package_task'
 
-begin
-  require 'bones'
+SPEC = Gem::Specification.load('btree.gemspec')
+VERSION = SPEC.version.to_s
+GEM_FILE = "pkg/#{SPEC.full_name}.gem"
+
+CLOBBER.include('pkg', 'doc')
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/test_*.rb']
+end
+
+task :default => :test
+
+Gem::PackageTask.new(SPEC) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+desc 'Build the gem into pkg/'
+task :build => :package
+
+desc 'Install the built gem locally'
+task :install => :build do
+  sh 'gem', 'install', GEM_FILE
+end
+
+# Shells out with Bundler's environment stripped. Anything that inspects the
+# gem as an end user would -- installing it, requiring it -- has to run outside
+# this project's bundle, or it picks up the working tree instead of the package.
+def unbundled(*cmd)
+  require 'bundler'
+  Bundler.with_unbundled_env { sh(*cmd) }
 rescue LoadError
-  abort '### Please install the "bones" gem ###'
+  sh(*cmd)
+end
+
+def rubygems_versions
+  require 'open-uri'
+  require 'json'
+  JSON.parse(URI.open("https://rubygems.org/api/v1/versions/#{SPEC.name}.json").read)
+rescue OpenURI::HTTPError, SocketError, JSON::ParserError => e
+  warn "WARNING: could not reach rubygems.org (#{e.class}: #{e.message})."
+  nil
 end
 
-task :default => 'test:run'
-task 'gem:release' => 'test:run'
+namespace :release do
+  desc 'Check the working tree, metadata and credentials are fit to release'
+  task :check do
+    problems = []
+
+    problems << 'working tree is dirty; commit or stash first' unless
+      `git status --porcelain`.strip.empty?
+
+    # The tag has to point at a commit that exists somewhere other than this
+    # laptop, otherwise a published gem can be built from work nobody else has.
+    if `git branch -r --contains HEAD 2>/dev/null`.strip.empty?
+      problems << 'HEAD is not on any remote branch; push it before releasing'
+    end
+
+    problems << "tag v#{VERSION} already exists; bump version.txt" if
+      `git tag -l v#{VERSION}`.strip == "v#{VERSION}"
+
+    problems << "History.txt has no entry for #{VERSION}" unless
+      File.read('History.txt').start_with?("== #{VERSION} ")
 
-Bones {
-  name  'btree'
-  authors  'Douglas A. Seifert'
-  email    'doug@dseifert.net'
-  url      'http://www.dseifert.net/btree'
-  readme_file 'README.md'
-}
+    # A version number is the one genuinely unrecoverable resource in a
+    # release: RubyGems refuses to re-push it even after a yank.
+    if (published = rubygems_versions)
+      problems << "#{SPEC.name} #{VERSION} is already on rubygems.org" if
+        published.any? {|v| v['number'] == VERSION }
+    end
 
+    # Surfaced now rather than as a 403 after the tag has been pushed.
+    # Ask RubyGems where the credentials file lives rather than assuming
+    # ~/.gem/credentials: modern installs use the XDG path
+    # (~/.local/share/gem/credentials), and hardcoding the old one reports a
+    # missing key that is really there.
+    require 'rubygems/config_file'
+    creds = Gem.configuration.credentials_path
+    unless ENV['GEM_HOST_API_KEY'] || File.exist?(creds)
+      problems << "no rubygems credentials at #{creds}; run `gem signin` (the key needs the push_rubygem scope)"
+    end
+
+    branch = `git rev-parse --abbrev-ref HEAD`.strip
+    warn "WARNING: releasing from #{branch}, not master." unless branch == 'master'
+
+    unless problems.empty?
+      abort "ERROR: not ready to release #{SPEC.name} #{VERSION}:\n" +
+            problems.map {|p| "  - #{p}" }.join("\n")
+    end
+
+    puts "OK: #{SPEC.name} #{VERSION} passes pre-release checks."
+  end
+
+  desc 'Build the gem and prove the built artifact actually works'
+  task :verify => :repackage do
+    require 'tmpdir'
+
+    puts "Packaged #{GEM_FILE}:"
+    Gem::Package.new(GEM_FILE).spec.files.each {|f| puts "  #{f}" }
+
+    # Installing into a throwaway GEM_HOME is the only check that covers what
+    # was actually packaged rather than what is sitting in the working tree --
+    # a file missing from the manifest looks fine locally and breaks on install.
+    Dir.mktmpdir do |dir|
+      unbundled 'gem', 'install', '--no-document', '--install-dir', dir, GEM_FILE
+
+      script = <<~RUBY
+        gem 'btree'
+        require 'btree'
+        raise "version mismatch: \#{Btree.version} != #{VERSION}" unless Btree.version == '#{VERSION}'
+        t = Btree.create(3)
+        (1..50).each {|i| t[i] = i.to_s }
+        got = t[10..14]
+        raise "bad range query: \#{got.inspect}" unless got == %w[10 11 12 13 14]
+        raise "bad lookup" unless t[37] == '37'
+        puts "smoke test passed on the installed gem"
+      RUBY
+
+      Dir.chdir(dir) do
+        unbundled({'GEM_HOME' => dir, 'RUBYOPT' => nil}, RbConfig.ruby, '-e', script)
+      end
+    end
+  end
+
+  desc 'Tag the release and push the tag to origin (reversible)'
+  task :tag do
+    sh 'git', 'tag', '-a', "v#{VERSION}", '-m', "#{SPEC.name} #{VERSION}"
+    sh 'git', 'push', 'origin', "v#{VERSION}"
+    puts "Tagged v#{VERSION}. To undo: git tag -d v#{VERSION} && git push origin :v#{VERSION}"
+  end
+
+  # repackage, not build: the packaged gem is a file task, so an existing
+  # pkg/*.gem newer than its sources satisfies :build without rebuilding. Fine
+  # locally, wrong when the next step is irreversible.
+  desc 'Push the gem to rubygems.org (IRREVERSIBLE)'
+  task :push => :repackage do
+    puts
+    puts "About to push #{GEM_FILE} to rubygems.org."
+    puts "This cannot be undone: #{SPEC.name} #{VERSION} can never be re-pushed,"
+    puts 'even if it is yanked afterwards.'
+
+    unless ENV['FORCE'] == '1'
+      abort 'ERROR: refusing to push from a non-interactive shell without FORCE=1.' unless $stdin.tty?
+      print "Type the version (#{VERSION}) to confirm: "
+      abort 'Aborted.' unless $stdin.gets.to_s.strip == VERSION
+    end
+
+    sh 'gem', 'push', GEM_FILE
+  end
+
+  desc 'Confirm the version is live on rubygems.org'
+  task :confirm do
+    published = rubygems_versions
+    if published&.any? {|v| v['number'] == VERSION }
+      puts "Confirmed: #{SPEC.name} #{VERSION} is live on rubygems.org."
+    else
+      warn "WARNING: #{SPEC.name} #{VERSION} is not visible on rubygems.org yet (indexing can lag)."
+    end
+  end
+end
+
+desc 'Full release: check, test, verify the built gem, tag, then push'
+task :release do
+  # Ordered so that everything reversible happens first. The tag is cheap to
+  # delete; the push is permanent, so it goes last and only after the packaged
+  # gem has been installed and exercised.
+  %w[release:check test release:verify release:tag release:push release:confirm].each do |t|
+    puts "\n==> #{t}"
+    Rake::Task[t].invoke
+  end
+  puts "\nReleased #{SPEC.name} #{VERSION}."
+end

data/btree.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = 'btree'
+  # version.txt stays the single source of truth: Btree.version reads it back
+  # at runtime, so it has to ship in the gem regardless.
+  s.version     = File.read(File.expand_path('version.txt', __dir__)).strip
+  s.authors     = ['Douglas A. Seifert']
+  s.email       = 'doug@dseifert.net'
+  s.homepage    = 'https://github.com/seifertd/Ruby-BTree'
+  s.license     = 'MIT'
+
+  s.summary     = 'Pure ruby implementation of a btree'
+  s.description = <<~DESC
+    Pure ruby implementation of a btree as described in Introduction to
+    Algorithms by Cormen, Leiserson, Rivest and Stein, Chapter 18.
+  DESC
+
+  # Array#bsearch_index, used by Node#key_index, is the oldest thing here that
+  # is not universally available. CI only exercises 3.2 and up, because that is
+  # the floor imposed by the development gems, not by the library.
+  s.required_ruby_version = '>= 2.3.0'
+
+  # Rejecting dotfiles drops .github/, .gitignore and the .ruby-* files, which
+  # is the same set the old Bones exclude list named by hand. Building outside
+  # a git checkout is not supported, which matches how this gem is released.
+  s.files = `git ls-files -z`.split("\x0").reject {|f| f.start_with?('.') }
+
+  s.require_paths      = ['lib']
+  s.extra_rdoc_files   = ['History.txt', 'README.md']
+  s.rdoc_options       = ['--main', 'README.md']
+
+  s.metadata = {
+    'homepage_uri'    => s.homepage,
+    'source_code_uri' => s.homepage,
+    'changelog_uri'   => "#{s.homepage}/blob/master/History.txt",
+    'bug_tracker_uri' => "#{s.homepage}/issues",
+
+    # Requires that whoever pushes this gem has MFA enabled on their
+    # rubygems.org account, so a leaked API key is not enough on its own.
+    # This needs MFA turned on for the account first, or the push is rejected.
+    'rubygems_mfa_required' => 'true'
+  }
+end

data/lib/btree/node.rb

@@ -1,18 +1,28 @@
 class Btree::Node
-  attr_accessor :leaf
+
+  # Nodes holding at most this many keys are searched by a straight scan
+  # rather than by bsearch, whose per-probe block dispatch costs more than the
+  # comparisons it saves on a short array.  The measured crossover is around
+  # 23 keys and the curves are within a couple of percent of each other from
+  # roughly 19 to 23, so the exact value here matters little.  Note that a
+  # degree of 12 or less can never exceed the limit (a node holds at most
+  # 2*degree - 1 keys), and that a node under a larger degree still scans
+  # while it is sparsely filled.
+  LINEAR_SCAN_LIMIT = 20
+  private_constant :LINEAR_SCAN_LIMIT
+
   def initialize(degree)
     @degree = degree
     @keys = []
     @children = []
-    @leaf = true
   end
 
   def dump(level = 0)
     @keys.each_with_index do |key, idx|
+      puts "LEVEL: #{level} => #{key.first}: full? #{full?} leaf? #{leaf?} children: #{values.inspect}"
       if @children[idx]
          @children[idx].dump(level + 1)
       end
-      puts "#{level}: #{key.first}: full? #{full?} leaf? #{leaf?}"
     end
     (@children[@keys.size..-1] || []).each do |c|
       c.dump(level+1)
@@ -41,50 +51,76 @@ class Btree::Node
   end
 
   def leaf?
-    @leaf
+    @children.length == 0
   end
 
   def size
     @keys.size
   end
 
-  def value_of(key)
-    i = 1
-    while i <= size && key > @keys[i-1].first
+  # Values whose keys fall in the range, in key order.  Subtrees that cannot
+  # contain an in-range key are never visited.
+  def values_of(range)
+
+    result = Array.new
+    lo = range.begin
+    hi = range.end
+
+    # Skip the keys, and the subtrees between them, that sort entirely below
+    # the range.  When every key is below it, this lands on the rightmost
+    # child, which may still hold in-range keys.
+    i = lo ? key_index(lo) : 0
+
+    result += @children[i].values_of(range) if !leaf? && @children[i]
+
+    while i < size
+      key = @keys[i].first
+      # Everything from here on sorts above the range.
+      break if hi && (range.exclude_end? ? key >= hi : key > hi)
+      result << @keys[i].last if range.cover? key
+      result += @children[i+1].values_of(range) if !leaf? && @children[i+1]
       i += 1
     end
 
-    if i <= size && key == @keys[i-1].first
-      return @keys[i-1].last
+    result
+
+  end
+
+
+  def value_of(key)
+
+    return values_of(key) if key.kind_of? Range
+
+    i = key_index(key)
+
+    if i < size && key == @keys[i].first
+      return @keys[i].last
     elsif leaf?
       return nil
     else
-      return @children[i-1].value_of(key)
+      return @children[i].value_of(key)
     end
   end
 
   def insert(key, value)
-    i = size - 1
-    #puts "INSERTING #{key} INTO NODE: #{self.inspect}"
+    # The slot the key would occupy is also the slot it would already occupy if
+    # it were present, so locating it and rejecting a duplicate are one step.
+    # Checked at every node on the way down, not just at the leaf: a key that a
+    # split has promoted into an internal node would otherwise be descended
+    # past and inserted a second time, hiding one copy in a subtree.
+    i = key_index(key)
+    raise "Duplicate key" if i < size && @keys[i].first == key
+
     if leaf?
-      raise "Duplicate key" if @keys.any?{|(k,v)| k == key }  #OPTIMIZE: This is inefficient
-      while i >= 0 && @keys[i] && key < @keys[i].first
-        @keys[i+1] = @keys[i]
-        i -= 1
-      end
-      @keys[i+1] = [key, value]
+      @keys.insert(i, [key, value])
     else
-      while i >= 0 && @keys[i] &&  key < @keys[i].first
-        i -= 1
+      if @children[i] && @children[i].full?
+        split(i)
+        # The split just promoted a key into this node, after the check above.
+        raise "Duplicate key" if @keys[i].first == key
+        i += 1 if key > @keys[i].first
       end
-      #puts "   -- INSERT KEY INDEX #{i}"
-      if @children[i+1] && @children[i+1].full?
-        split(i+1)
-        if key > @keys[i+1].first
-          i += 1
-        end
-      end
-      @children[i+1].insert(key, value)
+      @children[i].insert(key, value)
     end
   end
 
@@ -94,7 +130,6 @@ class Btree::Node
     splitee = @children[child_idx]
     y = Btree::Node.new(@degree)
     z = Btree::Node.new(@degree)
-    z.leaf = splitee.leaf
     (@degree-1).times do |j|
       z._keys[j] = splitee._keys[j+@degree]
       y._keys[j] = splitee._keys[j]
@@ -136,4 +171,21 @@ class Btree::Node
     @children
   end
 
+  private
+
+  # Index of the first key that does not sort below the given one, or size if
+  # every key sorts below it.  For an internal node that is also the index of
+  # the child to descend into.  Both branches test only < so that keys need
+  # only support <, > and == -- bsearch's natural k >= key would widen that.
+  def key_index(key)
+    n = size
+    if n <= LINEAR_SCAN_LIMIT
+      i = 0
+      i += 1 while i < n && @keys[i].first < key
+      i
+    else
+      @keys.bsearch_index {|(k, _)| !(k < key) } || n
+    end
+  end
+
 end

data/lib/btree/tree.rb

@@ -6,7 +6,6 @@ class Btree::Tree
   def initialize(degree = 2)
     @degree = degree
     @root = Btree::Node.new(@degree)
-    @root.leaf = true
     @size = 0
   end
 
@@ -15,7 +14,6 @@ class Btree::Tree
     node = @root
     if node.full?  
       @root = Btree::Node.new(@degree)
-      @root.leaf = false
       @root.add_child(node)
       @root.split(@root.children.size - 1)
       #puts "After split, root = #{@root.inspect}"

data/test/test_btree.rb

@@ -1,8 +1,50 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'btree'
-require 'shoulda'
+require 'shoulda/context'
+
+class TestBtree < Minitest::Test
+  # Degree 2 tree with a real internal node:
+  #   root                [10, 20]
+  #   children  [5,6,7] [12,17] [30]
+  def multi_level_tree
+    t = Btree.create(2)
+    [10, 20, 5, 6, 12, 30, 7, 17].each {|k| t.insert(k, k.to_s)}
+    t
+  end
+
+  def test_range_query_spans_multiple_children
+    t = multi_level_tree
+    assert_equal %w[5 6 7 10 12 17], t.value_of(5..17)
+  end
+
+  def test_range_query_finds_keys_in_rightmost_child
+    t = Btree.create(2)
+    (1..10).each {|k| t.insert(k, k.to_s)}
+    assert_equal %w[8 9 10], t.value_of(8..10)
+  end
+
+  def test_insert_duplicate_of_internal_key
+    t = multi_level_tree
+    internal_key = t.root.keys.first
+    refute t.root.leaf?, "fixture should have an internal root"
+    assert_raises(RuntimeError) do
+      t.insert(internal_key, "duplicate")
+    end
+  end
+
+  def test_duplicate_of_internal_key_does_not_corrupt_size
+    t = multi_level_tree
+    internal_key = t.root.keys.first
+    size_before = t.size
+    begin
+      t.insert(internal_key, "duplicate")
+    rescue RuntimeError
+      # expected once duplicate detection descends past the leaves
+    end
+    assert_equal size_before, t.size
+    assert_equal internal_key.to_s, t.value_of(internal_key)
+  end
 
-class TestBtree < Test::Unit::TestCase
   def test_insert_notfull
     t = Btree.create(5)
     t.insert(5, "5")
@@ -26,6 +68,17 @@ class TestBtree < Test::Unit::TestCase
     end
   end
 
+  def test_insert_a_lot
+    t = Btree.create(2)
+    45.times do |i|
+      t.insert i, i*i
+    end
+    assert_equal 45, t.size
+    45.times do |i|
+      assert_equal i*i, t.value_of(i)
+    end
+  end
+
   def test_value_of
     t = Btree.create(5)
     t.insert(1, "foo")
@@ -38,6 +91,7 @@ class TestBtree < Test::Unit::TestCase
     assert_equal "foo", t.value_of(1)
     assert_nil t.value_of(11)
     assert_equal 4, t.size
+    assert_equal ["findme", "bar"], t.value_of(3..6)
   end
 
   def test_fill_root

data/version.txt

@@ -1 +1 @@
-0.0.0
+1.0.1

metadata

@@ -1,96 +1,61 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: btree
-version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 0
-  version: 0.0.0
+version: !ruby/object:Gem::Version
+  version: 1.0.1
 platform: ruby
-authors: 
+authors:
 - Douglas A. Seifert
-autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-20 00:00:00 -08:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: bones
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 3
-        - 5
-        - 4
-        version: 3.5.4
-  type: :development
-  version_requirements: *id001
-description: |-
-  Pure ruby implementation of a btree as described in Introduction to Algorithms by 
-  Cormen, Leiserson, Rivest and Stein, Chapter 18.
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Pure ruby implementation of a btree as described in Introduction to
+  Algorithms by Cormen, Leiserson, Rivest and Stein, Chapter 18.
 email: doug@dseifert.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.txt
-- lib/btree/.node.rb.swp
-- version.txt
-files: 
-- .bnsignore
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
 - History.txt
 - README.md
 - Rakefile
+- btree.gemspec
 - lib/btree.rb
-- lib/btree/.node.rb.swp
 - lib/btree/node.rb
 - lib/btree/tree.rb
 - test/test_btree.rb
 - version.txt
-has_rdoc: true
-homepage: http://www.dseifert.net/btree
-licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --main
+homepage: https://github.com/seifertd/Ruby-BTree
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/seifertd/Ruby-BTree
+  source_code_uri: https://github.com/seifertd/Ruby-BTree
+  changelog_uri: https://github.com/seifertd/Ruby-BTree/blob/master/History.txt
+  bug_tracker_uri: https://github.com/seifertd/Ruby-BTree/issues
+  rubygems_mfa_required: 'true'
+rdoc_options:
+- "--main"
 - README.md
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: btree
-rubygems_version: 1.3.7
-signing_key: 
-specification_version: 3
-summary: Pure ruby implementation of a btree as described in Introduction to Algorithms by  Cormen, Leiserson, Rivest and Stein, Chapter 18.
-test_files: 
-- test/test_btree.rb
+rubygems_version: 4.0.17
+specification_version: 4
+summary: Pure ruby implementation of a btree
+test_files: []

data/.bnsignore

@@ -1,18 +0,0 @@
-# The list of files that should be ignored by Mr Bones.
-# Lines that start with '#' are comments.
-#
-# A .gitignore file can be used instead by setting it as the ignore
-# file in your Rakefile:
-#
-#   Bones {
-#     ignore_file  '.gitignore'
-#   }
-#
-# For a project with a C extension, the following would be a good set of
-# exclude patterns (uncomment them if you want to use them):
-# *.[oa]
-# *~
-announcement.txt
-coverage
-doc
-pkg