fontisan 0.4.21 → 0.4.23

data/lib/fontisan/subset/table_strategy/glyf_loca_builder.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Glyf + Loca are emitted together because loca is just an offset
+      # index into glyf. This builder walks the subset's glyph mapping,
+      # extracts each glyph's bytes (remapping composite component refs),
+      # and produces the new glyf bytes, the new loca offsets, and the
+      # union bounding box over the subset's glyphs.
+      #
+      # Extracted as a collaborator so both the Glyf and Loca strategies
+      # can share a single build pass without coupling to each other or
+      # to TableSubsetter internals.
+      class GlyfLocaBuilder
+        # @param font [SfntFont]
+        # @param mapping [GlyphMapping]
+        def initialize(font:, mapping:)
+          @font = font
+          @mapping = mapping
+        end
+
+        # @return [String] new glyf bytes
+        attr_reader :glyf_data
+
+        # @return [Array<Integer>] loca offsets (one per glyph + 1)
+        attr_reader :loca_offsets
+
+        # @return [Array(Integer, Integer, Integer, Integer), nil] union
+        #   bbox as [x_min, y_min, x_max, y_max], or nil if all glyphs empty
+        attr_reader :bbox
+
+        # Build glyf + loca + bbox. Idempotent — re-calling is a no-op.
+        #
+        # @return [self]
+        def build
+          return self if @glyf_data
+
+          glyf = @font.table("glyf")
+          loca = @font.table("loca")
+          head = @font.table("head")
+
+          ensure_loca_parsed!(loca, head)
+
+          @glyf_data = String.new(encoding: Encoding::BINARY)
+          @loca_offsets = []
+          current_offset = 0
+
+          bbox_x_min = 1 << 30
+          bbox_y_min = 1 << 30
+          bbox_x_max = -(1 << 30)
+          bbox_y_max = -(1 << 30)
+
+          @mapping.old_ids.each do |old_id|
+            @loca_offsets << current_offset
+
+            offset = loca.offset_for(old_id)
+            size = loca.size_of(old_id)
+            next if size.nil? || size.zero?
+
+            glyph_data = glyf.raw_data[offset, size]
+
+            if glyph_data.bytesize >= 10
+              _n, gx_min, gy_min, gx_max, gy_max = glyph_data[0, 10].unpack("n5")
+              gx_min = to_signed_16(gx_min)
+              gy_min = to_signed_16(gy_min)
+              gx_max = to_signed_16(gx_max)
+              gy_max = to_signed_16(gy_max)
+              bbox_x_min = gx_min if gx_min < bbox_x_min
+              bbox_y_min = gy_min if gy_min < bbox_y_min
+              bbox_x_max = gx_max if gx_max > bbox_x_max
+              bbox_y_max = gy_max if gy_max > bbox_y_max
+            end
+
+            glyph_data = remap_compound!(glyph_data) if compound?(glyph_data)
+
+            @glyf_data << glyph_data
+            current_offset += glyph_data.bytesize
+          end
+
+          @loca_offsets << current_offset
+
+          return if bbox_x_min > bbox_x_max
+
+          @bbox = [bbox_x_min, bbox_y_min, bbox_x_max, bbox_y_max]
+          self
+        end
+
+        private
+
+        def ensure_loca_parsed!(loca, head)
+          return if loca.parsed?
+
+          maxp = @font.table("maxp")
+          loca.parse_with_context(head.index_to_loc_format, maxp.num_glyphs)
+        end
+
+        def compound?(data)
+          return false if data.length < 2
+
+          num_contours = to_signed_16(data[0, 2].unpack1("n"))
+          num_contours == -1
+        end
+
+        def remap_compound!(data)
+          new_data = data.dup
+          offset = 10 # skip 10-byte header
+
+          loop do
+            break if offset >= new_data.length - 4
+
+            flags = new_data[offset, 2].unpack1("n")
+            old_glyph_index = new_data[offset + 2, 2].unpack1("n")
+
+            new_glyph_index = @mapping.new_id(old_glyph_index)
+            unless new_glyph_index
+              raise Fontisan::SubsettingError,
+                    "Component glyph #{old_glyph_index} not in subset"
+            end
+
+            new_data[offset + 2, 2] = [new_glyph_index].pack("n")
+            offset += 4 # flags + glyph_index
+            offset += (flags & 0x0001).zero? ? 2 : 4 # args
+
+            if (flags & 0x0080) != 0
+              offset += 8 # 2x2 matrix
+            elsif (flags & 0x0040) != 0
+              offset += 4 # X and Y scale
+            elsif (flags & 0x0008) != 0
+              offset += 2 # uniform scale
+            end
+
+            break unless (flags & 0x0020) != 0 # MORE_COMPONENTS
+          end
+
+          new_data
+        end
+
+        def to_signed_16(value)
+          value > 0x7FFF ? value - 0x10000 : value
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/head.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Head strategy: recompute xMin/yMin/xMax/yMax (offsets 36–43) from
+      # the subset's actual glyphs. The source TTC's bbox covers every
+      # donor font in the collection and is far larger than any per-block
+      # subset needs; an inflated bbox makes browsers render glyphs at
+      # the wrong visual size. The remaining head fields pass through
+      # unchanged — checksumAdjustment is rewritten by FontWriter.
+      class Head
+        # @param context [SubsetContext]
+        # @param tag [String] "head"
+        # @param table [Head] parsed head table (unused)
+        # @return [String] binary head bytes for the subset
+        def self.call(context:, tag:, table:)
+          ensure_glyf_built!(context)
+
+          data = context.font.table_data["head"].dup
+          bbox = context.state.subset_bbox
+          return data unless bbox
+
+          x_min, y_min, x_max, y_max = bbox
+          data[36, 8] = [x_min, y_min, x_max, y_max].pack("n4")
+          data
+        end
+
+        def self.ensure_glyf_built!(context)
+          return if context.state.glyf_data
+
+          builder = GlyfLocaBuilder.new(font: context.font,
+                                        mapping: context.mapping).build
+          context.state.glyf_data = builder.glyf_data
+          context.state.loca_offsets = builder.loca_offsets
+          context.state.subset_bbox = builder.bbox
+        end
+        private_class_method :ensure_glyf_built!
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/hhea.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Hhea strategy: rewrite numberOfHMetrics (offset 34, uint16) and
+      # advanceWidthMax (offset 10, uint16). The source TTC's
+      # advanceWidthMax covers every donor font and can be far larger
+      # than any per-block subset needs; recomputing from the subset's
+      # actual hmtx keeps the value honest.
+      #
+      # Hhea runs alphabetically before Hmtx, so the Hmtx strategy's
+      # SharedState cache hasn't been populated yet — we walk the source
+      # hmtx directly to find the max.
+      class Hhea
+        # @param context [SubsetContext]
+        # @param tag [String] "hhea"
+        # @param table [Hhea] parsed hhea table
+        # @return [String] binary hhea bytes for the subset
+        def self.call(context:, tag:, table:)
+          data = table.to_binary_s.dup
+
+          new_num_h_metrics = calculate_number_of_h_metrics(context, table)
+          data[34, 2] = [new_num_h_metrics].pack("n")
+
+          new_max = compute_subset_max_advance(context)
+          data[10, 2] = [new_max].pack("n") if new_max.positive?
+
+          data
+        end
+
+        def self.calculate_number_of_h_metrics(context, _table)
+          hmtx = context.font.table("hmtx")
+          if hmtx&.parsed? && hmtx.h_metrics
+            hmtx.h_metrics.size
+          else
+            context.mapping.size
+          end
+        end
+
+        def self.compute_subset_max_advance(context)
+          hmtx = context.font.table("hmtx")
+          return 0 unless hmtx
+
+          unless hmtx.parsed?
+            hhea = context.font.table("hhea")
+            maxp = context.font.table("maxp")
+            hmtx.parse_with_context(hhea.number_of_h_metrics,
+                                    maxp.num_glyphs)
+          end
+
+          max_advance = 0
+          context.mapping.old_ids.each do |old_id|
+            metric = hmtx.metric_for(old_id)
+            next unless metric
+
+            advance = metric[:advance_width]
+            max_advance = advance if advance && advance > max_advance
+          end
+          max_advance
+        end
+        private_class_method :calculate_number_of_h_metrics,
+                             :compute_subset_max_advance
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/hmtx.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Hmtx strategy: emit one LongHorMetric per glyph in the subset's
+      # glyph mapping, in the same order as the mapping. Also records
+      # the maximum advanceWidth into [SharedState] so Hhea (which is
+      # processed alphabetically before Hmtx) can read it.
+      #
+      # Tables are processed in profile order — Hhea comes before Hmtx
+      # alphabetically — so Hhea reads its max advance via a private
+      # helper that walks the source hmtx directly. Hmtx then stashes
+      # the value into SharedState for any later consumer.
+      class Hmtx
+        # @param context [SubsetContext]
+        # @param tag [String] "hmtx"
+        # @param table [Hmtx] parsed hmtx table
+        # @return [String] binary hmtx bytes for the subset
+        def self.call(context:, tag:, table:)
+          ensure_parsed!(context, table)
+
+          data = String.new(encoding: Encoding::BINARY)
+          max_advance = 0
+
+          context.mapping.old_ids.each do |old_id|
+            metric = table.metric_for(old_id)
+            next unless metric
+
+            advance = metric[:advance_width]
+            max_advance = advance if advance && advance > max_advance
+            data << [advance].pack("n")
+            data << [metric[:lsb]].pack("n")
+          end
+
+          context.state.subset_max_advance = max_advance
+          data
+        end
+
+        def self.ensure_parsed!(context, table)
+          return if table.parsed?
+
+          hhea = context.font.table("hhea")
+          maxp = context.font.table("maxp")
+          table.parse_with_context(hhea.number_of_h_metrics,
+                                   maxp.num_glyphs)
+        end
+        private_class_method :ensure_parsed!
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/loca.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Loca strategy: emit one entry per subset glyph + a final offset,
+      # using short or long format based on the source head.index_to_loc_format.
+      # Glyph offsets come from [SharedState], populated earlier by the
+      # Glyf strategy. If Glyf hasn't run yet (e.g. direct invocation
+      # from a spec), this strategy triggers the build lazily.
+      class Loca
+        # @param context [SubsetContext]
+        # @param tag [String] "loca"
+        # @param table [Loca] parsed loca table (unused)
+        # @return [String] binary loca bytes for the subset
+        def self.call(context:, tag:, table:)
+          offsets = context.state.loca_offsets
+          if offsets.nil?
+            builder = GlyfLocaBuilder.new(font: context.font,
+                                          mapping: context.mapping).build
+            context.state.glyf_data = builder.glyf_data
+            context.state.loca_offsets = builder.loca_offsets
+            context.state.subset_bbox = builder.bbox
+            offsets = builder.loca_offsets
+          end
+
+          head = context.font.table("head")
+          data = String.new(encoding: Encoding::BINARY)
+
+          if head.index_to_loc_format.zero?
+            offsets.each { |o| data << [o / 2].pack("n") }
+          else
+            offsets.each { |o| data << [o].pack("N") }
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/maxp.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Maxp strategy: rewrite numGlyphs (offset 4, uint16) to the
+      # subset's glyph count. The remaining maxp fields describe worst-
+      # case outline/instruction complexity and can be left as-is —
+      # a smaller subset cannot exceed the source's maxima.
+      class Maxp
+        # @param context [SubsetContext]
+        # @param tag [String] "maxp"
+        # @param table [Maxp] parsed maxp table
+        # @return [String] binary maxp bytes for the subset
+        def self.call(context:, tag:, table:)
+          data = table.to_binary_s.dup
+          data[4, 2] = [context.mapping.size].pack("n")
+          data
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/name.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Name strategy: name records don't reference glyph IDs, so the
+      # full source table is preserved.
+      class Name
+        # @param context [SubsetContext]
+        # @param tag [String] "name"
+        # @param table [Name] parsed name table (unused)
+        # @return [String] source name bytes verbatim
+        def self.call(context:, tag:, table:)
+          context.font.table_data[tag]
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/os2.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # OS/2 strategy: OS/2 currently passes through unchanged. Unicode
+      # range pruning is left as future work — the source OS/2 ranges
+      # remain valid (they describe the source character coverage, which
+      # is a superset of the subset's).
+      class Os2
+        # @param context [SubsetContext]
+        # @param tag [String] "OS/2"
+        # @param table [Os2] parsed OS/2 table (unused)
+        # @return [String] source OS/2 bytes verbatim
+        def self.call(context:, tag:, table:)
+          context.font.table_data[tag]
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/pass_through.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Default fallback for tags that have no dedicated strategy.
+      # Returns the source table bytes verbatim — used for tables that
+      # don't need any glyph-aware subsetting (e.g. name, OS/2).
+      class PassThrough
+        # @param context [SubsetContext]
+        # @param tag [String] table tag
+        # @param table [Object, nil] parsed table (unused)
+        # @return [String, nil] source binary bytes for `tag`, or nil
+        def self.call(context:, tag:, table:)
+          context.font.table_data[tag]
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/post.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Post strategy: if the `drop_names` option is set, rewrite as a
+      # version 3.0 post table (no glyph names). Otherwise pass through
+      # the source post bytes.
+      class Post
+        # @param context [SubsetContext]
+        # @param tag [String] "post"
+        # @param table [Post] parsed post table
+        # @return [String] binary post bytes for the subset
+        def self.call(context:, tag:, table:)
+          return build_v3(context) if context.options.drop_names
+
+          context.font.table_data["post"]
+        end
+
+        def self.build_v3(context)
+          data = String.new(encoding: Encoding::BINARY)
+          data << [0x00030000].pack("N") # version 3.0
+
+          original = context.font.table_data["post"]
+          data << if original&.length && original.length >= 32
+                    original[4, 28]
+                  else
+                    [0, 0, 0, 0, 0, 0, 0].pack("N7")
+                  end
+
+          data
+        end
+        private_class_method :build_v3
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Subset::TableStrategy namespace.
+#
+# Each table tag handled by the subsetter has a corresponding strategy
+# class (e.g. `TableStrategy::Maxp` for the "maxp" tag). Strategies are
+# stateless — they receive a [SubsetContext] + tag + table and return
+# the subset table's binary bytes. Unknown tags fall back to
+# [TableStrategy::PassThrough], which preserves the source bytes.
+#
+# Registering a new tag is a one-line change: add the autoload here and
+# an entry in REGISTRY. No edits to TableSubsetter required (Open/Closed).
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      autoload :Cblc, "fontisan/subset/table_strategy/cblc"
+      autoload :Cbdt, "fontisan/subset/table_strategy/cbdt"
+      autoload :Cmap, "fontisan/subset/table_strategy/cmap"
+      autoload :ColorBitmapPlacement,
+               "fontisan/subset/table_strategy/color_bitmap_placement"
+      autoload :ColorBitmapStrikePlan,
+               "fontisan/subset/table_strategy/color_bitmap_strike_plan"
+      autoload :ColorBitmapSubsetPlan,
+               "fontisan/subset/table_strategy/color_bitmap_subset_plan"
+      autoload :ColorBitmapSubsetter,
+               "fontisan/subset/table_strategy/color_bitmap_subsetter"
+      autoload :ColorBitmapSubtablePlan,
+               "fontisan/subset/table_strategy/color_bitmap_subtable_plan"
+      autoload :Glyf, "fontisan/subset/table_strategy/glyf"
+      autoload :GlyfLocaBuilder,
+               "fontisan/subset/table_strategy/glyf_loca_builder"
+      autoload :Head, "fontisan/subset/table_strategy/head"
+      autoload :Hhea, "fontisan/subset/table_strategy/hhea"
+      autoload :Hmtx, "fontisan/subset/table_strategy/hmtx"
+      autoload :Loca, "fontisan/subset/table_strategy/loca"
+      autoload :Maxp, "fontisan/subset/table_strategy/maxp"
+      autoload :Name, "fontisan/subset/table_strategy/name"
+      autoload :Os2, "fontisan/subset/table_strategy/os2"
+      autoload :PassThrough, "fontisan/subset/table_strategy/pass_through"
+      autoload :Post, "fontisan/subset/table_strategy/post"
+
+      # Tag → strategy class name (resolved lazily via const_get to keep
+      # this file loadable in any order). Add new subsetting logic by
+      # adding one autoload + one entry here, plus a strategy file under
+      # `lib/fontisan/subset/table_strategy/`.
+      REGISTRY = {
+        "maxp" => :Maxp,
+        "hhea" => :Hhea,
+        "hmtx" => :Hmtx,
+        "loca" => :Loca,
+        "glyf" => :Glyf,
+        "cmap" => :Cmap,
+        "post" => :Post,
+        "name" => :Name,
+        "head" => :Head,
+        "OS/2" => :Os2,
+        "CBDT" => :Cbdt,
+        "CBLC" => :Cblc,
+      }.freeze
+
+      # Resolve a table tag to its strategy class. Returns PassThrough
+      # for any tag without an explicit registration.
+      #
+      # @param tag [String] OpenType table tag (e.g. "maxp", "CBDT")
+      # @return [Class] a strategy class responding to `.call`
+      def self.for(tag)
+        const_name = REGISTRY[tag]
+        return PassThrough unless const_name
+
+        const_get(const_name)
+      end
+    end
+  end
+end