rustpdf 0.1.0-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 338ced9bc04f0b7ec32aaf50f6f3a6dae01b06330a635624af41c28ccaa255b2
+  data.tar.gz: a3d214e870c8e3c7a064235ad273c8637cd801a423ed32500589eab7e13407a0
+SHA512:
+  metadata.gz: 6e9c32134dff46cf7c803414833a6a17e79538a4de354c71c6185179a0310f951292546180b652b0f3d95fdf949e6bd43ff30974e2f21a93836b0e42709d8c5b
+  data.tar.gz: 8b0fc3c9289e2285535a6a58812e4dd99b2317b235bd4f309dc23399bb96ec9d466d8482efb02205d8eba5caf5bbbc5230eeddfbc60cac97f76672097480c9f1

data/README.md

@@ -0,0 +1,57 @@
+# rustpdf (Ruby binding)
+
+Idiomatic Ruby binding for the `rust-pdf` core over its C ABI (`libpdf_ffi`),
+using the built-in **Fiddle** standard library — no native gem to compile. It
+covers the whole product surface: vector graphics, embedded/subsetted fonts and
+text, wrapping paragraphs, images, **PDF/A** (levels 1b–3a),
+**tagged/accessible** output, embedded-file attachments, **AcroForm** fields,
+manipulation (merge/split/rotate/optimize/incremental update), **text
+extraction**, **encryption** (RC4 / AES-128 / AES-256) and **digital signatures**
+(PKCS#7 / PAdES) — plus **feature licensing**.
+
+Files (module `RustPdf`):
+
+* `lib/rustpdf.rb` — module functions (`version`, `activate_license`,
+  `extract_text`, `sign`, `timestamp`, `add_dss`), enums, error, helpers;
+* `lib/rustpdf/native.rb` — the Fiddle signature table + loader;
+* `lib/rustpdf/document.rb`, `editable_doc.rb` — the `Document` / `EditableDoc`
+  classes.
+
+## Loading the native library
+
+`Native` finds `libpdf_ffi` via `RUSTPDF_LIB`, then by walking up from `lib/` to
+`target/{debug,release}`. Build it from the repo root with
+`cargo build -p pdf-ffi`. Requires Ruby ≥ 2.6 (Fiddle is bundled).
+
+## Quick start
+
+```ruby
+require "rustpdf"
+
+RustPdf.activate_license(token)  # or set RUSTPDF_LICENSE (auto-activated)
+
+doc = RustPdf::Document.new
+doc.pdfa(RustPdf::Pdfa::A2A).info(title: "Report")
+f = doc.add_font_file("assets/fonts/Roboto-Regular.ttf")
+doc.add_page
+   .show_text(f, 20, 72, 760, "Title", heading_level: 1)
+   .paragraph(f, 12, 72, 720, 450, "A wrapping body…", align: RustPdf::Align::JUSTIFY)
+data = doc.to_bytes
+
+puts RustPdf.extract_text(data)
+
+ed = RustPdf::EditableDoc.load(data)
+ed.encrypt(method: RustPdf::Cipher::AES256, owner: "owner").save("secured.pdf")
+
+signed = RustPdf.sign(data, key_der, cert_der, pades: true)
+```
+
+Corporate features (PDF/A, signing, encryption, accessibility) require a license;
+without one they raise `RustPdf::Error`. See [`docs/LICENSING.md`](../../docs/LICENSING.md).
+
+## Test
+
+```sh
+cargo build -p pdf-ffi
+ruby bindings/ruby/test/run.rb     # or: make ruby-test
+```

data/lib/rustpdf/document.rb

@@ -0,0 +1,186 @@
+module RustPdf
+  # A PDF document being authored. Call #close (or rely on GC) to free.
+  class Document
+    def initialize
+      @ptr = Native.call("pdf_document_new")
+      raise Error, "pdf_document_new returned NULL" if @ptr.null?
+    end
+
+    def close
+      return if @ptr.nil? || @ptr.null?
+
+      Native.call("pdf_document_free", @ptr)
+      @ptr = nil
+    end
+
+    # ---- configuration ------------------------------------------------------
+
+    def pdfa(level = nil)
+      RustPdf.check(
+        level ? Native.call("pdf_document_pdfa_level", ptr, level) : Native.call("pdf_document_pdfa", ptr)
+      )
+      self
+    end
+
+    def tagged
+      RustPdf.check(Native.call("pdf_document_tagged", ptr))
+      self
+    end
+
+    def version=(v)
+      RustPdf.check(Native.call("pdf_document_set_version", ptr, v))
+    end
+
+    def default_size(width, height)
+      RustPdf.check(Native.call("pdf_document_set_default_size", ptr, width, height))
+      self
+    end
+
+    def info(title: nil, author: nil, subject: nil, keywords: nil, creator: nil)
+      RustPdf.check(Native.call("pdf_document_set_info", ptr, title, author, subject, keywords, creator))
+      self
+    end
+
+    # ---- pages + graphics ---------------------------------------------------
+
+    def add_page(width: nil, height: nil)
+      RustPdf.check(
+        width && height ? Native.call("pdf_document_add_page_sized", ptr, width, height)
+                        : Native.call("pdf_document_add_page", ptr)
+      )
+      self
+    end
+
+    def fill_rgb(r, g, b)
+      RustPdf.check(Native.call("pdf_page_set_fill_rgb", ptr, r, g, b))
+      self
+    end
+
+    def stroke_rgb(r, g, b)
+      RustPdf.check(Native.call("pdf_page_set_stroke_rgb", ptr, r, g, b))
+      self
+    end
+
+    def line_width(w)
+      RustPdf.check(Native.call("pdf_page_set_line_width", ptr, w))
+      self
+    end
+
+    def rect(x, y, w, h)
+      RustPdf.check(Native.call("pdf_page_rect", ptr, x, y, w, h))
+      self
+    end
+
+    def fill
+      RustPdf.check(Native.call("pdf_page_fill", ptr))
+      self
+    end
+
+    def stroke
+      RustPdf.check(Native.call("pdf_page_stroke", ptr))
+      self
+    end
+
+    # ---- fonts + text -------------------------------------------------------
+
+    def add_font_file(path)
+      RustPdf.out_int { |buf| Native.call("pdf_document_add_font_file", ptr, path, buf) }
+    end
+
+    def add_font(data)
+      RustPdf.out_int { |buf| Native.call("pdf_document_add_font", ptr, data, data.bytesize, buf) }
+    end
+
+    def show_text(font, size, x, y, text, heading_level: 0)
+      RustPdf.check(Native.call("pdf_page_show_text", ptr, font, size, x, y, text, heading_level))
+      self
+    end
+
+    def paragraph(font, size, x, y, width, text, align: Align::LEFT)
+      RustPdf.check(Native.call("pdf_page_paragraph", ptr, font, size, x, y, width, align, text))
+      self
+    end
+
+    # ---- images -------------------------------------------------------------
+
+    def add_image_file(path)
+      RustPdf.out_int { |buf| Native.call("pdf_document_add_image_file", ptr, path, buf) }
+    end
+
+    def add_image_png(data)
+      RustPdf.out_int { |buf| Native.call("pdf_document_add_image_png", ptr, data, data.bytesize, buf) }
+    end
+
+    def add_image_jpeg(data)
+      RustPdf.out_int { |buf| Native.call("pdf_document_add_image_jpeg", ptr, data, data.bytesize, buf) }
+    end
+
+    def draw_image(image, x, y, w, h)
+      RustPdf.check(Native.call("pdf_page_draw_image", ptr, image, x, y, w, h))
+      self
+    end
+
+    def figure(image, x, y, w, h, alt)
+      RustPdf.check(Native.call("pdf_page_figure", ptr, image, x, y, w, h, alt))
+      self
+    end
+
+    # ---- attachments + forms ------------------------------------------------
+
+    def attach_file(name, mime, data, relationship: Relationship::SOURCE, description: "")
+      RustPdf.check(Native.call("pdf_document_attach_file", ptr, name, mime, data, data.bytesize, relationship, description))
+      self
+    end
+
+    # rect = [x0, y0, x1, y1]
+    def text_field(name, page, rect, value: "", size: 0.0)
+      RustPdf.check(Native.call("pdf_document_text_field", ptr, name, page, rect[0], rect[1], rect[2], rect[3], value, size))
+      self
+    end
+
+    def checkbox(name, page, rect, checked)
+      RustPdf.check(Native.call("pdf_document_checkbox", ptr, name, page, rect[0], rect[1], rect[2], rect[3], checked ? 1 : 0))
+      self
+    end
+
+    # options: Array<String>; selected: index or nil
+    def dropdown(name, page, rect, options, selected: nil, size: 0.0)
+      RustPdf.check(Native.call("pdf_document_dropdown", ptr, name, page, rect[0], rect[1], rect[2], rect[3],
+                                options.join("\n"), selected || -1, size))
+      self
+    end
+
+    # buttons: Array<[ [x0,y0,x1,y1], "export" ]>; selected: index or nil
+    def radio_group(name, page, buttons, selected: nil)
+      rects = buttons.flat_map { |(r, _)| r }.pack("d*")
+      cstrs = buttons.map { |(_, e)| Fiddle::Pointer[e.to_s] }
+      addrs = cstrs.map(&:to_i).pack("J*")
+      RustPdf.check(Native.call("pdf_document_radio_group", ptr, name, page, buttons.size, rects, addrs, selected || -1))
+      cstrs.clear # released after the call returned
+      self
+    end
+
+    # ---- output -------------------------------------------------------------
+
+    def page_count
+      Native.call("pdf_document_page_count", ptr)
+    end
+
+    def to_bytes
+      p = ptr
+      RustPdf.take_bytes { |pp, pn| Native.call("pdf_document_write", p, pp, pn) }
+    end
+
+    def save(path)
+      RustPdf.check(Native.call("pdf_document_save", ptr, path))
+    end
+
+    private
+
+    def ptr
+      raise Error, "operation on a closed Document" if @ptr.nil? || @ptr.null?
+
+      @ptr
+    end
+  end
+end

data/lib/rustpdf/editable_doc.rb

@@ -0,0 +1,136 @@
+module RustPdf
+  # An existing PDF loaded for manipulation. Call #close (or rely on GC) to free.
+  class EditableDoc
+    # Load a PDF from bytes (optionally with a password).
+    def self.load(data, password: nil)
+      ptr = if password
+              Native.call("pdf_editable_load_password", data, data.bytesize, password)
+            else
+              Native.call("pdf_editable_load", data, data.bytesize)
+            end
+      raise Error, RustPdf.last_error if ptr.null?
+
+      new(ptr)
+    end
+
+    def self.load_file(path, password: nil)
+      load(File.binread(path), password: password)
+    end
+
+    def initialize(ptr)
+      @ptr = ptr
+    end
+    private_class_method :new
+
+    def close
+      return if @ptr.nil? || @ptr.null?
+
+      Native.call("pdf_editable_free", @ptr)
+      @ptr = nil
+    end
+
+    def page_count
+      Native.call("pdf_editable_page_count", ptr)
+    end
+
+    def merge(other)
+      RustPdf.check(Native.call("pdf_editable_merge", ptr, other.send(:ptr)))
+      self
+    end
+
+    def rotate_page(index, degrees)
+      RustPdf.check(Native.call("pdf_editable_rotate_page", ptr, index, degrees))
+      self
+    end
+
+    def delete_page(index)
+      RustPdf.check(Native.call("pdf_editable_delete_page", ptr, index))
+      self
+    end
+
+    def reorder_pages(order)
+      buf = order.pack("J*")
+      RustPdf.check(Native.call("pdf_editable_reorder_pages", ptr, buf, order.size))
+      self
+    end
+
+    def extract_pages(indices)
+      buf = indices.pack("J*")
+      out = Fiddle::Pointer.malloc(Native::SIZEOF_SZ, Fiddle::RUBY_FREE)
+      RustPdf.check(Native.call("pdf_editable_extract_pages", ptr, buf, indices.size, out))
+      EditableDoc.send(:new, out.ptr)
+    end
+
+    def info=(pair)
+      key, value = pair
+      RustPdf.check(Native.call("pdf_editable_set_info", ptr, key, value))
+    end
+
+    def set_info(key, value)
+      RustPdf.check(Native.call("pdf_editable_set_info", ptr, key, value))
+      self
+    end
+
+    def get_info(key)
+      p = ptr
+      RustPdf.take_bytes { |pp, pn| Native.call("pdf_editable_get_info", p, key, pp, pn) }
+             .force_encoding(Encoding::UTF_8)
+    end
+
+    def set_xmp(xml)
+      RustPdf.check(Native.call("pdf_editable_set_xmp", ptr, xml, xml.bytesize))
+      self
+    end
+
+    def overlay_page(index, content)
+      RustPdf.check(Native.call("pdf_editable_overlay_page", ptr, index, content, content.bytesize))
+      self
+    end
+
+    # Returns whether the field existed.
+    def fill_text_field(name, value)
+      found = RustPdf.out_int { |buf| Native.call("pdf_editable_fill_text_field", ptr, name, value, buf) }
+      found != 0
+    end
+
+    def optimize
+      RustPdf.check(Native.call("pdf_editable_optimize", ptr))
+      self
+    end
+
+    def compact(on = true)
+      RustPdf.check(Native.call("pdf_editable_compact", ptr, on ? 1 : 0))
+      self
+    end
+
+    # Encrypt on save (requires a license).
+    def encrypt(method: Cipher::AES256, user: "", owner: "", read_only: false)
+      RustPdf.check(Native.call("pdf_editable_encrypt", ptr, method, user, owner, read_only ? 1 : 0))
+      self
+    end
+
+    def to_bytes
+      p = ptr
+      RustPdf.take_bytes { |pp, pn| Native.call("pdf_editable_to_bytes", p, pp, pn) }
+    end
+
+    def to_bytes_incremental(original)
+      p = ptr
+      RustPdf.take_bytes do |pp, pn|
+        Native.call("pdf_editable_to_bytes_incremental", p, original, original.bytesize, pp, pn)
+      end
+    end
+
+    def save(path)
+      RustPdf.check(Native.call("pdf_editable_save", ptr, path))
+    end
+
+    private
+
+    def ptr
+      raise Error, "operation on a closed EditableDoc" if @ptr.nil? || @ptr.null?
+
+      @ptr
+    end
+  end
+end

data/lib/rustpdf/native.rb

@@ -0,0 +1,143 @@
+require "fiddle"
+
+module RustPdf
+  # Internal: dlopen's libpdf_ffi and builds memoized Fiddle::Function objects
+  # from a signature table. Not part of the public API.
+  module Native
+    module_function
+
+    VP   = Fiddle::TYPE_VOIDP
+    I    = Fiddle::TYPE_INT
+    D    = Fiddle::TYPE_DOUBLE
+    SZ   = Fiddle::TYPE_SIZE_T
+    VOID = Fiddle::TYPE_VOID
+
+    # size_t / uintptr_t and int widths (for out-parameter buffers).
+    SIZEOF_SZ  = Fiddle::SIZEOF_VOIDP
+    SIZEOF_INT = Fiddle::SIZEOF_INT
+
+    SIGS = {
+      "pdf_version"                  => [[], VP],
+      "pdf_last_error_message"       => [[], VP],
+      "pdf_activate_license"         => [[VP], I],
+      "pdf_buffer_free"              => [[VP, SZ], VOID],
+
+      "pdf_document_new"             => [[], VP],
+      "pdf_document_free"            => [[VP], VOID],
+      "pdf_document_add_page"        => [[VP], I],
+      "pdf_document_add_page_sized"  => [[VP, D, D], I],
+      "pdf_document_page_count"      => [[VP], I],
+      "pdf_page_set_fill_rgb"        => [[VP, D, D, D], I],
+      "pdf_page_set_stroke_rgb"      => [[VP, D, D, D], I],
+      "pdf_page_set_line_width"      => [[VP, D], I],
+      "pdf_page_rect"                => [[VP, D, D, D, D], I],
+      "pdf_page_fill"                => [[VP], I],
+      "pdf_page_stroke"              => [[VP], I],
+      "pdf_document_save"            => [[VP, VP], I],
+      "pdf_document_write"           => [[VP, VP, VP], I],
+      "pdf_document_pdfa"            => [[VP], I],
+      "pdf_document_pdfa_level"      => [[VP, I], I],
+      "pdf_document_tagged"          => [[VP], I],
+      "pdf_document_set_version"     => [[VP, I], I],
+      "pdf_document_set_default_size" => [[VP, D, D], I],
+      "pdf_document_set_info"        => [[VP, VP, VP, VP, VP, VP], I],
+      "pdf_document_add_font_file"   => [[VP, VP, VP], I],
+      "pdf_document_add_font"        => [[VP, VP, SZ, VP], I],
+      "pdf_page_show_text"           => [[VP, I, D, D, D, VP, I], I],
+      "pdf_page_paragraph"           => [[VP, I, D, D, D, D, I, VP], I],
+      "pdf_document_add_image_file"  => [[VP, VP, VP], I],
+      "pdf_document_add_image_png"   => [[VP, VP, SZ, VP], I],
+      "pdf_document_add_image_jpeg"  => [[VP, VP, SZ, VP], I],
+      "pdf_page_draw_image"          => [[VP, I, D, D, D, D], I],
+      "pdf_page_figure"              => [[VP, I, D, D, D, D, VP], I],
+      "pdf_document_attach_file"     => [[VP, VP, VP, VP, SZ, I, VP], I],
+      "pdf_document_text_field"      => [[VP, VP, SZ, D, D, D, D, VP, D], I],
+      "pdf_document_checkbox"        => [[VP, VP, SZ, D, D, D, D, I], I],
+      "pdf_document_dropdown"        => [[VP, VP, SZ, D, D, D, D, VP, I, D], I],
+      "pdf_document_radio_group"     => [[VP, VP, SZ, SZ, VP, VP, I], I],
+
+      "pdf_editable_load"            => [[VP, SZ], VP],
+      "pdf_editable_load_password"   => [[VP, SZ, VP], VP],
+      "pdf_editable_free"            => [[VP], VOID],
+      "pdf_editable_page_count"      => [[VP], I],
+      "pdf_editable_merge"           => [[VP, VP], I],
+      "pdf_editable_rotate_page"     => [[VP, SZ, I], I],
+      "pdf_editable_delete_page"     => [[VP, SZ], I],
+      "pdf_editable_reorder_pages"   => [[VP, VP, SZ], I],
+      "pdf_editable_extract_pages"   => [[VP, VP, SZ, VP], I],
+      "pdf_editable_set_info"        => [[VP, VP, VP], I],
+      "pdf_editable_get_info"        => [[VP, VP, VP, VP], I],
+      "pdf_editable_set_xmp"         => [[VP, VP, SZ], I],
+      "pdf_editable_overlay_page"    => [[VP, SZ, VP, SZ], I],
+      "pdf_editable_fill_text_field" => [[VP, VP, VP, VP], I],
+      "pdf_editable_optimize"        => [[VP], I],
+      "pdf_editable_compact"         => [[VP, I], I],
+      "pdf_editable_encrypt"         => [[VP, I, VP, VP, I], I],
+      "pdf_editable_to_bytes"        => [[VP, VP, VP], I],
+      "pdf_editable_to_bytes_incremental" => [[VP, VP, SZ, VP, VP], I],
+      "pdf_editable_save"            => [[VP, VP], I],
+
+      "pdf_extract_text"             => [[VP, SZ, VP, VP], I],
+      "pdf_sign"                     => [[VP, SZ, VP, SZ, VP, SZ, VP, VP, VP, I, VP, VP], I],
+      "pdf_timestamp"                => [[VP, SZ, VP, SZ, VP, SZ, VP, VP, VP], I],
+      "pdf_add_dss"                  => [[VP, SZ, VP, VP, SZ, VP, VP, SZ, VP, VP], I],
+    }.freeze
+
+    def lib
+      @lib ||= Fiddle.dlopen(lib_path)
+    end
+
+    def [](name)
+      @fns ||= {}
+      @fns[name] ||= begin
+        args, ret = SIGS.fetch(name)
+        Fiddle::Function.new(lib[name], args, ret)
+      end
+    end
+
+    def call(name, *args)
+      self[name].call(*args)
+    end
+
+    def lib_path
+      env = ENV["RUSTPDF_LIB"]
+      return env if env && !env.empty? && File.file?(env)
+
+      file = lib_file_name
+
+      # Packaged gem: the platform-specific cdylib is vendored under
+      # vendor/<gem-platform>/ (staged by CI, see release-ruby.yml). Matches the
+      # per-platform wheel/npm-package layout used by the Python/Node bindings.
+      # A platform gem ships exactly one vendor/<plat>/ dir, so the first match
+      # for this OS's lib file name is the right one — no platform-string parsing.
+      vendored = Dir[File.join(gem_root, "vendor", "*", file)].find { |p| File.file?(p) }
+      return vendored if vendored
+
+      # Monorepo dev: walk up from lib/ to the Cargo build tree.
+      dir = __dir__
+      10.times do
+        %w[debug release].each do |profile|
+          candidate = File.join(dir, "target", profile, file)
+          return candidate if File.file?(candidate)
+        end
+        parent = File.dirname(dir)
+        break if parent == dir
+        dir = parent
+      end
+      raise Error, "could not locate #{file}; build it with `cargo build -p pdf-ffi` or set RUSTPDF_LIB"
+    end
+
+    # Repo/gem root = two levels up from lib/rustpdf/.
+    def gem_root
+      File.expand_path("../..", __dir__)
+    end
+
+    def lib_file_name
+      case RbConfig::CONFIG["host_os"]
+      when /mswin|mingw|cygwin/ then "pdf_ffi.dll"
+      when /darwin/ then "libpdf_ffi.dylib"
+      else "libpdf_ffi.so"
+      end
+    end
+  end
+end

data/lib/rustpdf.rb

@@ -0,0 +1,142 @@
+require "fiddle"
+require_relative "rustpdf/native"
+
+# Idiomatic Ruby binding for the rust-pdf core over its C ABI (libpdf_ffi),
+# using the built-in Fiddle stdlib. Covers the whole product surface: vector
+# graphics, fonts/text, paragraphs, images, PDF/A (1b-3a), tagged/accessible
+# output, attachments, AcroForm fields, manipulation, text extraction,
+# encryption and digital signatures, plus feature licensing.
+module RustPdf
+  # Raised when a native call returns a non-zero PdfStatus.
+  class Error < StandardError
+    attr_reader :status
+
+    def initialize(message, status = 0)
+      @status = status
+      super(status.zero? ? message : "PdfStatus=#{status}: #{message}")
+    end
+  end
+
+  # PDF/A conformance levels.
+  module Pdfa
+    A1B = 0
+    A2B = 1
+    A2A = 2
+    A3B = 3
+    A3A = 4
+  end
+
+  # Paragraph alignment.
+  module Align
+    LEFT = 0
+    RIGHT = 1
+    CENTER = 2
+    JUSTIFY = 3
+  end
+
+  # Embedded-file relationship (PDF/A-3).
+  module Relationship
+    SOURCE = 0
+    DATA = 1
+    ALTERNATIVE = 2
+    SUPPLEMENT = 3
+    UNSPECIFIED = 4
+  end
+
+  # Encryption ciphers.
+  module Cipher
+    RC4 = 0
+    AES128 = 1
+    AES256 = 2
+  end
+
+  module_function
+
+  # Native library version string.
+  def version
+    Native.call("pdf_version").to_s
+  end
+
+  # Activate a license token (unlocks PDF/A, signing, encryption,
+  # accessibility). Tokens may also be supplied via the RUSTPDF_LICENSE /
+  # RUSTPDF_LICENSE_FILE environment variables (auto-activated).
+  def activate_license(token)
+    check(Native.call("pdf_activate_license", token))
+  end
+
+  # Extract a document's text (Unicode via ToUnicode).
+  def extract_text(pdf)
+    take_bytes { |pp, pn| Native.call("pdf_extract_text", pdf, pdf.bytesize, pp, pn) }
+      .force_encoding(Encoding::UTF_8)
+  end
+
+  # Sign a PDF (PKCS#7 detached, incremental update). Requires a license.
+  def sign(pdf, key_der, cert_der, reason: nil, location: nil, name: nil, pades: false)
+    take_bytes do |pp, pn|
+      Native.call("pdf_sign", pdf, pdf.bytesize, key_der, key_der.bytesize,
+                  cert_der, cert_der.bytesize, reason, location, name, pades ? 1 : 0, pp, pn)
+    end
+  end
+
+  # Append a document timestamp (/DocTimeStamp, PAdES-B-LTA).
+  def timestamp(pdf, tsa_key_der, tsa_cert_der, date: nil)
+    take_bytes do |pp, pn|
+      Native.call("pdf_timestamp", pdf, pdf.bytesize, tsa_key_der, tsa_key_der.bytesize,
+                  tsa_cert_der, tsa_cert_der.bytesize, date, pp, pn)
+    end
+  end
+
+  # Append a Document Security Store (/DSS, PAdES-B-LT).
+  def add_dss(pdf, certs: [], crls: [])
+    cptrs = certs.map { |c| Fiddle::Pointer[c] }
+    rptrs = crls.map { |c| Fiddle::Pointer[c] }
+    cptr_buf = cptrs.map(&:to_i).pack("J*")
+    clen_buf = certs.map(&:bytesize).pack("J*")
+    rptr_buf = rptrs.map(&:to_i).pack("J*")
+    rlen_buf = crls.map(&:bytesize).pack("J*")
+    result = take_bytes do |pp, pn|
+      Native.call("pdf_add_dss", pdf, pdf.bytesize, cptr_buf, clen_buf, certs.size,
+                  rptr_buf, rlen_buf, crls.size, pp, pn)
+    end
+    # keep the per-item pointers alive until the call has returned
+    cptrs.clear
+    rptrs.clear
+    result
+  end
+
+  # ---- internal helpers (used by Document/EditableDoc) ----------------------
+
+  def last_error
+    p = Native.call("pdf_last_error_message")
+    p.null? ? "unknown error" : p.to_s
+  end
+
+  def check(status)
+    raise Error.new(last_error, status) unless status.zero?
+  end
+
+  # Run an out-buffer producer { |out_ptr, out_len| status } and return the
+  # produced bytes, always freeing the native buffer.
+  def take_bytes
+    pp = Fiddle::Pointer.malloc(Native::SIZEOF_SZ, Fiddle::RUBY_FREE)
+    pn = Fiddle::Pointer.malloc(Native::SIZEOF_SZ, Fiddle::RUBY_FREE)
+    check(yield(pp, pn))
+    len = pn[0, Native::SIZEOF_SZ].unpack1("J")
+    return "".b if len.zero?
+
+    dptr = pp.ptr
+    bytes = dptr[0, len]
+    Native.call("pdf_buffer_free", dptr, len)
+    bytes
+  end
+
+  # Run a producer { |out_int| status } and return the written int.
+  def out_int
+    buf = Fiddle::Pointer.malloc(Native::SIZEOF_INT, Fiddle::RUBY_FREE)
+    check(yield(buf))
+    buf[0, Native::SIZEOF_INT].unpack1("i!")
+  end
+end
+
+require_relative "rustpdf/document"
+require_relative "rustpdf/editable_doc"

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: rustpdf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: x86_64-linux
+authors:
+- rust-pdf
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-27 00:00:00.000000000 Z
+dependencies: []
+description: Idiomatic Ruby binding over the rust-pdf C ABI (libpdf_ffi) using the
+  built-in Fiddle stdlib.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rustpdf.rb
+- lib/rustpdf/document.rb
+- lib/rustpdf/editable_doc.rb
+- lib/rustpdf/native.rb
+- vendor/x86_64-linux/libpdf_ffi.so
+homepage:
+licenses:
+- Nonstandard
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby binding for the rust-pdf core (generate, manipulate, sign and validate
+  PDFs).
+test_files: []