stationery 0.1.0 → 0.2.0

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gpos
+      # OpenType Coverage table: the glyphs a subtable applies to, in
+      # coverage-index order. Format 1 lists glyphs, format 2 ranges.
+      module Coverage
+        def self.read(ttf, offset)
+          count = ttf.u16(offset + 2)
+          return ttf.data.byteslice(offset + 4, count * 2).unpack("n*") if ttf.u16(offset) == 1
+
+          ttf.data.byteslice(offset + 4, count * 6).unpack("n*").each_slice(3).flat_map do |first, last, _index|
+            (first..last).to_a
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gpos
+      # PairPos subtables (GPOS lookup type 2), keeping only the first glyph's
+      # X advance. `adjust` answers nil when the subtable does not apply, so
+      # the lookup tries its next subtable.
+      module PairPos
+        X_ADVANCE = 0x0004
+
+        def self.read(ttf, offset)
+          ttf.u16(offset) == 1 ? Pairs.read(ttf, offset) : Classes.read(ttf, offset)
+        end
+
+        # The first glyph's X advance of `count` records at `offset`, each
+        # `lead` 16-bit fields (a second glyph id) followed by two value
+        # records. A value record has one field per bit set in its format.
+        def self.x_advances(ttf, offset, count, format1, format2, lead: 0)
+          width = [lead + fields(format1) + fields(format2), 1].max
+          records = ttf.data.byteslice(offset, count * width * 2).unpack("s>*").each_slice(width)
+          return records.map { |record| [record.first & 0xFFFF, 0] } unless format1.anybits?(X_ADVANCE)
+
+          index = lead + fields(format1 & (X_ADVANCE - 1))
+          records.map { |record| [record.first & 0xFFFF, record[index]] }
+        end
+
+        def self.fields(format) = format.to_s(2).count("1")
+
+        # Format 1: explicit pairs, grouped by first glyph.
+        class Pairs
+          def self.read(ttf, offset)
+            format1 = ttf.u16(offset + 4)
+            format2 = ttf.u16(offset + 6)
+            pairs = {}
+            Coverage.read(ttf, offset + ttf.u16(offset + 2)).each_with_index do |left, i|
+              set = offset + ttf.u16(offset + 10 + (i * 2))
+              PairPos.x_advances(ttf, set + 2, ttf.u16(set), format1, format2, lead: 1).each do |right, value|
+                pairs[(left << 16) | right] = value
+              end
+            end
+            new(pairs)
+          end
+
+          def initialize(pairs)
+            @pairs = pairs.freeze
+            freeze
+          end
+
+          def adjust(left, right) = @pairs[(left << 16) | right]
+        end
+
+        # Format 2: a class-by-class matrix over two ClassDefs, kept as classes
+        # rather than expanded into every glyph pair.
+        class Classes
+          def self.read(ttf, offset)
+            format1 = ttf.u16(offset + 4)
+            format2 = ttf.u16(offset + 6)
+            columns = ttf.u16(offset + 14)
+            values = PairPos.x_advances(ttf, offset + 16, ttf.u16(offset + 12) * columns, format1, format2)
+            new(Coverage.read(ttf, offset + ttf.u16(offset + 2)),
+                ClassDef.read(ttf, offset + ttf.u16(offset + 8)), ClassDef.read(ttf, offset + ttf.u16(offset + 10)),
+                values.map(&:last).each_slice(columns).to_a)
+          end
+
+          def initialize(coverage, first_classes, second_classes, matrix)
+            @coverage = coverage.to_h { |gid| [gid, true] }.freeze
+            @first_classes = first_classes
+            @second_classes = second_classes
+            @matrix = matrix.each(&:freeze).freeze
+            freeze
+          end
+
+          def adjust(left, right)
+            return unless @coverage[left]
+
+            @matrix.dig(@first_classes.fetch(left, 0), @second_classes.fetch(right, 0)) || 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gpos.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Pair kerning from the GPOS `kern` feature: PairPos lookups (formats 1
+    # and 2), directly or behind Extension lookups. Scripts and languages are
+    # not distinguished; every lookup any `kern` feature record names applies.
+    # Adjustments are the first glyph's X advance, in font units.
+    class Gpos
+      PAIR = 2
+      EXTENSION = 9
+
+      # nil when the font has no GPOS table or no `kern` feature.
+      def self.parse(ttf)
+        base = ttf.table_offset("GPOS")
+        return unless base && ttf.u16(base) == 1
+
+        indices = kern_lookups(ttf, base + ttf.u16(base + 6))
+        return if indices.empty?
+
+        list = base + ttf.u16(base + 8)
+        new(indices.map { |i| lookup(ttf, list + ttf.u16(list + 2 + (i * 2))) })
+      end
+
+      def self.kern_lookups(ttf, list)
+        records = Array.new(ttf.u16(list)) { |i| list + 2 + (i * 6) }
+        records.select { |record| ttf.data.byteslice(record, 4) == "kern" }.flat_map do |record|
+          feature = list + ttf.u16(record + 4)
+          Array.new(ttf.u16(feature + 2)) { |j| ttf.u16(feature + 4 + (j * 2)) }
+        end.uniq
+      end
+
+      # A lookup's PairPos subtables; other lookup types have none.
+      def self.lookup(ttf, offset)
+        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 == PAIR
+            PairPos.read(ttf, subtable)
+          elsif type == EXTENSION && ttf.u16(subtable + 2) == PAIR
+            PairPos.read(ttf, subtable + ttf.u32(subtable + 4))
+          end
+        end.freeze
+      end
+      private_class_method :kern_lookups, :lookup
+
+      def initialize(lookups)
+        @lookups = lookups.freeze
+        freeze
+      end
+
+      # Within a lookup the first subtable that applies wins; lookups add up.
+      def adjust(left, right)
+        @lookups.sum do |subtables|
+          value = nil
+          subtables.find { |subtable| value = subtable.adjust(left, right) }
+          value || 0
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/installer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Copies a catalog pack into `<into>/<pack>/`: every file is fetched (or
+    # read from `from:`, a directory or .tar.gz, for offline installs) and its
+    # SHA-256 checked before anything is written, then each file is written to
+    # a temporary name and renamed into place. Existing files are kept unless
+    # `force:`. Development-time only; documents never download fonts.
+    class Installer
+      # Fetches an https URL, following up to five redirects.
+      HTTP = lambda do |url, redirects = 5|
+        require "net/http"
+        uri = URI(url)
+        raise Error, "refusing to download over #{uri.scheme}: #{url} (https only)" unless uri.scheme == "https"
+
+        response = Net::HTTP.get_response(uri)
+        case response
+        when Net::HTTPSuccess then response.body.b
+        when Net::HTTPRedirection
+          raise Error, "too many redirects fetching #{url}" if redirects.zero?
+
+          HTTP.call(uri.merge(response["location"]).to_s, redirects - 1)
+        else raise Error, "HTTP #{response.code} fetching #{url}"
+        end
+      end
+
+      attr_reader :into
+
+      def initialize(into: DEFAULT_DIR, force: false, from: nil, fetcher: HTTP, out: nil)
+        @into = into
+        @force = force
+        @from = from
+        @fetcher = fetcher
+        @out = out
+        @archives = {}
+      end
+
+      # Installs one pack; returns { style => path }.
+      def install(key)
+        pack = Catalog.fetch(key)
+        dir = File.join(@into, pack.key.to_s)
+        entries = [*pack.files.values, pack.license_file]
+        pending = entries.filter_map { |entry| [entry, File.join(dir, entry.last)] unless keep?(entry.last, dir) }
+        verified = pending.map { |(url, sha, name), target| [target, verify(name, sha, read(url, name))] }
+        verified.each { |target, bytes| write(target, bytes) }
+        pack.files.transform_values { |(*, name)| File.join(dir, name) }
+      end
+
+      private
+
+      def keep?(name, dir)
+        target = File.join(dir, name)
+        return false if @force || !File.exist?(target)
+
+        say "exists #{target} (--force replaces it)"
+        true
+      end
+
+      def read(url, name)
+        source = source_name(url, name)
+        return offline(source) if @from
+        return File.binread(File.join(Bundled::DIR, source)) unless url
+
+        location, member = url.split("#", 2)
+        bytes = @archives[location] ||= fetch(location)
+        member ? untar(bytes, location, member) { it == member } : bytes
+      end
+
+      def source_name(url, name) = url ? File.basename(url.split("#").last) : name
+
+      def fetch(url)
+        say "fetch #{url}"
+        @fetcher.call(url)
+      end
+
+      def offline(source)
+        if File.directory?(@from)
+          path = Dir.glob("**/#{source}", base: @from).min or raise Error, "#{source} not found in #{@from}"
+          File.binread(File.join(@from, path))
+        else
+          @archives[@from] ||= File.binread(@from)
+          untar(@archives[@from], @from, source) { File.basename(it) == source }
+        end
+      end
+
+      # The first file in a .tar.gz whose member name the block accepts.
+      def untar(bytes, label, wanted)
+        require "rubygems/package"
+        require "stringio"
+        require "zlib"
+        tar = StringIO.new(Zlib::GzipReader.new(StringIO.new(bytes)).read)
+        Gem::Package::TarReader.new(tar).each do |entry|
+          return entry.read.b if entry.file? && yield(entry.full_name)
+        end
+        raise Error, "#{wanted} not found in #{label}"
+      end
+
+      def verify(name, sha, bytes)
+        require "digest"
+        actual = Digest::SHA256.hexdigest(bytes)
+        return bytes if actual == sha
+
+        raise Error, "SHA-256 mismatch for #{name}: expected #{sha}, got #{actual}; nothing written"
+      end
+
+      def write(target, bytes)
+        require "fileutils"
+        FileUtils.mkdir_p(File.dirname(target))
+        temp = "#{target}.#{Process.pid}.tmp"
+        File.binwrite(temp, bytes)
+        File.rename(temp, target)
+        say "wrote #{target}"
+      ensure
+        FileUtils.rm_f(temp) if temp
+      end
+
+      def say(line) = @out&.puts(line)
+    end
+  end
+end

data/lib/stationery/fonts/kern_table.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Pair kerning from a TrueType `kern` table: the OpenType (version 0)
+    # layout with horizontal format 0 subtables. Apple's version 1 table,
+    # vertical, cross-stream and class-based subtables are ignored.
+    class KernTable
+      HORIZONTAL = 0x0001
+      CROSS_STREAM = 0x0004
+      OVERRIDE = 0x0008
+      SUBTABLE_HEADER = 6
+      PAIR = 6
+
+      # nil when the font has no usable kern table.
+      def self.parse(ttf)
+        offset = ttf.table_offset("kern")
+        return unless offset && ttf.u16(offset).zero?
+
+        pairs = {}
+        cursor = offset + 4
+        ttf.u16(offset + 2).times { cursor = read_subtable(ttf, cursor, pairs) }
+        new(pairs)
+      end
+
+      # Returns the offset of the next subtable. A format 0 subtable's length
+      # is derived from its pair count: large tables overflow the 16-bit field.
+      def self.read_subtable(ttf, offset, pairs)
+        coverage = ttf.u16(offset + 4)
+        return offset + ttf.u16(offset + 2) unless (coverage >> 8).zero?
+
+        count = ttf.u16(offset + SUBTABLE_HEADER)
+        start = offset + SUBTABLE_HEADER + 8
+        if coverage.anybits?(HORIZONTAL) && coverage.nobits?(CROSS_STREAM)
+          ttf.data.byteslice(start, count * PAIR).unpack("nns>" * count).each_slice(3) do |left, right, value|
+            key = (left << 16) | right
+            pairs[key] = coverage.nobits?(OVERRIDE) ? pairs.fetch(key, 0) + value : value
+          end
+        end
+        start + (count * PAIR)
+      end
+      private_class_method :read_subtable
+
+      def initialize(pairs)
+        @pairs = pairs.freeze
+        freeze
+      end
+
+      def adjust(left, right) = @pairs.fetch((left << 16) | right, 0)
+    end
+  end
+end

data/lib/stationery/fonts/kerning.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Chooses where a font's pair kerning comes from. Every source answers
+    # `adjust(left_gid, right_gid)` with an extra advance in font units.
+    module Kerning
+      # For fonts without kerning data.
+      module NONE
+        def self.adjust(_left, _right) = 0
+      end
+
+      # A GPOS `kern` feature takes precedence over the legacy `kern` table.
+      def self.for(ttf) = Gpos.parse(ttf) || KernTable.parse(ttf) || NONE
+    end
+  end
+end

data/lib/stationery/fonts/packs.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Font packs: `Fonts.install(:noto_sans)` copies a catalog pack into
+  # vendor/fonts/noto_sans/, after which `font_family "Noto Sans"` finds it
+  # through `Stationery.font_paths` (the Railtie adds vendor/fonts).
+  module Fonts
+    DEFAULT_DIR = "vendor/fonts"
+
+    def self.catalog = Catalog::PACKS
+
+    def self.install(key, into: DEFAULT_DIR, **) = Installer.new(into:, **).install(key)
+
+    # { style => path } for a pack installed under dir.
+    def self.paths(key, dir: DEFAULT_DIR)
+      pack = Catalog.fetch(key)
+      pack.files.transform_values { |(*, file)| File.join(dir, pack.key.to_s, file) }
+    end
+
+    # Ruby lines selecting an installed pack.
+    def self.usage(key, dir)
+      pack = Catalog.fetch(key)
+      short = "font_family #{pack.family.inspect}"
+      return [short] if Stationery.font_paths.include?(File.expand_path(dir))
+
+      ["#{short}  # when #{dir} is in Stationery.font_paths (Rails adds vendor/fonts)",
+       "#{short}, **Stationery::Fonts.paths(:#{pack.key}, dir: #{dir.inspect})"]
+    end
+
+    # Installed packs found by family name in Stationery.font_paths.
+    module Packs
+      def self.family(name)
+        Catalog::PACKS.each do |pack|
+          next unless pack.family.casecmp?(name.to_s)
+
+          Stationery.font_paths.each do |dir|
+            paths = Fonts.paths(pack.key, dir:).select { |_, path| File.file?(path) }
+            return Family.new(pack.family, **paths) if paths[:regular]
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/stationery/fonts/sfnt_metrics.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # The hhea, post and OS/2 metrics of an sfnt font, with fallbacks for the
+    # optional tables. Included by TrueType.
+    module SfntMetrics
+      private
+
+      def parse_hhea
+        t = table_offset("hhea")
+        @ascender = i16(t + 4)
+        @descender = i16(t + 6)
+        @line_gap = i16(t + 8)
+        @number_of_hmetrics = u16(t + 34)
+      end
+
+      def parse_post
+        if (t = table_offset("post"))
+          @italic_angle = i16(t + 4) + (u16(t + 6) / 65_536.0)
+          @underline_position = i16(t + 8)
+          @underline_thickness = i16(t + 10)
+          @fixed_pitch = u32(t + 12) != 0
+        else
+          @italic_angle = 0
+          @underline_position = -@units_per_em / 10
+          @underline_thickness = @units_per_em / 20
+          @fixed_pitch = false
+        end
+      end
+
+      def parse_os2
+        if (t = table_offset("OS/2"))
+          @weight = u16(t + 4)
+          @strikeout_size = i16(t + 26)
+          @strikeout_position = i16(t + 28)
+          if u16(t) >= 2
+            @x_height = i16(t + 86)
+            @cap_height = i16(t + 88)
+          end
+        end
+
+        @weight ||= 400
+        @strikeout_size ||= @underline_thickness
+        @strikeout_position ||= (@ascender * 0.25).round
+        @x_height ||= (@ascender * 0.5).round
+        @cap_height = (@ascender * 0.7).round if @cap_height.nil?
+      end
+    end
+  end
+end

data/lib/stationery/fonts/to_unicode.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # The ToUnicode CMap mapping each two-byte character code a document drew
+    # back to its text, so the PDF extracts and searches correctly.
+    module ToUnicode
+      module_function
+
+      # `chars` is { code => character }.
+      def cmap(chars)
+        mappings = chars.sort.map do |code, char|
+          format("<%<code>04X> <%<utf16>s>", code:, 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
+      end
+    end
+  end
+end

data/lib/stationery/fonts/true_type.rb

@@ -2,13 +2,18 @@
 
 module Stationery
   module Fonts
-    # Reads the tables of a TrueType (.ttf) font needed to measure text and to
-    # embed a subset of it. Static TrueType outlines only: CFF (.otf), font
-    # collections and web font wrappers are rejected with a named reason.
+    # Reads the sfnt tables of a static font needed to measure text and to
+    # embed it: TrueType outlines (.ttf) or CFF outlines (.otf). Variable CFF2
+    # fonts, font collections and web font wrappers are rejected with a named
+    # reason.
     class TrueType
-      REQUIRED_TABLES = %w[head hhea maxp hmtx loca glyf].freeze
+      include SfntMetrics
+
+      REQUIRED_TABLES = %w[head hhea maxp hmtx].freeze
+      OUTLINE_TABLES = { "OTTO" => ["CFF "] }.freeze
+      GLYF_TABLES = %w[loca glyf].freeze
+      SFNT_VERSIONS = ["\x00\x01\x00\x00".b, "true", "OTTO"].freeze
       SIGNATURES = {
-        "OTTO" => "OpenType fonts with CFF outlines (.otf) are not supported, use a TrueType (.ttf) font",
         "ttcf" => "TrueType collections (.ttc) are not supported, use a single TrueType (.ttf) font",
         "wOFF" => "WOFF web fonts are not supported, use the TrueType (.ttf) file",
         "wOF2" => "WOFF2 web fonts are not supported, use the TrueType (.ttf) file"
@@ -28,7 +33,7 @@ module Stationery
         parse_hhea
         parse_maxp
         parse_hmtx
-        parse_loca
+        parse_loca unless cff?
         @cmap = cmap ? Cmap.parse(self) : {}
         parse_post
         parse_os2
@@ -57,6 +62,21 @@ module Stationery
         end
       end
 
+      # Pair kerning, read on first use. Shared by every document using this
+      # parse; the source is immutable once built.
+      def kerning
+        @kerning ||= Kerning.for(self)
+      end
+
+      def cff?
+        @tables.key?("CFF ")
+      end
+
+      # The CFF table, read on first use; nil for TrueType outlines.
+      def cff
+        @cff ||= CFF.new(table_data("CFF ")) if cff?
+      end
+
       def fixed_pitch?
         @fixed_pitch
       end
@@ -88,7 +108,7 @@ module Stationery
 
       def check_signature
         signature = @data.byteslice(0, 4)
-        return if ["\x00\x01\x00\x00".b, "true"].include?(signature)
+        return if SFNT_VERSIONS.include?(signature)
 
         raise UnsupportedFont, SIGNATURES.fetch(signature, "not a TrueType font")
       end
@@ -99,9 +119,12 @@ module Stationery
           record = 12 + (i * 16)
           @tables[@data.byteslice(record, 4)] = [u32(record + 8), u32(record + 12)]
         end
-        required = cmap ? REQUIRED_TABLES + ["cmap"] : REQUIRED_TABLES
+        raise UnsupportedFont, "variable CFF2 fonts are not supported" if @tables.key?("CFF2")
+
+        required = REQUIRED_TABLES + OUTLINE_TABLES.fetch(@data.byteslice(0, 4), GLYF_TABLES)
+        required += ["cmap"] if cmap
         missing = required.reject { |tag| @tables.key?(tag) }
-        raise UnsupportedFont, "font is missing the #{missing.join(", ")} table" if missing.any?
+        raise UnsupportedFont, "font is missing the #{missing.map(&:strip).join(", ")} table" if missing.any?
       end
 
       def parse_head
@@ -111,14 +134,6 @@ module Stationery
         @index_to_loc_format = i16(t + 50)
       end
 
-      def parse_hhea
-        t = table_offset("hhea")
-        @ascender = i16(t + 4)
-        @descender = i16(t + 6)
-        @line_gap = i16(t + 8)
-        @number_of_hmetrics = u16(t + 34)
-      end
-
       def parse_maxp
         @num_glyphs = u16(table_offset("maxp") + 4)
       end
@@ -137,38 +152,6 @@ module Stationery
                 end
         @glyf_offset = table_offset("glyf")
       end
-
-      def parse_post
-        if (t = table_offset("post"))
-          @italic_angle = i16(t + 4) + (u16(t + 6) / 65_536.0)
-          @underline_position = i16(t + 8)
-          @underline_thickness = i16(t + 10)
-          @fixed_pitch = u32(t + 12) != 0
-        else
-          @italic_angle = 0
-          @underline_position = -@units_per_em / 10
-          @underline_thickness = @units_per_em / 20
-          @fixed_pitch = false
-        end
-      end
-
-      def parse_os2
-        if (t = table_offset("OS/2"))
-          @weight = u16(t + 4)
-          @strikeout_size = i16(t + 26)
-          @strikeout_position = i16(t + 28)
-          if u16(t) >= 2
-            @x_height = i16(t + 86)
-            @cap_height = i16(t + 88)
-          end
-        end
-
-        @weight ||= 400
-        @strikeout_size ||= @underline_thickness
-        @strikeout_position ||= (@ascender * 0.25).round
-        @x_height ||= (@ascender * 0.5).round
-        @parse_os2 ||= (@ascender * 0.7).round
-      end
     end
   end
 end

data/lib/stationery/html/document.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "tokenizer"
+require_relative "tree_builder"
+
+module Stationery
+  # Lenient HTML to rich-text blocks (see Stationery::Rich).
+  module HTML
+    def self.parse(source) = TreeBuilder.parse(Tokenizer.tokenize(source))
+  end
+end