acrofill 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28d2db0f5f96d10602a2c8dd994a9957665df1426cffdbc045b3860c675e504e
+  data.tar.gz: c683b238b9ff31d182ad316712e3982c3ffa6dd38a92fa6547efca3e784d02c4
+SHA512:
+  metadata.gz: fb49f9bb0fe9efd45665d92c09c845a4156695b457bd9a3fddc13e7496a1221a009732147958f2a753130ebd5dc2f78b569b0ad117bf10ffa3262ba85bd3464e
+  data.tar.gz: 492ac4103cfa6fb500c70a648a94f479cf7411eb2293d5b7fc29ab7753e90bcd3a52f244facd94732e237f410a0038a9ca2a0ed2e7321a6ae4cc907744a4c265

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 stiig
+
+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,194 @@
+# Acrofill
+
+Pure-Ruby PDF form (AcroForm) filling and flattening. No pdftk, no Java,
+no native extensions — drop it into any Ruby or Rails project and fill
+PDF templates in-process.
+
+```ruby
+Acrofill.fill_form('template.pdf', 'out.pdf',
+                   { 'Full Name' => 'Jane Roe', 'agree' => 'Yes' },
+                   flatten: true)
+```
+
+Parsing is delegated to [pdf-reader](https://github.com/yob/pdf-reader)
+(MIT), which handles classic and cross-reference-stream PDFs, object
+streams, and every standard filter. Acrofill adds the write side: field
+value setting, appearance-stream generation, checkbox/radio state
+selection, flattening, and a full document serializer.
+
+## Why
+
+The usual Ruby answer to "fill this PDF form" is the `pdf-forms` gem,
+which shells out to [pdftk](https://gitlab.com/pdftk-java/pdftk) — a
+Java application you must install on every machine and container, and
+pay a JVM start-up for on every call. The main in-process alternative,
+HexaPDF, is AGPL/commercial. Acrofill is MIT-licensed and fills a form
+in a few milliseconds in-process.
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'acrofill'
+```
+
+## Usage
+
+```ruby
+require 'acrofill'
+
+# Discover fields in a template
+Acrofill.field_names('form.pdf')
+# => ["Full Name", "amount", "agree", "color", "notes"]
+
+Acrofill.fields('form.pdf').map { |f| [f.name, f.type, f.states] }
+# => [["Full Name", :Tx, nil], ["agree", :Btn, [:Yes]], ["color", :Btn, [:Red, :Blue]], ...]
+
+# Fill: text fields take strings, checkboxes/radios take a state name
+Acrofill.fill_form('form.pdf', 'out.pdf', {
+  'Full Name' => 'Jane Roe',
+  'agree' => 'Yes',        # checkbox: state name, or anything truthy
+  'color' => 'Blue',       # radio group: state name
+  'notes' => "line one\nline two" # multiline fields wrap automatically
+})
+
+# Flatten: burn values into page content and drop the interactive form
+Acrofill.fill_form('form.pdf', 'out.pdf', data, flatten: true)
+
+# Filling the same template many times (the typical server pattern)?
+# Parse it once — each subsequent fill skips parsing entirely (~3-8x
+# faster per fill) and works on its own copy, so it is thread-safe:
+template = Acrofill::Template.new('form.pdf')
+template.fill_form('out1.pdf', { 'Full Name' => 'Jane' }, flatten: true)
+template.fill_form('out2.pdf', { 'Full Name' => 'John' }, flatten: true)
+```
+
+### Drop-in for pdf-forms
+
+`Acrofill.new` accepts (and ignores) a pdftk path, so most `PdfForms`
+call sites work unchanged:
+
+```ruby
+filler = Acrofill.new                    # was: PdfForms.new('/usr/bin/pdftk')
+filler.fill_form(tpl, out, data, flatten: true)
+```
+
+Unknown field names are silently ignored, matching pdftk.
+
+## Performance
+
+Because Acrofill runs in-process, it avoids the JVM (or C++ process)
+start-up that dominates a `pdftk` subprocess call — the exact pattern a
+web app hits when it fills one form per request. Filling **and
+flattening** three real-world government claim forms, 50 iterations
+each, on an Apple M-series laptop against `pdftk-java` 3.3.3:
+
+| Form                       | acrofill | pdftk (java) | speedup |
+|----------------------------|---------:|-------------:|--------:|
+| form A (124 fields, 3 pp)  | 49 ms    | 192 ms       | 3.9×    |
+| form B (53 fields, 2 pp)   | 16 ms    | 124 ms       | 7.6×    |
+| form C (187 fields, 2 pp)  | 47 ms    | 154 ms       | 3.3×    |
+| **weighted total**         |          |              | **4.2×**|
+
+Reproduce with your own templates — the benchmark discovers each form's
+fields automatically:
+
+```bash
+ruby benchmark/compare.rb path/to/*.pdf   # ITERATIONS=50 by default
+```
+
+### Self-contained synthetic benchmark
+
+`benchmark/synthetic.rb` needs no templates — it generates a form with a
+configurable number of text fields and reports three variants. Because
+`pdftk` (a CLI) has no server mode, the JVM boots on every call; to be
+fair we also measure that start-up cost separately and subtract it, so
+**pdftk warm** models the marginal PDF-processing cost with the runtime
+already hot (a lower bound on any long-lived-pdftk setup):
+
+```
+$ FIELDS=30 ruby benchmark/synthetic.rb
+variant                        ms/fill vs acrofill
+acrofill (in-process)             3.4       1.0×
+acrofill (cached template)        1.1       0.3×
+pdftk cold (subprocess)         122.3      36.0×
+pdftk warm (JVM excluded)        90.6      26.6×
+(measured pdftk start-up overhead: ~32 ms/call)
+```
+
+Even discounting JVM start-up entirely, Acrofill is ~13–29× faster on
+synthetic forms (the multiplier shrinks as field count grows: ~29× at 30
+fields, ~13× at 80). The gap is largest on simple forms — exactly the
+common case — and start-up is a real per-request cost for any `pdftk`-CLI
+integration. The `pdftk warm` figure is a conservative estimate: `pdftk
+--version` loads fewer classes than an actual fill, so true warm cost is
+somewhat higher than shown.
+
+Parsing dominates a one-shot fill (~86% of the time on a real 3-page
+form), which is what `Acrofill::Template` eliminates: on the 124-field
+form above a one-shot fill takes ~47 ms while a cached-template fill
+takes ~6 ms — against pdftk's ~192 ms for the same job.
+
+## Security
+
+The PDF **template** is treated as untrusted input (the typical
+"upload a PDF and fill it" case), and so are field names and values.
+Acrofill is pure Ruby with no `eval`/`system`/native calls in its hot
+path, so the worst an input can do is cause an exception — never memory
+corruption or code execution. Specifically it defends against:
+
+- **Cyclic and exponentially-shared object graphs** — the page tree and
+  field tree walkers carry visited-sets, so a `/Pages` or `/Kids` cycle,
+  or a "billion laughs" DAG, terminates in O(objects) instead of hanging
+  or overflowing the stack.
+- **Content-stream injection via `/DA`** — the template's default
+  appearance string is sanitized: the font name must be a regular PDF
+  name and only well-formed colour operators (`g`/`rg`/`k`) are copied
+  into generated appearances. Field **values** are always written as
+  escaped literals / hex strings, never as operators.
+- **Malformed scalars** — non-finite reals, deeply nested arrays, and
+  mistyped dictionaries are clamped or rejected rather than crashing the
+  writer.
+- **Encrypted / unparseable input** — rejected up front; every failure
+  at the parse boundary surfaces as `Acrofill::Error`, so callers only
+  ever rescue one error type.
+
+## Feature matrix
+
+Supported:
+
+- Text fields (`/Tx`) — hierarchical names (`parent.kid`), inherited
+  `/DA`, alignment via `/Q` (left/center/right), auto font size (`0 Tf`),
+  shrink-to-fit for overflowing values, multiline fields (`/Ff` bit 13)
+  with word wrapping, standard-14 width metrics
+  (Helvetica/Courier/Times).
+- Checkboxes and radio groups (`/Btn`) — state selection via `/V`+`/AS`
+  using the template's own appearance states.
+- Choice fields (`/Ch`) — value set and rendered like text.
+- Flattening — every visible widget appearance is stamped into the page
+  content; widget annotations and the AcroForm dictionary are removed.
+- Values in any encoding (stored as UTF-16BE when needed; appearances
+  render the Windows-1252 subset).
+
+Not supported (rejected or ignored, never a hard crash):
+
+- Encrypted documents (raise `Acrofill::Error`), XFA forms, digital
+  signatures, JavaScript actions.
+- Push buttons; comb fields render as plain text; rich text (`/RV`) is
+  dropped on fill.
+- Glyphs outside Windows-1252 in generated appearances (stored values
+  keep full Unicode; unrenderable glyphs appear as `?`).
+
+## Development
+
+```bash
+bundle install
+bundle exec rake spec
+```
+
+The test suite generates its fixture PDFs from scratch — the repository
+contains no binary files.
+
+## License
+
+MIT. See LICENSE.txt.

data/lib/acrofill/appearance.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Acrofill
+  # Builds the /AP /N appearance stream (a Form XObject) for a filled
+  # text-field widget, honouring the field's /DA string and /Q alignment.
+  class Appearance
+    PADDING = 2.0
+    ASCENT = 0.718 # Helvetica cap-height-ish ascent, em fractions
+    DESCENT = 0.207
+    # Colour-setting operators allowed in a /DA string, and their operand counts.
+    COLOR_OP_ARITY = { 'g' => 1, 'rg' => 3, 'k' => 4 }.freeze
+
+    def initialize(doc, acroform)
+      @doc = doc
+      @acroform = acroform
+    end
+
+    # Returns a Reference to the new appearance XObject, or nil when the
+    # widget geometry is unusable.
+    def build(field_node, widget, value, multiline: false)
+      rect = normalized_rect(widget[:Rect] || @doc.inherited_value(field_node, :Rect))
+      return nil unless rect
+
+      width = rect[2] - rect[0]
+      height = rect[3] - rect[1]
+      return nil if width <= 0 || height <= 0
+
+      font_name, size, color_ops = parse_da(field_node)
+      base_font = base_font_for(font_name)
+      align = @doc.inherited_value(field_node, :Q) || @acroform[:Q] || 0
+
+      body =
+        if multiline
+          size = 12.0 if size <= 0
+          size = size.clamp(2.0, 144.0)
+          multiline_body(value, base_font, size, width, height, align)
+        else
+          text = printable_text(value)
+          size = [height * 0.66, 12.0].min if size.zero?
+          size = shrink_to_fit(text, base_font, size, width)
+          ty = [(height - (size * (ASCENT - DESCENT))) / 2.0, size * DESCENT].max
+          "#{fmt(line_x(text, base_font, size, width, align))} #{fmt(ty)} Td\n" \
+            "(#{escape_literal(text)}) Tj\n"
+        end
+
+      content = +"/Tx BMC\nq\nBT\n"
+      content << "#{color_ops}\n" unless color_ops.empty?
+      content << "/#{font_name} #{fmt(size)} Tf\n"
+      content << body
+      content << "ET\nQ\nEMC\n"
+
+      dict = {
+        Type: :XObject,
+        Subtype: :Form,
+        FormType: 1,
+        BBox: [0, 0, width, height],
+        Resources: { Font: { font_name.to_sym => font_ref(font_name) } }
+      }
+      @doc.add(StreamObject.new(dict, content.b))
+    end
+
+    private
+
+    def fmt(num)
+      Serializer.format_number(num.to_f)
+    end
+
+    def line_x(text, base_font, size, width, align)
+      text_width = Metrics.string_width(text, base_font, size)
+      case align
+      when 1 then [(width - text_width) / 2.0, PADDING].max
+      when 2 then [width - PADDING - text_width, PADDING].max
+      else PADDING
+      end
+    end
+
+    # Greedy word wrap, top-down, honouring explicit line breaks. Lines
+    # that would fall below the box are clipped by the BBox.
+    def multiline_body(value, base_font, size, width, height, align)
+      max_width = width - (2 * PADDING)
+      lines = value.to_s.split(/\r\n|[\r\n]/).flat_map do |paragraph|
+        wrap_line(printable_text(paragraph), base_font, size, max_width)
+      end
+
+      leading = size * 1.15
+      first_y = height - PADDING - (size * ASCENT)
+      body = "#{fmt(leading)} TL\n"
+      previous_x = 0.0
+      lines.each_with_index do |line, index|
+        x = line_x(line, base_font, size, width, align)
+        body << "#{fmt(x - previous_x)} #{index.zero? ? fmt(first_y) : '0'} Td\n"
+        body << "(#{escape_literal(line)}) Tj\nT*\n"
+        previous_x = x
+      end
+      body
+    end
+
+    # Greedy wrap. Line and space widths are accumulated incrementally so
+    # the cost is O(total characters), not O(words * line-length).
+    def wrap_line(text, base_font, size, max_width)
+      space = Metrics.string_width(' ', base_font, size)
+      lines = ['']
+      widths = [0.0]
+      text.split.each do |word|
+        word_width = Metrics.string_width(word, base_font, size)
+        if lines.last.empty?
+          lines[-1] = word
+          widths[-1] = word_width
+        elsif widths.last + space + word_width <= max_width
+          lines[-1] = "#{lines.last} #{word}"
+          widths[-1] += space + word_width
+        else
+          lines << word
+          widths << word_width
+        end
+      end
+      lines
+    end
+
+    def normalized_rect(rect)
+      rect = @doc.deref(rect)
+      return nil unless rect.is_a?(Array) && rect.size == 4
+
+      xs = [rect[0].to_f, rect[2].to_f].sort
+      ys = [rect[1].to_f, rect[3].to_f].sort
+      [xs[0], ys[0], xs[1], ys[1]]
+    end
+
+    # /DA is e.g. "/Helv 8 Tf 0 g": font + size around Tf, plus a colour.
+    # The /DA string is template-controlled and copied into the generated
+    # appearance stream, so the font name and colour operators are both
+    # sanitized here — otherwise a crafted /DA could inject arbitrary
+    # content operators (e.g. rectangle fills) into the output.
+    def parse_da(field_node)
+      da = @doc.deref(@doc.inherited_value(field_node, :DA)) || @doc.deref(@acroform[:DA]) || '/Helv 0 Tf 0 g'
+      return ['Helv', 0.0, '0 g'] unless da.is_a?(String)
+
+      tokens = da.split
+      tf = tokens.index('Tf')
+      return ['Helv', 0.0, '0 g'] unless tf && tf >= 2
+
+      font = sanitize_font(tokens[tf - 2].to_s.delete_prefix('/'))
+      size = tokens[tf - 1].to_f
+      color = safe_color_ops(tokens[0...(tf - 2)] + tokens[(tf + 1)..])
+      [font, size, color]
+    end
+
+    # Only a name made of PDF-regular characters may be written as /Name.
+    def sanitize_font(name)
+      Serializer::REGULAR_NAME.match?(name) ? name : 'Helv'
+    end
+
+    # Keep only well-formed colour-setting operators (g / rg / k) with the
+    # right count of numeric operands immediately before them; drop anything
+    # else the /DA might carry.
+    def safe_color_ops(tokens)
+      ops = []
+      tokens.each_with_index do |tok, i|
+        arity = COLOR_OP_ARITY[tok]
+        next unless arity
+
+        operands = tokens[[i - arity, 0].max...i]
+        next unless operands.size == arity && operands.all? { |o| o =~ /\A-?\d*\.?\d+\z/ }
+
+        ops << "#{operands.join(' ')} #{tok}"
+      end
+      ops.empty? ? '0 g' : ops.join(' ')
+    end
+
+    # Fixed sizes that overflow the box are scaled down so the whole value
+    # stays visible (Acrobat-style best-fit; pdftk would clip instead).
+    def shrink_to_fit(text, base_font, size, width)
+      max_width = width - (2 * PADDING)
+      text_width = Metrics.string_width(text, base_font, size)
+      size *= max_width / text_width if text_width > max_width && text_width.positive?
+      size.clamp(2.0, 144.0)
+    end
+
+    # The font resource dictionary from /AcroForm /DR /Font, or {} when the
+    # template supplies a malformed (non-dictionary) /DR or /Font.
+    def dr_fonts
+      dr = @doc.deref(@acroform[:DR])
+      return {} unless dr.is_a?(Hash)
+
+      fonts = @doc.deref(dr[:Font])
+      fonts.is_a?(Hash) ? fonts : {}
+    end
+
+    def base_font_for(resource_name)
+      font = @doc.deref(dr_fonts[resource_name.to_sym])
+      base = font.is_a?(Hash) ? font[:BaseFont].to_s : ''
+      base.sub(/\A[A-Z]{6}\+/, '')
+    end
+
+    def font_ref(resource_name)
+      entry = dr_fonts[resource_name.to_sym]
+      return @doc.ref_for(entry) if entry
+
+      # Font not present in /DR: register a plain Helvetica.
+      @doc.add(Type: :Font, Subtype: :Type1, BaseFont: :Helvetica, Encoding: :WinAnsiEncoding)
+    end
+
+    def printable_text(value)
+      value.to_s.gsub(/[[:space:]]+/, ' ').strip
+           .encode('Windows-1252', invalid: :replace, undef: :replace, replace: '?')
+    end
+
+    def escape_literal(text)
+      text.b
+          .gsub(/[\\()]/) { |ch| "\\#{ch}" }
+          .gsub(/[\x00-\x1F]/) { |ch| format('\\%03o', ch.ord) }
+    end
+  end
+end

data/lib/acrofill/document.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'pdf-reader'
+
+module Acrofill
+  # A new stream object created by acrofill (appearance streams, stamped
+  # content). +raw+ holds the final, already-encoded stream bytes.
+  StreamObject = Struct.new(:dict, :raw)
+
+  # In-memory object store for a parsed PDF. All indirect objects are
+  # materialized once via pdf-reader (which transparently handles xref
+  # streams and object streams), then mutated in place before writing.
+  class Document
+    attr_reader :objects, :trailer
+
+    def initialize(path)
+      hash = load_object_hash(path)
+      raise Error, 'encrypted PDFs are not supported' if hash.trailer[:Encrypt]
+
+      @objects = {}
+      @max_oid = 0
+      hash.each do |ref, obj|
+        @objects[ref.id] = obj
+        @max_oid = ref.id if ref.id > @max_oid
+      end
+      @trailer = hash.trailer.slice(:Root, :Info, :ID)
+      raise Error, 'PDF has no document catalog' unless @trailer[:Root]
+    end
+
+    # A serialized copy of the pristine object graph; see Template.
+    def snapshot
+      Marshal.dump([@objects, @trailer, @max_oid])
+    end
+
+    # Rebuilds a Document from a snapshot produced by #snapshot. Restoring
+    # deep-copies every object, so mutations never leak between fills.
+    # Snapshots are an internal format: only feed this data produced by
+    # #snapshot in the same process (Marshal is not safe on foreign input).
+    def self.restore(snapshot)
+      doc = allocate
+      # Snapshots are produced by #snapshot in the same process and never
+      # accepted from external input, so Marshal here is not a deserialization
+      # boundary (see Template docs).
+      doc.send(:restore_state, *Marshal.load(snapshot)) # rubocop:disable Security/MarshalLoad
+      doc
+    end
+
+    private
+
+    def restore_state(objects, trailer, max_oid)
+      @objects = objects
+      @trailer = trailer
+      @max_oid = max_oid
+    end
+
+    # The parse boundary for untrusted input: pdf-reader (and the decryptors
+    # it calls) can raise a wide assortment of errors on crafted files, so
+    # everything is normalized to a single Acrofill::Error type.
+    def load_object_hash(path)
+      PDF::Reader::ObjectHash.new(path)
+    rescue PDF::Reader::EncryptedPDFError => e
+      raise Error, "encrypted PDFs are not supported (#{e.message})"
+    rescue StandardError => e
+      raise Error, "could not parse PDF (#{e.class}: #{e.message})"
+    end
+
+    public
+
+    # Follows reference chains (ref -> ref -> value is legal PDF), with a
+    # hop cap so a reference cycle cannot loop forever.
+    def deref(obj)
+      hops = 0
+      while obj.is_a?(PDF::Reader::Reference)
+        return nil if (hops += 1) > 16
+
+        obj = @objects[obj.id]
+      end
+      obj
+    end
+
+    # Adds a new indirect object and returns a reference to it.
+    def add(obj)
+      @max_oid += 1
+      @objects[@max_oid] = obj
+      PDF::Reader::Reference.new(@max_oid, 0)
+    end
+
+    # Wraps a direct object into an indirect one; passes references through.
+    def ref_for(obj)
+      obj.is_a?(PDF::Reader::Reference) ? obj : add(obj)
+    end
+
+    def root
+      deref(@trailer[:Root])
+    end
+
+    def each_page(node = root[:Pages], seen = {}, &block)
+      dict = deref(node)
+      return unless dict.is_a?(Hash)
+
+      # Guard against cyclic and shared (billion-laughs) /Pages trees: a
+      # node reachable more than once is walked only the first time.
+      if node.is_a?(PDF::Reader::Reference)
+        return if seen[node.id]
+
+        seen[node.id] = true
+      end
+
+      case dict[:Type]
+      when :Pages
+        (deref(dict[:Kids]) || []).each { |kid| each_page(kid, seen, &block) }
+      when :Page
+        yield dict
+      end
+    end
+
+    # Resolves an attribute inheritable through the /Parent chain
+    # (field attributes like /FT, /DA, /Q or page attributes).
+    def inherited_value(node, key)
+      seen = 0
+      while node.is_a?(Hash)
+        return node[key] if node.key?(key)
+        return nil if (seen += 1) > 64 # cycle guard
+
+        node = deref(node[:Parent])
+      end
+      nil
+    end
+  end
+end

data/lib/acrofill/filler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Acrofill
+  # Public entry point, signature-compatible with PdfForms#fill_form:
+  #
+  #   Acrofill.new.fill_form(template, output, { 'Field' => 'value' }, flatten: true)
+  #
+  # Note: PdfForms-specific options (data_format:, utf8_fields:, ...) are
+  # accepted and ignored — acrofill needs no FDF and is always UTF-aware.
+  class Filler
+    # Accepts and ignores a pdftk path argument for drop-in compatibility.
+    def initialize(*); end
+
+    def fill_form(template, destination, data = {}, options = {})
+      apply(Document.new(template), destination, data, options)
+    end
+
+    # Field metadata (name, type, current value, checkbox/radio states)
+    # without modifying the document.
+    def fields(template)
+      Form.new(Document.new(template)).fields
+    end
+
+    # Fully-qualified names of all fillable fields.
+    def field_names(template)
+      fields(template).map(&:name)
+    end
+
+    # Shared fill pipeline, also driven by Template with a restored
+    # document. Values are normalized to valid UTF-8 up front so that a
+    # mis-encoded input degrades (replacement character) instead of
+    # leaking a raw Encoding error from deep inside the appearance code.
+    def apply(doc, destination, data, options)
+      form = Form.new(doc)
+      data.each do |name, value|
+        form.fill(normalize(name), normalize(value))
+      end
+      form.flatten! if options[:flatten] || options['flatten']
+      File.binwrite(destination, Writer.new(doc).render)
+      destination
+    end
+
+    private
+
+    def normalize(value)
+      return '' if value.nil?
+
+      value.to_s.encode('UTF-8', invalid: :replace, undef: :replace).scrub
+    end
+  end
+end

data/lib/acrofill/form.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module Acrofill
+  # The interactive form of a document: field lookup by fully-qualified
+  # name, value filling with appearance regeneration, and flattening.
+  class Form
+    HIDDEN_FLAG = 2
+    MULTILINE_FLAG = 1 << 12
+    PUSHBUTTON_FLAG = 1 << 16
+
+    Field = Struct.new(:name, :type, :value, :states, keyword_init: true)
+
+    def initialize(doc)
+      @doc = doc
+      @acroform = doc.deref(doc.root[:AcroForm])
+      raise Error, 'document has no AcroForm' unless @acroform.is_a?(Hash)
+
+      @appearance = Appearance.new(doc, @acroform)
+      # name => array of { node:, widgets: } groups. Several field dicts may
+      # share one fully-qualified name (PDF 32000 §12.7.3.2 treats them as a
+      # single logical field, e.g. "SSN" repeated on every page) — filling
+      # must update all of them.
+      @fields = Hash.new { |h, k| h[k] = [] }
+      collect_fields(doc.deref(@acroform[:Fields]) || [], nil, {})
+    end
+
+    # Metadata for every logical field, in document order.
+    def fields
+      @fields.map do |name, groups|
+        type = field_type(groups.first[:node])
+        Field.new(
+          name: name,
+          type: type,
+          value: decode_text_string(groups.first[:node][:V]),
+          states: type == :Btn ? on_states(all_widgets(groups)) : nil
+        )
+      end
+    end
+
+    # Sets the field value and rebuilds widget appearances. Unknown names
+    # are ignored (returns false), matching pdftk's fill_form behaviour.
+    def fill(name, value)
+      groups = @fields.fetch(name, [])
+      return false if groups.empty?
+
+      case field_type(groups.first[:node])
+      when :Btn then fill_button(groups, value)
+      when :Tx, :Ch, nil then groups.each { |group| fill_text(group, value) }.any?
+      else false # signatures and unknown types are left untouched
+      end
+    end
+
+    # Stamps every visible widget appearance into its page's content and
+    # removes the interactive layer, like pdftk's `output ... flatten`.
+    def flatten!
+      @doc.each_page { |page| flatten_page(page) }
+      @doc.root.delete(:AcroForm)
+    end
+
+    private
+
+    def all_widgets(groups)
+      groups.flat_map { |group| group[:widgets] }
+    end
+
+    def field_type(node)
+      type = @doc.inherited_value(node, :FT)
+      type.is_a?(Symbol) ? type : nil
+    end
+
+    # /Ff is an integer bit set; coerce defensively since malformed input
+    # can supply a non-integer here (Array#to_i does not exist).
+    def field_flags(node)
+      flags = @doc.deref(@doc.inherited_value(node, :Ff))
+      flags.is_a?(Integer) ? flags : 0
+    end
+
+    # Annotation /F flags. Must be dereferenced before to_i: on a
+    # PDF::Reader::Reference, to_i returns the object *number*.
+    def annotation_flags(widget)
+      flags = @doc.deref(widget[:F])
+      flags.is_a?(Integer) ? flags : 0
+    end
+
+    def fill_text(group, value)
+      node = group[:node]
+      node[:V] = pdf_text_string(value)
+      node.delete(:RV)
+      node.delete(:I)
+      multiline = field_flags(node).anybits?(MULTILINE_FLAG)
+      group[:widgets].each do |widget|
+        widget.delete(:AS)
+        if value.empty?
+          widget.delete(:AP)
+        else
+          ap_ref = @appearance.build(node, widget, value, multiline: multiline)
+          widget[:AP] = { N: ap_ref } if ap_ref
+        end
+      end
+      true
+    end
+
+    # Checkboxes and radio groups carry per-state appearance streams, so
+    # filling only selects a state: /V on the field, /AS on each widget.
+    # The value may be a state name ("Yes"), or anything non-empty when the
+    # group has a single on state. Empty, "Off" or false-ish unchecks.
+    def fill_button(groups, value)
+      widgets = all_widgets(groups)
+      states = on_states(widgets)
+      # Match against the state names already present in the template
+      # rather than interning the untrusted value (avoids unbounded
+      # symbol creation from attacker-controlled field values).
+      named = states.find { |s| s.to_s == value }
+      state =
+        if ['', 'Off', 'false', 'no'].include?(value)
+          :Off
+        elsif named
+          named
+        elsif states.size == 1
+          states.first
+        else
+          return false
+        end
+
+      filled = false
+      groups.each do |group|
+        node = group[:node]
+        next if field_flags(node).anybits?(PUSHBUTTON_FLAG)
+
+        node[:V] = state
+        group[:widgets].each do |widget|
+          widget[:AS] = widget_states(widget).include?(state) ? state : :Off
+        end
+        filled = true
+      end
+      filled
+    end
+
+    def on_states(widgets)
+      widgets.flat_map { |widget| widget_states(widget) }.uniq - [:Off]
+    end
+
+    def widget_states(widget)
+      ap = @doc.deref(widget[:AP])
+      return [] unless ap.is_a?(Hash)
+
+      normal = @doc.deref(ap[:N])
+      normal.is_a?(Hash) && !normal.is_a?(PDF::Reader::Stream) ? normal.keys : []
+    end
+
+    # Guard against cyclic and shared /Kids graphs: a field node reachable
+    # more than once is expanded only the first time.
+    def visited?(ref, seen)
+      return false unless ref.is_a?(PDF::Reader::Reference)
+      return true if seen[ref.id]
+
+      seen[ref.id] = true
+      false
+    end
+
+    def collect_fields(kids, prefix, seen)
+      kids.each do |ref|
+        next if visited?(ref, seen)
+
+        node = @doc.deref(ref)
+        next unless node.is_a?(Hash)
+
+        name = [prefix, decode_name(node[:T])].compact.join('.')
+        child_refs = @doc.deref(node[:Kids]) || []
+        child_pairs = child_refs.map { |kid| [kid, @doc.deref(kid)] }
+                                .select { |_kid, dict| dict.is_a?(Hash) }
+        subfields, widgets = child_pairs.partition { |_kid, dict| dict.key?(:T) }
+
+        if subfields.any?
+          # Recurse only into the named subfields; a stray bare widget mixed
+          # into the same /Kids must not register itself under this name.
+          collect_fields(subfields.map(&:first), name, seen)
+        else
+          widget_dicts = widgets.map(&:last)
+          widget_dicts = [node] if widget_dicts.empty? && node[:Rect]
+          @fields[name] << { node: node, widgets: widget_dicts } unless name.empty?
+        end
+      end
+    end
+
+    def decode_name(raw)
+      decode_text_string(@doc.deref(raw))
+    end
+
+    # PDF text strings are UTF-16BE (with BOM) or PDFDoc/Latin-ish; both are
+    # template-controlled, so decoding failures degrade instead of raising.
+    def decode_text_string(raw)
+      return raw unless raw.is_a?(String)
+
+      if raw.start_with?("\xFE\xFF".b)
+        raw.byteslice(2..).force_encoding('UTF-16BE')
+           .encode('UTF-8', invalid: :replace, undef: :replace)
+      else
+        raw.dup.force_encoding('UTF-8').scrub
+      end
+    end
+
+    def pdf_text_string(value)
+      return value.b if value.ascii_only?
+
+      "\xFE\xFF".b + value.encode('UTF-16BE').b
+    end
+
+    def flatten_page(page)
+      annots = (@doc.deref(page[:Annots]) || []).map { |a| [a, @doc.deref(a)] }
+      widgets, others = annots.partition { |_ref, dict| dict.is_a?(Hash) && dict[:Subtype] == :Widget }
+      return if widgets.empty?
+
+      stamps = []
+      widgets.each do |_ref, widget|
+        stamp = stamp_operations(page, widget)
+        stamps << stamp if stamp
+      end
+
+      unless stamps.empty?
+        wrap = ->(bytes) { @doc.add(StreamObject.new({}, bytes.b)) }
+        derefed = @doc.deref(page[:Contents])
+        contents = (derefed.is_a?(Array) ? derefed : [page[:Contents]]).compact
+        contents = contents.map { |stream| @doc.ref_for(stream) }
+        page[:Contents] = [wrap.call("q\n"), *contents, wrap.call("\nQ\n#{stamps.join("\n")}\n")]
+      end
+
+      remaining = others.map(&:first)
+      if remaining.empty?
+        page.delete(:Annots)
+      else
+        page[:Annots] = remaining
+      end
+    end
+
+    # Returns content-stream operations placing the widget's normal
+    # appearance onto the page, or nil when there is nothing to draw.
+    # Implements the appearance-box algorithm of PDF 32000 §12.5.5: the
+    # form's /Matrix is applied to its BBox, and the resulting extent is
+    # mapped onto the annotation rectangle.
+    def stamp_operations(page, widget)
+      return nil if annotation_flags(widget).anybits?(HIDDEN_FLAG)
+
+      ap_ref = normal_appearance(widget)
+      xobject = @doc.deref(ap_ref)
+      dict = xobject.is_a?(StreamObject) ? xobject.dict : xobject&.hash
+      return nil unless dict.is_a?(Hash)
+
+      bbox = @doc.deref(dict[:BBox])
+      rect = @doc.deref(widget[:Rect])
+      return nil unless bbox.is_a?(Array) && rect.is_a?(Array)
+
+      # Appearance streams are form XObjects, but /Type and /Subtype are
+      # sometimes omitted; /Do requires them.
+      dict[:Type] ||= :XObject
+      dict[:Subtype] ||= :Form
+
+      llx, lly, urx, ury = normalize_box(rect)
+      bx0, by0, bx1, by1 = transformed_bbox(bbox, @doc.deref(dict[:Matrix]))
+      bw = bx1 - bx0
+      bh = by1 - by0
+      return nil if bw <= 0 || bh <= 0
+
+      sx = (urx - llx) / bw
+      sy = (ury - lly) / bh
+      name = register_xobject(page, ap_ref)
+      matrix = [sx, 0, 0, sy, llx - (bx0 * sx), lly - (by0 * sy)]
+      ops = matrix.map { |n| Serializer.format_number(n.to_f) }
+      "q #{ops.join(' ')} cm /#{name} Do Q"
+    end
+
+    # Bounding box of the BBox corners after the form's /Matrix (identity
+    # when absent or malformed).
+    def transformed_bbox(bbox, matrix)
+      x0, y0, x1, y1 = normalize_box(bbox)
+      return [x0, y0, x1, y1] unless matrix.is_a?(Array) && matrix.size == 6 &&
+                                     matrix.all?(Numeric)
+
+      a, b, c, d, e, f = matrix.map(&:to_f)
+      xs = []
+      ys = []
+      [[x0, y0], [x1, y0], [x0, y1], [x1, y1]].each do |x, y|
+        xs << ((a * x) + (c * y) + e)
+        ys << ((b * x) + (d * y) + f)
+      end
+      [xs.min, ys.min, xs.max, ys.max]
+    end
+
+    def normal_appearance(widget)
+      ap = @doc.deref(widget[:AP])
+      return nil unless ap.is_a?(Hash)
+
+      normal = ap[:N]
+      states = @doc.deref(normal)
+      if states.is_a?(Hash) && !states.is_a?(PDF::Reader::Stream)
+        # Pick the widget's current state; without /AS default to /Off
+        # (never an arbitrary "on" appearance for an unset checkbox).
+        state = @doc.deref(widget[:AS])
+        state = :Off unless state.is_a?(Symbol) && states.key?(state)
+        normal = states[state]
+      end
+      normal
+    end
+
+    def normalize_box(box)
+      xs = [box[0].to_f, box[2].to_f].sort
+      ys = [box[1].to_f, box[3].to_f].sort
+      [xs[0], ys[0], xs[1], ys[1]]
+    end
+
+    def register_xobject(page, ap_ref)
+      resources = @doc.deref(page[:Resources]) || @doc.inherited_value(page, :Resources)
+      resources = @doc.deref(resources) || {}
+      resources = resources.dup
+      xobjects = (@doc.deref(resources[:XObject]) || {}).dup
+
+      @stamp_counter = (@stamp_counter || 0) + 1
+      name = :"AcrofillAP#{@stamp_counter}"
+      xobjects[name] = @doc.ref_for(ap_ref)
+      resources[:XObject] = xobjects
+      page[:Resources] = resources
+      name
+    end
+  end
+end

data/lib/acrofill/metrics.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Glyph widths (1/1000 em) for standard-14 fonts, ASCII 32..126,
+# extracted from Adobe AFM metrics. Index = char code - 32.
+module Acrofill
+  module Metrics
+    WIDTHS = {
+      'Helvetica' => [278, 278, 355, 556, 556, 889, 667, 222, 333, 333, 389, 584, 278, 333, 278, 278, 556,
+                      556, 556, 556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584, 584, 556, 1015, 667, 667, 722, 722, 667, 611, 778, 722, 278, 500, 667, 556, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278, 278, 278, 469, 556, 222, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222, 500, 222, 833, 556, 556, 556, 556, 333, 500, 278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584],
+      'Helvetica-Bold' => [278, 333, 474, 556, 556, 889, 722, 278, 333, 333, 389, 584, 278, 333, 278, 278,
+                           556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584, 584, 611, 975, 722, 722, 722, 722, 667, 611, 778, 722, 278, 556, 722, 611, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 333, 278, 333, 584, 556, 278, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278, 556, 278, 889, 611, 611, 611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584],
+      'Courier' => [600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600,
+                    600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600],
+      'Times-Roman' => [250, 333, 408, 500, 500, 833, 778, 333, 333, 333, 500, 564, 250, 333, 250, 278, 500,
+                        500, 500, 500, 500, 500, 500, 500, 500, 500, 278, 278, 564, 564, 564, 444, 921, 722, 667, 667, 722, 611, 556, 722, 722, 333, 389, 722, 611, 889, 722, 722, 556, 722, 667, 556, 611, 722, 722, 944, 722, 722, 611, 333, 278, 333, 469, 500, 333, 444, 500, 444, 500, 444, 333, 500, 500, 278, 278, 500, 278, 778, 500, 500, 500, 500, 333, 389, 278, 500, 500, 722, 500, 500, 444, 480, 200, 480, 541]
+    }.freeze
+
+    DEFAULT_WIDTH = 556
+
+    def self.string_width(str, base_font, size)
+      table = WIDTHS[base_font] || WIDTHS['Helvetica']
+      units = str.each_char.sum do |ch|
+        code = ch.ord
+        code.between?(32, 126) ? table[code - 32] : DEFAULT_WIDTH
+      end
+      units * size / 1000.0
+    end
+  end
+end

data/lib/acrofill/serializer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Acrofill
+  # Serializes Ruby values (as produced by pdf-reader) back into PDF syntax.
+  # References are renumbered through the map supplied by the Writer.
+  class Serializer
+    # PDF "regular characters": printable ASCII minus whitespace, the
+    # delimiters ( ) < > [ ] { } / % and the name-escape character #.
+    REGULAR_NAME_CHAR = %r{[!-~&&[^()<>\[\]{}/%#]]}
+    REGULAR_NAME = /\A#{REGULAR_NAME_CHAR.source}+\z/
+    MAX_DEPTH = 200
+
+    def self.format_number(num)
+      # PDF has no syntax for infinity/NaN, and #to_i on them raises;
+      # a non-finite number can only come from malformed input, so clamp.
+      return '0' unless num.finite?
+      return num.to_i.to_s if num == num.to_i
+
+      format('%.5f', num).sub(/\.?0+\z/, '')
+    end
+
+    def initialize(oid_map)
+      @oid_map = oid_map
+    end
+
+    def serialize(obj, depth = 0)
+      # Bound recursion: a pathologically nested array/dict from malformed
+      # input would otherwise overflow the stack.
+      raise Error, 'object nesting too deep' if depth > MAX_DEPTH
+
+      case obj
+      when PDF::Reader::Reference
+        oid = @oid_map[obj.id]
+        oid ? "#{oid} 0 R" : 'null'
+      when Hash then serialize_dict(obj, depth)
+      when Array then "[#{obj.map { |el| serialize(el, depth + 1) }.join(' ')}]"
+      when Symbol then serialize_name(obj)
+      when String then serialize_string(obj)
+      when Integer then obj.to_s
+      when Float then self.class.format_number(obj)
+      when TrueClass then 'true'
+      when FalseClass then 'false'
+      when NilClass then 'null'
+      else
+        raise Error, "cannot serialize #{obj.class}"
+      end
+    end
+
+    private
+
+    def serialize_dict(dict, depth = 0)
+      inner = dict.map { |k, v| "#{serialize_name(k)} #{serialize(v, depth + 1)}" }.join(' ')
+      "<< #{inner} >>"
+    end
+
+    def serialize_name(sym)
+      str = sym.to_s
+      return "/#{str}" if REGULAR_NAME.match?(str) # fast path: no escaping
+
+      encoded = str.bytes.map do |byte|
+        char = byte.chr
+        REGULAR_NAME_CHAR.match?(char) ? char : format('#%02X', byte)
+      end.join
+      "/#{encoded}"
+    end
+
+    # Hex strings sidestep every escaping concern for binary payloads
+    # (/ID entries, UTF-16BE values, Info metadata).
+    def serialize_string(str)
+      "<#{str.unpack1('H*').upcase}>"
+    end
+  end
+end

data/lib/acrofill/template.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Acrofill
+  # A pre-parsed, reusable template. Parsing is the dominant cost of a
+  # fill (tokenizing and inflating the whole file); Template pays it once
+  # and restores a pristine object graph from a Marshal snapshot for each
+  # subsequent fill — roughly 50x faster than re-parsing per fill.
+  #
+  #   template = Acrofill::Template.new('claim_form.pdf')
+  #   template.fill_form('a.pdf', { 'Name' => 'Jane' }, flatten: true)
+  #   template.fill_form('b.pdf', { 'Name' => 'John' }, flatten: true)
+  #
+  # Instances are cheap to keep around (the snapshot is a single string,
+  # comparable to the file size) and safe to share across threads: every
+  # fill works on its own restored copy.
+  class Template
+    def initialize(path)
+      doc = Document.new(path)
+      @snapshot = doc.snapshot
+    end
+
+    def fill_form(destination, data = {}, options = {})
+      Filler.new.apply(Document.restore(@snapshot), destination, data, options)
+    end
+
+    # Field metadata without touching disk again.
+    def fields
+      Form.new(Document.restore(@snapshot)).fields
+    end
+
+    def field_names
+      fields.map(&:name)
+    end
+  end
+end

data/lib/acrofill/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Acrofill
+  VERSION = '0.1.0'
+end

data/lib/acrofill/writer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+module Acrofill
+  # Writes the document back out as a fresh PDF: only objects reachable from
+  # the trailer are emitted, renumbered contiguously, with a classic xref
+  # table. Existing streams are copied verbatim with their original filters.
+  class Writer
+    HEADER = "%PDF-1.6\n%\xE2\xE3\xCF\xD3\n".b
+
+    def initialize(document)
+      @doc = document
+    end
+
+    def render
+      order = reachable_oids
+      oid_map = order.each_with_index.to_h { |oid, idx| [oid, idx + 1] }
+      serializer = Serializer.new(oid_map)
+
+      out = HEADER.dup
+      offsets = []
+      order.each do |oid|
+        offsets << out.bytesize
+        out << "#{oid_map[oid]} 0 obj\n"
+        out << serialize_object(@doc.objects[oid], serializer)
+        out << "\nendobj\n"
+      end
+
+      xref_offset = out.bytesize
+      out << "xref\n0 #{order.size + 1}\n0000000000 65535 f \n"
+      offsets.each { |offset| out << format("%010d 00000 n \n", offset) }
+
+      trailer = {
+        Size: order.size + 1,
+        Root: @doc.trailer[:Root],
+        Info: @doc.trailer[:Info],
+        ID: trailer_id(out)
+      }.compact
+      out << "trailer\n#{serializer.serialize(trailer)}\n"
+      out << "startxref\n#{xref_offset}\n%%EOF\n"
+      out
+    end
+
+    private
+
+    # Preserves the original /ID pair, or derives one from the serialized
+    # body so identical inputs always produce identical output bytes.
+    def trailer_id(body)
+      id = @doc.trailer[:ID]
+      return id if id.is_a?(Array) && id.size == 2 && id.all?(String)
+
+      digest = Digest::MD5.digest(body)
+      [digest, digest]
+    end
+
+    def serialize_object(obj, serializer)
+      dict, raw =
+        case obj
+        when PDF::Reader::Stream then [obj.hash, obj.data]
+        when StreamObject then [obj.dict, obj.raw]
+        else return serializer.serialize(obj)
+        end
+
+      dict = dict.merge(Length: raw.bytesize)
+      "#{serializer.serialize(dict)}\nstream\n".b + raw.b + "\nendstream".b
+    end
+
+    # Breadth-first walk from the trailer; keeps original ordering stable
+    # and drops everything orphaned (old xref streams, removed form fields).
+    def reachable_oids
+      queue = [@doc.trailer[:Root], @doc.trailer[:Info]].compact
+      seen = {}
+      order = []
+
+      until queue.empty?
+        current = queue.shift
+        case current
+        when PDF::Reader::Reference
+          next if seen[current.id]
+
+          seen[current.id] = true
+          obj = @doc.objects[current.id]
+          next if obj.nil?
+
+          order << current.id
+          queue << obj
+        when Hash
+          queue.concat(current.values)
+        when Array
+          queue.concat(current)
+        when PDF::Reader::Stream
+          queue << current.hash
+        when StreamObject
+          queue << current.dict
+        end
+      end
+      order
+    end
+  end
+end

data/lib/acrofill.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'acrofill/version'
+require_relative 'acrofill/document'
+require_relative 'acrofill/metrics'
+require_relative 'acrofill/serializer'
+require_relative 'acrofill/writer'
+require_relative 'acrofill/appearance'
+require_relative 'acrofill/form'
+require_relative 'acrofill/filler'
+require_relative 'acrofill/template'
+
+module Acrofill
+  class Error < StandardError; end
+
+  # Mirrors the PdfForms.new(pdftk_path) constructor shape.
+  def self.new(*args)
+    Filler.new(*args)
+  end
+
+  def self.fill_form(template, destination, data = {}, options = {})
+    Filler.new.fill_form(template, destination, data, options)
+  end
+
+  def self.fields(template)
+    Filler.new.fields(template)
+  end
+
+  def self.field_names(template)
+    Filler.new.field_names(template)
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: acrofill
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- stiig
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pdf-reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: Fills PDF form fields (text, checkbox, radio, choice) in-process and
+  optionally flattens the result into static page content. An MIT-licensed, no-dependencies-on-binaries
+  alternative to the pdftk fill_form pipeline.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/acrofill.rb
+- lib/acrofill/appearance.rb
+- lib/acrofill/document.rb
+- lib/acrofill/filler.rb
+- lib/acrofill/form.rb
+- lib/acrofill/metrics.rb
+- lib/acrofill/serializer.rb
+- lib/acrofill/template.rb
+- lib/acrofill/version.rb
+- lib/acrofill/writer.rb
+homepage: https://github.com/stiig/acrofill
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/stiig/acrofill
+  source_code_uri: https://github.com/stiig/acrofill
+  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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Pure-Ruby PDF form (AcroForm) filling and flattening
+test_files: []