acrofill 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7b9246e478c6ab2f8206ba44e766a2b4e9e9a946a48245d171d7e212bac54d2
-  data.tar.gz: e6f70298a5008e1419089328788cb1d66908cd3e2edfa2e3bd724e0a220ff176
+  metadata.gz: 633b173570db39e5b16714fd23e558a6832ed36f38a549802eb9dcda64967854
+  data.tar.gz: 26d94b282728f297c7c61d51ed817749d8435ecdd6dd4962a11942ac0af30fe9
 SHA512:
-  metadata.gz: 4f858c6d8e34cf948d8ef554d31d9e0a7187408f256fadff63c15bd4af3ad6ad6e61329770e9db506482f179635b9305393d432a9176742893aa45643810f22c
-  data.tar.gz: 75b8174ebb610ec9be61a7b214a69a47071d5aa797bb13378917eb3d41b4279c9ee81e1348641703dd29e5436ca1dcda30148b3e50c70759b2d47fad8c137cb1
+  metadata.gz: c5aad0c14c51e0d9e28a2c4c09b03d840b01c91ef83908ea0d31674f12ff0e4da8c33e7918600ba8ef409313a4faf0e8cfad30b325b3e23fa5c2786643fcdc97
+  data.tar.gz: 18be3697b53f7fe00d6d815a8cd7e0755ca3eef63eccc02e4f9dba181c4a14df648b05289e10ba9bf92b4e0ff62032ff9b1f42a6464a4ed3b75cd2c09b693261

data/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-07-27
+
+### Added
+
+- Comb fields (`/Ff` bit 25 with `/MaxLen`) lay each character out centered
+  in its own cell, `/Q` choosing which run of cells the value occupies,
+  matching pdftk cell for cell. They previously rendered as plain text.
+
+### Fixed
+
+- A value is now written in the codes its font actually draws it with. A
+  `/DR` font whose `/Encoding` carries a `/Differences` array moves glyphs
+  to other codes; writing the raw bytes drew whatever glyph happened to sit
+  there — a font mapping "A" to code 90 rendered "AZ" as "ZA". Widths
+  follow the emitted code, so measurement and rendering stay in step.
+
+### Changed
+
+- Flattening no longer stamps widgets a viewer would not display: `/F`
+  Hidden (bit 2) was already dropped, and NoView (bit 6, "not on screen",
+  PDF 32000 §12.5.3) now is too. pdftk stamps both, but burning in a
+  widget the template author concealed makes hidden values permanently
+  visible, so parity loses here. Widgets that are merely non-printing are
+  still stamped: they are what the viewer shows.
+
 ## [0.3.0] - 2026-07-27
 
 ### Fixed
@@ -142,7 +167,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `PdfForms`-compatible entry points (`Acrofill.new`, `fill_form`, `fields`,
   `field_names`).
 
-[Unreleased]: https://github.com/stiig/acrofill/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/stiig/acrofill/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/stiig/acrofill/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/stiig/acrofill/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/stiig/acrofill/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/stiig/acrofill/compare/v0.1.1...v0.1.2

data/README.md

@@ -91,11 +91,16 @@ your own templates with:
 ruby benchmark/geometry_diff.rb path/to/form.pdf
 ```
 
-Three differences are deliberate: acrofill shrinks an overlong value to fit
-where pdftk clips it, it writes Windows-1252 for non-ASCII values where
-pdftk emits UTF-8 bytes into a WinAnsi font (which renders as mojibake), and
-it caps auto-sized (`0 Tf`) text at 12pt where pdftk scales it to fill the
-box. See the changelog for the measured numbers.
+Flattened output was checked the same way: on those four forms every
+stamped fragment lands where pdftk stamps it, bar the fields covered by the
+deliberate differences below.
+
+Four differences are deliberate: acrofill shrinks an overlong value to fit
+where pdftk clips it; it writes Windows-1252 for non-ASCII values where
+pdftk emits UTF-8 bytes into a WinAnsi font (which renders as mojibake); it
+caps auto-sized (`0 Tf`) text at 12pt where pdftk scales it to fill the box;
+and it drops widgets flagged Hidden or NoView when flattening instead of
+burning them into the page. See the changelog for the measured numbers.
 
 ## Performance
 
@@ -194,6 +199,7 @@ Supported:
   rather than all measured as Helvetica.
 - Checkboxes and radio groups (`/Btn`) — state selection via `/V`+`/AS`
   using the template's own appearance states.
+- Comb fields (`/Ff` bit 25) — one character centered per `/MaxLen` cell.
 - 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.
@@ -204,8 +210,7 @@ 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.
+- Push buttons; rich text (`/RV`) is dropped on fill.
 - Glyphs outside Windows-1252 in generated appearances (stored values
   keep full Unicode; unrenderable glyphs appear as `?`).
 

data/lib/acrofill/appearance.rb

@@ -7,6 +7,9 @@ module Acrofill
     PADDING = 2.0
     # pdftk offsets the first multiline row by 1pt from the box top.
     TOP_OFFSET = 1.0
+
+    # The drawable area of one widget: its size and the field's /Q.
+    Box = Struct.new(:width, :height, :align)
     # Colour-setting operators allowed in a /DA string, and their operand counts.
     COLOR_OP_ARITY = { 'g' => 1, 'rg' => 3, 'k' => 4 }.freeze
 
@@ -18,51 +21,65 @@ module Acrofill
 
     # Returns a Reference to the new appearance XObject, or nil when the
     # widget geometry is unusable.
-    def build(field_node, widget, value, multiline: false)
+    def build(field_node, widget, value, multiline: false, comb: nil)
       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
+      box = Box.new(rect[2] - rect[0], rect[3] - rect[1], alignment(field_node))
+      return nil if box.width <= 0 || box.height <= 0
 
       font_name, size, color_ops = parse_da(field_node)
       font = @fonts.metrics(font_name)
-      align = alignment(field_node)
+      size, body = draw(value, font, size, box, multiline: multiline, comb: comb)
 
-      body =
-        if multiline
-          size = 12.0 if size <= 0
-          size = size.clamp(2.0, 144.0)
-          multiline_body(value, 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, font, size, width)
-          "#{fmt(line_x(text, font, size, width, align))} #{fmt(baseline(height, font, size))} Td\n" \
-            "(#{escape_literal(text)}) Tj\n"
-        end
+      @doc.add(StreamObject.new(appearance_dict(font_name, box),
+                                content(font_name, size, color_ops, body).b))
+    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"
+    private
 
-      dict = {
+    def fmt(num)
+      Serializer.format_number(num.to_f)
+    end
+
+    # The operators drawing +value+, and the point size they were laid out
+    # at — auto-sizing and shrink-to-fit both adjust the /DA size.
+    def draw(value, font, size, box, multiline:, comb:)
+      if multiline
+        size = (size <= 0 ? 12.0 : size).clamp(2.0, 144.0)
+        [size, multiline_body(value, font, size, box)]
+      elsif comb
+        size = auto_size(size, box.height).clamp(2.0, 144.0)
+        [size, comb_body(font.encode(printable_text(value)), font, size, box, comb)]
+      else
+        text = font.encode(printable_text(value))
+        size = shrink_to_fit(text, font, auto_size(size, box.height), box.width)
+        [size, "#{fmt(line_x(text, font, size, box))} #{fmt(baseline(box.height, font, size))} Td\n" \
+               "(#{escape_literal(text)}) Tj\n"]
+      end
+    end
+
+    # A /DA size of 0 means "fit the box"; acrofill caps that at 12pt.
+    def auto_size(size, height)
+      size.zero? ? [height * 0.66, 12.0].min : size
+    end
+
+    def content(font_name, size, color_ops, body)
+      stream = +"/Tx BMC\nq\nBT\n"
+      stream << "#{color_ops}\n" unless color_ops.empty?
+      stream << "/#{font_name} #{fmt(size)} Tf\n"
+      stream << body
+      stream << "ET\nQ\nEMC\n"
+    end
+
+    def appearance_dict(font_name, box)
+      {
         Type: :XObject,
         Subtype: :Form,
         FormType: 1,
-        BBox: [0, 0, width, height],
+        BBox: [0, 0, box.width, box.height],
         Resources: { Font: { font_name.to_sym => @fonts.reference(font_name) } }
       }
-      @doc.add(StreamObject.new(dict, content.b))
-    end
-
-    private
-
-    def fmt(num)
-      Serializer.format_number(num.to_f)
     end
 
     # Where pdftk puts a single line's baseline: the ascent box centered in
@@ -84,31 +101,49 @@ module Acrofill
       align.is_a?(Integer) ? align : 0
     end
 
-    def line_x(text, font, size, width, align)
+    def line_x(text, font, size, box)
       text_width = Metrics.string_width(text, font.widths, size)
-      case align
-      when 1 then [(width - text_width) / 2.0, PADDING].max
-      when 2 then [width - PADDING - text_width, PADDING].max
+      case box.align
+      when 1 then [(box.width - text_width) / 2.0, PADDING].max
+      when 2 then [box.width - PADDING - text_width, PADDING].max
       else PADDING
       end
     end
 
+    # A comb field divides its box into /MaxLen equal cells and centers one
+    # character in each; /Q picks the run of cells the value occupies. Each
+    # glyph is positioned absolutely, the way pdftk writes it.
+    def comb_body(text, font, size, box, cells)
+      cell = box.width / cells.to_f
+      chars = text.chars
+      first = case box.align
+              when 1 then [(cells - chars.size) / 2, 0].max
+              when 2 then [cells - chars.size, 0].max
+              else 0
+              end
+      ty = fmt(baseline(box.height, font, size))
+      chars.each_with_index.map do |char, index|
+        x = ((first + index + 0.5) * cell) - (Metrics.string_width(char, font.widths, size) / 2.0)
+        "1 0 0 1 #{fmt(x)} #{ty} Tm\n(#{escape_literal(char)}) Tj\n"
+      end.join
+    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, font, size, width, height, align)
-      max_width = width - (2 * PADDING)
+    def multiline_body(value, font, size, box)
+      max_width = box.width - (2 * PADDING)
       lines = value.to_s.split(/\r\n|[\r\n]/).flat_map do |paragraph|
-        wrap_line(printable_text(paragraph), font, size, max_width)
+        wrap_line(font.encode(printable_text(paragraph)), font, size, max_width)
       end
 
       # pdftk spaces rows by the font's FontBBox extent and drops the first
       # baseline by that extent from the top of the box.
       leading = font.line_height(size)
-      first_y = height - font.top(size) + TOP_OFFSET
+      first_y = box.height - font.top(size) + TOP_OFFSET
       body = "#{fmt(leading)} TL\n"
       previous_x = 0.0
       lines.each_with_index do |line, index|
-        x = line_x(line, font, size, width, align)
+        x = line_x(line, font, size, box)
         body << "#{fmt(x - previous_x)} #{index.zero? ? fmt(first_y) : '0'} Td\n"
         body << "(#{escape_literal(line)}) Tj\nT*\n"
         previous_x = x

data/lib/acrofill/flattener.rb

@@ -6,6 +6,8 @@ module Acrofill
   # comes from the template, so each one is validated before use.
   class Flattener
     HIDDEN_FLAG = 2
+    NOVIEW_FLAG = 32
+    INVISIBLE = HIDDEN_FLAG | NOVIEW_FLAG
 
     def initialize(doc)
       @doc = doc
@@ -61,7 +63,12 @@ module Acrofill
     # 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)
+      # Flattening produces the document as it is displayed, so a widget the
+      # viewer would not show is dropped rather than burned in: /F Hidden,
+      # and NoView, which means "not on screen" (PDF 32000 §12.5.3). pdftk
+      # stamps both, but stamping Hidden makes values the template author
+      # concealed permanently visible, so parity loses here.
+      return nil if annotation_flags(widget).anybits?(INVISIBLE)
 
       ap_ref = normal_appearance(widget)
       xobject = @doc.deref(ap_ref)

data/lib/acrofill/fonts.rb

@@ -15,6 +15,7 @@ module Acrofill
   #   widths     /Widths + /FirstChar, else the standard-14 table
   #   ascender   /FontDescriptor /Ascent, else standard-14 AFM, else 800
   #   FontBBox   /FontDescriptor /FontBBox, else standard-14 AFM, else 900/-200
+  #   codes      /Encoding /Differences remap the value's bytes
   #
   # The standard-14 fallbacks apply only to a BaseFont that literally names
   # one of the fourteen; a face merely *resembling* one (ArialMT and friends)
@@ -29,6 +30,7 @@ module Acrofill
     # not consult /MissingWidth (verified — setting it changes nothing).
     OUT_OF_RANGE_WIDTH = 0
     SUBSET_PREFIX = /\A[A-Z]{6}\+/
+    IDENTITY = Array.new(256) { |code| code }.freeze
 
     def initialize(doc, acroform)
       @doc = doc
@@ -82,8 +84,56 @@ module Acrofill
       name = base_font_name(dict)
       standard = Metrics.standard_font(name)
       ascender, descender, top, bottom = vertical(dict, standard)
-      Metrics::Font.new(widths(dict) || Metrics.widths_for(name), ascender, descender, top, bottom)
-                   .freeze
+      Metrics::Font.new(widths(dict) || Metrics.widths_for(name),
+                        ascender, descender, top, bottom, remap(dict)).freeze
+    end
+
+    # A 256-entry code translation table when /Encoding /Differences moves
+    # glyphs to codes other than their WinAnsi ones, else nil. Without it a
+    # value is drawn with whatever glyphs happen to sit at its bytes: a font
+    # that puts "A" at code 90 would render "AZ" as "ZA".
+    def remap(dict)
+      differences = differences(dict)
+      return nil if differences.empty?
+
+      by_code = {}
+      Metrics::WIN_ANSI_GLYPHS.each_with_index do |glyph, index|
+        by_code[index + Metrics::FIRST_CODE] = glyph if glyph
+      end
+      differences.each { |code, glyph| by_code[code] = glyph }
+
+      at = {}
+      by_code.each { |code, glyph| at[glyph] ||= code }
+      table = Array.new(256) { |code| code }
+      Metrics::WIN_ANSI_GLYPHS.each_with_index do |glyph, index|
+        code = glyph && at[glyph]
+        table[index + Metrics::FIRST_CODE] = code if code
+      end
+      table == IDENTITY ? nil : table.freeze
+    end
+
+    # /Differences is a flat array where an integer restarts the code
+    # counter and each following name takes the next code (PDF 32000
+    # §9.6.6.1).
+    def differences(dict)
+      encoding = @doc.deref(dict[:Encoding])
+      return {} unless encoding.is_a?(Hash)
+
+      entries = @doc.deref(encoding[:Differences])
+      return {} unless entries.is_a?(Array)
+
+      code = nil
+      entries.each_with_object({}) do |raw, result|
+        item = @doc.deref(raw)
+        case item
+        when Integer then code = item
+        when Symbol
+          next unless code&.between?(0, 255)
+
+          result[code] = item # a glyph name, matching Metrics::WIN_ANSI_GLYPHS
+          code += 1
+        end
+      end
     end
 
     def base_font_name(dict)

data/lib/acrofill/form.rb

@@ -6,6 +6,7 @@ module Acrofill
   class Form
     MULTILINE_FLAG = 1 << 12
     PUSHBUTTON_FLAG = 1 << 16
+    COMB_FLAG = 1 << 24
 
     Field = Struct.new(:name, :type, :value, :states, keyword_init: true)
 
@@ -81,15 +82,23 @@ module Acrofill
       true
     end
 
+    def build_appearance(node, widget, value, multiline, comb)
+      return nil if value.empty?
+
+      @appearance.build(node, widget, value, multiline: multiline, comb: comb)
+    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)
+      flags = field_flags(node)
+      multiline = flags.anybits?(MULTILINE_FLAG)
+      comb = comb_cells(node, flags, multiline)
       group[:widgets].each do |widget|
         widget.delete(:AS)
-        ap_ref = @appearance.build(node, widget, value, multiline: multiline) unless value.empty?
+        ap_ref = build_appearance(node, widget, value, multiline, comb)
         # An unusable geometry yields no appearance; dropping /AP is still
         # required, or the widget would keep rendering the *previous* value
         # while /V already holds the new one.
@@ -102,6 +111,16 @@ module Acrofill
       true
     end
 
+    # How many cells a comb field lays its value out in, or nil when the
+    # field is not a comb. The flag only means anything alongside /MaxLen
+    # and on a single-line field (PDF 32000 §12.7.4.3).
+    def comb_cells(node, flags, multiline)
+      return nil if multiline || !flags.anybits?(COMB_FLAG)
+
+      cells = @doc.deref(@doc.inherited_value(node, :MaxLen))
+      cells.is_a?(Integer) && cells.positive? ? cells : nil
+    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

data/lib/acrofill/metrics.rb

@@ -16,6 +16,8 @@ module Acrofill
     FIRST_CODE = 32
     LAST_CODE = 255
     WINDOWS_1252 = Encoding::Windows_1252
+    # Encodings whose bytes are already the codes the font is drawn with.
+    BYTE_ENCODINGS = [Encoding::Windows_1252, Encoding::BINARY].freeze
 
     # The standard-14 text cuts, indexed by bold + 2 * italic per family.
     CUTS = {
@@ -158,8 +160,48 @@ module Acrofill
       'Courier-BoldOblique' => [629, -157, 801, -250].freeze
     }.freeze
 
-    # Everything the appearance code needs about one resolved face.
-    Font = Struct.new(:widths, :ascender, :descender, :bbox_top, :bbox_bottom) do
+    # WinAnsiEncoding glyph names, index = code - 32. Used to re-encode a
+    # value for a font whose /Encoding remaps codes: the value is turned
+    # into glyph names, then into the codes *this* font draws them at.
+    WIN_ANSI_GLYPHS = [
+      :space, :exclam, :quotedbl, :numbersign, :dollar, :percent, :ampersand, :quotesingle,
+      :parenleft, :parenright, :asterisk, :plus, :comma, :hyphen, :period, :slash, :zero,
+      :one, :two, :three, :four, :five, :six, :seven, :eight, :nine, :colon, :semicolon,
+      :less, :equal, :greater, :question, :at, :A, :B, :C, :D, :E, :F, :G, :H, :I, :J, :K,
+      :L, :M, :N, :O, :P, :Q, :R, :S, :T, :U, :V, :W, :X, :Y, :Z, :bracketleft, :backslash,
+      :bracketright, :asciicircum, :underscore, :grave, :a, :b, :c, :d, :e, :f, :g, :h, :i,
+      :j, :k, :l, :m, :n, :o, :p, :q, :r, :s, :t, :u, :v, :w, :x, :y, :z, :braceleft, :bar,
+      :braceright, :asciitilde, :controlDEL, :Euro, nil, :quotesinglbase, :florin,
+      :quotedblbase, :ellipsis, :dagger, :daggerdbl, :circumflex, :perthousand, :Scaron,
+      :guilsinglleft, :OE, nil, :Zcaron, nil, nil, :quoteleft, :quoteright, :quotedblleft,
+      :quotedblright, :bullet, :endash, :emdash, :tilde, :trademark, :scaron,
+      :guilsinglright, :oe, nil, :zcaron, :Ydieresis, :space, :exclamdown, :cent, :sterling,
+      :currency, :yen, :brokenbar, :section, :dieresis, :copyright, :ordfeminine,
+      :guillemotleft, :logicalnot, :hyphen, :registered, :macron, :degree, :plusminus,
+      :twosuperior, :threesuperior, :acute, :mu, :paragraph, :periodcentered, :cedilla,
+      :onesuperior, :ordmasculine, :guillemotright, :onequarter, :onehalf, :threequarters,
+      :questiondown, :Agrave, :Aacute, :Acircumflex, :Atilde, :Adieresis, :Aring, :AE,
+      :Ccedilla, :Egrave, :Eacute, :Ecircumflex, :Edieresis, :Igrave, :Iacute, :Icircumflex,
+      :Idieresis, :Eth, :Ntilde, :Ograve, :Oacute, :Ocircumflex, :Otilde, :Odieresis,
+      :multiply, :Oslash, :Ugrave, :Uacute, :Ucircumflex, :Udieresis, :Yacute, :Thorn,
+      :germandbls, :agrave, :aacute, :acircumflex, :atilde, :adieresis, :aring, :ae,
+      :ccedilla, :egrave, :eacute, :ecircumflex, :edieresis, :igrave, :iacute, :icircumflex,
+      :idieresis, :eth, :ntilde, :ograve, :oacute, :ocircumflex, :otilde, :odieresis,
+      :divide, :oslash, :ugrave, :uacute, :ucircumflex, :udieresis, :yacute, :thorn,
+      :ydieresis
+    ].freeze
+
+    # Everything the appearance code needs about one resolved face. +remap+
+    # is a 256-entry code translation table, or nil when the font draws
+    # WinAnsi codes as they are.
+    Font = Struct.new(:widths, :ascender, :descender, :bbox_top, :bbox_bottom, :remap) do
+      # Windows-1252 text as the byte codes this font draws it with.
+      def encode(text)
+        return text unless remap
+
+        text.b.each_byte.map { |code| remap[code] }.pack('C*')
+      end
+
       def ascent(size) = ascender * size / 1000.0
 
       def descent(size) = -descender * size / 1000.0
@@ -225,10 +267,11 @@ module Acrofill
       (BOLD.match?(lower) ? 1 : 0) + (ITALIC.match?(lower) ? 2 : 0)
     end
 
-    # Appearance text is already Windows-1252; anything else is converted so
-    # that measuring and rendering agree byte for byte.
+    # Appearance text is already Windows-1252, or raw font codes after
+    # #encode; anything else is converted so that measuring and rendering
+    # agree byte for byte.
     def self.to_win_ansi(str)
-      return str if str.encoding == WINDOWS_1252
+      return str if BYTE_ENCODINGS.include?(str.encoding)
 
       str.encode(WINDOWS_1252, invalid: :replace, undef: :replace, replace: '?')
     end

data/lib/acrofill/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acrofill
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - stiig