rdf-oxigraph 0.0.1-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3998d114420e71667cd34d012257eb3f9bd0eda248df52cc5f1beedebc88e193
+  data.tar.gz: be902d50e35dc817568b3413de8482023cdb7cb8e6d14d629e01d2b5597345a2
+SHA512:
+  metadata.gz: 5925144c48c78f26bae8c63fa78e0861dd93e8ff2dea49a356db5e1b1fba859366f57d127931a7edd64217a0153529584f39f0c90d849053e69f05af6e038e1a
+  data.tar.gz: 2313fa31f1f553e966cd4864a5b90c3743edfc1ad7bcde1a2fab93f82cf064861b192087b4737c495633f2d5181897af0fddc395c69302ef21dd6ffdd997311f

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## [Unreleased] (0.0.1)
+
+Initial development release. A drop-in RDF.rb-compatible storage/SPARQL backend
+powered by the [oxigraph](https://github.com/oxigraph/oxigraph) Rust engine via a
+magnus + rb-sys native extension.
+
+### Added
+- Built on **oxigraph 0.5** (in-memory store; `default-features = false`, no RocksDB).
+- Native `RDF::Oxigraph::Store` over `oxigraph::store::Store`
+  (insert/delete/size/load/dump/each_quad/query/update) with full term
+  marshalling (IRIs, blank nodes, simple/typed/language literals, default and
+  named graphs).
+- `RDF::Oxigraph::Repository < RDF::Repository` — passes 319/338 of the official
+  `rdf-spec` `RDF::Repository` shared examples (the remainder is oxigraph's
+  typed-literal canonicalization; see README).
+- `RDF::Reader`/`RDF::Writer`/`RDF::Format` for Turtle, TriG, N-Triples, N-Quads,
+  RDF/XML and JSON-LD (native oxigraph parse/serialize), plus fast
+  `Repository#load`/`#dump`.
+- SPARQL query + update: `Repository#sparql` (→ `RDF::Query::Solutions` /
+  `RDF::Graph` / boolean), `Repository#sparql_update`, and a
+  `RDF::Oxigraph::SPARQL::Client` string-based wrapper. Full FILTER/REGEX/PREFIX.
+- In-process **SHACL validation** via the rudof `shacl` crate (0.3.x):
+  `Repository#shacl_validate(shapes)` and `RDF::Oxigraph::SHACL.validate(data:, shapes:)`,
+  returning a report with `#conforms?`, `#violations`, `#results`, `#to_s`. No external
+  service; no RocksDB/C++ pulled in.
+- Precompiled, platform-specific gems (install with no Rust toolchain required)
+  for Linux x86_64/arm64 (glibc + musl) and macOS arm64/x86_64. oxigraph is built
+  with `default-features = false` (in-memory store only, no RocksDB/C++), keeping
+  Linux cross-compilation reliable.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mehmet Celik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,366 @@
+# rdf-oxigraph
+
+A Ruby gem providing a **drop-in [RDF.rb](https://github.com/ruby-rdf/rdf)-compatible**
+storage + SPARQL backend powered by the
+[oxigraph](https://github.com/oxigraph/oxigraph) Rust engine, via a
+[magnus](https://github.com/matsadler/magnus) + [rb-sys](https://github.com/oxidize-rb/rb-sys)
+native extension.
+
+## Why
+
+`RDF::Repository` ships with rdf.rb as a pure-Ruby, in-memory store, and SPARQL on top of
+it (the `sparql` gem) is a pure-Ruby query engine. That's portable but slow, and SPARQL 1.1
+coverage is uneven.
+
+**rdf-oxigraph is a drop-in replacement for that backend.** It swaps the pure-Ruby store and
+query engine for oxigraph — a fast, embedded, native **SPARQL 1.1** engine written in Rust —
+while keeping the exact RDF.rb surface your code already uses. Existing rdf.rb /
+`SPARQL::Client` consumers get the native engine **without changing their
+code**: the only edit is which `Repository` class you instantiate.
+
+What you get over the stock backend:
+
+- Native SPARQL 1.1 **query + update** (SELECT/ASK/CONSTRUCT/DESCRIBE, full FILTER/REGEX/PREFIX).
+- Native, fast **parse/serialize** for Turtle, TriG, N-Triples, N-Quads, RDF/XML, JSON-LD.
+- In-process **SHACL validation** (oxigraph has none; provided via the rudof `shacl` crate).
+- **Precompiled gems** — no Rust toolchain needed to install on the common platforms.
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "rdf-oxigraph"
+```
+
+or:
+
+```bash
+gem install rdf-oxigraph
+```
+
+Precompiled, platform-specific gems are published, so **no Rust toolchain is required to
+install** on:
+
+| Platform | Targets |
+|----------|---------|
+| Linux (glibc) | `x86_64-linux`, `aarch64-linux` |
+| Linux (musl, Alpine, …) | `x86_64-linux-musl`, `aarch64-linux-musl` |
+| macOS | `arm64-darwin` (Apple Silicon), `x86_64-darwin` (Intel) |
+
+If no precompiled gem matches your platform, the gem falls back to **compiling from source**,
+which requires a Rust toolchain (rustup recommended), Ruby headers, and clang/libclang.
+
+> The extension uses oxigraph's **in-memory** store only (oxigraph built with
+> `default-features = false`, no RocksDB / no C++). This keeps the gem small (~2.5 MB) and the
+> Linux glibc/musl cross-builds reliable. On-disk persistence (`Store::open`) is intentionally
+> not enabled — re-enable oxigraph's `rocksdb` feature in `ext/rdf_oxigraph/Cargo.toml` if you
+> need it.
+
+## Architecture — how it fits into rdf.rb
+
+rdf.rb defines the *interface* (the `RDF::Enumerable` / `RDF::Queryable` / `RDF::Mutable`
+mixins, plus the `RDF::Reader` / `RDF::Writer` / `RDF::Format` registries). The slow parts
+are the *implementations*: the pure-Ruby in-memory store and the pure-Ruby SPARQL engine.
+
+rdf-oxigraph keeps the interfaces and replaces the implementations. Your code talks to the
+same rdf.rb objects (`RDF::Statement`, `RDF::Query::Solutions`, `RDF::Graph`); underneath,
+calls cross a thin tagged-tuple bridge into the native oxigraph engine.
+
+```mermaid
+flowchart TD
+    App["Your app<br/>(plain RDF.rb code)"]
+
+    subgraph rdfrb["rdf.rb (interfaces — unchanged)"]
+        Mixins["RDF::Enumerable / Queryable / Mutable"]
+        Registry["RDF::Reader / Writer / Format registry"]
+        Terms["RDF::Statement · Query::Solutions · Graph"]
+    end
+
+    subgraph gem["rdf-oxigraph (this gem, Ruby)"]
+        Repo["RDF::Oxigraph::Repository<br/>< RDF::Repository"]
+        RW["Oxigraph Reader / Writer / Format<br/>(turtle, trig, n-triples, n-quads, rdf/xml, json-ld)"]
+        Sparql["SPARQL.results + SPARQL::Client"]
+        Shacl["SHACL.validate → Report"]
+        Conv["Conversion<br/>(RDF.rb terms ⇄ tagged tuples)"]
+    end
+
+    subgraph native["native extension (Rust, via magnus + rb-sys)"]
+        Store["RDF::Oxigraph::Store"]
+        Oxi["oxigraph 0.5<br/>(in-memory store + SPARQL 1.1)"]
+        Rudof["rudof shacl crate"]
+    end
+
+    App --> Mixins
+    App --> Registry
+    App --> Terms
+
+    Mixins --> Repo
+    Registry --> RW
+    Repo --> Sparql
+    Repo --> Shacl
+    Repo --> Conv
+    RW --> Conv
+
+    Conv <--> Store
+    Sparql --> Store
+    Shacl --> Rudof
+    Store --> Oxi
+```
+
+The native boundary is deliberately narrow: terms are marshalled as small tagged tuples
+(e.g. `["uri", "..."]`, `["lit", value, datatype, lang]`), and SHACL crosses the boundary
+only as serialized RDF strings.
+
+## Usage
+
+### Do I have to use `RDF::Oxigraph::Repository`?
+
+**Yes — instantiating `RDF::Oxigraph::Repository` (or the lower-level
+`RDF::Oxigraph::Store`) is the one and only thing you change.** That object *is* the
+oxigraph-backed store; without it, your data lives in the stock pure-Ruby store and none of the
+native speedups apply. Everything else stays standard rdf.rb:
+
+```ruby
+require "rdf/oxigraph"
+
+repo = RDF::Oxigraph::Repository.new   # <-- the only oxigraph-specific line
+
+# ...from here on it's plain RDF.rb — identical to stock RDF::Repository:
+repo << RDF::Statement.new(subject, predicate, object)
+repo.query([nil, RDF.type, RDF::URI("http://example.org/Person")])
+repo.count
+```
+
+Two nuances:
+
+- **Readers/Writers register globally.** Once `rdf/oxigraph` is required, the oxigraph-backed
+  Turtle/TriG/N-Triples/N-Quads/RDF-XML/JSON-LD readers/writers are registered in rdf.rb's
+  format registry. `RDF::Reader.for(...)` / `RDF::Writer.for(...)` and `Repository#load` /
+  `#dump` then use the native parsers — no extra wiring.
+- **SPARQL needs the repository.** `repo.sparql(...)`, `repo.sparql_update(...)`, and the
+  `RDF::Oxigraph::SPARQL::Client` wrapper all run against the oxigraph store, so they require
+  the oxigraph repository.
+
+### Drop-in repository
+
+The same rdf.rb code runs unchanged against the stock store and the oxigraph store with
+identical results:
+
+```ruby
+require "rdf/oxigraph"
+
+EX = RDF::Vocabulary.new("http://example.org/")
+repo = RDF::Oxigraph::Repository.new
+repo << RDF::Statement.new(EX.alice, RDF.type, EX.Person)
+repo << RDF::Statement.new(EX.alice, EX.name, RDF::Literal("Alice"))
+
+repo.query([nil, RDF.type, EX.Person]).each { |s| puts s.subject }
+```
+
+### Load & serialize (native parse/serialize)
+
+```ruby
+repo = RDF::Oxigraph::Repository.new
+repo.load("data.ttl")            # native Turtle parse, straight into the store
+puts repo.dump(:ntriples)        # native serialization
+puts repo.dump(:jsonld)
+
+RDF::Reader.for(content_type: "text/turtle")  # => oxigraph-backed reader
+RDF::Writer.for(:ntriples)                    # => oxigraph-backed writer
+```
+
+### SPARQL query + update
+
+```ruby
+repo = RDF::Oxigraph::Repository.new
+repo.load("data.ttl")
+
+# SELECT -> RDF::Query::Solutions
+repo.sparql("SELECT ?s WHERE { ?s a <http://example.org/Book> }").each { |sol| puts sol[:s] }
+
+# ASK -> true/false ; CONSTRUCT/DESCRIBE -> RDF::Graph
+repo.sparql("ASK { ?s ?p ?o }")
+graph = repo.sparql("CONSTRUCT { ?a ?b ?c } WHERE { ?a ?b ?c }")
+
+# SPARQL 1.1 Update
+repo.sparql_update("INSERT DATA { <http://example.org/x> a <http://example.org/Book> }")
+
+# SPARQL::Client-shaped wrapper (string-based query/update)
+client = RDF::Oxigraph::SPARQL::Client.new(repo)
+client.query("SELECT (COUNT(?s) AS ?n) WHERE { ?s ?p ?o }")
+```
+
+### SHACL validation
+
+oxigraph itself has no SHACL; validation is provided in-process by the rudof
+[`shacl`](https://crates.io/crates/shacl) crate (native, no external service):
+
+```ruby
+report = repo.shacl_validate(shapes_turtle_string)  # validate the repo's data
+report.conforms?    # => true / false
+report.violations   # => count
+report.results      # => [{ "focus" => ..., "severity" => ..., "message" => ..., "path" => ... }, ...]
+puts report.to_s    # human-readable report
+
+# or validate two RDF strings directly, no repository needed:
+RDF::Oxigraph::SHACL.validate(data: data_ttl, shapes: shapes_ttl)
+```
+
+### Runnable examples
+
+The [`examples/`](examples/) directory has self-contained scripts (shared dataset in
+`examples/data/books.ttl`). After `rake compile` (or installing the gem):
+
+```bash
+ruby -Ilib examples/01_drop_in_repository.rb   # drop-in: same code, stock vs oxigraph
+ruby -Ilib examples/02_load_and_serialize.rb   # native load + serialize, format registry
+ruby -Ilib examples/03_sparql.rb               # SELECT/ASK/CONSTRUCT + UPDATE + client
+ruby -Ilib examples/04_shacl.rb                # SHACL validation
+```
+
+(Drop the `-Ilib` once the gem is installed.)
+
+## Conformance & known deviations
+
+`RDF::Oxigraph::Repository` passes **319/338** of the official `rdf-spec` `RDF::Repository`
+shared examples (`rake conformance`). The remaining ~19 failures stem from a single,
+documented backend behavior:
+
+- **oxigraph canonicalizes typed literals.** `"01"^^xsd:integer` is stored as
+  `"1"^^xsd:integer`, and `"1.0e0"^^xsd:double` as its canonical form. rdf-spec treats
+  distinct lexical forms as distinct terms, so the lexical-preservation / term-count /
+  value-pattern tests fail. This is semantically reasonable (both denote the same value) and
+  is harmless.
+- `#dump` differs only in auto-assigned blank-node labels (the triples are identical).
+
+These are inherent to oxigraph's value-based storage and are not fixable in the gem.
+
+## Tests
+
+Two suites:
+
+- **Minitest** — the main suite and the default `rake` task:
+
+  ```bash
+  CARGO_TARGET_DIR="$HOME/.cargo-target/rdf-oxigraph" bundle exec rake test
+  ```
+
+- **RSpec** — runs only the `rdf-spec` conformance shared examples (which are RSpec-only):
+
+  ```bash
+  CARGO_TARGET_DIR="$HOME/.cargo-target/rdf-oxigraph" bundle exec rake conformance
+  ```
+
+`rake test` is green; `rake conformance` has ~19 expected failures (see
+[Conformance & known deviations](#conformance--known-deviations)). Both tasks depend on
+`:compile`, so they rebuild the native extension first. Setting `CARGO_TARGET_DIR` keeps Rust
+build artifacts out of Dropbox/source control (optional but recommended).
+
+CI (`.github/workflows/ci.yml`) runs both suites across Ruby 3.1–3.4 on Linux and macOS.
+
+## Compile (development)
+
+```bash
+bundle install
+
+# Build the native extension into lib/rdf/oxigraph/:
+CARGO_TARGET_DIR="$HOME/.cargo-target/rdf-oxigraph" bundle exec rake compile
+
+# Smoke test:
+ruby -Ilib -e 'require "rdf/oxigraph"; \
+  r = RDF::Oxigraph::Repository.new; \
+  r.sparql_update("INSERT DATA { <http://ex/a> <http://ex/b> <http://ex/c> }"); \
+  puts r.sparql("ASK { ?s ?p ?o }")'
+```
+
+Requirements for compiling from source: Ruby >= 3.0 with headers, a Rust toolchain (rustup
+recommended), and clang/libclang.
+
+## Building & publishing the gem (Intel + ARM)
+
+The pure-Ruby `gem build` produces a source gem (Rust compiled at install time). To ship
+**precompiled, platform-specific** gems so users don't need Rust, build one gem per platform.
+
+### Recommended: GitHub Actions (all platforms)
+
+The [`precompile`](.github/workflows/precompile.yml) workflow uses
+[`oxidize-rb/actions/cross-gem`](https://github.com/oxidize-rb/actions) to cross-compile gems
+for every supported platform (Linux x86_64/arm64 glibc + musl, macOS arm64/x86_64) across Ruby
+3.1–3.4. It triggers on a version tag or manually:
+
+```bash
+# Tag a release -> the workflow builds every platform gem and uploads them as artifacts:
+git tag v0.0.1
+git push origin v0.0.1
+```
+
+Download the artifacts and push them:
+
+```bash
+gem push rdf-oxigraph-0.0.1-arm64-darwin.gem
+gem push rdf-oxigraph-0.0.1-x86_64-darwin.gem
+gem push rdf-oxigraph-0.0.1-x86_64-linux.gem
+gem push rdf-oxigraph-0.0.1-aarch64-linux.gem
+gem push rdf-oxigraph-0.0.1-x86_64-linux-musl.gem
+gem push rdf-oxigraph-0.0.1-aarch64-linux-musl.gem
+```
+
+> The gemspec sets `rubygems_mfa_required`, so `gem push` will prompt for your RubyGems OTP.
+
+### Local cross-compilation (Intel + ARM)
+
+Cross-compilation is Docker-based, via
+[`rb-sys-dock`](https://github.com/oxidize-rb/rb-sys) — no per-platform machines needed. It
+requires Docker (or Podman) running locally.
+
+#### Easiest: `rake build` (interactive)
+
+```bash
+bundle exec rake build
+```
+
+This wraps `rb-sys-dock` with a menu: it lists every supported target, builds the one you
+pick, and loops until you quit. It also handles the two footguns described below for you
+(corrects symlinked paths, pins Ruby to `~> 3.0`). Override the Ruby pin with
+`RUBY_VERSIONS=... bundle exec rake build` if you need to.
+
+#### Manual: `rb-sys-dock` per platform
+
+```bash
+# macOS — Apple Silicon (arm64) and Intel (x86_64):
+bundle exec rb-sys-dock --platform arm64-darwin   --ruby-versions "~> 3.0" --build
+bundle exec rb-sys-dock --platform x86_64-darwin  --ruby-versions "~> 3.0" --build
+
+# Linux — Intel + ARM (glibc and musl):
+bundle exec rb-sys-dock --platform x86_64-linux       --ruby-versions "~> 3.0" --build
+bundle exec rb-sys-dock --platform aarch64-linux      --ruby-versions "~> 3.0" --build
+bundle exec rb-sys-dock --platform x86_64-linux-musl  --ruby-versions "~> 3.0" --build
+bundle exec rb-sys-dock --platform aarch64-linux-musl --ruby-versions "~> 3.0" --build
+```
+
+Each build drops a `pkg/rdf-oxigraph-<version>-<platform>.gem`; push each with `gem push` as
+above.
+
+> **Two gotchas** (both handled automatically by `rake build`):
+>
+> - **Pin Ruby to `~> 3.0`.** The cross-compile image also ships a Ruby 4.0 target, but
+>   `magnus 0.7` cannot compile against it (`no field 'typed_flag' on type RTypedData`). The
+>   `--ruby-versions "~> 3.0"` flag builds for Ruby 3.0–3.4 and skips 4.0. (Plain `--build`
+>   targets every Ruby in the image and fails on 4.0.)
+> - **Don't launch from a symlinked path.** `rb-sys-dock` mounts the shell's `$(pwd)`
+>   (symlinks *not* resolved) but runs the container in the resolved path. If you reached the
+>   project through a symlink (e.g. `~/Sources -> …/Dropbox/AllSources`), the container's
+>   working dir ends up empty — surfacing as `No Rakefile found` or `Could not locate Gemfile`.
+>   `cd "$(pwd -P)"` first, or just use `rake build`.
+
+A native gem for **your current machine only** (no Docker) is just:
+
+```bash
+CARGO_TARGET_DIR="$HOME/.cargo-target/rdf-oxigraph" bundle exec rake native gem
+# => pkg/rdf-oxigraph-<version>-<your-platform>.gem
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/lib/rdf/oxigraph/conversion.rb

@@ -0,0 +1,76 @@
+module RDF
+  module Oxigraph
+    # Maps between RDF.rb terms and the native extension's tagged-tuple wire format.
+    #
+    #   IRI:        ["uri",   "<iri>"]
+    #   blank node: ["bnode", "<id>"]
+    #   literal:    ["lit",   "<value>", <datatype-iri or nil>, <lang or nil>]
+    #   nil (e.g. default graph): nil
+    module Conversion
+      module_function
+
+      # RDF.rb term -> tagged tuple (or nil).
+      def serialize(term)
+        case term
+        when nil
+          nil
+        when RDF::URI
+          ["uri", term.to_s]
+        when RDF::Node
+          ["bnode", term.id.to_s]
+        when RDF::Literal
+          if term.language? && !term.language.to_s.empty?
+            ["lit", term.value, nil, term.language.to_s]
+          else
+            ["lit", term.value, term.datatype.to_s, nil]
+          end
+        else
+          raise ArgumentError, "cannot serialize term: #{term.inspect}"
+        end
+      end
+
+      # tagged tuple (or nil) -> RDF.rb term.
+      def deserialize(tuple)
+        return nil if tuple.nil?
+
+        case tuple[0]
+        when "uri"
+          RDF::URI.new(tuple[1])
+        when "bnode"
+          RDF::Node.new(tuple[1])
+        when "lit"
+          value, datatype, lang = tuple[1], tuple[2], tuple[3]
+          if lang && !lang.empty?
+            RDF::Literal.new(value, language: lang.to_sym)
+          elsif datatype && !datatype.empty?
+            RDF::Literal.new(value, datatype: RDF::URI.new(datatype))
+          else
+            RDF::Literal.new(value)
+          end
+        else
+          raise ArgumentError, "cannot deserialize tuple: #{tuple.inspect}"
+        end
+      end
+
+      # RDF::Statement -> [s, p, o, g] tagged tuples.
+      def serialize_statement(statement)
+        [
+          serialize(statement.subject),
+          serialize(statement.predicate),
+          serialize(statement.object),
+          statement.graph_name ? serialize(statement.graph_name) : nil
+        ]
+      end
+
+      # [s, p, o, g] tagged tuples -> RDF::Statement.
+      def deserialize_statement(quad)
+        RDF::Statement.new(
+          deserialize(quad[0]),
+          deserialize(quad[1]),
+          deserialize(quad[2]),
+          graph_name: deserialize(quad[3])
+        )
+      end
+    end
+  end
+end

data/lib/rdf/oxigraph/format.rb

@@ -0,0 +1,117 @@
+module RDF
+  module Oxigraph
+    # Native-format strings keyed by RDF.rb format symbol.
+    FORMATS = {
+      turtle:   "turtle",
+      ntriples: "ntriples",
+      nquads:   "nquads",
+      trig:     "trig",
+      rdfxml:   "rdfxml",
+      jsonld:   "jsonld"
+    }.freeze
+
+    # Map an RDF.rb format symbol (or content type / file name) to the native
+    # oxigraph format string, or nil if unsupported.
+    def self.native_format(format)
+      return FORMATS[format] if format.is_a?(Symbol)
+
+      fmt = RDF::Format.for(format)
+      fmt && FORMATS[fmt.to_sym]
+    end
+
+    # Batch RDF::Reader backed by oxigraph's native parsers. Subclasses set the
+    # oxigraph format via `oxigraph_format`.
+    class Reader < RDF::Reader
+      def self.oxigraph_format(value = nil)
+        @oxigraph_format = value unless value.nil?
+        @oxigraph_format
+      end
+
+      def initialize(input = $stdin, **options, &block)
+        @content = input.respond_to?(:read) ? input.read : input.to_s
+        super
+      end
+
+      def each_statement
+        return enum_for(:each_statement) unless block_given?
+        RDF::Oxigraph.parse(@content, self.class.oxigraph_format).each do |quad|
+          yield Conversion.deserialize_statement(quad)
+        end
+      end
+      alias_method :each, :each_statement
+
+      def each_triple
+        return enum_for(:each_triple) unless block_given?
+        each_statement { |st| yield(st.subject, st.predicate, st.object) }
+      end
+    end
+
+    # Batch RDF::Writer backed by oxigraph's native serializers. Buffers statements
+    # and serializes once on epilogue. Subclasses set `oxigraph_format`.
+    class Writer < RDF::Writer
+      def self.oxigraph_format(value = nil)
+        @oxigraph_format = value unless value.nil?
+        @oxigraph_format
+      end
+
+      def initialize(output = $stdout, **options, &block)
+        @quads = []
+        super
+      end
+
+      def write_statement(statement)
+        @quads << Conversion.serialize_statement(statement)
+        statement
+      end
+
+      def write_triple(subject, predicate, object)
+        write_statement(RDF::Statement.new(subject, predicate, object))
+      end
+
+      def write_epilogue
+        @output.write(RDF::Oxigraph.serialize(@quads, self.class.oxigraph_format))
+        super
+      end
+    end
+
+    class TurtleReader < Reader; oxigraph_format "turtle"; end
+    class TurtleWriter < Writer; oxigraph_format "turtle"; end
+    class Turtle < RDF::Format
+      content_type "text/turtle", extension: :ttl
+      reader { TurtleReader }
+      writer { TurtleWriter }
+    end
+
+    class NTriplesReader < Reader; oxigraph_format "ntriples"; end
+    class NTriplesWriter < Writer; oxigraph_format "ntriples"; end
+    class NTriples < RDF::Format
+      content_type "application/n-triples", extension: :nt
+      reader { NTriplesReader }
+      writer { NTriplesWriter }
+    end
+
+    class NQuadsReader < Reader; oxigraph_format "nquads"; end
+    class NQuadsWriter < Writer; oxigraph_format "nquads"; end
+    class NQuads < RDF::Format
+      content_type "application/n-quads", extension: :nq
+      reader { NQuadsReader }
+      writer { NQuadsWriter }
+    end
+
+    class TriGReader < Reader; oxigraph_format "trig"; end
+    class TriGWriter < Writer; oxigraph_format "trig"; end
+    class TriG < RDF::Format
+      content_type "application/trig", extension: :trig
+      reader { TriGReader }
+      writer { TriGWriter }
+    end
+
+    class JsonLdReader < Reader; oxigraph_format "jsonld"; end
+    class JsonLdWriter < Writer; oxigraph_format "jsonld"; end
+    class JsonLd < RDF::Format
+      content_type "application/ld+json", extension: :jsonld
+      reader { JsonLdReader }
+      writer { JsonLdWriter }
+    end
+  end
+end

data/lib/rdf/oxigraph/repository.rb

@@ -0,0 +1,97 @@
+module RDF
+  module Oxigraph
+    # An RDF.rb-compatible {RDF::Repository} backed by the native oxigraph store.
+    #
+    # Implements the storage backend protocol (insert/delete/each/count) over the
+    # tagged-tuple bridge; the RDF::Enumerable/Queryable/Mutable mixins build the
+    # rest of the RDF.rb surface on top.
+    class Repository < RDF::Repository
+      def initialize(**options, &block)
+        @store = RDF::Oxigraph::Store.new
+        super(**options, &block)
+      end
+
+      def supports?(feature)
+        case feature.to_sym
+        when :graph_name then true   # quad store
+        when :literal_equality then true
+        else false
+        end
+      end
+
+      def durable?
+        false # in-memory; persistent (RocksDB) variant comes later
+      end
+
+      def count
+        @store.size
+      end
+
+      def empty?
+        count.zero?
+      end
+
+      def each_statement(&block)
+        return enum_for(:each_statement) unless block_given?
+        @store.each_quad.each do |quad|
+          block.call(Conversion.deserialize_statement(quad))
+        end
+      end
+      alias_method :each, :each_statement
+
+      def insert_statement(statement)
+        raise ArgumentError, "incomplete statement: #{statement.inspect}" if statement.incomplete?
+        s, p, o, g = Conversion.serialize_statement(statement)
+        @store.insert(s, p, o, g)
+      end
+
+      def delete_statement(statement)
+        s, p, o, g = Conversion.serialize_statement(statement)
+        @store.delete(s, p, o, g)
+      end
+
+      # Fast bulk load via oxigraph's native parser (skips per-statement Ruby
+      # inserts). Falls back to RDF::Mutable#load for unsupported formats or when
+      # a graph_name override is requested.
+      def load(filename, **options)
+        format = options[:format] || RDF::Format.for(file_name: filename.to_s)&.to_sym
+        native = RDF::Oxigraph::FORMATS[format]
+        return super if native.nil? || options[:graph_name]
+        @store.load(File.read(filename), native)
+        self
+      end
+
+      # Fast native serialization of the whole repository for supported formats;
+      # falls back to RDF::Enumerable#dump otherwise.
+      def dump(format, **options)
+        native = format.is_a?(Symbol) && RDF::Oxigraph::FORMATS[format]
+        return super if native == false || native.nil?
+        @store.dump(native)
+      end
+
+      # Execute a SPARQL query string via oxigraph's native engine. Returns
+      # RDF.rb-native results: RDF::Query::Solutions (SELECT), RDF::Graph
+      # (CONSTRUCT/DESCRIBE), or true/false (ASK).
+      def sparql(query_string)
+        RDF::Oxigraph::SPARQL.results(@store.query(query_string))
+      end
+
+      # Execute a SPARQL 1.1 Update string against this repository.
+      def sparql_update(update_string)
+        @store.update(update_string)
+        self
+      end
+
+      # Validate this repository's data against SHACL `shapes` (a serialized-RDF
+      # string). Returns an RDF::Oxigraph::SHACL::Report.
+      def shacl_validate(shapes, shapes_format: :turtle)
+        RDF::Oxigraph::SHACL.validate(
+          data: @store.dump("ntriples"),
+          data_format: :ntriples,
+          shapes: shapes,
+          shapes_format: shapes_format
+        )
+      end
+    end
+  end
+end

data/lib/rdf/oxigraph/shacl.rb

@@ -0,0 +1,46 @@
+module RDF
+  module Oxigraph
+    # In-process SHACL validation, backed by the rudof `shacl` engine in the native
+    # extension. Decoupled from the store via serialized strings.
+    module SHACL
+      module_function
+
+      # Validate a data graph against SHACL shapes. Both `data` and `shapes` are
+      # strings of serialized RDF (default Turtle), or anything that responds to
+      # #to_s. Returns a {Report}.
+      def validate(data:, shapes:, data_format: :turtle, shapes_format: :turtle)
+        raw = RDF::Oxigraph.shacl_validate(
+          data.to_s, data_format.to_s, shapes.to_s, shapes_format.to_s
+        )
+        Report.new(raw)
+      end
+
+      # A SHACL validation report. `#results` is an array of hashes with string keys:
+      # focus, path, value, source, severity, message.
+      class Report
+        attr_reader :raw
+
+        def initialize(raw)
+          @raw = raw
+        end
+
+        def conforms?
+          @raw["conforms"]
+        end
+
+        def violations
+          @raw["violations"]
+        end
+
+        def results
+          @raw["results"]
+        end
+
+        # Human-readable validation report.
+        def to_s
+          @raw["text"]
+        end
+      end
+    end
+  end
+end

data/lib/rdf/oxigraph/sparql.rb

@@ -0,0 +1,66 @@
+module RDF
+  module Oxigraph
+    module SPARQL
+      module_function
+
+      # Convert a native Store#query tagged result into RDF.rb-native objects:
+      #   ["boolean", bool]                  -> true / false
+      #   ["solutions", vars, rows]          -> RDF::Query::Solutions
+      #   ["graph", triples]                 -> RDF::Graph
+      def results(tagged)
+        case tagged[0]
+        when "boolean"
+          tagged[1]
+        when "solutions"
+          _, vars, rows = tagged
+          solutions = RDF::Query::Solutions.new
+          rows.each do |row|
+            bindings = {}
+            vars.each_with_index do |var, i|
+              term = Conversion.deserialize(row[i])
+              bindings[var.to_sym] = term unless term.nil?
+            end
+            solutions << RDF::Query::Solution.new(bindings)
+          end
+          solutions
+        when "graph"
+          graph = RDF::Graph.new
+          tagged[1].each do |triple|
+            graph << RDF::Statement.new(
+              Conversion.deserialize(triple[0]),
+              Conversion.deserialize(triple[1]),
+              Conversion.deserialize(triple[2])
+            )
+          end
+          graph
+        else
+          raise ArgumentError, "unknown query result kind: #{tagged[0].inspect}"
+        end
+      end
+
+      # A small `SPARQL::Client`-shaped wrapper around a repository (anything that
+      # responds to #sparql and #sparql_update). Covers the string-based query/update
+      # surface; the chainable query-builder DSL of the sparql-client gem is out of scope.
+      class Client
+        attr_reader :repository
+
+        def initialize(repository)
+          @repository = repository
+        end
+
+        # Execute a SPARQL query string. `update: true` routes to #update (mirrors
+        # the sparql-client gem's convention used by some callers).
+        def query(query_string, **options)
+          return update(query_string) if options[:update]
+          @repository.sparql(query_string)
+        end
+
+        # Execute a SPARQL Update string.
+        def update(update_string, **)
+          @repository.sparql_update(update_string)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/rdf/oxigraph/version.rb

@@ -0,0 +1,5 @@
+module RDF
+  module Oxigraph
+    VERSION = "0.0.1"
+  end
+end

data/lib/rdf/oxigraph.rb

@@ -0,0 +1,12 @@
+require "rdf"
+require_relative "oxigraph/version"
+
+# Load the compiled native extension (built into lib/rdf/oxigraph/ by rake-compiler).
+# Defines RDF::Oxigraph::Store.
+require "rdf/oxigraph/rdf_oxigraph"
+
+require_relative "oxigraph/conversion"
+require_relative "oxigraph/format"
+require_relative "oxigraph/sparql"
+require_relative "oxigraph/shacl"
+require_relative "oxigraph/repository"

data/rdf-oxigraph.gemspec

@@ -0,0 +1,43 @@
+require_relative "lib/rdf/oxigraph/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "rdf-oxigraph"
+  spec.version     = RDF::Oxigraph::VERSION
+  spec.authors     = ["Mehmet Celik"]
+  spec.email       = ["mehmet@celik.be"]
+  spec.summary     = "Drop-in RDF.rb-compatible storage/SPARQL backed by oxigraph (Rust)"
+  spec.description = "A Ruby RDF.rb backend (RDF::Repository + SPARQL::Client-compatible) " \
+                     "backed by the oxigraph Rust engine via a magnus/rb-sys native extension."
+  spec.homepage    = "https://github.com/libis/rdf-oxigraph"
+  spec.license     = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+  spec.required_rubygems_version = ">= 3.3.11"
+
+  spec.metadata = {
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "ext/**/*.{rs,toml,rb,lock}",
+    "Cargo.toml",
+    "Cargo.lock",
+    "*.gemspec",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE*"
+  ]
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/rdf_oxigraph/extconf.rb"]
+
+  spec.add_dependency "rdf", "~> 3.3"
+  spec.add_dependency "rb_sys", "~> 0.9"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rake-compiler", "~> 1.2"
+  spec.add_development_dependency "minitest", "~> 5.16"          # main test suite
+  spec.add_development_dependency "rspec", "~> 3.0"              # rdf-spec conformance only
+  spec.add_development_dependency "rdf-spec", "~> 3.3"           # rdf-spec conformance only
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: rdf-oxigraph
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: x86_64-linux
+authors:
+- Mehmet Celik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !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.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: A Ruby RDF.rb backend (RDF::Repository + SPARQL::Client-compatible) backed
+  by the oxigraph Rust engine via a magnus/rb-sys native extension.
+email:
+- mehmet@celik.be
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/rdf/oxigraph.rb
+- lib/rdf/oxigraph/3.0/rdf_oxigraph.so
+- lib/rdf/oxigraph/3.1/rdf_oxigraph.so
+- lib/rdf/oxigraph/3.2/rdf_oxigraph.so
+- lib/rdf/oxigraph/3.3/rdf_oxigraph.so
+- lib/rdf/oxigraph/3.4/rdf_oxigraph.so
+- lib/rdf/oxigraph/conversion.rb
+- lib/rdf/oxigraph/format.rb
+- lib/rdf/oxigraph/repository.rb
+- lib/rdf/oxigraph/shacl.rb
+- lib/rdf/oxigraph/sparql.rb
+- lib/rdf/oxigraph/version.rb
+- rdf-oxigraph.gemspec
+homepage: https://github.com/libis/rdf-oxigraph
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/libis/rdf-oxigraph
+  changelog_uri: https://github.com/libis/rdf-oxigraph/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.5.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Drop-in RDF.rb-compatible storage/SPARQL backed by oxigraph (Rust)
+test_files: []