btree 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 64a14900f4f059a6341312729643c101a88d19ea
-  data.tar.gz: da8ab66ed5bdf738658f2ef7ecb1421c9d58d1dc
+SHA256:
+  metadata.gz: 5a5640c8a1cddfdfb4f56acbc605aaa5722ab154605f133a8dfa8b089cc32e1c
+  data.tar.gz: edf0f1348d367ddacb3337d42df137201064c981b5becc84ab6a0b1368990217
 SHA512:
-  metadata.gz: 0a1929ec3cb16b36af5ef5cbc1546bf59652f4aeddf6765b9ff70c7ea502c77827e29fb41ce7b556d7bb93c3cf6f293b46ce1ae06dcd79551cfe4b8e5d74924c
-  data.tar.gz: 26fc63048a49802026ba22661f025fc904d295ff0198c277dfd410650bbf539efb2477203e778d13e3328af2ed0247d6aeee1083d39bfaa5d88d545e5eb4d7f3
+  metadata.gz: a7ded3fe792d31605f5a115402419f819c0bebfc72d38ac50fac86300bd595b871be8d73a19d538a75445a76579b327bdc2884f38e5606f94ca8761df976a26d
+  data.tar.gz: 0cee704dabf324cddfab2e6edac454fe7698cfdd8b936f013969aec0b4b22e75ef6ac2ca272ab2d04313b0bdd5b1b6d35ce0d4e54f5eb6d6789988c95d64121e

data/Gemfile

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 source "https://rubygems.org"
-#repo_name "seifertd/Ruby-BTree"
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-# gem "rails"
-
-# Added at 2017-11-09 08:39:45 -0800 by doug:
-gem "rake", "~> 12.2", :group => [:development, :test]
-
-# Added at 2017-11-09 08:40:02 -0800 by doug:
-gem "bones", "~> 3.8", :group => [:development, :test]
-
-# Added at 2017-11-09 08:40:12 -0800 by doug:
-gem "shoulda", "~> 3.5", :group => [:development, :test]
+# 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

@@ -1,41 +1,36 @@
+PATH
+  remote: .
+  specs:
+    btree (1.0.1)
+
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.1.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    bones (3.8.4)
-      little-plugger (~> 1.1)
-      loquacious (~> 1.9)
-      rake (~> 12.0)
-      rdoc (~> 5.0)
-    concurrent-ruby (1.0.5)
-    i18n (0.9.1)
-      concurrent-ruby (~> 1.0)
-    little-plugger (1.1.4)
-    loquacious (1.9.1)
-    minitest (5.10.3)
-    rake (12.2.1)
-    rdoc (5.1.0)
-    shoulda (3.5.0)
-      shoulda-context (~> 1.0, >= 1.0.1)
-      shoulda-matchers (>= 1.4.1, < 3.0)
-    shoulda-context (1.2.2)
-    shoulda-matchers (2.8.0)
-      activesupport (>= 3.0.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.4)
-      thread_safe (~> 0.1)
+    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
-  bones (~> 3.8)
-  rake (~> 12.2)
-  shoulda (~> 3.5)
+  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
-   1.15.3
+  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/Rakefile

@@ -1,19 +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      'https://github.com/seifertd/Ruby-BTree'
-  readme_file 'README.md'
-  exclude ['.bnsignore', '.gitignore', '.ruby-gemset', '.ruby-version', '.travis.yml', 'vendor', '.git']
-}
+    # 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,4 +1,16 @@
 class Btree::Node
+
+  # 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 = []
@@ -46,17 +58,27 @@ class Btree::Node
     @keys.size
   end
 
+  # 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
-
-    i = 1
-    while i <= size && range.end >= @keys[i-1].first
-      if range.cover? @keys[i-1].first
-        result << @keys[i-1].last
-        child = @children[i-1].values_of(range) unless leaf?
-        result += child if child
-      end
+    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
 
@@ -69,47 +91,36 @@ class Btree::Node
 
     return values_of(key) if key.kind_of? Range
 
-    i = 1
-    while i <= size && key > @keys[i-1].first
-      i += 1
-    end
-
-    #puts "Getting value of key #{key}, i = #{i}, keys = #{@keys.inspect}, leaf? #{leaf?}, numchildren: #{@children.size}"
+    i = key_index(key)
 
-    if i <= size && key == @keys[i-1].first
-      #puts "Found key: #{key.inspect}"
-      return @keys[i-1].last
+    if i < size && key == @keys[i].first
+      return @keys[i].last
     elsif leaf?
-      #puts "We are a leaf, no more children, so val is nil"
       return nil
     else
-      #puts "Looking into child #{i}"
-      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
 
@@ -160,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/test/test_btree.rb

@@ -1,8 +1,50 @@
 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 < MiniTest::Test
   def test_insert_notfull
     t = Btree.create(5)
     t.insert(5, "5")

data/version.txt

@@ -1 +1 @@
-1.0.0
+1.0.1

metadata

@@ -1,52 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: btree
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Douglas A. Seifert
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-09 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bones
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.8.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.8.4
-description: "Pure ruby implementation of a btree as described in Introduction to
-  Algorithms by \nCormen, 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:
 - History.txt
+- README.md
 files:
 - Gemfile
 - Gemfile.lock
 - History.txt
 - README.md
 - Rakefile
+- btree.gemspec
 - lib/btree.rb
 - lib/btree/node.rb
 - lib/btree/tree.rb
-- lib/insert_alot.rb
 - test/test_btree.rb
 - version.txt
 homepage: https://github.com/seifertd/Ruby-BTree
-licenses: []
-metadata: {}
-post_install_message: 
+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
@@ -56,18 +48,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: btree
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 4.0.17
 specification_version: 4
-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
+summary: Pure ruby implementation of a btree
+test_files: []

data/lib/insert_alot.rb

@@ -1,7 +0,0 @@
-require "./lib/btree"
-
-t = Btree.create(2)
-45.times {|n| t.insert n, n*n}
-puts "tree size = #{t.size}"
-puts "Value of 0: #{t.value_of(0).inspect}"
-t.dump