lithos 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7741f8dffd9dd5d4d0f710b18fca0a7b1a0d574e893d60c9f5735c36a93954d6
-  data.tar.gz: 6d4eb49a96a6cb44a97587f997905cc77c4e93bd4c33f64579db48754180b7d8
+  metadata.gz: 010db6b8b65ba9a4c32abe95c6d58dfc11a9e8a50e9599aaca10b32460a545dc
+  data.tar.gz: 912268f45027878b57a7cf0629c8b7efac5043f1df9e02f7855e91e2bbbf0d2f
 SHA512:
-  metadata.gz: 6d24765cfbfdc9d6394eacd84081eeba1891f9f8423d2c3665cb7270e417e0cfe4d3e147b79e97607cc1ed6c56d96894805c13a88db2957de37fe350401f60bb
-  data.tar.gz: 4af63db49e563dc16b3411f44a238b86174336b532f1caa6ab478c8e7d68b8282e3ec8d291eeba821177bdda0d0ab654eeaca2a61b4eaf4d735797d40d244883
+  metadata.gz: ee08a3bac4e558814df30ae9c92a9a119912be3be89828755bb85186b68570cd86d32f2746f195ec4d7edd48ceb0e7628918f42fb6a1784875cdf7978c95690c
+  data.tar.gz: adc8d75678a6625460996dd376021ec4ed18101982015ac2ae96344df6533ba57e465aaca9ab6f353585dfeb8a53af10187de71ea6f1b638aa643456ceb9402c

data/README.md

@@ -1,101 +1,11 @@
-# lithos
-
-**A small embedded, ordered, crash-safe key-value store for Ruby — no external database.**
-
-`lithos` is a from-scratch storage engine: a **log-structured merge (LSM) tree**,
-the same design behind LevelDB/RocksDB, written as a native Ruby extension with
-**zero external dependency**. You get:
-
-- **Durable writes** — every `put`/`delete` is appended to a CRC-checked
-  write-ahead log and `fsync`'d before it returns (in the default `sync:` mode).
-- **Crash recovery** — on open, the WAL is replayed; a torn or corrupted tail is
-  detected and discarded.
-- **Ordered keys** — keys are stored sorted (unsigned-byte order), so you get
-  `each`, `each_key`, and range `scan`s for free.
-- **Binary safe** — keys and values are arbitrary byte strings (embedded NULs OK).
-
-The niche it fills: every other ordered + crash-safe Ruby KV store is a binding
-to an external C/C++ library (LMDB/LevelDB/RocksDB) that's a pain to build on a
-native-MSVC Windows Ruby. `lithos` is self-contained and builds with
-[`vcvars`](https://rubygems.org/gems/vcvars) — no prebuilt database needed.
-
-## Requirements
-
-- **Windows** with a native **MSVC (mswin)** Ruby. Not supported on MinGW/UCRT.
-- Visual Studio 2017+ / Build Tools with the **Desktop development with C++** workload.
-
-## Install
-
-```sh
-gem install lithos
-```
-
-## Usage
-
-```ruby
-require "lithos"
-
-Lithos.open("data/mydb") do |db|
-  db["alpha"] = "one"
-  db.put("beta", "two")
-  db.put("\x00raw\xff", "binary ok")     # arbitrary binary keys + values
-
-  db["alpha"]            # => "one"
-  db["missing"]          # => nil
-  db.key?("beta")        # => true
-  db.fetch("nope", "default")            # => "default" (or raises KeyError)
-  db.delete("beta")      # => true (existed)
-
-  # ordered iteration (ascending unsigned-byte key order)
-  db.each      { |k, v| puts "#{k}=#{v}" }
-  db.each_key  { |k|    puts k }
-
-  # ordered range scans
-  db.scan(gte: "a", lt: "m") { |k, v| ... }   # gt/lt exclusive, gte/lte inclusive
-  db.range("a", "m")         { |k, v| ... }    # half-open [a, m)
-  db.scan(gte: "a").to_a                       # Enumerator without a block
-
-  db.size                # live key count
-  db.flush               # seal the memtable into an SSTable
-  db.compact             # merge SSTables, dropping shadowed keys + tombstones
-end                      # closed automatically (flush + fsync)
-```
-
-Open without a block when you want to manage the lifetime yourself:
-
-```ruby
-db = Lithos.open("data/mydb", sync: true)
-db["k"] = "v"
-db.close
-```
-
-Data persists across reopens, and survives a crash (process kill, power loss at
-the OS-flush boundary): reopening replays the WAL and discards any partial tail.
-
-## How it works
-
-```
-put/delete ──> WAL (append + CRC + fsync) ──> memtable (sorted std::map)
-                                                  │  (size threshold)
-                                                  ▼
-                                          SSTable (immutable, mmap'd:
-                                          sorted data + bloom + sparse index)
-get ──> memtable ──> SSTables newest→oldest (bloom-filtered)
-compact ──> k-way merge of all SSTables ──> one SSTable (drops tombstones)
-```
-
-The set of live SSTables + the active WAL is recorded in a `MANIFEST` that is
-rewritten atomically (temp file + `FlushFileBuffers` + atomic rename), so the
-on-disk catalog is never observed half-updated.
-
-## Notes
-
-- **Durability vs speed:** `sync: true` (default) `fsync`s every write. For bulk
-  loads, `Lithos.open(path, sync: false)` skips per-write `fsync` (call `#flush`
-  or `#close` to make data durable) — faster, but a crash can lose recent writes.
-- **Single writer:** a store takes an exclusive directory lock on open; it is not
-  safe to share one store across threads (give each thread its own, or use a Mutex).
-
-## License
-
-[MIT](LICENSE.txt).
+# lithos (discontinued)
+
+**lithos is no longer maintained.** This final release (0.1.1) contains no
+code: installing it compiles nothing, and `require "lithos"` raises a
+`LoadError` explaining the discontinuation.
+
+Use sqlite3, or PStore from the standard library instead.
+
+Earlier releases remain on RubyGems only because RubyGems does not allow
+versions older than 30 days to be yanked. They are unmaintained and not
+recommended.

data/lib/lithos.rb

@@ -1,170 +1,4 @@
-# frozen_string_literal: true
-
-require "lithos/version"
-require "lithos/lithos" # native extension: defines Lithos::DB + Lithos::Error
-
-# lithos — a small embedded, ordered, crash-safe key-value store.
-#
-#   Lithos.open("data/db") do |db|
-#     db["alpha"] = "1"
-#     db.put("\x00bin\xff", "raw")           # binary keys/values welcome
-#     db["alpha"]                            # => "1"
-#     db.scan(gte: "a", lt: "m") { |k, v| }  # ordered range
-#   end                                      # auto-closed (flushes + fsyncs)
-module Lithos
-  # Open a store at `path` (a directory, created if missing). Options:
-  #   sync:           durably fsync each write before it returns (default true)
-  #   memtable_bytes: flush the in-memory table to an SSTable past this size
-  #
-  # With a block: yields the store, closes it when the block returns (even on
-  # error), and returns the block's value. Without a block: returns the store,
-  # and the caller must #close it.
-  def self.open(path, **opts)
-    db = DB.new(path, **opts)
-    return db unless block_given?
-
-    begin
-      yield db
-    ensure
-      db.close
-    end
-  end
-
-  class DB
-    include Enumerable
-
-    # --- mutators (forbidden while an each/scan is in progress) --------------
-    # The merge iterator holds raw pointers into memory-mapped SSTables and live
-    # memtable iterators; mutating mid-scan would free them underneath it. We
-    # refuse here with a plain Ruby exception (which unwinds safely), rather than
-    # let it reach the C engine during iteration.
-
-    def put(key, value)
-      forbid_during_iteration!
-      _put(key, value)
-    end
-
-    def delete(key)
-      forbid_during_iteration!
-      _delete(key)
-    end
-
-    def flush
-      forbid_during_iteration!
-      _flush
-    end
-
-    def compact
-      forbid_during_iteration!
-      _compact
-    end
-
-    def close
-      forbid_during_iteration!
-      _close
-    end
-
-    # Hash-like access. `db[k]` => value or nil; `db[k] = v` stores v.
-    def [](key)
-      get(key)
-    end
-
-    def []=(key, value)
-      put(key, value)
-      value
-    end
-
-    # Like Hash#fetch: return the value, else the block result, else the default,
-    # else raise KeyError. (Stored values are never nil, so nil == absent.)
-    def fetch(key, *default)
-      if default.size > 1
-        raise ArgumentError, "wrong number of arguments (given #{default.size + 1}, expected 1..2)"
-      end
-
-      value = get(key)
-      return value unless value.nil?
-      return yield(key) if block_given?
-      return default.first unless default.empty?
-
-      raise KeyError, "key not found: #{key.inspect}"
-    end
-
-    alias include? key?
-    alias has_key? key?
-    alias member? key?
-
-    # Iterate all pairs in ascending (unsigned-byte) key order.
-    def each(&block)
-      return enum_for(:each) unless block
-
-      bounded_each(nil, false, nil, false, &block)
-    end
-    alias each_pair each
-
-    # Iterate keys only, ascending.
-    def each_key
-      return enum_for(:each_key) unless block_given?
-
-      bounded_each(nil, false, nil, false) { |k, _| yield k }
-    end
-
-    # Ordered range scan. Bounds are optional; gt/lt are exclusive, gte/lte
-    # inclusive. Returns an Enumerator without a block.
-    def scan(gte: nil, gt: nil, lte: nil, lt: nil, &block)
-      lower, lower_incl = gt ? [gt, false] : (gte ? [gte, true] : [nil, false])
-      upper, upper_incl = lt ? [lt, false] : (lte ? [lte, true] : [nil, false])
-      bounded_each(lower, lower_incl, upper, upper_incl, &block)
-    end
-
-    # Half-open range [from, to) in ascending order.
-    def range(from, to, &block)
-      bounded_each(from, true, to, false, &block)
-    end
-
-    # Number of live keys. O(n) — counts via an ordered scan.
-    def size
-      n = 0
-      each_key { n += 1 }
-      n
-    end
-    alias length size
-
-    def empty?
-      each { return false }
-      true
-    end
-
-    def to_h
-      h = {}
-      each { |k, v| h[k] = v }
-      h
-    end
-
-    def inspect
-      "#<Lithos::DB path=#{path.inspect}#{closed? ? ' (closed)' : ''}>"
-    end
-
-    private
-
-    def forbid_during_iteration!
-      return unless (@iterating || 0).positive?
-
-      raise Error, "lithos: cannot modify the store during iteration"
-    end
-
-    # Shared range driver; positional args so enum_for forwards cleanly. The
-    # @iterating depth lets reads nest while mutations are blocked, and the
-    # ensure guarantees the count is restored even on break/exception.
-    def bounded_each(lower, lower_incl, upper, upper_incl, &block)
-      return enum_for(:bounded_each, lower, lower_incl, upper, upper_incl) unless block
-
-      @iterating = (@iterating || 0) + 1
-      begin
-        _each_range(lower, lower_incl, upper, upper_incl, &block)
-      ensure
-        @iterating -= 1
-      end
-      self
-    end
-  end
-end
+# frozen_string_literal: true
+
+raise LoadError, "lithos is discontinued and this release contains no code. Use sqlite3, or PStore from the standard library instead." \
+  " Earlier lithos releases are unmaintained and not recommended."

metadata

@@ -1,104 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: lithos
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - ned
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: vcvars
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-description: |
-  lithos is a self-contained embedded key-value store written from scratch as a
-  native extension — no external database dependency. It uses a log-structured
-  merge (LSM) tree: a write-ahead log makes every write durable, an in-memory
-  sorted memtable flushes to immutable SSTables (with bloom filters), and
-  compaction merges them. Keys and values are arbitrary binary strings; keys
-  are kept in sorted order so you get ordered iteration and range scans, plus
-  crash recovery via WAL replay. Windows MSVC (mswin) Ruby only.
+dependencies: []
+description: lithos is discontinued. This final release contains no code and exists
+  only so that installing lithos explains the discontinuation instead of building
+  an unmaintained native extension.
 executables: []
-extensions:
-- ext/lithos/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- ext/lithos/extconf.rb
-- ext/lithos/lithos.cpp
 - lib/lithos.rb
-- lib/lithos/version.rb
-homepage: https://github.com/main-path/lithos
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/main-path/lithos
-  changelog_uri: https://github.com/main-path/lithos/blob/main/CHANGELOG.md
-  bug_tracker_uri: https://github.com/main-path/lithos/issues
   rubygems_mfa_required: 'true'
+post_install_message: lithos is discontinued and this release contains no code. Use
+  sqlite3, or PStore from the standard library instead.
 rdoc_options: []
 require_paths:
 - lib
@@ -106,7 +32,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -115,5 +41,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A small embedded, ordered, crash-safe key-value store (LSM-tree) for Ruby.
+summary: Discontinued. Use sqlite3, or PStore from the standard library instead.
 test_files: []

data/CHANGELOG.md

@@ -1,28 +0,0 @@
-# Changelog
-
-All notable changes to this project are documented here. The format is based on
-[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
-adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-## [0.1.0] - 2026-05-30
-
-### Added
-- `Lithos.open(path, sync:, memtable_bytes:)` with block (auto-close) and
-  non-block forms; `#close`, `#closed?`, `#path`.
-- `#put`/`#[]=`, `#get`/`#[]`, `#delete`, `#key?` (+ `include?`/`has_key?`),
-  `#fetch` (with default/block, raises `KeyError`).
-- Ordered iteration: `#each`, `#each_key`, `#scan(gte:/gt:/lte:/lt:)`,
-  `#range(from, to)`; `Enumerable` mixed in; `#size`/`#length`, `#empty?`, `#to_h`.
-- `#flush` (seal the memtable into an SSTable) and `#compact` (merge SSTables,
-  dropping shadowed keys and tombstones).
-- LSM engine: CRC32 write-ahead log (durable per write in sync mode), sorted
-  memtable, immutable memory-mapped SSTables with bloom filters + sparse index,
-  atomically-published MANIFEST catalog, crash recovery via WAL replay (torn /
-  bad-CRC tail discarded), and an exclusive single-writer directory lock.
-- Arbitrary binary keys and values (embedded NULs); lexicographic unsigned-byte
-  key ordering.
-
-[Unreleased]: https://github.com/main-path/lithos/compare/v0.1.0...HEAD
-[0.1.0]: https://github.com/main-path/lithos/releases/tag/v0.1.0

data/ext/lithos/extconf.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-#
-# extconf.rb for the lithos LSM key-value store extension.
-
-require "mkmf"
-
-unless RbConfig::CONFIG["target_os"] =~ /mswin/
-  abort <<~MSG
-    lithos requires a native Windows MSVC (mswin) Ruby — its storage engine uses
-    Win32 file APIs (memory-mapped SSTables, FlushFileBuffers, atomic rename) and
-    is built with cl.exe. Your Ruby is "#{RbConfig['arch']}".
-  MSG
-end
-
-# C++ engine (std::map/std::string/std::vector/std::priority_queue) — needs C++ exceptions.
-$CXXFLAGS << " -EHsc"
-
-# kernel32 (file APIs / mapping) is linked by default; no extra import libs needed.
-
-create_makefile("lithos/lithos")