stationery 0.6.0 → 0.7.0

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.