fontisan 0.4.43 → 0.4.44

data/lib/fontisan/hints/postscript_hint_extractor.rb

@@ -56,24 +56,23 @@ module Fontisan
       def extract(charstring)
         return [] if charstring.nil?
 
-        # Get CharString bytes
-        bytes = if charstring.respond_to?(:data)
-                  charstring.data
-                elsif charstring.respond_to?(:bytes)
-                  charstring.bytes
-                elsif charstring.is_a?(String)
-                  charstring.bytes
-                else
-                  return []
-                end
-
-        return [] if bytes.empty?
+        bytes = charstring_to_bytes(charstring)
+        return [] if bytes.nil? || bytes.empty?
 
         parse_charstring(bytes)
       end
 
       private
 
+      # Coerce a CharString input to an Array<Integer> of bytes.
+      # Accepts a String (raw bytes) or a CFF::CharString.
+      def charstring_to_bytes(charstring)
+        return charstring.bytes if charstring.is_a?(String)
+        return charstring.data if charstring.is_a?(Tables::Cff::CharString)
+
+        raise TypeError, "Unsupported charstring type: #{charstring.class}"
+      end
+
       # Parse CharString bytes to extract hints
       #
       # @param bytes [Array<Integer>] CharString bytes
@@ -289,58 +288,19 @@ module Fontisan
 
         # Extract hint-related parameters from Private DICT
         # These are the key hinting parameters in CFF
-        if private_dict.respond_to?(:blue_values)
-          hints[:blue_values] =
-            private_dict.blue_values
-        end
-        if private_dict.respond_to?(:other_blues)
-          hints[:other_blues] =
-            private_dict.other_blues
-        end
-        if private_dict.respond_to?(:family_blues)
-          hints[:family_blues] =
-            private_dict.family_blues
-        end
-        if private_dict.respond_to?(:family_other_blues)
-          hints[:family_other_blues] =
-            private_dict.family_other_blues
-        end
-        if private_dict.respond_to?(:blue_scale)
-          hints[:blue_scale] =
-            private_dict.blue_scale
-        end
-        if private_dict.respond_to?(:blue_shift)
-          hints[:blue_shift] =
-            private_dict.blue_shift
-        end
-        if private_dict.respond_to?(:blue_fuzz)
-          hints[:blue_fuzz] =
-            private_dict.blue_fuzz
-        end
-        if private_dict.respond_to?(:std_hw)
-          hints[:std_hw] =
-            private_dict.std_hw
-        end
-        if private_dict.respond_to?(:std_vw)
-          hints[:std_vw] =
-            private_dict.std_vw
-        end
-        if private_dict.respond_to?(:stem_snap_h)
-          hints[:stem_snap_h] =
-            private_dict.stem_snap_h
-        end
-        if private_dict.respond_to?(:stem_snap_v)
-          hints[:stem_snap_v] =
-            private_dict.stem_snap_v
-        end
-        if private_dict.respond_to?(:force_bold)
-          hints[:force_bold] =
-            private_dict.force_bold
-        end
-        if private_dict.respond_to?(:language_group)
-          hints[:language_group] =
-            private_dict.language_group
-        end
+        hints[:blue_values] = private_dict.blue_values
+        hints[:other_blues] = private_dict.other_blues
+        hints[:family_blues] = private_dict.family_blues
+        hints[:family_other_blues] = private_dict.family_other_blues
+        hints[:blue_scale] = private_dict.blue_scale
+        hints[:blue_shift] = private_dict.blue_shift
+        hints[:blue_fuzz] = private_dict.blue_fuzz
+        hints[:std_hw] = private_dict.std_hw
+        hints[:std_vw] = private_dict.std_vw
+        hints[:stem_snap_h] = private_dict.stem_snap_h
+        hints[:stem_snap_v] = private_dict.stem_snap_v
+        hints[:force_bold] = private_dict.force_bold?
+        hints[:language_group] = private_dict.language_group
 
         hints.compact
       rescue StandardError => e

data/lib/fontisan/hints/truetype_hint_extractor.rb

@@ -63,7 +63,7 @@ module Fontisan
       # @return [Array<Hint>] Extracted hints
       def extract(glyph)
         return [] if glyph.nil? || glyph.empty?
-        return [] unless glyph.respond_to?(:instructions)
+        return [] unless glyph.is_a?(Fontisan::Tables::SimpleGlyph)
 
         instructions = glyph.instructions || []
         return [] if instructions.empty?

data/lib/fontisan/models/ttx/tables/binary_table.rb

@@ -18,7 +18,7 @@ module Fontisan
           # based on table tag
           def to_xml(options = {})
             builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
-              xml.send(tag.to_sym) do
+              xml.public_send(tag.to_sym) do
                 xml.hexdata do
                   xml.text("\n    #{format_hexdata(hexdata)}\n  ")
                 end

data/lib/fontisan/optimizers/charstring_rewriter.rb

@@ -127,7 +127,7 @@ module Fontisan
         replacements = []
 
         patterns.each do |pattern|
-          if glyph_id && pattern.respond_to?(:positions) && pattern.positions.is_a?(Hash)
+          if glyph_id && pattern.is_a?(PatternAnalyzer::Pattern) && pattern.positions.is_a?(Hash)
             # Use exact positions from pattern analysis for this glyph
             glyph_positions = pattern.positions[glyph_id] || []
 

data/lib/fontisan/sfnt_font.rb

@@ -52,6 +52,8 @@ module Fontisan
   # @example Writing a font
   #   ttf.to_file("output.ttf")
   class SfntFont < BinData::Record
+    include SfntSource
+
     endian :big
 
     offset_table :header

data/lib/fontisan/sfnt_source.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Marks a class as providing the SFNT font source interface.
+  #
+  # SfntFont, WoffFont, and Woff2Font all expose the same table-access
+  # surface (#table, #tables, #table_data, #table_names, #has_table?)
+  # but don't share a common base class (WOFF/WOFF2 wrap an SfntFont
+  # but inherit from BinData::Record directly).
+  #
+  # Including this module lets callers type-check with `is_a?(SfntSource)`
+  # instead of `respond_to?(:table)` duck-typing.
+  module SfntSource
+    # @param tag [String] table tag
+    # @return [Object, nil] parsed table or nil
+    def table(tag); end
+
+    # @return [Hash<String, String>] raw table bytes by tag
+    def table_data(tag = nil); end
+
+    # @return [Array<String>] table tags present in this font
+    def table_names; end
+
+    # @param tag [String] table tag
+    # @return [Boolean]
+    def has_table?(tag); end
+  end
+end

data/lib/fontisan/stitcher/source.rb

@@ -80,7 +80,7 @@ module Fontisan
       # @return [Symbol]
       def bitmap_mode
         return :none if @font.is_a?(Fontisan::Ufo::Font)
-        return :none unless @font.respond_to?(:has_table?)
+        return :none unless @font.is_a?(SfntSource)
 
         has_cbdt = @font.has_table?("CBDT") && @font.has_table?("CBLC")
         has_glyf = @font.has_table?("glyf") || @font.has_table?("CFF ")
@@ -190,7 +190,7 @@ module Fontisan
           cache[:loca] = @font.table("loca")
           cache[:glyf] = @font.table("glyf")
           # loca needs head's index_to_loc_format to size its offsets
-          if cache[:loca].respond_to?(:parse_with_context) && cache[:head]
+          if cache[:head]
             cache[:loca].parse_with_context(
               cache[:head].index_to_loc_format,
               @font.table("maxp")&.num_glyphs || 0,
@@ -217,15 +217,13 @@ module Fontisan
         num_h_metrics = hhea&.number_of_h_metrics || 1
         num_glyphs = maxp&.num_glyphs || 0
 
-        if hmtx.respond_to?(:parse_with_context)
-          hmtx.parse_with_context(num_h_metrics, num_glyphs)
-        end
+        hmtx.parse_with_context(num_h_metrics, num_glyphs)
 
         # Fallback advance width when hmtx lookup fails for a GID.
         # Per the OpenType spec, glyphs at GID >= numberOfHMetrics
         # inherit the last LongHorMetric's advanceWidth. If the table
         # is empty or corrupt, fall back to the font's unitsPerEm.
-        fallback_width = if hmtx.respond_to?(:h_metrics) && hmtx.h_metrics&.any?
+        fallback_width = if hmtx.h_metrics&.any?
                            hmtx.h_metrics.last[:advance_width]
                          else
                            head&.units_per_em || 1000
@@ -284,9 +282,9 @@ module Fontisan
         glyph = Fontisan::Ufo::Glyph.new(name: name)
         glyph.width = glyph_width(gid)
 
-        if raw.respond_to?(:simple?) && raw.simple?
+        if raw.is_a?(Fontisan::Tables::SimpleGlyph) && raw.simple?
           copy_simple_contours(raw, glyph)
-        elsif raw.respond_to?(:compound?) && raw.compound?
+        elsif raw.is_a?(Fontisan::Tables::CompoundGlyph) && raw.compound?
           flatten_compound_into(raw, glyph, cache, Set.new)
         end
 
@@ -372,9 +370,9 @@ module Fontisan
 
           matrix = component.transformation_matrix
 
-          if raw.respond_to?(:simple?) && raw.simple?
+          if raw.is_a?(Fontisan::Tables::SimpleGlyph) && raw.simple?
             flatten_simple_component(raw, ufo_glyph, matrix)
-          elsif raw.respond_to?(:compound?) && raw.compound?
+          elsif raw.is_a?(Fontisan::Tables::CompoundGlyph) && raw.compound?
             flatten_compound_into(raw, ufo_glyph, cache, visited, depth + 1)
           end
         end

data/lib/fontisan/subset/builder.rb

@@ -110,8 +110,8 @@ module Fontisan
       def validate_input!
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:table)
-          raise ArgumentError, "Font must respond to :table method"
+        unless font.is_a?(SfntSource)
+          raise ArgumentError, "Font must be an SfntSource instance"
         end
 
         # Validate options

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

@@ -55,13 +55,12 @@ module Fontisan
         end
 
         def self.raw_bytes_from_font(font)
-          t = font.table("CFF2") if font.respond_to?(:table)
-          t&.raw_data
+          font.table("CFF2")&.raw_data
         end
         private_class_method :raw_bytes_from_font
 
         def self.raw_bytes_from_table(table)
-          table&.raw_data if table.respond_to?(:raw_data)
+          table&.raw_data
         end
         private_class_method :raw_bytes_from_table
 

data/lib/fontisan/svg_to_glyf/assembler.rb

@@ -7,7 +7,10 @@ module Fontisan
     #   path data + transforms
     #     → Path::Parser.parse → [Command]
     #     → Path::ContourBuilder.build → [Ufo::Contour]
-    #     → apply final transform (normalization · group transform)
+    #     → measure content bounds (Ufo::Bounds)
+    #     → union content bounds with the SVG viewBox bounds
+    #     → Normalizer maps the unioned space into the em-square
+    #     → compose with the accumulated group transform
     #     → round to Integer
     #     → Ufo::Glyph
     #
@@ -16,6 +19,8 @@ module Fontisan
     # composes the normalizer with the group transform and runs the
     # pipeline once per path.
     class Assembler
+      DEFAULT_VIEWBOX = Ufo::Bounds.new(min_x: 0, min_y: 0, max_x: DEFAULT_UPM, max_y: DEFAULT_UPM)
+
       attr_reader :upm
 
       # @param upm [Integer] font units-per-em
@@ -28,15 +33,16 @@ module Fontisan
       # @param path_data [String] SVG path d= attribute
       # @param codepoint [Integer, nil] Unicode codepoint
       # @param name [String, nil] glyph name
-      # @param viewbox [Hash{Symbol=>Float}, nil] :width, :height
+      # @param viewbox [Ufo::Bounds, Hash{Symbol=>Float}, nil] SVG viewbox
       # @param transform [Geometry::AffineTransform, nil] group transform
       # @return [Fontisan::Ufo::Glyph]
       def build_from_path_data(path_data, codepoint: nil, name: nil,
                                viewbox: nil, transform: nil)
-        viewbox ||= { width: @upm, height: @upm }
-        final = normalizer_for(**viewbox).final_transform(transform || Geometry::AffineTransform.identity)
-        contours = build_contours(path_data, final)
-        assemble_glyph(name || glyph_name_for(codepoint), contours, codepoint)
+        assemble(path_data: path_data,
+                 viewbox: resolve_viewbox(viewbox),
+                 group_transform: transform || Geometry::AffineTransform.identity,
+                 codepoint: codepoint,
+                 name: name)
       end
 
       # Build a glyph from an SVG file.
@@ -49,7 +55,11 @@ module Fontisan
         codepoint ||= codepoint_from_filename(File.basename(file_path))
 
         doc.each_path.with_object(nil) do |(data, transform), _|
-          return build_from_doc_path(data, transform, doc, codepoint)
+          return assemble(path_data: data,
+                          viewbox: doc.viewbox || default_viewbox,
+                          group_transform: transform,
+                          codepoint: codepoint,
+                          name: nil)
         end
 
         empty_glyph(codepoint)
@@ -73,18 +83,33 @@ module Fontisan
 
       private
 
-      def build_from_doc_path(data, group_transform, doc, codepoint)
-        final = normalizer_for(width: doc.viewbox_width,
-                               height: doc.viewbox_height)
-          .final_transform(group_transform)
-        contours = build_contours(data, final)
-        assemble_glyph(glyph_name_for(codepoint), contours, codepoint)
-      end
-
-      def build_contours(path_data, final_transform)
+      # Shared pipeline used by every entry point. Parses the d-string,
+      # builds contours, computes the normalization bounds as the union
+      # of the actual content bounds and the declared viewBox bounds,
+      # applies the normalizer composed with the group transform, and
+      # assembles the result into a Ufo::Glyph.
+      def assemble(path_data:, viewbox:, group_transform:, codepoint:, name:)
         commands = Path::Parser.parse(path_data)
         contours = Path::ContourBuilder.new.build(commands)
-        contours.map { |c| transform_contour(c, final_transform) }
+        norm_bounds = normalization_bounds(contours, viewbox)
+        final = normalizer_for(norm_bounds).final_transform(group_transform)
+        transformed = contours.map { |c| transform_contour(c, final) }
+        assemble_glyph(name || glyph_name_for(codepoint), transformed, codepoint)
+      end
+
+      # Union the actual content bounds with the SVG viewBox bounds.
+      # Content outside the viewBox is preserved (not clipped) by
+      # expanding the normalization space to contain it; content inside
+      # a larger viewBox keeps its relative scale.
+      #
+      # @param contours [Array<Ufo::Contour>]
+      # @param viewbox [Ufo::Bounds]
+      # @return [Ufo::Bounds]
+      def normalization_bounds(contours, viewbox)
+        content = Ufo::Bounds.measure(contours)
+        return viewbox if content.empty?
+
+        content.union(viewbox)
       end
 
       def transform_contour(contour, transform)
@@ -96,9 +121,23 @@ module Fontisan
         Fontisan::Ufo::Contour.new(points)
       end
 
-      def normalizer_for(width:, height:)
-        Geometry::Normalizer.new(viewbox_width: width, viewbox_height: height,
-                                 upm: @upm)
+      def normalizer_for(bounds)
+        Geometry::Normalizer.new(bounds: bounds, upm: @upm)
+      end
+
+      # Accept either a Ufo::Bounds (preferred) or a legacy hash with
+      # :width, :height (treated as origin 0,0). Returns a Bounds.
+      def resolve_viewbox(viewbox)
+        return default_viewbox unless viewbox
+        return viewbox if viewbox.is_a?(Ufo::Bounds)
+
+        Ufo::Bounds.new(min_x: 0, min_y: 0,
+                        max_x: viewbox[:width].to_f,
+                        max_y: viewbox[:height].to_f)
+      end
+
+      def default_viewbox
+        self.class.const_get(:DEFAULT_VIEWBOX)
       end
 
       def assemble_glyph(name, contours, codepoint)

data/lib/fontisan/svg_to_glyf/document.rb

@@ -9,7 +9,7 @@ module Fontisan
     # transforms apply to which paths and what coordinate space the
     # SVG defines (via viewBox).
     class Document
-      attr_reader :viewbox_width, :viewbox_height, :source
+      attr_reader :viewbox, :source
 
       # @param xml [String] raw SVG XML
       def self.from_xml(xml)
@@ -25,7 +25,7 @@ module Fontisan
       def initialize(doc)
         @doc = doc
         @source = doc
-        extract_viewbox
+        @viewbox = extract_viewbox
       end
 
       # Yield each <path> element's d= string along with the accumulated
@@ -41,17 +41,36 @@ module Fontisan
 
       private
 
+      # Parse the SVG viewBox attribute. The SVG spec allows either
+      # whitespace- or comma-separated values: "0 0 1000 1000" or
+      # "0,0,1000,1000". The four components are min_x, min_y, width,
+      # height — all are significant for normalization.
+      #
+      # Falls back to the root element's width/height attributes (origin
+      # assumed to be 0,0). Returns nil if no geometry can be derived.
+      #
+      # @return [Ufo::Bounds, nil]
       def extract_viewbox
         root = @doc.root
-        vb = root&.attribute("viewBox")&.value
+        return unless root
+
+        vb = root.attribute("viewBox")&.value
         if vb
-          _, _, w, h = vb.split(/\s+/).map(&:to_f)
-          @viewbox_width = w
-          @viewbox_height = h
-        else
-          @viewbox_width = (root&.attribute("width")&.value || DEFAULT_UPM).to_f
-          @viewbox_height = (root&.attribute("height")&.value || DEFAULT_UPM).to_f
+          parts = vb.split(/[\s,]+/).map(&:to_f)
+          return if parts.length != 4
+
+          min_x, min_y, w, h = parts
+          return if w.zero? || h.zero?
+
+          return Ufo::Bounds.new(min_x: min_x, min_y: min_y,
+                                 max_x: min_x + w, max_y: min_y + h)
         end
+
+        w = root.attribute("width")&.value&.to_f
+        h = root.attribute("height")&.value&.to_f
+        return if w.nil? || h.nil? || w.zero? || h.zero?
+
+        Ufo::Bounds.new(min_x: 0, min_y: 0, max_x: w, max_y: h)
       end
 
       # Recursively walk the XML tree. When a <g> has a transform=,

data/lib/fontisan/svg_to_glyf/geometry/normalizer.rb

@@ -3,32 +3,49 @@
 module Fontisan
   module SvgToGlyf
     module Geometry
-      # Computes the affine transform that maps SVG viewBox coordinates
-      # (Y-down, origin at top-left) into font coordinates (Y-up, origin
-      # at bottom-left, scaled to UPM).
+      # Computes the affine transform that maps SVG coordinate space
+      # (Y-down, arbitrary origin) into font coordinate space (Y-up,
+      # origin at the bottom-left of the em-square, scaled to UPM).
       #
-      # The normalization combines a Y-flip across the viewBox midline
-      # with a uniform scale from viewBox units to font units. The
-      # resulting matrix is then composed with the SVG document's
+      # The normalization accepts a Ufo::Bounds describing the SVG
+      # coordinate extent to map into the em-square. That bounds may
+      # be the SVG viewBox, the actual content extents, or the union
+      # of both — Assembler decides which.
+      #
+      # The transform is:
+      #
+      #   1. Translate the source origin (min_x, min_y) to (0, 0).
+      #   2. Scale uniformly to font units: (upm/w, upm/h).
+      #   3. Flip Y across the half-height of the scaled space.
+      #   4. Translate up by upm so the top of the source maps to the
+      #      top of the em-square.
+      #
+      # The resulting matrix is composed with the SVG document's
       # accumulated group transform to produce the final per-point
       # transform.
       class Normalizer
-        attr_reader :viewbox_width, :viewbox_height, :upm
+        attr_reader :bounds, :upm
 
-        # @param viewbox_width [Float] SVG viewBox width
-        # @param viewbox_height [Float] SVG viewBox height
-        # @param upm [Integer] font units-per-em
-        def initialize(viewbox_width:, viewbox_height:, upm:)
-          @viewbox_width = viewbox_width.to_f
-          @viewbox_height = viewbox_height.to_f
+        # @param bounds [Ufo::Bounds] source coordinate extents
+        # @param upm [Integer, Float] font units-per-em
+        def initialize(bounds:, upm:)
+          @bounds = bounds
           @upm = upm.to_f
         end
 
-        # @return [AffineTransform] the viewBox→font normalization
+        # @return [AffineTransform] the source→font normalization
         def matrix
-          sx = @upm / @viewbox_width
-          sy = @upm / @viewbox_height
-          AffineTransform.new(sx, 0, 0, -sy, 0, @upm)
+          w = @bounds.width
+          h = @bounds.height
+          return AffineTransform.identity if w.zero? || h.zero?
+
+          sx = @upm / w
+          sy = @upm / h
+          # x' = sx * (x - min_x)
+          # y' = -sy * (y - min_y) + upm
+          AffineTransform.new(sx, 0, 0, -sy,
+                              -sx * @bounds.min_x,
+                              sy * @bounds.min_y + @upm)
         end
 
         # Compose the normalization with an SVG group transform,

data/lib/fontisan/tables/cff/charstring.rb

@@ -36,6 +36,9 @@ module Fontisan
       #   puts charstring.path   # => array of path commands
       #   bbox = charstring.bounding_box  # => [xMin, yMin, xMax, yMax]
       class CharString
+        # @return [String, Array<Integer>] Raw charstring data/bytes
+        attr_reader :data
+
         # @return [Integer, nil] Glyph width (nil if using default width)
         attr_reader :width
 

data/lib/fontisan/tables/cff/dict.rb

@@ -106,10 +106,13 @@ module Fontisan
           @dict.values
         end
 
-        # Convert DICT to Hash
+        # Expose the raw key/value pairs as a Hash. This is an accessor
+        # for the DICT's internal hash, NOT wire-format serialization —
+        # CFF DICT wire format is the binary operand/operator stream
+        # produced by to_binary_s.
         #
-        # @return [Hash] Dictionary as hash
-        def to_h
+        # @return [Hash] Dictionary as hash (dup of internal storage)
+        def raw_hash
           @dict.dup
         end
 

data/lib/fontisan/tables/cff/index.rb

@@ -58,7 +58,7 @@ module Fontisan
         def initialize(io, start_offset: 0)
           @io = io.is_a?(String) ? StringIO.new(io) : io
           @start_offset = start_offset
-          @io.seek(start_offset) if @io.respond_to?(:seek)
+          @io.seek(start_offset)
 
           parse!
         end

data/lib/fontisan/tables/cff/private_dict_writer.rb

@@ -69,10 +69,10 @@ module Fontisan
         #
         # @param source_dict [PrivateDict] Source dictionary
         def parse_source(source_dict)
-          return unless source_dict.respond_to?(:to_h)
+          return unless source_dict.is_a?(Tables::Cff::Dict)
 
           # Extract only non-hint params (subrs, widths)
-          @params = source_dict.to_h.select do |k, _|
+          @params = source_dict.raw_hash.select do |k, _|
             %i[subrs default_width_x nominal_width_x].include?(k)
           end
         end

data/lib/fontisan/tables/cff/table_builder.rb

@@ -168,7 +168,7 @@ module Fontisan
         #
         # @return [Hash] Top DICT parameters
         def extract_top_dict_data
-          @source.top_dict(0).to_h
+          @source.top_dict(0).raw_hash
         end
 
         # Rebuild Top DICT INDEX with updated data

data/lib/fontisan/tables/cff.rb

@@ -41,6 +41,9 @@ module Fontisan
     #   puts cff.font_count  # => 1
     #   puts cff.header.version  # => "1.0"
     class Cff < Binary::BaseRecord
+      extend Registered
+
+      register_tag "CFF "
       # Inner namespace autoloads — declared here so Cff::* constants
       # resolve on first reference without require_relative.
       autoload :CFFGlyph, "fontisan/tables/cff/cff_glyph"

data/lib/fontisan/tables/cff2/table_builder.rb

@@ -161,9 +161,7 @@ module Fontisan
         # @return [Integer] Total stem count (hstem + vstem)
         def calculate_stem_count
           return 0 unless @hint_set
-
-          # Get font-level hints (from private_dict_hints JSON)
-          return 0 unless @hint_set.respond_to?(:private_dict_hints)
+          return 0 unless @hint_set.is_a?(Models::HintSet)
 
           begin
             font_hints = JSON.parse(@hint_set.private_dict_hints || "{}")
@@ -194,7 +192,7 @@ module Fontisan
         #
         # @return [Boolean] True if private_dict_hints are present
         def has_font_level_hints?
-          return false unless @hint_set.respond_to?(:private_dict_hints)
+          return false unless @hint_set.is_a?(Models::HintSet)
 
           hints = JSON.parse(@hint_set.private_dict_hints || "{}")
           !hints.empty?

data/lib/fontisan/tables/cff2.rb

@@ -20,6 +20,9 @@ module Fontisan
     #   cff2 = Fontisan::Tables::Cff2.read(data)
     #   num_glyphs = cff2.glyph_count
     class Cff2 < Binary::BaseRecord
+      extend Registered
+
+      register_tag "CFF2"
       # Inner namespace autoloads — declared here so Cff2::* constants
       # resolve on first reference without require_relative.
       autoload :BlendOperator, "fontisan/tables/cff2/blend_operator"

data/lib/fontisan/tables/cmap.rb

@@ -14,6 +14,9 @@ module Fontisan
     #
     # Reference: OpenType specification, cmap table
     class Cmap < Binary::BaseRecord
+      extend Registered
+
+      register_tag "cmap"
       # Platform IDs
       PLATFORM_UNICODE = 0
       PLATFORM_MACINTOSH = 1

data/lib/fontisan/tables/cvar.rb

@@ -20,6 +20,9 @@ module Fontisan
     #   cvar = Fontisan::Tables::Cvar.read(data)
     #   cvt_deltas = cvar.cvt_variations
     class Cvar < Binary::BaseRecord
+      extend Registered
+
+      register_tag "cvar"
       uint16 :major_version
       uint16 :minor_version
       uint16 :tuple_variation_count