fontisan 0.4.43 → 0.4.44

data/lib/fontisan/export/table_serializer.rb

@@ -5,44 +5,46 @@ require "json"
 
 module Fontisan
   module Export
-    # TableSerializer handles serialization of individual font tables
+    # Serializes individual font tables for export.
     #
-    # Uses strategy pattern to serialize different table types:
-    # - Fully parsed tables: Use Lutaml::Model serialization
-    # - Binary tables: Encode as hex or base64
-    # - Special tables: Custom serialization logic
+    # Tables fall into three categories:
+    # - Fully parsed: BinData records whose `snapshot` hash is exported
+    #   as JSON fields.
+    # - Binary-only: opaque blobs encoded as hex or base64.
+    # - Mixed: tables with a small typed summary alongside the binary
+    #   payload (glyf, loca, cmap, CFF).
     #
-    # @example Serializing a parsed table
-    #   serializer = TableSerializer.new(binary_format: :hex)
-    #   data = serializer.serialize(head_table, "head")
-    #
-    # @example Serializing binary table
-    #   data = serializer.serialize_binary(raw_data, "DSIG")
+    # All table objects are BinData::Record subclasses; we trust that
+    # interface rather than duck-typing each field.
     class TableSerializer
-      # Tables that have full Lutaml::Model parsing support
+      # Tables whose BinData fields are exported as JSON.
       FULLY_PARSED_TABLES = %w[
         head hhea maxp post OS/2 name
         fvar HVAR VVAR MVAR cvar gvar
       ].freeze
 
-      # Tables that should be stored as binary
+      # Tables stored as opaque binary with no field extraction.
       BINARY_ONLY_TABLES = %w[
         cvt fpgm prep gasp DSIG GDEF GPOS GSUB
       ].freeze
 
-      # Initialize table serializer
-      #
-      # @param binary_format [Symbol] Format for binary data (:hex or :base64)
+      # Tables that ship a summary alongside the raw binary.
+      MIXED_SUMMARIES = {
+        "glyf" => GlyphSummary,
+        "loca" => LocaSummary,
+        "cmap" => CmapSummary,
+        "CFF" => CffSummary,
+      }.freeze
+
+      # @param binary_format [Symbol] :hex or :base64
       def initialize(binary_format: :hex)
         @binary_format = binary_format
         validate_binary_format!
       end
 
-      # Serialize a table to exportable format
-      #
-      # @param table [Object] The table object
-      # @param tag [String] The table tag
-      # @return [Hash] Serialized table data
+      # @param table [BinData::Record] the table object
+      # @param tag [String] table tag
+      # @return [Hash] serialized payload
       def serialize(table, tag)
         if fully_parsed?(tag)
           serialize_parsed(table, tag)
@@ -53,185 +55,41 @@ module Fontisan
         end
       end
 
-      # Serialize a parsed table
-      #
-      # @param table [Object] The table object with Lutaml::Model
-      # @param tag [String] The table tag
-      # @return [Hash] Serialized data with parsed flag
-      def serialize_parsed(table, tag)
-        fields = extract_fields(table)
-        {
-          tag: tag,
-          parsed: true,
-          fields: fields.to_json,
-          data: nil,
-        }
-      end
-
-      # Serialize a binary-only table
-      #
-      # @param data [String] Binary data
-      # @param tag [String] The table tag
-      # @return [Hash] Serialized data with binary content
+      # @param data [String] binary bytes
+      # @param tag [String] table tag
+      # @return [Hash]
       def serialize_binary(data, tag)
-        encoded = encode_binary(data)
-        {
-          tag: tag,
-          parsed: false,
-          data: encoded,
-          fields: nil,
-        }
-      end
-
-      # Serialize tables with mixed content (summary + binary)
-      #
-      # @param table [Object] The table object
-      # @param tag [String] The table tag
-      # @return [Hash] Serialized data with both fields and binary
-      def serialize_mixed(table, tag)
-        summary = create_summary(table, tag)
-        binary = table.respond_to?(:to_binary_s) ? table.to_binary_s : ""
-
-        {
-          tag: tag,
-          parsed: true,
-          fields: summary.to_json,
-          data: encode_binary(binary),
-        }
+        { tag: tag, parsed: false, data: encode_binary(data), fields: nil }
       end
 
       private
 
-      # Check if table is fully parsed
-      #
-      # @param tag [String] Table tag
-      # @return [Boolean]
       def fully_parsed?(tag)
         FULLY_PARSED_TABLES.include?(tag)
       end
 
-      # Check if table is binary-only
-      #
-      # @param tag [String] Table tag
-      # @return [Boolean]
       def binary_only?(tag)
         BINARY_ONLY_TABLES.include?(tag)
       end
 
-      # Extract fields from a parsed table
-      #
-      # @param table [Object] The table object
-      # @return [Hash] Field names and values
-      def extract_fields(table)
-        fields = {}
-
-        # Get all instance variables
-        table.instance_variables.each do |var|
-          name = var.to_s.delete("@")
-          value = table.instance_variable_get(var)
-          fields[name] = serialize_value(value)
-        end
-
-        fields
-      end
-
-      # Serialize individual field value
-      #
-      # @param value [Object] The value to serialize
-      # @return [Object] Serialized value
-      def serialize_value(value)
-        case value
-        when Integer, Float, String, TrueClass, FalseClass, NilClass
-          value
-        when Array
-          value.map { |v| serialize_value(v) }
-        when Hash
-          value.transform_values { |v| serialize_value(v) }
-        when Time
-          value.iso8601
-        else
-          # For complex objects, try to extract fields
-          if value.respond_to?(:instance_variables)
-            extract_fields(value)
-          else
-            value.to_s
-          end
-        end
-      end
-
-      # Create summary for mixed-content tables
-      #
-      # @param table [Object] The table object
-      # @param tag [String] Table tag
-      # @return [Hash] Summary information
-      def create_summary(table, tag)
-        case tag
-        when "glyf"
-          create_glyf_summary(table)
-        when "loca"
-          create_loca_summary(table)
-        when "cmap"
-          create_cmap_summary(table)
-        when "CFF"
-          create_cff_summary(table)
-        else
-          { type: "binary", size: table.to_binary_s.bytesize }
-        end
-      end
-
-      # Create glyf table summary
-      #
-      # @param table [Object] glyf table
-      # @return [Hash] Summary
-      def create_glyf_summary(table)
-        {
-          type: "glyf",
-          num_glyphs: table.respond_to?(:glyphs) ? table.glyphs.length : 0,
-          note: "Outline data stored as binary",
-        }
+      def serialize_parsed(table, tag)
+        { tag: tag, parsed: true, fields: table.snapshot.to_json, data: nil }
       end
 
-      # Create loca table summary
-      #
-      # @param table [Object] loca table
-      # @return [Hash] Summary
-      def create_loca_summary(table)
-        {
-          type: "loca",
-          num_offsets: table.respond_to?(:offsets) ? table.offsets.length : 0,
-          format: table.respond_to?(:format) ? table.format : nil,
-        }
+      def serialize_mixed(table, tag)
+        summary = summary_for(table, tag)
+        { tag: tag, parsed: true,
+          fields: summary.to_json,
+          data: encode_binary(table.to_binary_s) }
       end
 
-      # Create cmap table summary
-      #
-      # @param table [Object] cmap table
-      # @return [Hash] Summary
-      def create_cmap_summary(table)
-        {
-          type: "cmap",
-          version: table.respond_to?(:version) ? table.version : 0,
-          note: "Character mappings stored as binary",
-        }
-      end
+      def summary_for(table, tag)
+        builder = MIXED_SUMMARIES[tag]
+        return { type: "binary", size: table.to_binary_s.bytesize } unless builder
 
-      # Create CFF table summary
-      #
-      # @param table [Object] CFF table
-      # @return [Hash] Summary
-      def create_cff_summary(_table)
-        {
-          type: "CFF",
-          note: "CharString data stored as binary",
-        }
+        builder.call(table)
       end
 
-      public
-
-      # Encode binary data based on format
-      #
-      # @param data [String] Binary data
-      # @return [String] Encoded data
       def encode_binary(data)
         case @binary_format
         when :hex
@@ -241,16 +99,43 @@ module Fontisan
         end
       end
 
-      # Validate binary format option
-      #
-      # @raise [ArgumentError] if format is invalid
       def validate_binary_format!
-        valid_formats = %i[hex base64]
-        return if valid_formats.include?(@binary_format)
+        valid = %i[hex base64]
+        return if valid.include?(@binary_format)
 
         raise ArgumentError,
               "Invalid binary format: #{@binary_format}. " \
-              "Must be one of: #{valid_formats.join(', ')}"
+              "Must be one of: #{valid.join(', ')}"
+      end
+
+      # Summary builders for mixed-content tables. Each is a callable
+      # that receives the typed table and returns a JSON-able Hash.
+
+      module GlyphSummary
+        def self.call(table)
+          { type: "glyf", num_glyphs: table.glyphs.length,
+            note: "Outline data stored as binary" }
+        end
+      end
+
+      module LocaSummary
+        def self.call(table)
+          { type: "loca", num_offsets: table.offsets.length,
+            format: table.format }
+        end
+      end
+
+      module CmapSummary
+        def self.call(table)
+          { type: "cmap", version: table.version,
+            note: "Character mappings stored as binary" }
+        end
+      end
+
+      module CffSummary
+        def self.call(_table)
+          { type: "CFF", note: "CharString data stored as binary" }
+        end
       end
     end
   end

data/lib/fontisan/export/transformers/font_to_ttx.rb

@@ -63,26 +63,26 @@ module Fontisan
 
         # Transform individual table
         #
-        # @param ttx [Models::Ttx::TtFont] TTX model being built
-        # @param tag [String] Table tag
-        # @return [void]
+        public
+
+        # Per-tag TTX model transformer dispatch.
+        TABLE_TRANSFORMERS = {
+          "head" => [HeadTransformer, :head_table=],
+          "hhea" => [HheaTransformer, :hhea_table=],
+          "maxp" => [MaxpTransformer, :maxp_table=],
+          "name" => [NameTransformer, :name_table=],
+          "OS/2" => [Os2Transformer, :os2_table=],
+          "post" => [PostTransformer, :post_table=],
+        }.freeze
+
         def transform_table(ttx, tag)
           table = @font.table(tag)
           return unless table
 
-          case tag
-          when "head"
-            ttx.head_table = HeadTransformer.transform(table)
-          when "hhea"
-            ttx.hhea_table = HheaTransformer.transform(table)
-          when "maxp"
-            ttx.maxp_table = MaxpTransformer.transform(table)
-          when "name"
-            ttx.name_table = NameTransformer.transform(table)
-          when "OS/2"
-            ttx.os2_table = Os2Transformer.transform(table)
-          when "post"
-            ttx.post_table = PostTransformer.transform(table)
+          entry = TABLE_TRANSFORMERS[tag]
+          if entry
+            transformer, setter = entry
+            ttx.public_send(setter, transformer.transform(table))
           else
             # Fallback to binary table
             binary_table = transform_binary_table(tag, table)
@@ -103,7 +103,7 @@ module Fontisan
         # @param table [Object] Table object
         # @return [Models::Ttx::Tables::BinaryTable, nil] Binary table model
         def transform_binary_table(tag, table)
-          binary_data = table.respond_to?(:to_binary_s) ? table.to_binary_s : ""
+          binary_data = table ? table.to_binary_s : ""
           return nil if binary_data.empty?
 
           Models::Ttx::Tables::BinaryTable.new.tap do |bin_table|
@@ -140,7 +140,7 @@ module Fontisan
         # @return [String] Glyph name
         def get_glyph_name(glyph_id)
           post = @font.table("post")
-          if post.respond_to?(:glyph_names) && post.glyph_names
+          if post.is_a?(Tables::Post) && post.glyph_names
             post.glyph_names[glyph_id] || ".notdef"
           elsif glyph_id.zero?
             ".notdef"

data/lib/fontisan/export/transformers/head_transformer.rb

@@ -42,7 +42,7 @@ module Fontisan
         # @param value [Object] BinData value or integer
         # @return [Integer] Native integer
         def self.to_int(value)
-          value.respond_to?(:to_i) ? value.to_i : value
+          Integer(value)
         end
 
         # Format fixed-point number (16.16)

data/lib/fontisan/export/transformers/hhea_transformer.rb

@@ -41,7 +41,7 @@ module Fontisan
         # @param value [Object] BinData value or integer
         # @return [Integer] Native integer
         def self.to_int(value)
-          value.respond_to?(:to_i) ? value.to_i : value
+          Integer(value)
         end
 
         # Format hex value

data/lib/fontisan/export/transformers/maxp_transformer.rb

@@ -45,7 +45,7 @@ module Fontisan
         # @param value [Object] BinData value or integer
         # @return [Integer] Native integer
         def self.to_int(value)
-          value.respond_to?(:to_i) ? value.to_i : value
+          Integer(value)
         end
 
         # Format hex value

data/lib/fontisan/export/transformers/name_transformer.rb

@@ -44,7 +44,7 @@ module Fontisan
         # @param value [Object] BinData value or integer
         # @return [Integer] Native integer
         def self.to_int(value)
-          value.respond_to?(:to_i) ? value.to_i : value
+          Integer(value)
         end
 
         # Format hex value

data/lib/fontisan/export/transformers/os2_transformer.rb

@@ -101,7 +101,7 @@ module Fontisan
         # @param value [Object] BinData value or integer
         # @return [Integer] Native integer
         def self.to_int(value)
-          value.respond_to?(:to_i) ? value.to_i : value
+          Integer(value)
         end
 
         # Format binary flags

data/lib/fontisan/export/transformers/post_transformer.rb

@@ -33,7 +33,7 @@ module Fontisan
         # @param value [Object] BinData value or integer
         # @return [Integer] Native integer
         def self.to_int(value)
-          value.respond_to?(:to_i) ? value.to_i : value
+          Integer(value)
         end
 
         # Format fixed-point number (16.16)

data/lib/fontisan/export/ttx_generator.rb

@@ -64,7 +64,7 @@ module Fontisan
       # @param value [Object] BinData value or integer
       # @return [Integer] Native integer
       def to_int(value)
-        value.respond_to?(:to_i) ? value.to_i : value
+        Integer(value)
       end
 
       # Generate GlyphOrder section (required first)
@@ -84,8 +84,28 @@ module Fontisan
       # Generate individual table XML
       #
       # @param xml [Nokogiri::XML::Builder] XML builder
-      # @param tag [String] Table tag
-      # @return [void]
+      public
+
+      # Per-tag emitter dispatch table. Adding a new table's TTX
+      # emitter means adding one entry here, not editing generate_table.
+      TABLE_EMITTERS = {
+        "head" => :generate_head_table,
+        "hhea" => :generate_hhea_table,
+        "maxp" => :generate_maxp_table,
+        "post" => :generate_post_table,
+        "name" => :generate_name_table,
+        "cmap" => :generate_cmap_table,
+        "loca" => :generate_loca_table,
+        "glyf" => :generate_glyf_table,
+        "CFF" => :generate_cff_table,
+        "CFF " => :generate_cff_table,
+        "hmtx" => :generate_hmtx_table,
+        "fvar" => :generate_fvar_table,
+      }.freeze
+
+      # Variation tags all share the same emitter shape.
+      VARIATION_TAGS = %w[gvar cvar HVAR VVAR MVAR].freeze
+
       def generate_table(xml, tag)
         table = @font.table(tag)
 
@@ -97,36 +117,15 @@ module Fontisan
           return
         end
 
-        case tag
-        when "head"
-          generate_head_table(xml, table)
-        when "hhea"
-          generate_hhea_table(xml, table)
-        when "maxp"
-          generate_maxp_table(xml, table)
-        when "post"
-          generate_post_table(xml, table)
-        when "name"
-          generate_name_table(xml, table)
-        when "OS/2"
-          # Skip OS/2 for now - Nokogiri builder can't handle slashes in element names
-          # TODO: Implement OS/2 table generation with proper XML escaping
+        if tag == "OS/2"
           xml.comment(" OS/2 table skipped - requires special XML handling ")
-        when "cmap"
-          generate_cmap_table(xml, table)
-        when "loca"
-          generate_loca_table(xml, table)
-        when "glyf"
-          generate_glyf_table(xml, table)
-        when "CFF"
-          generate_cff_table(xml, table)
-        when "CFF "
-          generate_cff_table(xml, table)
-        when "hmtx"
-          generate_hmtx_table(xml, table)
-        when "fvar"
-          generate_fvar_table(xml, table)
-        when "gvar", "cvar", "HVAR", "VVAR", "MVAR"
+          return
+        end
+
+        emitter = TABLE_EMITTERS[tag]
+        if emitter
+          method(emitter).call(xml, table)
+        elsif VARIATION_TAGS.include?(tag)
           generate_variation_table(xml, tag, table)
         else
           generate_binary_table(xml, tag, table)
@@ -293,8 +292,8 @@ module Fontisan
       # @param table [Object] Table object
       # @return [void]
       def generate_binary_table(xml, tag, table)
-        binary_data = table.respond_to?(:to_binary_s) ? table.to_binary_s : ""
-        xml.send(tag.to_sym) do
+        binary_data = table.to_binary_s
+        xml.public_send(tag.to_sym) do
           xml.hexdata do
             xml.text("\n    #{format_hex_data(binary_data)}\n  ")
           end
@@ -310,7 +309,7 @@ module Fontisan
       def generate_binary_table_from_data(xml, tag, data)
         # Remove trailing space from tag for XML element name
         clean_tag = tag.strip
-        xml.send(clean_tag.to_sym) do
+        xml.public_send(clean_tag.to_sym) do
           xml.hexdata do
             xml.text("\n    #{format_hex_data(data)}\n  ")
           end
@@ -432,7 +431,7 @@ module Fontisan
       # @return [String] Glyph name
       def get_glyph_name(glyph_id)
         post = @font.table("post")
-        if post.respond_to?(:glyph_names) && post.glyph_names
+        if post.is_a?(Tables::Post) && post.glyph_names
           post.glyph_names[glyph_id] || ".notdef"
         elsif glyph_id.zero?
           ".notdef"
@@ -471,7 +470,7 @@ module Fontisan
       # @param width [Integer] Minimum hex width
       # @return [String] Hex string (e.g., "0x1234")
       def format_hex(value, width: 8)
-        int_value = value.respond_to?(:to_i) ? value.to_i : value
+        int_value = Integer(value)
         "0x#{int_value.to_s(16).rjust(width, '0')}"
       end
 

data/lib/fontisan/font_writer.rb

@@ -165,7 +165,7 @@ module Fontisan
         checksum = calculate_table_checksum(data)
 
         # Calculate padding to 4-byte boundary
-        padding_length = Utilities::Padding.boundary(data)
+        padding_length = Utilities::Padding.boundary(data.bytesize)
         padding = "\0" * padding_length
 
         entries << {

data/lib/fontisan/glyph_accessor.rb

@@ -352,15 +352,13 @@ module Fontisan
         next unless glyph&.compound? && glyph.compound?
 
         # Add component glyph IDs
-        if glyph&.components
-          glyph.components.each do |component|
-            component_id = component[:glyph_index]
-            next unless glyph_exists?(component_id)
-
-            unless result.include?(component_id)
-              result.add(component_id)
-              to_process << component_id
-            end
+        glyph&.components&.each do |component|
+          component_id = component[:glyph_index]
+          next unless glyph_exists?(component_id)
+
+          unless result.include?(component_id)
+            result.add(component_id)
+            to_process << component_id
           end
         end
       end