stationery 0.1.0 → 0.3.0

data/lib/stationery/document.rb

@@ -5,7 +5,7 @@ module Stationery
   #
   #   class Invoice < Stationery::Document
   #     page size: :a4, margin: 40
-  #     font_family "Inter", regular: "Inter-Regular.ttf", bold: "Inter-Bold.ttf"
+  #     font_family "Brand", regular: "Brand-Regular.ttf", bold: "Brand-Bold.ttf"
   #     default_text font: "Inter", size: 9
   #     metadata title: "Invoice"
   #     page_template { |page| box(at: [40, page.height - 30]) { text "#{page.number}/#{page.count}" } }
@@ -23,7 +23,8 @@ module Stationery
         @config ||= if superclass.respond_to?(:config)
                       superclass.config.transform_values(&:dup)
                     else
-                      { page: { size: :letter, margin: 36 }, families: {}, text: {}, metadata: {}, templates: [] }
+                      { page: { size: :letter, margin: 36 }, families: {}, fallbacks: [], text: {}, metadata: {},
+                        templates: [], regions: [], strict: false }
                     end
       end
 
@@ -32,7 +33,13 @@ module Stationery
       end
 
       def font_family(name, **paths)
-        config[:families][name.to_s] = Fonts::Family.new(name, **paths)
+        config[:families][name.to_s] = Fonts::Family.build(name, **paths)
+      end
+
+      # Families tried, in order, for characters the text's own family has no
+      # glyph for; bundled Inter is tried last.
+      def font_fallbacks(*names)
+        config[:fallbacks] = names.map(&:to_s)
       end
 
       def default_text(**options)
@@ -43,11 +50,34 @@ module Stationery
         config[:metadata] = config[:metadata].merge(info)
       end
 
+      # Raise WarningsError instead of writing a PDF that produced warnings.
+      def strict(value = true) # rubocop:disable Style/OptionalBooleanParameter
+        config[:strict] = value
+      end
+
+      # Encrypts every render with the standard security handler; see
+      # PDF::Encryption::StandardSecurity for the options.
+      def encrypt(**)
+        config[:encrypt] = PDF::Encryption::StandardSecurity.options(**)
+      end
+
       # Runs after pagination on every page. `layer: :background` paints under
       # the page's content.
       def page_template(layer: :foreground, &block)
         config[:templates] << [layer, block]
       end
+
+      # Reserves space at the top of the pages `on:` matches and draws the
+      # block there. Without `height:` the block is measured once, on the
+      # first page that asks; pass `height:` when its content varies per page.
+      def header(height: nil, gap: 8, on: :all, &block)
+        config[:regions] << Region.new(slot: :header, height:, gap:, on: Regions.validate!(on), block:)
+      end
+
+      # Like header, at the bottom of the page; the block is bottom-aligned.
+      def footer(height: nil, gap: 8, on: :all, &block)
+        config[:regions] << Region.new(slot: :footer, height:, gap:, on: Regions.validate!(on), block:)
+      end
     end
 
     attr_reader :warnings
@@ -55,15 +85,21 @@ module Stationery
     def page_options = self.class.config[:page]
     def metadata = self.class.config[:metadata]
 
-    def to_pdf(target = nil)
-      book = Fonts::FontBook.new(self.class.config[:families])
+    def to_pdf(target = nil, strict: self.class.config[:strict], debug: false, encrypt: self.class.config[:encrypt])
+      encryption = encrypt && PDF::Encryption::StandardSecurity.new(**encrypt)
+      warnings = Warnings.new
+      book = Fonts::FontBook.new(self.class.config[:families], fallbacks: self.class.config[:fallbacks], warnings:)
       call(builder = Builder.new(book:, text: self.class.config[:text]))
       resources = Resources.new
-      paginator = Layout::Paginator.new(resources:, page: page_options)
+      regions = Regions.new(self.class.config[:regions], measure: region_measure(book))
+      paginator = Layout::Paginator.new(resources:, page: page_options, warnings:, debug:, regions:)
       pages = paginator.paginate(builder.root)
-      @warnings = paginator.warnings
-      PageTemplates.new(self, book:, resources:).apply(pages)
-      write(PDF::Assembler.new(pages:, resources:, info:).render, target)
+      PageTemplates.new(self, book:, resources:, debug:, regions:, warnings:).apply(pages)
+      outline = builder.outline.resolve(Structure.resolve(pages, warnings:, resources:, book:))
+      @warnings = warnings
+      raise WarningsError, warnings if strict && warnings.any?
+
+      write(PDF::Assembler.new(pages:, resources:, info:, outline:, encryption:).render, target)
     end
 
     # Used by page templates to build nodes into their own root.
@@ -75,8 +111,23 @@ module Stationery
       @_builder = previous
     end
 
+    # Builds a page template or region block into a fresh root node.
+    def template_root(info, book:, &)
+      builder = Builder.new(book:, text: self.class.config[:text])
+      build_with(builder) { instance_exec(info, &) }
+      builder.root
+    end
+
     private
 
+    def region_measure(book)
+      page = Page.new(**page_options)
+      lambda do |region, number|
+        info = PageInfo.new(number, number, page.width, page.height, page.margin, page.margin_box)
+        template_root(info, book:, &region.block).measure(page.margin_box.width)
+      end
+    end
+
     def info
       metadata.to_h do |key, value|
         [INFO_KEYS.fetch(key.to_sym) { key.to_sym }, value.is_a?(Array) ? value.join(", ") : value]

data/lib/stationery/elements/lists.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Bulleted and numbered lists.
+  module Elements
+    BULLETS = %i[disc circle square].freeze
+
+    # A bulleted list. `style:` is :disc, :circle, :square, :dash or any
+    # String; unstyled nested lists cycle disc → circle → square. Every node
+    # added inside becomes an item, `li` or not.
+    def ul(style: nil, gap: 4, indent: nil, marker_gap: 6, marker_color: nil, &)
+      shape = style || BULLETS[@_builder.list_depth % BULLETS.size]
+      marker_style = @_builder.style({ color: marker_color }.compact)
+      list(marker_style, gap:, indent:, marker_gap:, marker: ->(_) { list_bullet(shape, marker_style) }, &)
+    end
+
+    # A numbered list. `format:` is :decimal, :alpha, :upper_alpha, :roman,
+    # :upper_roman or a Proc given the number.
+    def ol(format: :decimal, start: 1, suffix: ".", gap: 4, indent: nil, marker_gap: 6, marker_color: nil, &)
+      marker_style = @_builder.style({ color: marker_color }.compact)
+      label = ->(index) { list_label(ListMarkers.label(format, start + index, suffix), marker_style) }
+      list(marker_style, gap:, indent:, marker_gap:, marker: label, &)
+    end
+
+    # A list item: a String becomes a paragraph (taking every text option),
+    # a block a flow of its children.
+    def li(content = nil, gap: 0, **text_options, &)
+      return text(content, **text_options) if content
+
+      @_builder.add(container(gap:, &))
+    end
+
+    private
+
+    def list(marker_style, gap:, indent:, marker_gap:, marker:, &)
+      items = Builder::Items.new
+      @_builder.nested_list { @_builder.within(items) { yield_content(&) } }
+      markers = items.nodes.each_index.map(&marker)
+      indent ||= [markers.map(&:natural_width).max || 0, marker_style.size].max + marker_gap
+      entries = items.nodes.zip(markers).map do |node, mark|
+        Layout::ListItem.new(mark, node.is_a?(Layout::Flow) ? node : Layout::Flow.new([node]), indent:, marker_gap:)
+      end
+      @_builder.add(Layout::Flow.new(entries, gap:))
+    end
+
+    def list_bullet(shape, style)
+      return Layout::Bullet.new(shape, style:, context: @_builder.context(style)) if BULLETS.include?(shape)
+      return list_label(shape.to_s, style) unless shape == :dash
+
+      font = @_builder.book.resolve(style).first
+      list_label(font.glyph?("–") ? "–" : "-", style)
+    end
+
+    def list_label(label, style)
+      Layout::Text.new([Text::Run.new(label, style)], context: @_builder.context(style), align: :right)
+    end
+  end
+end

data/lib/stationery/elements/rich.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Stationery
+  # HTML and Markdown rendered with the element DSL; the parsers load on first use.
+  module Elements
+    # HTML such as ActionText's `record.body.to_s`. `images:` resolves an
+    # image src to a path or IO (nil skips it); otherwise it is read from
+    # under `base_path:`. Remote images are never fetched.
+    def html(source, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false)
+      require_relative "../html/document"
+      rich(HTML.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:)
+    end
+
+    # CommonMark (plus GFM tables and strikethrough); options as for html.
+    def markdown(source, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false)
+      require_relative "../markdown/document"
+      rich(Markdown.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:)
+    end
+
+    private
+
+    def rich(blocks, **)
+      require_relative "../rich/renderer"
+      Rich::Renderer.new(self, @_builder, **).render(blocks)
+    end
+  end
+end

data/lib/stationery/elements.rb

@@ -7,7 +7,8 @@ module Stationery
 
     # A paragraph. Plain strings are always literal; pass `markup: true` to
     # read inline tags, or a block to build styled runs in Ruby.
-    def text(content = nil, markup: false, keep_with_next: nil, break_inside: nil, **options, &)
+    def text(content = nil, markup: false, keep_with_next: nil, break_inside: nil, anchor: nil, bookmark: nil,
+             **options, &)
       settings = PARAGRAPH_DEFAULTS.merge(@_builder.text_defaults.slice(:align, :leading)).merge(options)
       style = @_builder.style(options)
       runs = text_runs(content, style, markup, &)
@@ -15,40 +16,83 @@ module Stationery
                                     leading: settings[:leading])
       node.keep_with_next = keep_with_next
       node.break_inside = break_inside
-      @_builder.add(node)
+      @_builder.add(mark(node, anchor, bookmark))
     end
 
     # A container with padding, background, border and radius. `at: [x, y]`
     # places it at a fixed page position outside the flow.
-    def box(at: nil, align: nil, gap: 0, width: nil, keep_with_next: nil, **, &)
+    # `break_inside: :auto` splits it at any page break, `:avoid` never; by
+    # default it splits only when it does not fit on a page of its own.
+    def box(at: nil, align: nil, gap: 0, width: nil, keep_with_next: nil, break_inside: nil, anchor: nil, bookmark: nil,
+            **, &)
       node = Layout::Box.new(container(align:, gap:, &), width:, **)
       node.keep_with_next = keep_with_next
+      node.break_inside = break_inside
+      node = mark(node, anchor, bookmark)
       @_builder.add(at ? Layout::Positioned.new(node, x: at[0], y: at[1], width:) : node)
     end
 
-    def row(gap: 0, align: :top)
+    # Columns side by side; splits across pages like a box (`break_inside:`).
+    def row(gap: 0, align: :top, break_inside: nil)
       columns = Builder::Columns.new
       @_builder.within(columns) { yield if block_given? }
-      @_builder.add(Layout::Row.new(columns.nodes, gap:, align:))
+      node = Layout::Row.new(columns.nodes, gap:, align:)
+      node.break_inside = break_inside
+      @_builder.add(node)
     end
 
     # A row column: `width:` in points, as a fraction (0.5), :auto or nil for
     # an equal share. Takes every box option.
-    def column(width: nil, align: nil, gap: 0, **, &)
-      @_builder.add(Layout::Box.new(container(align:, gap:, &), width:, **))
+    def column(width: nil, align: nil, gap: 0, break_inside: nil, **, &)
+      node = Layout::Box.new(container(align:, gap:, &), width:, **)
+      node.break_inside = break_inside
+      @_builder.add(node)
     end
 
     # Children kept in one vertical group; `keep_together: true` moves the
     # whole group to the next page rather than splitting it.
-    def group(gap: 0, keep_together: false, keep_with_next: nil, &)
-      flow = container(gap:, &)
+    def group(gap: 0, align: nil, keep_together: false, keep_with_next: nil, anchor: nil, bookmark: nil, &)
+      flow = container(align:, gap:, &)
       flow.break_inside = :avoid if keep_together
       flow.keep_with_next = keep_with_next
-      @_builder.add(flow)
+      @_builder.add(mark(flow, anchor, bookmark))
     end
 
-    def table(rows, widths: nil, width: :auto, header: false, cell: {}, &)
-      @_builder.add(Layout::Table.new(rows, context: @_builder.context, widths:, width:, header:, cell:, &))
+    # Children side by side at their own widths, wrapping onto new rows.
+    def wrap(gap: 0, row_gap: nil, align: :left, &)
+      flow = container(&)
+      @_builder.add(Layout::Wrap.new(flow.children, gap:, row_gap: row_gap || gap, align:))
+    end
+
+    # An SVG drawing: markup String, or a path to a .svg file. `currentColor`
+    # takes `color:`.
+    def svg(source, width: nil, height: nil, color: "#000000", align: nil)
+      name = source.to_s.lstrip.start_with?("<") ? "inline" : File.basename(source.to_s)
+      source = File.read(source.to_s) unless name == "inline"
+      document = SVG::Document.parse(source)
+      if document.unsupported.any?
+        @_builder.warnings << Warnings::UnsupportedSvg.new(elements: document.unsupported, source: name)
+      end
+      node = Layout::Svg.new(document, width:, height:, color:, context: @_builder.context)
+      @_builder.add(align ? Layout::Flow.new([node], align:) : node)
+    end
+
+    # Cells are strings, layout nodes, procs built with the DSL (`-> { image … }`)
+    # or components.
+    def table(rows, widths: nil, width: :auto, header: false, split_rows: false, cell: {}, anchor: nil, bookmark: nil,
+              &)
+      rows = rows.map { |row| row.map { |content| cell_content(content) } }
+      node = Layout::Table.new(rows, context: @_builder.context, widths:, width:, header:, split_rows:, cell:, &)
+      @_builder.add(mark(node, anchor, bookmark))
+    end
+
+    # The document's bookmarks with their page numbers, one linked row each.
+    # `levels:` is a Range (or an Integer maximum depth); `leader:` is :dots,
+    # :line or nil; text options style the rows.
+    def table_of_contents(levels: 1.., leader: :dots, indent: 12, number_width: nil, gap: 4, **options)
+      node = Layout::TableOfContents.new(@_builder.outline, context: @_builder.context(@_builder.style(options)),
+                                                            levels:, leader:, indent:, number_width:, gap:)
+      @_builder.add(node)
     end
 
     def image(source, align: nil, **)
@@ -60,6 +104,16 @@ module Stationery
     def spacer(height) = @_builder.add(Layout::Spacer.new(height))
     def page_break = @_builder.add(Layout::PageBreak.new)
 
+    # A named link target (`link: "#name"`) at this point; it moves to the
+    # next page with whatever follows it.
+    def anchor(name) = @_builder.add(Layout::Mark.standalone(name))
+
+    # An outline entry (PDF bookmark) at this point; like a standalone anchor
+    # it moves to the next page with whatever follows it.
+    def bookmark(title, level: 1, open: false)
+      @_builder.add(Layout::Mark.standalone(@_builder.outline.add(title, level:, open:).anchor))
+    end
+
     # Draw directly: the block receives the canvas and the reserved rectangle.
     def canvas(height:, at: nil, width: nil, &)
       node = Layout::CanvasNode.new(height:, &)
@@ -73,6 +127,20 @@ module Stationery
 
     private
 
+    # `bookmark:` is a title, or { title:, level:, open: }.
+    def mark(node, anchor, bookmark)
+      names = [anchor&.to_s]
+      names << outline_entry(bookmark).anchor if bookmark
+      names.compact!
+      names.empty? ? node : Layout::Mark.new(node, names)
+    end
+
+    def outline_entry(bookmark)
+      return @_builder.outline.add(bookmark) unless bookmark.is_a?(Hash)
+
+      @_builder.outline.add(bookmark.fetch(:title), **bookmark.slice(:level, :open))
+    end
+
     def container(align: nil, gap: 0, &)
       flow = Layout::Flow.new([], gap:, align: align || :left)
       @_builder.within(flow) do
@@ -80,6 +148,14 @@ module Stationery
       end
     end
 
+    def cell_content(content)
+      case content
+      when Proc then container(&content)
+      when Component then container { render content }
+      else content
+      end
+    end
+
     def text_runs(content, style, markup, &)
       return Text::RunsBuilder.build(style, &) if block_given?
       return Text::Markup.parse(content, style) if markup

data/lib/stationery/errors.rb

@@ -3,9 +3,21 @@
 module Stationery
   class Error < StandardError; end
 
-  # A font file stationery cannot read or embed (CFF, collections, WOFF, …).
+  # A font file stationery cannot read or embed (CFF2, collections, WOFF, …).
   class UnsupportedFont < Error; end
 
   # An image format stationery cannot embed (WebP, GIF, interlaced PNG, …).
   class UnsupportedImage < Error; end
+
+  # Raised by a strict render (`to_pdf(strict: true)`) that produced warnings.
+  class WarningsError < Error
+    attr_reader :warnings
+
+    def initialize(warnings)
+      @warnings = warnings
+      lines = warnings.map { |warning| "  #{warning.message}" }
+      noun = lines.size == 1 ? "warning" : "warnings"
+      super("#{lines.size} #{noun}:\n#{lines.join("\n")}")
+    end
+  end
 end

data/lib/stationery/fonts/bundled.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Families shipped inside the gem. Only file names live here; a face is
+    # read the first time a document draws with it, so requiring the gem
+    # never touches the files.
+    module Bundled
+      DIR = File.expand_path("data", __dir__)
+      DEFAULT = "Inter"
+      FAMILIES = {
+        "Inter" => { regular: "Inter-Regular.ttf", bold: "Inter-Bold.ttf",
+                     italic: "Inter-Italic.ttf", bold_italic: "Inter-BoldItalic.ttf" }
+      }.freeze
+
+      def self.names = FAMILIES.keys
+
+      # A Family for a bundled name, or nil.
+      def self.family(name)
+        files = FAMILIES[name.to_s]
+        files && Family.new(name, **files.transform_values { |file| File.join(DIR, file) })
+      end
+    end
+  end
+end

data/lib/stationery/fonts/catalog.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Font packs `stationery fonts install` can put in vendor/fonts. Each file
+    # is [url, sha256, filename]; a URL with a `#member` fragment names a file
+    # inside a .tar.gz, and a nil URL copies the file bundled with the gem.
+    # `rake fonts:verify` downloads everything and checks the SHAs.
+    module Catalog
+      Pack = Data.define(:key, :family, :license, :files, :license_file)
+
+      NOTO = "https://raw.githubusercontent.com/notofonts/notofonts.github.io/" \
+             "f145d86c53996717bc4c25d4602eb9294e43dccc/fonts"
+      NOTO_OFL = ["https://raw.githubusercontent.com/notofonts/latin-greek-cyrillic/NotoSans-v2.015/OFL.txt",
+                  "cee9892f9f0cc8fe882c9e9537ee6a89621d86ee7ceaf70b02e2b2b1c25c061a", "OFL.txt"].freeze
+      LIBERATION = "https://github.com/liberationfonts/liberation-fonts/files/7261482/" \
+                   "liberation-fonts-ttf-2.1.5.tar.gz#liberation-fonts-ttf-2.1.5"
+      LIBERATION_OFL = ["#{LIBERATION}/LICENSE",
+                        "93fed46019c38bbe566b479d22148e2e8a1e85ada614accb0211c37b2c61c19b", "OFL.txt"].freeze
+      LIBERATION_LICENSE = 'OFL-1.1, Reserved Font Name "Liberation"'
+
+      # { style => [url, sha, "Family-Style.ttf"] } with the URL built from the file name.
+      def self.faces(family, shas)
+        shas.to_h do |style, sha|
+          file = "#{family}-#{style.to_s.split("_").map(&:capitalize).join}.ttf"
+          [style, [yield(file), sha, file].freeze]
+        end.freeze
+      end
+
+      def self.noto(family, shas) = faces(family, shas) { "#{NOTO}/#{family}/unhinted/ttf/#{it}" }
+      def self.liberation(family, shas) = faces(family, shas) { "#{LIBERATION}/#{it}" }
+      private_class_method :faces, :noto, :liberation
+
+      PACKS = [
+        Pack.new(
+          key: :inter, family: "Inter", license: "OFL-1.1",
+          files: {
+            regular: [nil, "40d692fce188e4471e2b3cba937be967878f631ad3ebbbdcd587687c7ebe0c82", "Inter-Regular.ttf"],
+            bold: [nil, "288316099b1e0a47a4716d159098005eef7c0066921f34e3200393dbdb01947f", "Inter-Bold.ttf"],
+            italic: [nil, "bbc051dd204b5019a1aa0bc0ae2aa8a05ab13e7a3f979fa357631dc7feb6833a", "Inter-Italic.ttf"],
+            bold_italic: [nil, "948405a16cdc62701da5f4005ed068ca5f4d27061d98f7974ccfc37831d9581d",
+                          "Inter-BoldItalic.ttf"]
+          },
+          license_file: [nil, "262481e844521b326f5ecd053e59b98c8b2da78c8ee1bdbb6e8174305e54935a", "OFL.txt"]
+        ),
+        Pack.new(
+          key: :noto_sans, family: "Noto Sans", license: "OFL-1.1", license_file: NOTO_OFL,
+          files: noto("NotoSans",
+                      regular: "f3961a9cde016d41a4879aecda1474d3a36d6bf54fa0e4643de029cc2248b0e8",
+                      bold: "87cb2d84472a7d66da659ee47b6cdb9552326e8c128245231f191b6ac72529d9",
+                      italic: "678288f868807d4d64a6f3b51466871d117d915780381ce9d0ed4b3bcbd06d37",
+                      bold_italic: "3d367743f371f28671d2764e911a53d7c20ec9b6aa8791d059e7090389fc52a5")
+        ),
+        Pack.new(
+          key: :noto_serif, family: "Noto Serif", license: "OFL-1.1", license_file: NOTO_OFL,
+          files: noto("NotoSerif",
+                      regular: "a15cfbbc1539d707115111d672d590a3d70d4f74b4c0a315956da20ae19a14e1",
+                      bold: "24ad531e6b05ddad8c3d89572d2c93eb86a6b74e652ce7ee3c3e171de68e84c3",
+                      italic: "c4b3c971741ecdb40f5a443bce754e8fe91efe761b6ea10c92be7c3597cdadc4",
+                      bold_italic: "1bc4f86502eaa368718f6192bee022ea9a703d5af1c18b7d291212657b63074a")
+        ),
+        Pack.new(
+          key: :noto_sans_mono, family: "Noto Sans Mono", license: "OFL-1.1", license_file: NOTO_OFL,
+          files: noto("NotoSansMono",
+                      regular: "87f8ce0522a6c99b743ee5fc75b4073cfdd575639119672828b7b9944b65b4f4",
+                      bold: "1100772b2f79c102402a1011df5e2226517d0f40ac553a25fb12fdbad8c11b85")
+        ),
+        Pack.new(
+          key: :liberation_sans, family: "Liberation Sans", license: LIBERATION_LICENSE, license_file: LIBERATION_OFL,
+          files: liberation("LiberationSans",
+                            regular: "76d04c18ea243f426b7de1f3ad208e927008f961dc5945e5aad352d0dfde8ee8",
+                            bold: "788abee4c806d660e8aee46689dd8540cd4bb98da03dcc9d171ce3efd99a9173",
+                            italic: "e5bae5c4cde31f22142753855f4f8fb86da6ff39955ed3c0a11248b0d16948b0",
+                            bold_italic: "698da70fc191cc5f33ad4d6d3fe830fe4624b898ea2e3169955928b7c491f1ee")
+        ),
+        Pack.new(
+          key: :liberation_serif, family: "Liberation Serif", license: LIBERATION_LICENSE,
+          license_file: LIBERATION_OFL,
+          files: liberation("LiberationSerif",
+                            regular: "058ea80864aef09a23f45cbec2bb5400bc3dfbdea01c3f10538a21fcb497fb74",
+                            bold: "d754ba427cfe0bca54ae052384baa8f842da5bd6550ad4da024ac441e7a7d5ce",
+                            italic: "0e3dea9f8d613e006ccfa62201f33e265d19167bd0907725c3e145368b04fc2e",
+                            bold_italic: "f17db8af71e24d2066b587546021d4f0b296be389512b658dec3c09affeb11a7")
+        ),
+        Pack.new(
+          key: :liberation_mono, family: "Liberation Mono", license: LIBERATION_LICENSE, license_file: LIBERATION_OFL,
+          files: liberation("LiberationMono",
+                            regular: "f2b83c763e8afd21709333370bed4774337fae82267937e2b5aea7e2fbd922c1",
+                            bold: "bd62a0672d0b9b6710b01df434c80ad54fa5f0835207eb7b17b7a761463067bb",
+                            italic: "605c01c711b44480a7508d349dfbf3264e81fa43d69e61cfa7d10b86e764c4d1",
+                            bold_italic: "79451f3c09fe25116098853b7a2ca6e2436220ccc11af022979adbcf195be130")
+        )
+      ].freeze
+
+      def self.fetch(key)
+        PACKS.find { |pack| pack.key.to_s == key.to_s } ||
+          raise(Error, "unknown font pack #{key.to_s.inspect} (available: #{PACKS.map(&:key).join(", ")})")
+      end
+    end
+  end
+end

data/lib/stationery/fonts/cff.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Reads the Compact Font Format table of an OpenType font (.otf): the
+    # INDEX structures, the Top DICT and, for a CID-keyed font, the charset
+    # that maps glyph ids to CIDs. Charstrings are not interpreted.
+    class CFF
+      STANDARD_STRINGS = 391
+      CHARSET = 15
+      ENCODING = 16
+      CHARSTRINGS = 17
+      PRIVATE = 18
+      ROS = 1230
+      FD_ARRAY = 1236
+      FD_SELECT = 1237
+      SUBRS = 19
+      REAL_NIBBLES = [*"0".."9", ".", "E", "E-", nil, "-"].freeze
+
+      # An INDEX from `start` to `stop` (exclusive); items are [offset, length].
+      Index = Data.define(:start, :items, :stop)
+
+      attr_reader :data, :top, :num_glyphs, :name_index, :top_index, :string_index, :global_subrs, :charstrings
+
+      def initialize(data)
+        @data = data.b
+        @name_index = index_at(@data.getbyte(2))
+        @top_index = index_at(@name_index.stop)
+        @string_index = index_at(@top_index.stop)
+        @global_subrs = index_at(@string_index.stop)
+        @top = self.class.parse_dict(item(@top_index, 0))
+        @charstrings = index_at(@top.fetch(CHARSTRINGS).first)
+        @num_glyphs = @charstrings.items.size
+        @charset = self.class.parse_charset(@data, @top.fetch(CHARSET).first, @num_glyphs) if cid_keyed?
+      end
+
+      def inspect = "#<#{self.class} glyphs=#{@num_glyphs}#{" cid" if cid_keyed?}>"
+
+      def cid_keyed? = @top.key?(ROS)
+
+      # [registry, ordering, supplement] of a CID-keyed font.
+      def ros
+        return unless cid_keyed?
+
+        registry, ordering, supplement = @top[ROS]
+        [string(registry), string(ordering), supplement]
+      end
+
+      # A name-keyed font has no CIDs; PDF addresses its glyphs by glyph id.
+      def cid_for(gid)
+        cid_keyed? ? @charset.fetch(gid, 0) : gid
+      end
+
+      def item(index, number) = @data.byteslice(*index.items.fetch(number))
+
+      def string(sid) = item(@string_index, sid - STANDARD_STRINGS)
+
+      class << self
+        # { operator => operands }; two-byte operators are 1200 + the second byte.
+        def parse_dict(bytes) = dict_entries(bytes).to_h { |op, operands, _| [op, operands] }
+
+        # [operator, operands, raw bytes of operands and operator] in order.
+        def dict_entries(bytes)
+          entries = []
+          operands = []
+          start = pos = 0
+          while pos < bytes.bytesize
+            b0 = bytes.getbyte(pos)
+            if b0 <= 21
+              op = b0 == 12 ? 1200 + bytes.getbyte(pos + 1) : b0
+              pos += b0 == 12 ? 2 : 1
+              entries << [op, operands, bytes.byteslice(start, pos - start)]
+              operands = []
+              start = pos
+            else
+              value, pos = operand(bytes, pos)
+              operands << value
+            end
+          end
+          entries
+        end
+
+        # The SID (name-keyed) or CID (CID-keyed) of every glyph, by glyph id.
+        def parse_charset(data, offset, num_glyphs)
+          format = data.getbyte(offset)
+          return [0, *data.byteslice(offset + 1, (num_glyphs - 1) * 2).unpack("n*")] if format.zero?
+
+          ids = [0]
+          pos = offset + 1
+          while ids.size < num_glyphs
+            first, left = data.byteslice(pos, format == 1 ? 3 : 4).unpack(format == 1 ? "nC" : "nn")
+            ids.concat((first..(first + left)).to_a)
+            pos += format == 1 ? 3 : 4
+          end
+          ids.first(num_glyphs)
+        end
+
+        private
+
+        def operand(bytes, pos)
+          b0 = bytes.getbyte(pos)
+          case b0
+          when 28 then [bytes.byteslice(pos + 1, 2).unpack1("s>"), pos + 3]
+          when 29 then [bytes.byteslice(pos + 1, 4).unpack1("l>"), pos + 5]
+          when 30 then real(bytes, pos + 1)
+          when 32..246 then [b0 - 139, pos + 1]
+          when 247..250 then [((b0 - 247) * 256) + bytes.getbyte(pos + 1) + 108, pos + 2]
+          when 251..254 then [((251 - b0) * 256) - bytes.getbyte(pos + 1) - 108, pos + 2]
+          else raise UnsupportedFont, "malformed CFF DICT operand #{b0}"
+          end
+        end
+
+        def real(bytes, pos)
+          text = +""
+          loop do
+            byte = bytes.getbyte(pos)
+            pos += 1
+            [byte >> 4, byte & 0x0F].each do |nibble|
+              return [Float(text), pos] if nibble == 0x0F
+
+              text << REAL_NIBBLES.fetch(nibble)
+            end
+          end
+        end
+      end
+
+      def index_at(offset)
+        count = @data.byteslice(offset, 2).unpack1("n")
+        return Index.new(offset, [], offset + 2) if count.zero?
+
+        size = @data.getbyte(offset + 2)
+        offsets = Array.new(count + 1) do |i|
+          @data.byteslice(offset + 3 + (i * size), size).bytes.inject(0) { |value, byte| (value << 8) | byte }
+        end
+        base = offset + 2 + ((count + 1) * size)
+        Index.new(offset, offsets.each_cons(2).map { |a, b| [base + a, b - a] }, base + offsets.last)
+      end
+    end
+  end
+end