rustpdf 0.4.6-universal-darwin → 0.5.0-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a018c5f29034f92337b5a0a185547538234b11f5ec1d3fc93137f8de940881ff
-  data.tar.gz: c7548986b1382cc27ed97c294b695c920c55711a11a5ffab08a5e1ba93ed2b75
+  metadata.gz: 64ca4d038b618dec18c4357fef57fb2fe6d9f78ee66ffc0ae1dd4e4f32d9f1cb
+  data.tar.gz: 8555d12cdc7b5c24df532892442d1d327a52285ae45b4416bc7eb074c29b4fbf
 SHA512:
-  metadata.gz: ff1e586560ed16e692167d9f8e3d1e579df55fa4f5be3daf982db7ff6704bbc7dbaa07369fddaea446450660cf4d269ebc931e4fc7ed232cbd083276adb917b7
-  data.tar.gz: 494538b02af21c8e75eabb351563b78ddf8df3cac3badbde01ddeef5a51e2480f1907dfd8539be14045c2f043e78a05bfaf1133b8da8f4b3f705eb39ca4194e5
+  metadata.gz: 499b563398fa46ab3a5efb9d77688ca9674305fb3e70f5e046e4ec4f62bfa065b7b0fa5da2a04bae38f4155fb3a4f353daa5bd049166448ce46c32659b575b20
+  data.tar.gz: 9d460b4c64c56d8810092a3336cf52fd91df84b440df88765e6db184fce4ceb0867b484ab49c1df3bb3468969eb3a17b1f1d6709e7f7c8b7c5b9857dd9e4b374

data/README.md

@@ -1,21 +1,16 @@
-# rustpdf (Ruby binding)
+# RustPdf for Ruby
 
-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**, **page rendering** (page to PNG image), **encryption** (RC4 / AES-128 / AES-256) and **digital signatures**
-(PKCS#7 / PAdES) — plus **feature licensing**.
+Generate, edit, sign and process PDFs from Ruby: vector graphics, embedded fonts and Unicode text, wrapping paragraphs, images, **PDF/A** (1b-4f), **tagged/accessible** output, attachments, **AcroForm** fields, page manipulation (merge/split/stamp), watermarks, true **redaction**, **AES-256** encryption, **digital signatures (PAdES)** with HSM/deferred signing, timestamps/LTV, text extraction and search, and page **rendering to PNG**. Pure Ruby gem (stdlib Fiddle), no native extension to compile.
 
-Files (module `RustPdf`):
+## Documentation
 
-* `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.
+- **Full API reference:** https://rustpdf.dev/docs/ruby
+- **Interactive positioning guide** (coordinates, anchors, rotation): https://rustpdf.dev/positioning
+- All product guides (PDF/A, signatures, encryption, redaction, rendering): https://rustpdf.dev/docs/
+
+The public API is `RustPdf::Document` (create PDFs), `RustPdf::EditableDoc`
+(load and edit existing PDFs) and module functions (`version`,
+`extract_text`, `sign`, `timestamp`, `add_dss`).
 
 ## Loading the native library
 
@@ -28,8 +23,6 @@ Files (module `RustPdf`):
 ```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")
@@ -46,8 +39,8 @@ 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, page rendering — a **Pro** feature) require a license;
-without one they raise `RustPdf::Error`. See [`docs/LICENSING.md`](../../docs/LICENSING.md).
+Every feature is free — PDF/A, digital signatures/PAdES, encryption,
+accessibility/tagging, redaction and page rendering are all included.
 
 ## Deferred / HSM signing
 

data/lib/rustpdf/editable_doc.rb

@@ -163,41 +163,130 @@ module RustPdf
       found != 0
     end
 
-    # Draw a line of positioned +text+ with baseline at (+x+, +y+) on page
-    # +page_index+ (0-based), using standard Helvetica at +size+ points in RGB
+    # Register a TrueType/OpenType font (from a file path) for text stamping;
+    # returns a font id usable with the +font_id+ keyword of #place_text /
+    # #masked_text / #place_paragraph. The font is embedded as a subset —
+    # stamped text renders with the real font's glyphs and metrics.
+    def add_font_file(path)
+      RustPdf.out_int { |buf| Native.call("pdf_editable_add_font_file", ptr, path, buf) }
+    end
+
+    # Register a stamping font from raw TrueType/OpenType bytes. See
+    # #add_font_file.
+    def add_font(data)
+      RustPdf.out_int { |buf| Native.call("pdf_editable_add_font", ptr, data, data.bytesize, buf) }
+    end
+
+    # Draw a line of positioned +text+ anchored at (+x+, +y+) on page
+    # +page_index+ (0-based), using standard Helvetica (or an embedded font —
+    # pass +font_id+ from #add_font_file / #add_font) at +size+ points in RGB
     # +color+ (each 0..1, default black). +rotation_deg+ rotates the text
     # counter-clockwise about its anchor (match the page rotation to follow a
     # rotated page). +align+ (RustPdf::Align, default LEFT) shifts the start
     # point along the baseline direction by the text width for RIGHT/CENTER
-    # alignment. Coordinates are in the page's VISIBLE space (origin lower-left,
-    # y up), regardless of the page's /Rotate. Returns whether the page existed.
+    # alignment. +anchor+ (RustPdf::VerticalAnchor) says what +y+ means:
+    # BASELINE (default, historical behavior), TOP (text hangs from +y+ —
+    # baseline lands ascent x size below it, legacy fixed-position layout), BOTTOM
+    # (descender line rests on +y+), or LINE_TOP / LINE_BOTTOM (legacy layout engines line
+    # box). Coordinates are in the page's VISIBLE space (origin lower-left,
+    # y up) unless #stamp_space= chose MEDIA. Returns whether the page (and
+    # font) existed.
     def place_text(page_index, x, y, text, size = 12.0, color = [0.0, 0.0, 0.0], rotation_deg = 0.0,
-                   align: Align::LEFT)
+                   align: Align::LEFT, font_id: -1, anchor: VerticalAnchor::BASELINE)
       r, g, b = color
       found = RustPdf.out_int do |buf|
-        Native.call("pdf_editable_place_text_aligned", ptr, page_index, x.to_f, y.to_f, text,
-                    size.to_f, r.to_f, g.to_f, b.to_f, rotation_deg.to_f, align, buf)
+        Native.call("pdf_editable_place_text_anchored", ptr, page_index, x.to_f, y.to_f, text,
+                    size.to_f, r.to_f, g.to_f, b.to_f, rotation_deg.to_f, align, anchor, font_id, buf)
       end
       found != 0
     end
 
+    # Choose the coordinate space of the positioned stamping primitives
+    # (#fill_rect, #place_text, #masked_text, #place_paragraph, #draw_image)
+    # for subsequent calls. StampSpace::VISIBLE (default) keeps the historical
+    # behavior — coordinates in the page's displayed space, compensating
+    # /Rotate. StampSpace::MEDIA interprets coordinates and +rotation_deg+ in
+    # the raw PDF user space (legacy layout semantics), never composing with the
+    # page's /Rotate — use it to reproduce legacy-engine placement on rotated/scanned
+    # pages. Watermarks and redaction are unaffected.
+    def stamp_space=(space)
+      RustPdf.check(Native.call("pdf_editable_set_stamp_space", ptr, space))
+      @stamp_space = space
+    end
+
+    # The current stamping coordinate space (see #stamp_space=).
+    def stamp_space
+      @stamp_space || StampSpace::VISIBLE
+    end
+
+    # Chainable form of #stamp_space=.
+    def set_stamp_space(space)
+      self.stamp_space = space
+      self
+    end
+
+    # Stamp a paragraph with automatic word wrapping on page +page_index+:
+    # +text+ is broken into lines that fit +width+ points (greedy, by word;
+    # "\n" forces a break) and drawn downward from (+x+, +y+). +anchor+
+    # (RustPdf::VerticalAnchor) says what +y+ means for the block: TOP
+    # (default) — top of the box, first baseline ascent x size below +y+
+    # (legacy fixed-position layout); BASELINE — the first line's baseline; BOTTOM /
+    # LINE_BOTTOM — bottom-pinned: the block's bottom rests on +y+ and grows
+    # upward by its real content height. +align+ lays lines out inside
+    # +[x, x+width]+ (JUSTIFY stretches the word gaps of every line but the
+    # last of each paragraph). +max_height+ (points, nil = unlimited) truncates
+    # overflowing lines (a ceiling for the bottom-pinned anchors — the last
+    # lines stay pinned). +line_height+ scales the default 1.2 x size leading.
+    # Pass +font_id+ from #add_font_file / #add_font to wrap and draw with an
+    # embedded font (its real metrics drive the break points); -1 uses the
+    # built-in Helvetica. +rotation_deg+ rotates the laid-out block
+    # counter-clockwise about the anchor. Returns whether the page (and font)
+    # existed and the box was valid.
+    def place_paragraph(page_index, x, y, width, text, size: 12.0, color: [0.0, 0.0, 0.0],
+                        align: Align::LEFT, font_id: -1, max_height: nil, line_height: 1.0,
+                        anchor: VerticalAnchor::TOP, rotation_deg: 0.0)
+      found, = paragraph_anchored(page_index, x, y, width, text, size, color, align,
+                                  font_id, max_height, line_height, anchor, rotation_deg)
+      found
+    end
+
+    # Like #place_paragraph but returns a Hash with the number of +:lines+
+    # drawn and the consumed block +:height+ in points (top of the first drawn
+    # line's box to the bottom of the last one's; 0 when nothing fit) — stack
+    # blocks without re-measuring.
+    def place_paragraph_measured(page_index, x, y, width, text, size: 12.0, color: [0.0, 0.0, 0.0],
+                                 align: Align::LEFT, font_id: -1, max_height: nil, line_height: 1.0,
+                                 anchor: VerticalAnchor::TOP, rotation_deg: 0.0)
+      _, lines, height = paragraph_anchored(page_index, x, y, width, text, size, color, align,
+                                            font_id, max_height, line_height, anchor, rotation_deg)
+      { lines: lines, height: height }
+    end
+
     # Mask a placeholder: fill an opaque background box +[x, y, x+width,
     # y+height]+ in +bg_color+ (each 0..1, default white), then write +text+
-    # over it using standard Helvetica at +size+ points in +text_color+ (each
+    # over it using standard Helvetica (or an embedded font — pass +font_id+
+    # from #add_font_file / #add_font) at +size+ points in +text_color+ (each
     # 0..1, default black), horizontally aligned per +align+ (RustPdf::Align,
-    # default LEFT) and vertically centered within the box. Saves hand-computing
-    # the baseline when stamping a real value over a placeholder. Coordinates are
-    # in the page's VISIBLE space (origin lower-left, y up). Returns whether the
-    # page existed.
+    # default LEFT). +valign+ (RustPdf::VerticalAlign) controls the vertical
+    # alignment of the line inside the box: MIDDLE (default, historical
+    # cap-height centering), TOP (line hangs from the top edge — legacy PDF libraries
+    # top line-alignment semantics) or BOTTOM (descender line rests on the
+    # bottom edge). +padding+ is the horizontal edge inset (points) for
+    # LEFT/RIGHT alignment: text starts at +x + padding+ (or ends at
+    # +x + width - padding+); nil keeps the historical
+    # min(0.15 x size, width / 4), 0 starts flush with the box edge like
+    # rectangle-based DrawString APIs. Coordinates are in the page's VISIBLE space
+    # (origin lower-left, y up). Returns whether the page (and font) existed.
     def masked_text(page_index, x, y, width, height, text, size = 12.0,
                     text_color = [0.0, 0.0, 0.0], bg_color = [1.0, 1.0, 1.0],
-                    align: Align::LEFT)
+                    align: Align::LEFT, font_id: -1, valign: VerticalAlign::MIDDLE, padding: nil)
       tr, tg, tb = text_color
       br, bg, bb = bg_color
       found = RustPdf.out_int do |buf|
-        Native.call("pdf_editable_masked_text", ptr, page_index, x.to_f, y.to_f,
+        Native.call("pdf_editable_masked_text_pad", ptr, page_index, x.to_f, y.to_f,
                     width.to_f, height.to_f, text, size.to_f,
-                    tr.to_f, tg.to_f, tb.to_f, br.to_f, bg.to_f, bb.to_f, align, buf)
+                    tr.to_f, tg.to_f, tb.to_f, br.to_f, bg.to_f, bb.to_f, align, valign,
+                    (padding || -1.0).to_f, font_id, buf)
       end
       found != 0
     end
@@ -205,13 +294,18 @@ module RustPdf
     # Stamp an +image+ (PNG or JPEG bytes; the core dispatches on the signature)
     # onto page +page_index+ (0-based), with its lower-left corner at (+x+, +y+),
     # scaled to +width+ x +height+ points and rotated +rotation_deg+ degrees
-    # counter-clockwise about that corner. Coordinates are in the page's VISIBLE
-    # space (origin lower-left, y up), regardless of the page's /Rotate. Returns
-    # whether the page existed.
-    def draw_image(page_index, image, x, y, width, height, rotation_deg = 0.0)
+    # counter-clockwise. +anchor+ (RustPdf::ImageAnchor) controls how a rotated
+    # image is anchored: CORNER (default) rotates the image about its own
+    # lower-left corner at (x, y); BOUNDING_BOX lands the rotated image's
+    # bounding box with its lower-left at (x, y) (bounding-box layout semantics —
+    # e.g. a 90-degree image occupies [x, x+height] x [y, y+width]).
+    # Coordinates are in the page's VISIBLE space (origin lower-left, y up),
+    # regardless of the page's /Rotate. Returns whether the page existed.
+    def draw_image(page_index, image, x, y, width, height, rotation_deg = 0.0,
+                   anchor: ImageAnchor::CORNER)
       found = RustPdf.out_int do |buf|
-        Native.call("pdf_editable_draw_image", ptr, page_index, image, image.bytesize,
-                    x.to_f, y.to_f, width.to_f, height.to_f, rotation_deg.to_f, buf)
+        Native.call("pdf_editable_draw_image_anchored", ptr, page_index, image, image.bytesize,
+                    x.to_f, y.to_f, width.to_f, height.to_f, rotation_deg.to_f, anchor, buf)
       end
       found != 0
     end
@@ -265,7 +359,7 @@ module RustPdf
       self
     end
 
-    # Encrypt on save (requires a license).
+    # Encrypt on save.
     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
@@ -289,6 +383,24 @@ module RustPdf
 
     private
 
+    # Shared core of #place_paragraph / #place_paragraph_measured. Returns
+    # [found (bool), lines (Integer), height (Float)].
+    def paragraph_anchored(page_index, x, y, width, text, size, color, align,
+                           font_id, max_height, line_height, anchor, rotation_deg)
+      r, g, b = color
+      height_buf = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+      lines_buf = Fiddle::Pointer.malloc(Native::SIZEOF_INT, Fiddle::RUBY_FREE)
+      found_buf = Fiddle::Pointer.malloc(Native::SIZEOF_INT, Fiddle::RUBY_FREE)
+      RustPdf.check(Native.call("pdf_editable_place_paragraph_anchored", ptr, page_index,
+                                x.to_f, y.to_f, width.to_f, text, size.to_f,
+                                r.to_f, g.to_f, b.to_f, align, anchor, font_id,
+                                (max_height || 0.0).to_f, line_height.to_f, rotation_deg.to_f,
+                                height_buf, lines_buf, found_buf))
+      [found_buf[0, Native::SIZEOF_INT].unpack1("i!") != 0,
+       lines_buf[0, Native::SIZEOF_INT].unpack1("i!"),
+       height_buf[0, Fiddle::SIZEOF_DOUBLE].unpack1("d")]
+    end
+
     def ptr
       raise Error, "operation on a closed EditableDoc" if @ptr.nil? || @ptr.null?
 

data/lib/rustpdf/native.rb

@@ -19,7 +19,6 @@ module RustPdf
     SIGS = {
       "pdf_version"                  => [[], VP],
       "pdf_last_error_message"       => [[], VP],
-      "pdf_activate_license"         => [[VP], I],
       "pdf_buffer_free"              => [[VP, SZ], VOID],
 
       "pdf_document_new"             => [[], VP],
@@ -135,6 +134,17 @@ module RustPdf
       # Issue #50: stamp a PNG/JPEG image onto an existing page. The image bytes
       # cross as the (uint8_t* data, uintptr_t len) pair, like pdf_editable_load.
       "pdf_editable_draw_image"      => [[VP, I, VP, SZ, D, D, D, D, D, VP], I],
+
+      # Stamping fonts + anchored stamping primitives. font_id -1 = built-in
+      # Helvetica; anchors/valign/space/image-anchor cross as small ints.
+      "pdf_editable_add_font_file"   => [[VP, VP, VP], I],
+      "pdf_editable_add_font"        => [[VP, VP, SZ, VP], I],
+      "pdf_editable_place_text_anchored" => [[VP, I, D, D, VP, D, D, D, D, D, I, I, I, VP], I],
+      "pdf_editable_masked_text_pad" => [[VP, I, D, D, D, D, VP, D, D, D, D, D, D, D, I, I, D, I, VP], I],
+      "pdf_editable_place_paragraph_anchored" =>
+        [[VP, I, D, D, D, VP, D, D, D, D, I, I, I, D, D, D, VP, VP, VP], I],
+      "pdf_editable_set_stamp_space" => [[VP, I], I],
+      "pdf_editable_draw_image_anchored" => [[VP, I, VP, SZ, D, D, D, D, D, I, VP], I],
     }.freeze
 
     def lib

data/lib/rustpdf.rb

@@ -7,7 +7,7 @@ require_relative "rustpdf/native"
 # 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.
+# encryption and digital signatures. Free and open source (MIT).
 module RustPdf
   # Raised when a native call returns a non-zero PdfStatus.
   class Error < StandardError
@@ -40,6 +40,48 @@ module RustPdf
     JUSTIFY = 3
   end
 
+  # What +y+ means for stamped text (EditableDoc#place_text /
+  # #place_paragraph). BASELINE is the historical place_text behavior; TOP
+  # hangs the text from +y+ (baseline lands ascent x size below it, legacy layout engines
+  # fixed-position layout semantics); BOTTOM rests the descender line on +y+.
+  # LINE_TOP / LINE_BOTTOM anchor via the layout line box (its height is also
+  # the leading basis, so a single line and a wrapped block agree vertically).
+  module VerticalAnchor
+    BASELINE = 0
+    TOP = 1
+    BOTTOM = 2
+    LINE_TOP = 3
+    LINE_BOTTOM = 4
+  end
+
+  # Vertical alignment of the line inside a masked_text box. MIDDLE is the
+  # historical cap-height centering; TOP hangs the line from the top edge
+  # (top line-alignment in rectangle-based text APIs semantics); BOTTOM rests the descender
+  # line on the bottom edge.
+  module VerticalAlign
+    TOP = 0
+    MIDDLE = 1
+    BOTTOM = 2
+  end
+
+  # Coordinate space of the positioned stamping primitives (EditableDoc).
+  # VISIBLE (default) compensates the page /Rotate so coordinates match what
+  # a viewer displays; MEDIA is the raw PDF user space (legacy layout engines
+  # fixed-position layout/rotation semantics — no /Rotate composition).
+  module StampSpace
+    VISIBLE = 0
+    MEDIA = 1
+  end
+
+  # How a rotated EditableDoc#draw_image is anchored. CORNER (default) rotates
+  # the image about its own lower-left corner at (x, y); BOUNDING_BOX lands
+  # the rotated image's bounding box with its lower-left at (x, y) (legacy layout engines
+  # layout semantics).
+  module ImageAnchor
+    CORNER = 0
+    BOUNDING_BOX = 1
+  end
+
   # Embedded-file relationship (PDF/A-3).
   module Relationship
     SOURCE = 0
@@ -215,13 +257,6 @@ module RustPdf
     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) }
@@ -244,13 +279,12 @@ module RustPdf
   end
 
   # Render page +page+ (0-based) of +pdf+ to a PNG image at +dpi+
-  # dots-per-inch. Page rendering is a licensed Pro feature: raises unless a
-  # license granting it is active.
+  # dots-per-inch.
   def render_page_to_png(pdf, page = 0, dpi = 150.0)
     take_bytes { |pp, pn| Native.call("pdf_render_page_to_png", pdf, pdf.bytesize, page, dpi.to_f, pp, pn) }
   end
 
-  # Number of pages in +pdf+ (free — no license required).
+  # Number of pages in +pdf+ (free).
   def page_count(pdf)
     count = Fiddle::Pointer.malloc(Native::SIZEOF_SZ, Fiddle::RUBY_FREE)
     check(Native.call("pdf_page_count", pdf, pdf.bytesize, count))
@@ -324,7 +358,7 @@ module RustPdf
     js.empty? ? [] : JSON.parse(js)
   end
 
-  # Sign a PDF (PKCS#7 detached, incremental update). Requires a license.
+  # Sign a PDF (PKCS#7 detached, incremental update).
   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,

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: rustpdf
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
 platform: universal-darwin
 authors:
 - rust-pdf
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies: []
-description: Idiomatic Ruby binding over the rust-pdf C ABI (libpdf_ffi) using the
-  built-in Fiddle stdlib.
+description: 'Generate, edit, sign and process PDFs in Ruby: PDF/A, AES-256 encryption,
+  digital signatures (PAdES), forms, stamping, redaction, text extraction and page
+  rendering. Docs: https://rustpdf.dev/docs/ruby'
 email:
 executables: []
 extensions: []
@@ -25,7 +26,7 @@ files:
 - vendor/universal-darwin/libpdf_ffi.dylib
 homepage:
 licenses:
-- Nonstandard
+- MIT
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -45,6 +46,5 @@ 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).
+summary: 'Generate, edit, sign and process PDFs in Ruby. Docs: https://rustpdf.dev/docs/ruby'
 test_files: []