stationery 0.1.0 → 0.3.0

data/lib/stationery/fonts/cff_subset.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Rewrites a CFF font so every glyph a document did not draw is a bare
+    # `endchar`. Glyph ids, the charset, FDSelect, the Private DICTs and all
+    # Subrs are kept byte for byte, so CIDs and hinting are unchanged; only the
+    # CharStrings INDEX shrinks. Offsets in the Top DICT and the Font DICTs are
+    # written as fixed five-byte integers so their size does not depend on the
+    # layout they describe. Charstrings are not interpreted: a deprecated
+    # `seac` accent in a drawn glyph would lose its base and accent glyphs.
+    module CffSubset
+      ENDCHAR = "\x0E".b
+
+      module_function
+
+      # Header, Name INDEX, Top DICT INDEX, String and Global Subr INDEXes,
+      # then the blocks the Top DICT points at.
+      def build(cff, gids)
+        blocks = blocks(cff, gids)
+        head = cff.data.byteslice(0, cff.name_index.stop)
+        globals = cff.data.byteslice(cff.string_index.start, cff.global_subrs.stop - cff.string_index.start)
+        pos = head.bytesize + index([top_dict(cff, blocks.transform_values { 0 })]).bytesize + globals.bytesize
+        offsets = blocks.transform_values { |block| pos.tap { pos += block.bytesize } }
+        blocks[:fd_array] = fd_array(cff, offsets) if cff.cid_keyed?
+
+        [head, index([top_dict(cff, offsets)]), globals, *blocks.values].join
+      end
+
+      # The FDArray is sized here with placeholder offsets; build fills them in.
+      def blocks(cff, gids)
+        keep = Set.new(gids) << 0
+        charstrings = Array.new(cff.num_glyphs) { |gid| keep.include?(gid) ? cff.item(cff.charstrings, gid) : ENDCHAR }
+        blocks = tables(cff).merge(charstrings: index(charstrings))
+        privates(cff).each_with_index { |region, i| blocks[[:private, i]] = region }
+        blocks[:fd_array] = fd_array(cff, Hash.new(0)) if cff.cid_keyed?
+        blocks
+      end
+
+      # Charset, custom Encoding and FDSelect, copied as they are.
+      def tables(cff)
+        data = cff.data
+        top = cff.top
+        blocks = {}
+        if (offset = top.fetch(CFF::CHARSET, [0]).first) > 2
+          blocks[:charset] = data.byteslice(offset, charset_size(data, offset, cff.num_glyphs))
+        end
+        if (offset = top.fetch(CFF::ENCODING, [0]).first) > 1
+          blocks[:encoding] = data.byteslice(offset, encoding_size(data, offset))
+        end
+        if (offset = top[CFF::FD_SELECT]&.first)
+          blocks[:fd_select] = data.byteslice(offset, fd_select_size(data, offset, cff.num_glyphs))
+        end
+        blocks
+      end
+
+      # Each Private DICT with its local Subrs, as one region so the Subrs
+      # offset (relative to the Private DICT) still holds.
+      def privates(cff)
+        font_dicts(cff).map do |dict|
+          size, offset = dict.fetch(CFF::PRIVATE)
+          stop = offset + size
+          if (subrs = CFF.parse_dict(cff.data.byteslice(offset, size))[CFF::SUBRS])
+            stop = [stop, cff.index_at(offset + subrs.first).stop].max
+          end
+          cff.data.byteslice(offset, stop - offset)
+        end
+      end
+
+      def font_dicts(cff)
+        return [cff.top] unless cff.cid_keyed?
+
+        fd_array = cff.index_at(cff.top.fetch(CFF::FD_ARRAY).first)
+        fd_array.items.each_index.map { |i| CFF.parse_dict(cff.item(fd_array, i)) }
+      end
+
+      def top_dict(cff, offsets)
+        encode(CFF.dict_entries(cff.item(cff.top_index, 0))) do |op, operands|
+          case op
+          when CFF::CHARSET then offsets.key?(:charset) ? [offsets[:charset]] : operands
+          when CFF::ENCODING then offsets.key?(:encoding) ? [offsets[:encoding]] : operands
+          when CFF::CHARSTRINGS then [offsets[:charstrings]]
+          when CFF::FD_SELECT then [offsets[:fd_select]]
+          when CFF::FD_ARRAY then [offsets[:fd_array]]
+          when CFF::PRIVATE then [operands.first, offsets[[:private, 0]]]
+          end
+        end
+      end
+
+      def fd_array(cff, offsets)
+        fd_array = cff.index_at(cff.top.fetch(CFF::FD_ARRAY).first)
+        dicts = fd_array.items.each_index.map do |i|
+          encode(CFF.dict_entries(cff.item(fd_array, i))) do |op, operands|
+            [operands.first, offsets[[:private, i]]] if op == CFF::PRIVATE
+          end
+        end
+        index(dicts)
+      end
+
+      # Entries the block answers are rewritten with five-byte integers; the
+      # rest keep their original bytes.
+      def encode(entries)
+        entries.map do |op, operands, raw|
+          values = yield(op, operands)
+          next raw unless values
+
+          values.map { |value| [29, value].pack("Cl>") }.join + (op >= 1200 ? [12, op - 1200].pack("CC") : op.chr)
+        end.join.b
+      end
+
+      def index(items)
+        offsets = items.each_with_object([1]) { |item, acc| acc << (acc.last + item.bytesize) }
+        size = [1, 2, 3, 4].find { |bytes| offsets.last < 256**bytes }
+        [items.size, size].pack("nC") + offsets.map { |offset| [offset].pack("N").byteslice(4 - size, size) }.join +
+          items.join
+      end
+
+      def charset_size(data, offset, num_glyphs)
+        format = data.getbyte(offset)
+        return 1 + ((num_glyphs - 1) * 2) if format.zero?
+
+        range = format == 1 ? 3 : 4
+        pos = offset + 1
+        covered = 1
+        while covered < num_glyphs
+          covered += 1 + (format == 1 ? data.getbyte(pos + 2) : data.byteslice(pos + 2, 2).unpack1("n"))
+          pos += range
+        end
+        pos - offset
+      end
+
+      def encoding_size(data, offset)
+        format = data.getbyte(offset)
+        count = data.getbyte(offset + 1)
+        size = 2 + (format.nobits?(0x7F) ? count : count * 2)
+        size += 1 + (data.getbyte(offset + size) * 3) if format.allbits?(0x80)
+        size
+      end
+
+      def fd_select_size(data, offset, num_glyphs)
+        data.getbyte(offset).zero? ? 1 + num_glyphs : 5 + (data.byteslice(offset + 1, 2).unpack1("n") * 3)
+      end
+    end
+  end
+end

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?