doltlite 0.11.18-x86_64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d5b871d91389729fdbcdac4ddbacc1c9b8ab546772c90b049bfe6d76a02afb15
+  data.tar.gz: a1bbf9b1d9c8ec51300833ac2d630bd916df5e8e8330881eb5e0ac0903631106
+SHA512:
+  metadata.gz: ef8f1159a3e889537e83987282dfe17834077eea7bcd9a3268577ecfc86299ecadc5331fd7a334bd6ad6af32bbf36e5b37a957533880d46d7d0984b99901bfe9
+  data.tar.gz: c8609e2b579493735c3695dd26818a99b6d7f85199db2c35a69ee424556417c377075c4a31ff727d75f88078ab9ae74fbee19c36687d4e9bc6b24bd284b0fd95

data/LICENSE.md

@@ -0,0 +1,8 @@
+# License
+
+Apache License 2.0. Copyright 2024-2026 DoltHub, Inc.
+
+This gem bundles the DoltLite engine built from
+https://github.com/dolthub/doltlite (Apache-2.0). SQLite itself is public domain.
+
+Full text: https://www.apache.org/licenses/LICENSE-2.0

data/README.md

@@ -0,0 +1,46 @@
+# doltlite (Ruby)
+
+[DoltLite](https://github.com/dolthub/doltlite) for Ruby: SQLite with Dolt-style
+version control — `dolt_commit`, `dolt_branch`, `dolt_merge`, `dolt_diff`, and
+the rest. A thin [FFI](https://github.com/ffi/ffi) layer over a bundled
+`libdoltlite`; the `dolt_*` functions are reached through SQL.
+
+## Install
+
+```bash
+gem install doltlite
+```
+
+Precompiled gems bundle `libdoltlite` for common platforms (Linux x86_64/arm64,
+macOS arm64/x86_64), so no compiler is needed. The plain-Ruby gem falls back to
+a system-installed `libdoltlite`.
+
+## Usage
+
+```ruby
+require "doltlite"
+
+db = Doltlite.open("app.db")   # or ":memory:"
+
+db.execute("CREATE TABLE notes(id INTEGER PRIMARY KEY, body TEXT)")
+db.execute("INSERT INTO notes(body) VALUES (?)", "first note")
+
+hash = db.commit(message: "add first note")
+puts "committed #{hash}"
+
+db.query("SELECT commit_hash, message FROM dolt_log").each do |commit_hash, message|
+  puts "#{commit_hash}  #{message}"
+end
+
+db.close
+```
+
+`execute`/`query` take positional bind values (`?`) and return rows as arrays of
+column values. The `dolt_*` functions and virtual tables (`dolt_log`,
+`dolt_status`, `dolt_diff`, `dolt_branches`, ...) are invoked through SQL.
+
+## License
+
+Apache-2.0. The bundled engine is built from
+[dolthub/doltlite](https://github.com/dolthub/doltlite); SQLite itself is public
+domain.

data/lib/doltlite/database.rb

@@ -0,0 +1,115 @@
+module Doltlite
+  class Error < StandardError; end
+
+  # A doltlite database connection: SQLite with Dolt version control.
+  #
+  #   db = Doltlite::Database.new("app.db")   # or ":memory:"
+  #   db.execute("CREATE TABLE t(id INTEGER PRIMARY KEY, v TEXT)")
+  #   db.execute("INSERT INTO t(v) VALUES (?)", "hello")
+  #   db.commit(message: "first commit")
+  #   db.query("SELECT commit_hash, message FROM dolt_log")
+  class Database
+    def initialize(path = ":memory:")
+      handle_ptr = FFI::MemoryPointer.new(:pointer)
+      flags = C::OPEN_READWRITE | C::OPEN_CREATE
+      rc = C.sqlite3_open_v2(path, handle_ptr, flags, nil)
+      @handle = handle_ptr.read_pointer
+      if rc != C::OK
+        message = @handle.null? ? "unable to open #{path}" : C.sqlite3_errmsg(@handle)
+        C.sqlite3_close_v2(@handle) unless @handle.null?
+        @handle = nil
+        raise Error, "open failed (#{rc}): #{message}"
+      end
+      @open = true
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@handle))
+    end
+
+    # Run SQL with optional positional bind values. Returns an array of rows
+    # (each row an array of column values); empty for non-SELECT statements.
+    def execute(sql, *binds)
+      stmt_ptr = FFI::MemoryPointer.new(:pointer)
+      rc = C.sqlite3_prepare_v2(@handle, sql, -1, stmt_ptr, nil)
+      raise Error, "prepare failed: #{C.sqlite3_errmsg(@handle)}" if rc != C::OK
+      stmt = stmt_ptr.read_pointer
+      begin
+        bind_all(stmt, binds)
+        collect_rows(stmt)
+      ensure
+        C.sqlite3_finalize(stmt)
+      end
+    end
+    alias query execute
+
+    # Convenience for SELECT dolt_commit(...). Stages everything when all is
+    # true. Returns the new commit hash.
+    def commit(message:, all: true)
+      args = all ? ["-A", "-m", message] : ["-m", message]
+      placeholders = (["?"] * args.length).join(", ")
+      rows = execute("SELECT dolt_commit(#{placeholders})", *args)
+      rows.dig(0, 0)
+    end
+
+    def version
+      C.sqlite3_libversion
+    end
+
+    def close
+      return unless @open
+      C.sqlite3_close_v2(@handle)
+      @open = false
+      @handle = nil
+    end
+
+    def closed?
+      !@open
+    end
+
+    def self.finalizer(handle)
+      proc { C.sqlite3_close_v2(handle) unless handle.nil? || handle.null? }
+    end
+
+    private
+
+    def bind_all(stmt, binds)
+      binds.each_with_index do |value, i|
+        index = i + 1
+        case value
+        when nil
+          C.sqlite3_bind_null(stmt, index)
+        when Integer
+          C.sqlite3_bind_int64(stmt, index, value)
+        when Float
+          C.sqlite3_bind_double(stmt, index, value)
+        else
+          str = value.to_s
+          C.sqlite3_bind_text(stmt, index, str, str.bytesize, C::TRANSIENT)
+        end
+      end
+    end
+
+    def collect_rows(stmt)
+      rows = []
+      ncols = C.sqlite3_column_count(stmt)
+      loop do
+        rc = C.sqlite3_step(stmt)
+        break if rc == C::DONE
+        raise Error, "step failed: #{C.sqlite3_errmsg(@handle)}" if rc != C::ROW
+        rows << (0...ncols).map { |c| column_value(stmt, c) }
+      end
+      rows
+    end
+
+    def column_value(stmt, col)
+      case C.sqlite3_column_type(stmt, col)
+      when C::INTEGER then C.sqlite3_column_int64(stmt, col)
+      when C::FLOAT then C.sqlite3_column_double(stmt, col)
+      when C::NULL then nil
+      when C::BLOB
+        n = C.sqlite3_column_bytes(stmt, col)
+        C.sqlite3_column_blob(stmt, col).read_bytes(n)
+      else
+        C.sqlite3_column_text(stmt, col)
+      end
+    end
+  end
+end

data/lib/doltlite/library.rb

@@ -0,0 +1,80 @@
+require "ffi"
+require "rbconfig"
+
+module Doltlite
+  # Locates and binds the doltlite shared library. Precompiled platform gems
+  # bundle the library under vendor/libdoltlite/; otherwise we fall back to a
+  # system-installed libdoltlite on the loader path.
+  module Library
+    module_function
+
+    def library_name
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/ then "libdoltlite.dylib"
+      when /mswin|mingw|cygwin/ then "doltlite.dll"
+      else "libdoltlite.so"
+      end
+    end
+
+    # Path to the bundled library inside the gem, or nil if not present.
+    def bundled_path
+      path = File.expand_path("../../vendor/libdoltlite/#{library_name}", __dir__)
+      File.exist?(path) ? path : nil
+    end
+
+    # What FFI should load: the bundled library if present, else the bare name
+    # so the system loader resolves an installed libdoltlite.
+    def target
+      bundled_path || library_name
+    end
+  end
+
+  # FFI bindings to the doltlite C API (the SQLite C API; dolt_* functions are
+  # reached through SQL).
+  module C
+    extend FFI::Library
+    ffi_lib Doltlite::Library.target
+
+    # Result codes
+    OK = 0
+    ROW = 100
+    DONE = 101
+
+    # Column types
+    INTEGER = 1
+    FLOAT = 2
+    TEXT = 3
+    BLOB = 4
+    NULL = 5
+
+    # open flags
+    OPEN_READWRITE = 0x00000002
+    OPEN_CREATE = 0x00000004
+
+    # SQLITE_TRANSIENT tells the engine to copy bound buffers.
+    TRANSIENT = FFI::Pointer.new(-1)
+
+    attach_function :sqlite3_open_v2, [:string, :pointer, :int, :string], :int
+    attach_function :sqlite3_close_v2, [:pointer], :int
+    attach_function :sqlite3_errmsg, [:pointer], :string
+    attach_function :sqlite3_errcode, [:pointer], :int
+    attach_function :sqlite3_exec, [:pointer, :string, :pointer, :pointer, :pointer], :int
+    attach_function :sqlite3_prepare_v2, [:pointer, :string, :int, :pointer, :pointer], :int
+    attach_function :sqlite3_step, [:pointer], :int
+    attach_function :sqlite3_reset, [:pointer], :int
+    attach_function :sqlite3_finalize, [:pointer], :int
+    attach_function :sqlite3_column_count, [:pointer], :int
+    attach_function :sqlite3_column_name, [:pointer, :int], :string
+    attach_function :sqlite3_column_type, [:pointer, :int], :int
+    attach_function :sqlite3_column_int64, [:pointer, :int], :int64
+    attach_function :sqlite3_column_double, [:pointer, :int], :double
+    attach_function :sqlite3_column_text, [:pointer, :int], :string
+    attach_function :sqlite3_column_bytes, [:pointer, :int], :int
+    attach_function :sqlite3_column_blob, [:pointer, :int], :pointer
+    attach_function :sqlite3_bind_int64, [:pointer, :int, :int64], :int
+    attach_function :sqlite3_bind_double, [:pointer, :int, :double], :int
+    attach_function :sqlite3_bind_text, [:pointer, :int, :string, :int, :pointer], :int
+    attach_function :sqlite3_bind_null, [:pointer, :int], :int
+    attach_function :sqlite3_libversion, [], :string
+  end
+end

data/lib/doltlite/version.rb

@@ -0,0 +1,4 @@
+module Doltlite
+  # Updated per release by the dolthub/doltlite release workflow.
+  VERSION = "0.11.18"
+end

data/lib/doltlite.rb

@@ -0,0 +1,13 @@
+require "doltlite/version"
+require "doltlite/library"
+require "doltlite/database"
+
+# DoltLite for Ruby: SQLite with Dolt-style version control (branches, commits,
+# merge, diff). A thin FFI layer over a bundled libdoltlite; the dolt_*
+# functions are reached through SQL.
+module Doltlite
+  # Open (creating if needed) a database. Use ":memory:" for in-memory.
+  def self.open(path = ":memory:")
+    Database.new(path)
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: doltlite
+version: !ruby/object:Gem::Version
+  version: 0.11.18
+platform: x86_64-darwin
+authors:
+- DoltHub, Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: 'DoltLite for Ruby: a drop-in SQLite engine with Dolt version control,
+  via a thin FFI layer over a bundled libdoltlite. The dolt_* functions are reached
+  through SQL.'
+email:
+- support@dolthub.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/doltlite.rb
+- lib/doltlite/database.rb
+- lib/doltlite/library.rb
+- lib/doltlite/version.rb
+- vendor/libdoltlite/libdoltlite.dylib
+homepage: https://github.com/dolthub/doltlite-ruby
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/dolthub/doltlite-ruby
+  source_code_uri: https://github.com/dolthub/doltlite-ruby
+  bug_tracker_uri: https://github.com/dolthub/doltlite/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: SQLite with Dolt-style version control (branches, commits, merge, diff)
+test_files: []