stationery 0.1.0 → 0.2.0

data/lib/stationery/fonts/data/OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

data/lib/stationery/fonts/data/README.md

@@ -0,0 +1,14 @@
+# Bundled fonts
+
+Inter 4.1 by Rasmus Andersson, SIL Open Font License 1.1 (`OFL.txt`).
+Static TTF instances copied unchanged from `extras/ttf/` in
+https://github.com/rsms/inter/releases/download/v4.1/Inter-4.1.zip
+
+| File | SHA-256 |
+|---|---|
+| Inter-Regular.ttf | 40d692fce188e4471e2b3cba937be967878f631ad3ebbbdcd587687c7ebe0c82 |
+| Inter-Bold.ttf | 288316099b1e0a47a4716d159098005eef7c0066921f34e3200393dbdb01947f |
+| Inter-Italic.ttf | bbc051dd204b5019a1aa0bc0ae2aa8a05ab13e7a3f979fa357631dc7feb6833a |
+| Inter-BoldItalic.ttf | 948405a16cdc62701da5f4005ed068ca5f4d27061d98f7974ccfc37831d9581d |
+
+Used when a document declares no `font_family`, or with `font_family "Inter"`.

data/lib/stationery/fonts/embedding/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module Stationery
+  module Fonts
+    module Embedding
+      # What every CIDFont embedding shares: the font descriptor's metrics, the
+      # glyph widths keyed by character code, and the subset tag.
+      class Base
+        IDENTITY = { Registry: "Adobe", Ordering: "Identity", Supplement: 0 }.freeze
+
+        def initialize(font)
+          @font = font
+          @ttf = font.ttf
+        end
+
+        private
+
+        def descriptor(writer, name, **font_file)
+          writer.add(
+            Type: :FontDescriptor, FontName: name, Flags: flags,
+            FontBBox: @ttf.bbox.map { |v| glyph_space(v) }, ItalicAngle: @ttf.italic_angle,
+            Ascent: glyph_space(@ttf.ascender), Descent: glyph_space(@ttf.descender),
+            CapHeight: glyph_space(@ttf.cap_height), XHeight: glyph_space(@ttf.x_height),
+            StemV: @font.bold? ? 120 : 80, **font_file
+          )
+        end
+
+        # The W array: runs of consecutive codes, each with its glyphs' widths.
+        def widths(gids)
+          pairs = gids.map { |gid| [@font.code(gid), gid] }.sort
+          pairs.slice_when { |(a, _), (b, _)| b != a + 1 }.flat_map do |run|
+            [run.first.first, run.map { |_, gid| glyph_space(@ttf.advance(gid)) }]
+          end
+        end
+
+        def glyph_space(units)
+          (units * 1000.0 / @ttf.units_per_em).round
+        end
+
+        def flags
+          flags = 32 # Nonsymbolic
+          flags |= 1 if @ttf.fixed_pitch?
+          flags |= 64 unless @ttf.italic_angle.zero?
+          flags
+        end
+
+        # Subset fonts are named with six uppercase letters: ABCDEF+OpenSans-Regular.
+        def subset_tag(gids)
+          Digest::MD5.digest(gids.pack("n*") + @ttf.postscript_name).bytes.first(6).map { |b| (65 + (b % 26)).chr }.join
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/embedding/cff.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    module Embedding
+      # A CIDFontType0 over the font's CFF table with every undrawn glyph
+      # blanked (FontFile3 /CIDFontType0C). Codes are CIDs: the charset's for
+      # a CID-keyed font, glyph ids for a name-keyed one, so no CIDToGIDMap is
+      # needed.
+      class CFF < Base
+        # Returns [base_font_name, cid_font_reference].
+        def build(writer, gids)
+          name = :"#{subset_tag(gids)}+#{@ttf.postscript_name}"
+          font_file = writer.add(PDF::Stream.new(CffSubset.build(@ttf.cff, gids), { Subtype: :CIDFontType0C }))
+
+          cid_font = writer.add(
+            Type: :Font, Subtype: :CIDFontType0, BaseFont: name, CIDSystemInfo: system_info,
+            FontDescriptor: descriptor(writer, name, FontFile3: font_file),
+            DW: glyph_space(@ttf.advance(0)), W: widths(gids)
+          )
+          [name, cid_font]
+        end
+
+        private
+
+        def system_info
+          registry, ordering, supplement = @ttf.cff.ros
+          return IDENTITY unless registry
+
+          { Registry: registry, Ordering: ordering, Supplement: supplement }
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/embedding/true_type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    module Embedding
+      # A CIDFontType2 over a TrueType subset holding only the drawn glyphs.
+      # Text uses the original glyph ids as CIDs; CIDToGIDMap maps them to the
+      # subset's renumbered ids.
+      class TrueType < Base
+        # Returns [base_font_name, cid_font_reference].
+        def build(writer, gids)
+          subset, mapping = Subset.build(@ttf, gids)
+          name = :"#{subset_tag(gids)}+#{@ttf.postscript_name}"
+          font_file = writer.add(PDF::Stream.new(subset, { Length1: subset.bytesize }))
+
+          cid_font = writer.add(
+            Type: :Font, Subtype: :CIDFontType2, BaseFont: name, CIDSystemInfo: IDENTITY,
+            FontDescriptor: descriptor(writer, name, FontFile2: font_file),
+            DW: glyph_space(@ttf.advance(0)), W: widths(gids),
+            CIDToGIDMap: writer.add(PDF::Stream.new(cid_to_gid_map(gids, mapping)))
+          )
+          [name, cid_font]
+        end
+
+        private
+
+        def cid_to_gid_map(gids, mapping)
+          map = Array.new((gids.max || 0) + 1, 0)
+          gids.each { |gid| map[gid] = mapping.fetch(gid) }
+          map.pack("n*")
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/fallback.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Splits runs so each character is drawn by a font that has its glyph: the
+    # 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, 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.
+    class Fallback
+      CARRIED = /[\s‌‍︀-️\p{M}]/
+
+      def self.carried?(char) = CARRIED.match?(char)
+
+      def initialize(book)
+        @book = book
+        @found = {}
+      end
+
+      def apply(runs) = runs.flat_map { |run| split(run) }
+
+      private
+
+      def split(run)
+        style = run.style
+        font = @book.resolve(style).first
+        return [run] if run.text.each_char.all? { |char| self.class.carried?(char) || font.glyph?(char) }
+
+        chars = run.text.chars
+        families = fill(chars.map { |char| family_for(char, style) unless self.class.carried?(char) }, style.family)
+        pieces = chars.zip(families).chunk_while { |(_, left), (_, right)| left == right }.map do |group|
+          Text::Run.new(group.map(&:first).join, style.with(family: group.first.last))
+        end
+        Text::Run.merge(pieces)
+      end
+
+      def family_for(char, style)
+        key = [char, style.family, style.weight, style.style]
+        @found.fetch(key) do
+          @found[key] = chain(style.family).find do |name|
+            @book.resolve(style.with(family: name)).first.glyph?(char)
+          end || style.family
+        end
+      end
+
+      def chain(family) = [family, *@book.fallbacks, Bundled::DEFAULT].uniq
+
+      # Carried characters (nil) take the previous family, or the first one
+      # after them at the start.
+      def fill(families, default)
+        previous = families.compact.first || default
+        families.map { |family| previous = family || previous }
+      end
+    end
+  end
+end

data/lib/stationery/fonts/family.rb

@@ -12,6 +12,17 @@ module Stationery
 
       attr_reader :name, :paths
 
+      # A family from explicit files, or a bundled or installed pack one when
+      # no files are given.
+      def self.build(name, **paths)
+        return new(name, **paths) if paths.any?
+
+        Bundled.family(name) || Packs.family(name) ||
+          raise(ArgumentError, "font family #{name} needs a regular face (bundled: #{Bundled.names.join(", ")}; " \
+                               "or `stationery fonts install PACK` with PACK one of " \
+                               "#{Catalog::PACKS.map(&:key).join(", ")})")
+      end
+
       def initialize(name, **paths)
         unknown = paths.keys - STYLES
         raise ArgumentError, "unknown font style #{unknown.join(", ")} (use #{STYLES.join(", ")})" if unknown.any?

data/lib/stationery/fonts/font.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "digest/md5"
-
 module Stationery
   module Fonts
-    # One TrueType font as used by one document: measures text, encodes it as
-    # glyph ids and remembers which glyphs were drawn so only those are embedded.
+    # One font as used by one document: measures text, encodes it as
+    # character codes and remembers which glyphs were drawn so only those are
+    # embedded (TrueType) or so the widths and ToUnicode cover them (CFF).
     #
-    # Embedded as a Type0 font over a CIDFontType2 with Identity-H encoding and a
-    # ToUnicode map, so text extracts and searches correctly.
+    # Embedded as a Type0 font with Identity-H encoding and a ToUnicode map, so
+    # text extracts and searches correctly; the descendant CIDFont comes from
+    # Embedding::TrueType or Embedding::CFF.
     class Font
       OBLIQUE_SKEW = Math.tan(12 * Math::PI / 180)
 
@@ -18,131 +18,95 @@ module Stationery
         @ttf = ttf
         @used = {}
         @widths = {}
+        @pairs = {}
+        @glyphs = {}
+        @advances = {}
+        @kerns = {}
+        @cid_keyed = ttf.cff? && ttf.cff.cid_keyed?
       end
 
       def inspect = "#<#{self.class} #{@ttf.postscript_name} used=#{@used.size}>"
 
-      def width_of(text, size, letter_spacing: 0)
-        units = text.each_char.sum { |char| @widths[char] ||= @ttf.advance(@ttf.glyph_id(char.ord)) }
-        scale(units, size) + (letter_spacing * text.length)
+      # Advances and kerning are remembered per string, so measuring the same
+      # word again (wrapping, then laying out the line) allocates nothing.
+      def width_of(text, size, letter_spacing: 0, kerning: false)
+        width = scale(advance_units(text), size) + (letter_spacing * text.length)
+        return width unless kerning
+
+        width + (kerning_units(text) * size / 1000.0)
       end
 
       def ascender(size) = scale(@ttf.ascender, size)
       def descender(size) = -scale(@ttf.descender, size)
       def line_gap(size) = scale(@ttf.line_gap, size)
       def line_height(size) = ascender(size) + descender(size) + line_gap(size)
+      def x_height(size) = scale(@ttf.x_height, size)
       def underline_position(size) = scale(@ttf.underline_position, size)
       def underline_thickness(size) = scale(@ttf.underline_thickness, size)
       def strikeout_position(size) = scale(@ttf.strikeout_position, size)
       def strikeout_size(size) = scale(@ttf.strikeout_size, size)
-      def glyph?(char) = @ttf.glyph?(char)
+      def glyph?(char) = @glyphs.fetch(char) { @glyphs[char] = @ttf.glyph?(char) }
 
       def bold?
         @ttf.weight >= 600
       end
 
-      def encode(text)
-        text.each_char.map do |char|
+      def encode(text) = glyph_run(text).gids.map { |gid| code(gid) }.pack("n*")
+
+      # `kerning:` fills the adjustments with the font's pair kerning.
+      def glyph_run(text, kerning: false)
+        gids = text.each_char.map do |char|
           gid = @ttf.glyph_id(char.ord)
           @used[gid] ||= char
           gid
-        end.pack("n*")
+        end
+        adjust = gids.each_with_index.map { |gid, i| kerning && i + 1 < gids.size ? pair(gid, gids[i + 1]) : 0 }
+        GlyphRun.new(font: self, gids:, adjust:)
       end
 
       def used?
         @used.any?
       end
 
-      def build(writer)
-        gids = @used.keys.sort
-        subset, mapping = Subset.build(@ttf, gids)
-        name = :"#{subset_tag(gids)}+#{@ttf.postscript_name}"
-
-        writer.add(
-          Type: :Font, Subtype: :Type0, BaseFont: name, Encoding: :"Identity-H",
-          DescendantFonts: [cid_font(writer, name, gids, subset, mapping)],
-          ToUnicode: writer.add(PDF::Stream.new(to_unicode_cmap))
-        )
+      # The two-byte character code a glyph is written as: its CID in a
+      # CID-keyed CFF font, otherwise the glyph id itself.
+      def code(gid)
+        @cid_keyed ? @ttf.cff.cid_for(gid) : gid
       end
 
-      private
-
-      def cid_font(writer, name, gids, subset, mapping)
-        writer.add(
-          Type: :Font, Subtype: :CIDFontType2, BaseFont: name,
-          CIDSystemInfo: { Registry: "Adobe", Ordering: "Identity", Supplement: 0 },
-          FontDescriptor: descriptor(writer, name, subset),
-          DW: glyph_space(@ttf.advance(0)), W: glyph_widths(gids),
-          CIDToGIDMap: writer.add(PDF::Stream.new(cid_to_gid_map(gids, mapping)))
-        )
+      # { code => character } for every glyph drawn so far.
+      def used_codes
+        @used.to_h { |gid, char| [code(gid), char] }
       end
 
-      def descriptor(writer, name, subset)
+      def build(writer)
+        embedding = (@ttf.cff? ? Embedding::CFF : Embedding::TrueType).new(self)
+        name, cid_font = embedding.build(writer, @used.keys.sort)
+
         writer.add(
-          Type: :FontDescriptor, FontName: name, Flags: flags,
-          FontBBox: @ttf.bbox.map { |v| glyph_space(v) }, ItalicAngle: @ttf.italic_angle,
-          Ascent: glyph_space(@ttf.ascender), Descent: glyph_space(@ttf.descender),
-          CapHeight: glyph_space(@ttf.cap_height), XHeight: glyph_space(@ttf.x_height),
-          StemV: bold? ? 120 : 80,
-          FontFile2: writer.add(PDF::Stream.new(subset, { Length1: subset.bytesize }))
+          Type: :Font, Subtype: :Type0, BaseFont: name, Encoding: :"Identity-H",
+          DescendantFonts: [cid_font], ToUnicode: writer.add(PDF::Stream.new(ToUnicode.cmap(used_codes)))
         )
       end
 
-      def scale(units, size)
-        units * size / @ttf.units_per_em.to_f
-      end
-
-      def glyph_space(units)
-        (units * 1000.0 / @ttf.units_per_em).round
-      end
-
-      def flags
-        flags = 32 # Nonsymbolic
-        flags |= 1 if @ttf.fixed_pitch?
-        flags |= 64 unless @ttf.italic_angle.zero?
-        flags
-      end
+      private
 
-      # Subset fonts are named with six uppercase letters: ABCDEF+OpenSans-Regular.
-      def subset_tag(gids)
-        Digest::MD5.digest(gids.pack("n*") + @ttf.postscript_name).bytes.first(6).map { |b| (65 + (b % 26)).chr }.join
+      def advance_units(text)
+        @advances[text] ||= text.each_char.sum { |char| @widths[char] ||= @ttf.advance(@ttf.glyph_id(char.ord)) }
       end
 
-      # Text uses the original glyph ids as CIDs; this maps them to the subset's ids.
-      def cid_to_gid_map(gids, mapping)
-        map = Array.new((gids.max || 0) + 1, 0)
-        gids.each { |gid| map[gid] = mapping.fetch(gid) }
-        map.pack("n*")
+      def kerning_units(text)
+        @kerns[text] ||= text.each_char.map { |char| @ttf.glyph_id(char.ord) }
+                             .each_cons(2).sum { |left, right| pair(left, right) }
       end
 
-      def glyph_widths(gids)
-        gids.slice_when { |a, b| b != a + 1 }.flat_map do |run|
-          [run.first, run.map { |gid| glyph_space(@ttf.advance(gid)) }]
-        end
+      # Kerning between two glyphs in thousandths of an em.
+      def pair(left, right)
+        @pairs[(left << 16) | right] ||= @ttf.kerning.adjust(left, right) * 1000.0 / @ttf.units_per_em
       end
 
-      def to_unicode_cmap
-        mappings = @used.sort.map do |gid, char|
-          format("<%<gid>04X> <%<utf16>s>", gid:, utf16: char.encode(Encoding::UTF_16BE).unpack1("H*").upcase)
-        end
-        blocks = mappings.each_slice(100).map { |slice| "#{slice.size} beginbfchar\n#{slice.join("\n")}\nendbfchar" }
-
-        <<~CMAP
-          /CIDInit /ProcSet findresource begin
-          12 dict begin
-          begincmap
-          /CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def
-          /CMapName /Adobe-Identity-UCS def
-          /CMapType 2 def
-          1 begincodespacerange
-          <0000> <FFFF>
-          endcodespacerange
-          #{blocks.join("\n")}
-          endcmap
-          CMapName currentdict /CMap defineresource pop
-          end
-          end
-        CMAP
+      def scale(units, size)
+        units * size / @ttf.units_per_em.to_f
       end
     end
   end

data/lib/stationery/fonts/font_book.rb

@@ -6,30 +6,68 @@ module Stationery
     # document gets its own book so glyph usage (and so subsetting) is per
     # document, while the parsed TrueType data is shared through the Registry.
     class FontBook
-      attr_reader :families
+      attr_reader :families, :fallbacks, :warnings
 
-      def initialize(families = {})
+      # `fallbacks:` names the families tried, in order, for a character the
+      # run's own family has no glyph for.
+      def initialize(families = {}, fallbacks: [], warnings: Warnings.new)
         @families = families.dup
+        @fallbacks = fallbacks.map(&:to_s).freeze
+        @warnings = warnings
         @fonts = {}
+        @resolved = {}
+        @split = {}.compare_by_identity
       end
 
       def inspect = "#<#{self.class} families=#{@families.keys.inspect}>"
 
       def register(name, **paths)
-        @families[name.to_s] = Family.new(name, **paths)
+        @resolved.clear
+        @families[name.to_s] = Family.build(name, **paths)
       end
 
-      # Returns [Font, Family::Face] for a Text::Style.
+      # Returns [Font, Family::Face] for a Text::Style, memoised per style.
       def resolve(style)
-        face = family(style.family).face(weight: style.weight, style: style.style)
-        [@fonts[face.path] ||= Font.new(Registry.load(face.path)), face]
+        @resolved[style] ||= begin
+          face = family(style.family).face(weight: style.weight, style: style.style)
+          [@fonts[face.path] ||= Font.new(Registry.load(face.path)), face].freeze
+        end
+      end
+
+      # The runs split so every character is drawn by a font that has it. Runs
+      # this book already split come back as they are.
+      def fallback(runs)
+        return runs if @split.key?(runs)
+
+        (@fallback ||= Fallback.new(self)).apply(runs).tap { |split| @split[split] = true }
       end
 
       private
 
+      # Registered by name, bundled by name, an installed pack by name, then
+      # the first registered family, then the bundled default.
       def family(name)
-        @families[name.to_s] || @families.values.first ||
-          raise(Error, "no font registered; declare one with `font_family \"Name\", regular: \"path/to/font.ttf\"`")
+        @families[name.to_s] || bundled(name) || pack(name) || substitute(name)
+      end
+
+      # An unknown name draws with the first registered family, else bundled
+      # Inter, and says so once.
+      def substitute(name)
+        used = @families.values.first || bundled(Bundled::DEFAULT)
+        @warnings << Warnings::UnknownFamily.new(requested: name.to_s, used: used.name)
+        used
+      end
+
+      def bundled(name)
+        @bundled ||= {}
+        @bundled[name.to_s] ||= Bundled.family(name)
+      end
+
+      def pack(name)
+        @packs ||= {}
+        return @packs[name.to_s] if @packs.key?(name.to_s)
+
+        @packs[name.to_s] = Packs.family(name)
       end
     end
   end

data/lib/stationery/fonts/glyph_run.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Glyph ids for one run of text in one font, with an extra advance after
+    # each glyph in thousandths of the font size (positive widens). All-zero
+    # adjustments draw as a plain Tj string; otherwise as a TJ array. Glyphs
+    # are written as the font's character codes (see Font#code).
+    GlyphRun = Data.define(:font, :gids, :adjust) do
+      def width(size, letter_spacing: 0)
+        units = gids.sum { |gid| font.ttf.advance(gid) }
+        (units * size / font.ttf.units_per_em.to_f) + (adjust.sum * size / 1000.0) + (letter_spacing * gids.size)
+      end
+
+      def with_word_spacing(chars, extra_points, size)
+        extra = extra_points * 1000.0 / size
+        with(adjust: adjust.each_with_index.map { |a, i| chars[i] == " " ? a + extra : a })
+      end
+
+      def to_operator
+        return "<#{hex(gids)}> Tj" unless adjusted?
+
+        parts = gids.each_index.slice_after { |i| !adjust[i].zero? }.flat_map do |indices|
+          last = indices.last
+          chunk = ["<#{hex(indices.map { |i| gids[i] })}>"]
+          last == gids.size - 1 || adjust[last].zero? ? chunk : chunk << PDF::Serializer.number(-adjust[last])
+        end
+        "[#{parts.join(" ")}] TJ"
+      end
+
+      private
+
+      def adjusted? = adjust[0...-1].any? { |a| !a.zero? }
+
+      def hex(ids) = ids.map { |gid| font.code(gid) }.pack("n*").unpack1("H*").upcase
+    end
+  end
+end

data/lib/stationery/fonts/gpos/class_def.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gpos
+      # OpenType ClassDef table as a Hash of glyph id => class. Glyphs it
+      # does not list are class 0. Format 1 is a run of classes from a start
+      # glyph, format 2 ranges of glyphs sharing a class.
+      module ClassDef
+        def self.read(ttf, offset)
+          if ttf.u16(offset) == 1
+            start = ttf.u16(offset + 2)
+            classes = ttf.data.byteslice(offset + 6, ttf.u16(offset + 4) * 2).unpack("n*")
+            return classes.each_with_index.to_h { |klass, i| [start + i, klass] }.freeze
+          end
+
+          ranges = ttf.data.byteslice(offset + 4, ttf.u16(offset + 2) * 6).unpack("n*").each_slice(3)
+          ranges.each_with_object({}) do |(first, last, klass), map|
+            (first..last).each { |gid| map[gid] = klass }
+          end.freeze
+        end
+      end
+    end
+  end
+end