stationery 0.6.0 → 0.8.0

data/lib/stationery/elements.rb

@@ -123,7 +123,7 @@ module Stationery
     # `alt:` describes the image in a tagged PDF (false: decorative). Sizing,
     # `fit: :cover`, `radius:` and `rotate:` as for Layout::Image.
     def image(source, align: nil, **)
-      node = Layout::Image.new(source, **)
+      node = Layout::Image.new(source, **@_builder.images, **)
       @_builder.add(align ? Layout::Flow.new([node], align:) : node)
     end
 

data/lib/stationery/errors.rb

@@ -20,4 +20,17 @@ module Stationery
       super("#{lines.size} #{noun}:\n#{lines.join("\n")}")
     end
   end
+
+  # Raised when a render cannot keep the conformance it claims (PDF/A,
+  # PDF/UA): `levels` are the claimed levels, `issues` what breaks them.
+  class ConformanceError < Error
+    attr_reader :levels, :issues
+
+    def initialize(levels, issues)
+      @levels = levels
+      @issues = issues
+      super("not #{levels.map { |level| Stationery::PDF::Conformance.label(level) }.join(" + ")}:\n" \
+            "#{issues.map { |issue| "  #{issue}" }.join("\n")}")
+    end
+  end
 end

data/lib/stationery/fonts/fallback.rb

@@ -6,13 +6,13 @@ module Stationery
     # run's family, then the book's fallbacks in order, then bundled Inter. A
     # glyph no font has stays in the run's family and draws as .notdef.
     #
-    # Whitespace (any Unicode White_Space), joiners, variation selectors and
-    # combining marks carry the family of the character before them (or
+    # Whitespace (any Unicode White_Space), soft hyphens, joiners, variation
+    # selectors and combining marks carry the family of the character before them (or
     # after them at the start of a run) so words are not chopped and marks
     # stay with their base; whitespace a font lacks draws as a blank of the
     # right width (see Font::WHITESPACE).
     class Fallback
-      CARRIED = /[\p{Space}‌‍︀-️\p{M}]/
+      CARRIED = /[\p{Space}­‌‍︀-️\p{M}]/
 
       def self.carried?(char) = CARRIED.match?(char)
 

data/lib/stationery/fonts/font.rb

@@ -23,6 +23,7 @@ module Stationery
                           0x2005 => 0.25, 0x2006 => 1.0 / 6, 0x2009 => 0.2, 0x200A => 0.125, 0x205F => 4.0 / 18,
                           0x3000 => 1.0 }.freeze
       SPACE_LIKE = { 0x2007 => "0", 0x2008 => "." }.freeze
+      NO_FEATURES = [].freeze
 
       attr_reader :ttf
 
@@ -32,9 +33,9 @@ module Stationery
         @pairs = {}
         @glyphs = {}
         @blanks = {}
-        @shapes = { true => {}, false => {} }
-        @advances = { true => {}, false => {} }
-        @kerns = { true => {}, false => {} }
+        @shapes = {}
+        @advances = {}
+        @kerns = {}
         @cid_keyed = ttf.cff? && ttf.cff.cid_keyed?
       end
 
@@ -44,14 +45,19 @@ module Stationery
       # word again (wrapping, then laying out the line) allocates nothing.
       # Letter spacing is added per glyph, so a ligature counts once; any
       # letter spacing turns ligatures off, as it does when drawing.
-      def width_of(text, size, letter_spacing: 0, kerning: false, ligatures: true)
+      # `features:` are OpenType feature tags applied on top of `liga`.
+      def width_of(text, size, letter_spacing: 0, kerning: false, ligatures: true, features: NO_FEATURES)
         ligatures &&= letter_spacing.zero?
-        width = scale(advance_units(text, ligatures), size) + (letter_spacing * shape(text, ligatures).first.size)
+        key = shape_key(ligatures, features)
+        width = scale(advance_units(text, key), size) + (letter_spacing * shape(text, key).first.size)
         return width unless kerning
 
-        width + (kerning_units(text, ligatures) * size / 1000.0)
+        width + (kerning_units(text, key) * size / 1000.0)
       end
 
+      # The GSUB feature tags this font can apply.
+      def features = @ttf.ligatures.features
+
       def ascender(size) = scale(@ttf.ascender, size)
       def descender(size) = -scale(@ttf.descender, size)
       def line_gap(size) = scale(@ttf.line_gap, size)
@@ -69,10 +75,11 @@ module Stationery
 
       def encode(text) = glyph_run(text).gids.map { |gid| code(gid) }.pack("n*")
 
-      # `ligatures:` substitutes the font's standard ligatures; `kerning:`
-      # then fills the adjustments with pair kerning between the glyphs.
-      def glyph_run(text, kerning: false, ligatures: true)
-        gids, chars, blanks = shape(text, ligatures)
+      # `ligatures:` substitutes the font's standard ligatures and `features:`
+      # any further OpenType features; `kerning:` then fills the adjustments
+      # with pair kerning between the glyphs.
+      def glyph_run(text, kerning: false, ligatures: true, features: NO_FEATURES)
+        gids, chars, blanks = shape(text, shape_key(ligatures, features))
         gids.each_with_index { |gid, i| @used[gid] ||= blanks[i] ? " " : chars[i] }
         adjust = gids.each_with_index.map do |gid, i|
           kern = kerning && i + 1 < gids.size ? pair(gid, gids[i + 1]) : 0
@@ -118,19 +125,30 @@ module Stationery
 
       private
 
+      # The feature tags to substitute with: `liga` when ligatures are on, plus
+      # the requested features. Frozen and shared, so it keys the memos cheaply.
+      def shape_key(ligatures, features)
+        features = Text::Style.features(features) unless features.frozen? && features.all?(String)
+        return features unless ligatures
+        return Gsub::LIGA if features.empty?
+
+        @keys ||= {}
+        @keys[features] ||= (features + Gsub::LIGA).sort.freeze
+      end
+
       # [gids, source text of each glyph, extra advance in font units after
-      # each blank or nil], remembered per string.
-      def shape(text, ligatures)
-        @shapes[ligatures][text] ||= begin
+      # each blank or nil], remembered per string and feature tags.
+      def shape(text, tags)
+        (@shapes[tags] ||= {})[text] ||= begin
           gids = text.each_char.map { |char| glyph_for(char) }
-          gids, chars = ligatures ? ligate(gids, text) : [gids, text.chars]
+          gids, chars = tags.empty? ? [gids, text.chars] : substitute(gids, text, tags)
           [gids, chars, chars.map { |char| blank_units(char) }].each(&:freeze).freeze
         end
       end
 
-      def ligate(gids, text)
+      def substitute(gids, text, tags)
         start = 0
-        glyphs = @ttf.ligatures.substitute(gids)
+        glyphs = @ttf.ligatures.substitute(gids, tags)
         chars = glyphs.map { |_gid, count| text[start, count].tap { start += count } }
         [glyphs.map(&:first), chars]
       end
@@ -152,15 +170,15 @@ module Stationery
         width - space
       end
 
-      def advance_units(text, ligatures)
-        @advances[ligatures][text] ||= begin
-          gids, _, blanks = shape(text, ligatures)
+      def advance_units(text, tags)
+        (@advances[tags] ||= {})[text] ||= begin
+          gids, _, blanks = shape(text, tags)
           gids.sum { |gid| @ttf.advance(gid) } + blanks.sum { |units| units || 0 }
         end
       end
 
-      def kerning_units(text, ligatures)
-        @kerns[ligatures][text] ||= shape(text, ligatures).first.each_cons(2).sum { |left, right| pair(left, right) }
+      def kerning_units(text, tags)
+        (@kerns[tags] ||= {})[text] ||= shape(text, tags).first.each_cons(2).sum { |left, right| pair(left, right) }
       end
 
       # Kerning between two glyphs in thousandths of an em.

data/lib/stationery/fonts/gsub/single_subst.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gsub
+      # SingleSubst (GSUB lookup type 1): one glyph for another. Format 1
+      # adds a delta to every covered glyph, format 2 lists the substitute
+      # for each covered glyph in coverage order. Small caps, oldstyle and
+      # tabular figures, stylistic sets and slashed zero are all this.
+      class SingleSubst
+        def self.read(ttf, offset)
+          format = ttf.u16(offset)
+          coverage = Gpos::Coverage.read(ttf, offset + ttf.u16(offset + 2))
+          case format
+          when 1
+            delta = ttf.i16(offset + 4)
+            new(coverage.to_h { |gid| [gid, (gid + delta) & 0xFFFF] })
+          when 2
+            substitutes = ttf.data.byteslice(offset + 6, ttf.u16(offset + 4) * 2).unpack("n*")
+            new(coverage.zip(substitutes).to_h.compact)
+          end
+        end
+
+        def initialize(map)
+          @map = map.freeze
+          freeze
+        end
+
+        # [substitute gid, 1] for a covered glyph at `index`, or nil.
+        def match(gids, index)
+          gid = @map[gids[index]]
+          [gid, 1] if gid
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gsub.rb

@@ -2,51 +2,96 @@
 
 module Stationery
   module Fonts
-    # Standard ligatures from the GSUB `liga` feature: LigatureSubst lookups
-    # (format 1), directly or behind Extension lookups. Only `liga` applies;
-    # contextual (`clig`) and discretionary (`dlig`) ligatures are left out.
-    # Scripts, languages and lookup flags are not distinguished.
+    # Glyph substitution from the font's GSUB table: every feature's
+    # SingleSubst (type 1) and LigatureSubst (type 4) lookups, directly or
+    # behind Extension lookups. `liga` gives the standard ligatures; `smcp`,
+    # `onum`, `tnum`, `dlig`, `ss01` and the rest are applied on request.
+    # Contextual lookups (types 5, 6 and 8) are not read, so `calt` and
+    # `clig` do nothing. Scripts, languages and lookup flags are not
+    # distinguished.
     class Gsub
+      SINGLE = 1
       LIGATURE = 4
       EXTENSION = 7
+      LIGA = ["liga"].freeze
 
-      # nil when the font has no GSUB table or no `liga` ligatures.
+      # nil when the font has no GSUB table, an unknown version, or no lookup
+      # of a supported type behind any feature.
       def self.parse(ttf)
         base = ttf.table_offset("GSUB")
         return unless base && ttf.u16(base) == 1
 
-        lookups = Gpos.feature_lookups(ttf, base, "liga").map { |offset| lookup(ttf, offset) }.reject(&:empty?)
-        new(lookups) if lookups.any?
+        lookups = {}
+        features = feature_indices(ttf, base + ttf.u16(base + 6)).transform_values do |indices|
+          indices.filter_map do |i|
+            subtables = lookups[i] ||= lookup(ttf, base + ttf.u16(base + 8), i)
+            [i, subtables] unless subtables.empty?
+          end.freeze
+        end
+        features.reject! { |_, lookups_for| lookups_for.empty? }
+        new(features) if features.any?
       end
 
-      # A lookup's LigatureSubst subtables; other lookup types have none.
-      def self.lookup(ttf, offset)
+      # { tag => [lookup index, ...] } from the FeatureList, every record of a
+      # tag merged, in LookupList order.
+      def self.feature_indices(ttf, list)
+        Array.new(ttf.u16(list)) { |i| list + 2 + (i * 6) }.each_with_object({}) do |record, features|
+          tag = ttf.data.byteslice(record, 4)
+          feature = list + ttf.u16(record + 4)
+          indices = Array.new(ttf.u16(feature + 2)) { |j| ttf.u16(feature + 4 + (j * 2)) }
+          features[tag] = ((features[tag] || []) | indices).sort
+        end
+      end
+      private_class_method :feature_indices
+
+      # The `index`th lookup's supported subtables; other types have none.
+      def self.lookup(ttf, list, index)
+        offset = list + ttf.u16(list + 2 + (index * 2))
         type = ttf.u16(offset)
         subtables = Array.new(ttf.u16(offset + 4)) { |i| offset + ttf.u16(offset + 6 + (i * 2)) }
         subtables.filter_map do |subtable|
-          if type == LIGATURE
-            LigatureSubst.read(ttf, subtable)
-          elsif type == EXTENSION && ttf.u16(subtable + 2) == LIGATURE
-            LigatureSubst.read(ttf, subtable + ttf.u32(subtable + 4))
+          if type == EXTENSION
+            read(ttf.u16(subtable + 2), ttf, subtable + ttf.u32(subtable + 4))
+          else
+            read(type, ttf, subtable)
           end
         end.freeze
       end
       private_class_method :lookup
 
-      def initialize(lookups)
-        @lookups = lookups.freeze
+      def self.read(type, ttf, offset)
+        case type
+        when SINGLE then SingleSubst.read(ttf, offset)
+        when LIGATURE then LigatureSubst.read(ttf, offset)
+        end
+      end
+      private_class_method :read
+
+      def initialize(features)
+        @features = features.freeze
+        @plans = {}
         freeze
       end
 
-      # [[gid, number of source glyphs it stands for], ...]. Lookups apply in
-      # order; within one, the first subtable matching at a position wins and
-      # its glyph is not matched again by that lookup.
-      def substitute(gids)
-        @lookups.reduce(gids.map { |gid| [gid, 1] }) { |glyphs, subtables| apply(subtables, glyphs) }
+      # The feature tags this font can apply, e.g. ["liga", "onum", "tnum"].
+      def features = @features.keys
+
+      # [[gid, number of source glyphs it stands for], ...] after applying the
+      # lookups of `tags` (feature tag Strings) in LookupList order, each once.
+      # Within a lookup the first subtable matching at a position wins and its
+      # glyph is not matched again by that lookup.
+      def substitute(gids, tags = LIGA)
+        plan(tags).reduce(gids.map { |gid| [gid, 1] }) { |glyphs, subtables| apply(subtables, glyphs) }
       end
 
       private
 
+      # The lookups the tags name, merged and ordered; remembered per tag list.
+      def plan(tags)
+        @plans[tags] ||= tags.flat_map { |tag| @features[tag] || [] }.uniq(&:first).sort_by(&:first)
+                             .map(&:last).freeze
+      end
+
       def apply(subtables, glyphs)
         ids = glyphs.map(&:first)
         result = []

data/lib/stationery/fonts/ligatures.rb

@@ -2,12 +2,14 @@
 
 module Stationery
   module Fonts
-    # Chooses where a font's ligatures come from. Every source answers
-    # `substitute(gids)` with [[gid, source glyph count], ...].
+    # Chooses where a font's glyph substitutions come from. Every source
+    # answers `substitute(gids, feature_tags)` with [[gid, source glyph
+    # count], ...] and `features` with the tags it can apply.
     module Ligatures
-      # For fonts without ligatures: every glyph stands for itself.
+      # For fonts without a usable GSUB table: every glyph stands for itself.
       module NONE
-        def self.substitute(gids) = gids.map { |gid| [gid, 1] }
+        def self.substitute(gids, _tags = Gsub::LIGA) = gids.map { |gid| [gid, 1] }
+        def self.features = []
       end
 
       def self.for(ttf) = Gsub.parse(ttf) || NONE

data/lib/stationery/hyphenation/patterns/LICENSES.md

@@ -0,0 +1,60 @@
+# Hyphenation patterns
+
+The `*.pat.txt` and `*.hyp.txt` files in this directory are the plain-text
+(UTF-8) pattern and exception lists from the TeX `hyph-utf8` package
+(https://github.com/hyphenation/tex-hyphen, `hyph-utf8/tex/generic/hyph-utf8/patterns/txt/`),
+unmodified. Each file's own copyright and licence follow, copied from the header
+of its `.tex` source in the same package. The Ruby code that reads them
+(`lib/stationery/hyphenation.rb`) is stationery's and under stationery's licence.
+
+## en-us.pat.txt, en-us.hyp.txt — Hyphenation patterns for American English
+
+Copyright (C) 1990, 2004, 2005 Gerard D.C. Kuiken. Source: `hyph-en-us.tex`
+(`ushyphmax.tex`, version 2005-05-30). Based on Liang's patterns and the
+Hyphenation Exception Log published in TUGboat, Volume 10 (1989), No. 3.
+
+> Copying and distribution of this file, with or without modification, are
+> permitted in any medium without royalty provided the copyright notice and
+> this notice are preserved.
+
+Typesetting minimums: 2 letters before a break, 3 after.
+
+## de-1996.pat.txt — German Hyphenation Patterns (Reformed Orthography, 2006)
+
+TeX-Trennmuster für die reformierte (2006) deutsche Rechtschreibung, version
+2024-02-28, by the Deutschsprachige Trennmustermannschaft (trennmuster@dante.de).
+Copyright (c) 2013-2024 Stephan Hennig, Werner Lemberg, Günter Milde, Sander van
+Geloven, Georg Pfeiffer, Gisbert W. Selke, Tobias Wendorf, Keno Wehr. Source:
+`hyph-de-1996.tex`; generated from
+https://repo.or.cz/w/wortliste.git?a=commit;h=304aaa2188a75e57afe36bad0443d90a9c715b8e.
+Licence: MIT (https://opensource.org/licenses/mit-license.php).
+
+> 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.
+
+Typesetting minimums: 2 letters before a break, 2 after.
+
+## sv.pat.txt — Hyphenation patterns for Swedish
+
+Copyright (C) 1994 Jan Michael Rynning (jmr (at) incolumitas.se), version
+1994-03-03. Source: `hyph-sv.tex`. Licence: LaTeX Project Public License,
+version 1.2 or later (https://www.latex-project.org/lppl/). This file is
+distributed unmodified, as the "Current Maintainer" released it; the LPPL
+requires that a modified version be renamed and identified as such.
+
+Typesetting minimums: 2 letters before a break, 2 after.