fontisan 0.4.22 → 0.4.23

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