fontisan 0.4.42 → 0.4.44

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

data/lib/fontisan/tables/fvar.rb

@@ -71,6 +71,9 @@ module Fontisan
     #     puts "#{axis.axis_tag}: #{axis.min_value} - #{axis.max_value}"
     #   end
     class Fvar < Binary::BaseRecord
+      extend Registered
+
+      register_tag "fvar"
       uint16 :major_version
       uint16 :minor_version
       uint16 :axes_array_offset

data/lib/fontisan/tables/glyf/simple_glyph.rb

@@ -155,6 +155,15 @@ module Fontisan
         end
       end
 
+      # All points across every contour, in contour order.
+      #
+      # @return [Array<Hash>] Array of {x:, y:, on_curve:} hashes
+      def points
+        return [] if empty?
+
+        num_contours.times.flat_map { |c| points_for_contour(c) }
+      end
+
       private
 
       # Parse glyph header (10 bytes)

data/lib/fontisan/tables/glyf.rb

@@ -38,6 +38,9 @@ module Fontisan
     #   puts glyph.simple? ? "Simple glyph" : "Compound glyph"
     #   puts glyph.bounding_box  # => [xMin, yMin, xMax, yMax]
     class Glyf < Binary::BaseRecord
+      extend Registered
+
+      register_tag "glyf"
       # Store the raw data for deferred parsing
       attr_accessor :raw_data
 
@@ -215,13 +218,13 @@ module Fontisan
           next true if glyph.nil? # Empty glyphs are OK
 
           # Simple glyphs have instructions
-          if glyph.respond_to?(:instruction_length)
+          if glyph.nil?
+            # Compound glyphs may have instructions too
+            true
+          else
             inst_len = glyph.instruction_length
             # If instructions present, length should be reasonable
             inst_len.nil? || inst_len >= 0
-          else
-            # Compound glyphs may have instructions too
-            true
           end
         end
       rescue StandardError
@@ -240,7 +243,8 @@ module Fontisan
 
         # Simple glyphs: contours should be >= 0
         # Compound glyphs: numberOfContours = -1
-        if glyph.respond_to?(:num_contours)
+        case glyph
+        when SimpleGlyph, CompoundGlyph
           glyph.num_contours >= -1
         else
           true
@@ -277,9 +281,9 @@ module Fontisan
       # @param glyph_id [Integer] Glyph ID
       # @raise [ArgumentError] If validation fails
       def validate_context!(loca, head, glyph_id)
-        unless loca.respond_to?(:offset_for) && loca.respond_to?(:size_of)
+        unless loca.is_a?(Loca)
           raise ArgumentError,
-                "loca must be a parsed Loca table with offset_for and size_of methods"
+                "loca must be a parsed Loca table"
         end
 
         unless loca.parsed?
@@ -287,7 +291,7 @@ module Fontisan
                 "loca table must be parsed with parse_with_context before use"
         end
 
-        unless head.respond_to?(:units_per_em)
+        unless head.is_a?(Head)
           raise ArgumentError,
                 "head must be a parsed Head table"
         end

data/lib/fontisan/tables/glyf_table.rb

@@ -76,7 +76,7 @@ module Fontisan
         glyph = glyph_for(glyph_id)
         return false if glyph.nil?
 
-        glyph.respond_to?(:num_contours) && glyph.num_contours >= 0
+        !glyph.nil? && glyph.num_contours >= 0
       end
 
       # Check if a glyph is compound
@@ -87,7 +87,7 @@ module Fontisan
         glyph = glyph_for(glyph_id)
         return false if glyph.nil?
 
-        glyph.respond_to?(:num_contours) && glyph.num_contours == -1
+        !glyph.nil? && glyph.num_contours == -1
       end
 
       # Check if a glyph is empty
@@ -117,7 +117,7 @@ module Fontisan
         glyph = glyph_for(glyph_id)
         return nil if glyph.nil?
 
-        glyph.num_contours if glyph.respond_to?(:num_contours)
+        glyph&.num_contours
       end
 
       # Get number of points for a simple glyph
@@ -126,7 +126,7 @@ module Fontisan
       # @return [Integer, nil] Number of points, or nil
       def glyph_point_count(glyph_id)
         glyph = glyph_for(glyph_id)
-        return nil if glyph.nil? || !glyph.respond_to?(:num_points)
+        return nil if glyph.nil? || glyph.num_points.nil?
 
         glyph.num_points
       end

data/lib/fontisan/tables/gvar.rb

@@ -20,6 +20,9 @@ module Fontisan
     #   gvar = Fontisan::Tables::Gvar.read(data)
     #   deltas = gvar.glyph_variations(glyph_id)
     class Gvar < Binary::BaseRecord
+      extend Registered
+
+      register_tag "gvar"
       uint16 :major_version
       uint16 :minor_version
       uint16 :axis_count

data/lib/fontisan/tables/head.rb

@@ -15,6 +15,9 @@ module Fontisan
     #   puts head.units_per_em  # => 2048
     #   puts head.version_number  # => 1.0
     class Head < Binary::BaseRecord
+      extend Registered
+
+      register_tag "head"
       # Magic number that must be present in the head table
       MAGIC_NUMBER = 0x5F0F3CF5
 

data/lib/fontisan/tables/hhea.rb

@@ -18,6 +18,9 @@ module Fontisan
     #   puts hhea.descent          # => -512
     #   puts hhea.version_number   # => 1.0
     class Hhea < Binary::BaseRecord
+      extend Registered
+
+      register_tag "hhea"
       # Table size in bytes (fixed size)
       TABLE_SIZE = 36
 

data/lib/fontisan/tables/hmtx.rb

@@ -38,6 +38,9 @@ module Fontisan
     #   puts "Advance width: #{metric[:advance_width]}"
     #   puts "LSB: #{metric[:lsb]}"
     class Hmtx < Binary::BaseRecord
+      extend Registered
+
+      register_tag "hmtx"
       # LongHorMetric record structure
       #
       # @!attribute advance_width
@@ -47,13 +50,6 @@ module Fontisan
       class LongHorMetric < Binary::BaseRecord
         uint16 :advance_width
         int16 :lsb
-
-        # Convert to hash for convenience
-        #
-        # @return [Hash] Hash with :advance_width and :lsb keys
-        def to_h
-          { advance_width: advance_width, lsb: lsb }
-        end
       end
 
       # Store the raw data for deferred parsing

data/lib/fontisan/tables/hvar.rb

@@ -18,6 +18,10 @@ module Fontisan
     #   hvar = Fontisan::Tables::Hvar.read(data)
     #   advance_deltas = hvar.advance_width_deltas(glyph_id, coordinates)
     class Hvar < Binary::BaseRecord
+      extend Registered
+
+      register_tag "HVAR"
+
       uint16 :major_version
       uint16 :minor_version
       uint32 :item_variation_store_offset

data/lib/fontisan/tables/loca.rb

@@ -42,6 +42,9 @@ module Fontisan
     #   size = loca.size_of(42)
     #   is_empty = loca.empty?(42)
     class Loca < Binary::BaseRecord
+      extend Registered
+
+      register_tag "loca"
       # Short format constant (from head.indexToLocFormat)
       FORMAT_SHORT = 0
 

data/lib/fontisan/tables/maxp.rb

@@ -27,6 +27,9 @@ module Fontisan
     #   puts maxp.version          # => 1.0 or 0.5
     #   puts maxp.truetype?        # => true or false
     class Maxp < Binary::BaseRecord
+      extend Registered
+
+      register_tag "maxp"
       # Version 0.5 constant (CFF fonts)
       VERSION_0_5 = 0x00005000
 

data/lib/fontisan/tables/mvar.rb

@@ -21,6 +21,9 @@ module Fontisan
     #   mvar = Fontisan::Tables::Mvar.read(data)
     #   hasc_deltas = mvar.metric_deltas("hasc")
     class Mvar < Binary::BaseRecord
+      extend Registered
+
+      register_tag "MVAR"
       uint16 :major_version
       uint16 :minor_version
       uint16 :reserved

data/lib/fontisan/tables/name.rb

@@ -64,6 +64,9 @@ module Fontisan
     #   name = Fontisan::Tables::Name.read(data)
     #   puts name.english_name(Fontisan::Tables::Name::FAMILY)
     class Name < Binary::BaseRecord
+      extend Registered
+
+      register_tag "name"
       # Name ID constants for common name records
       COPYRIGHT = 0
       FAMILY = 1

data/lib/fontisan/tables/os2.rb

@@ -14,6 +14,9 @@ module Fontisan
     #
     # Reference: OpenType specification, OS/2 table
     class Os2 < Binary::BaseRecord
+      extend Registered
+
+      register_tag "OS/2"
       endian :big
 
       # Version 0 fields (all versions have these)

data/lib/fontisan/tables/post.rb

@@ -10,6 +10,9 @@ module Fontisan
     #
     # Reference: OpenType specification, post table
     class Post < Binary::BaseRecord
+      extend Registered
+
+      register_tag "post"
       # Standard Mac glyph names for version 1.0 (258 glyphs)
       # rubocop:disable Metrics/CollectionLiteralLength
       STANDARD_NAMES = %w[

data/lib/fontisan/tables/registry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Single source of truth mapping OpenType table tags to Ruby classes.
+    #
+    # Each table class registers itself via `register_tag`:
+    #
+    #   module Fontisan::Tables
+    #     class Hvar < Binary::BaseRecord
+    #       register_tag "HVAR"
+    #       ...
+    #     end
+    #   end
+    #
+    # Dispatch sites use `Tables::Registry.for(tag)` instead of a
+    # `case tag when "HVAR"` switch. This is OCP-compliant: adding a
+    # new table means adding one `register_tag` line in the table's
+    # file, not editing every dispatch site.
+    module Registry
+      @by_tag = {}
+      @by_class = {}
+
+      class << self
+        # @api internal Called by table classes at load time.
+        # @param tag [String] Four-byte OpenType table tag (e.g., "HVAR").
+        # @param klass [Class] The Ruby class implementing the table.
+        def register(tag, klass)
+          @by_tag[tag] = klass
+          @by_class[klass] = tag
+        end
+
+        # Look up the table class for a tag.
+        #
+        # @param tag [String] Four-byte OpenType table tag.
+        # @return [Class, nil] The table class, or nil if unknown.
+        def for(tag)
+          @by_tag[tag]
+        end
+
+        # Reverse lookup: tag for a given class.
+        #
+        # @param klass [Class] A table class.
+        # @return [String, nil] The tag, or nil if not registered.
+        def tag_for(klass)
+          @by_class[klass]
+        end
+
+        # @return [Array<String>] All registered tags.
+        def tags
+          @by_tag.keys
+        end
+
+        # Clear all registrations (testing only).
+        def __clear__
+          @by_tag.clear
+          @by_class.clear
+        end
+      end
+    end
+
+    # Mixin applied to table classes that register themselves with the
+    # Registry at load time. Used via `register_tag "HVAR"` in the
+    # class body.
+    module Registered
+      def register_tag(tag)
+        Tables::Registry.register(tag, self)
+      end
+    end
+  end
+end

data/lib/fontisan/tables/vvar.rb

@@ -18,6 +18,9 @@ module Fontisan
     #   vvar = Fontisan::Tables::Vvar.read(data)
     #   advance_deltas = vvar.advance_height_deltas(glyph_id, coordinates)
     class Vvar < Binary::BaseRecord
+      extend Registered
+
+      register_tag "VVAR"
       uint16 :major_version
       uint16 :minor_version
       uint32 :item_variation_store_offset

data/lib/fontisan/tables.rb

@@ -57,6 +57,8 @@ module Fontisan
     autoload :Os2Table, "fontisan/tables/os2_table"
     autoload :Post, "fontisan/tables/post"
     autoload :PostTable, "fontisan/tables/post_table"
+    autoload :Registered, "fontisan/tables/registry"
+    autoload :Registry, "fontisan/tables/registry"
     autoload :Sbix, "fontisan/tables/sbix"
     autoload :SimpleGlyph, "fontisan/tables/glyf/simple_glyph"
     autoload :Svg, "fontisan/tables/svg"

data/lib/fontisan/type1/afm_generator.rb

@@ -167,10 +167,10 @@ module Fontisan
 
         # Underline properties
         post = @font.table(Constants::POST_TAG)
-        underline_position = post&.underline_position if post.respond_to?(:underline_position)
+        underline_position = post&.underline_position
         afm_lines << "UnderlinePosition #{underline_position}" if underline_position
 
-        underline_thickness = post&.underline_thickness if post.respond_to?(:underline_thickness)
+        underline_thickness = post&.underline_thickness
         afm_lines << "UnderlineThickness #{underline_thickness}" if underline_thickness
       end
 
@@ -252,11 +252,7 @@ module Fontisan
         os2 = @font.table(Constants::OS2_TAG)
         return "Regular" unless os2
 
-        weight_class = if os2.respond_to?(:us_weight_class)
-                         os2.us_weight_class
-                       elsif os2.respond_to?(:weight_class)
-                         os2.weight_class
-                       end
+        weight_class = os2.us_weight_class
         return "Regular" unless weight_class
 
         case weight_class
@@ -280,11 +276,7 @@ module Fontisan
         post = @font.table(Constants::POST_TAG)
         return 0.0 unless post
 
-        if post.respond_to?(:italic_angle)
-          post.italic_angle
-        else
-          0.0
-        end
+        post.italic_angle
       end
 
       # Check if font is monospace
@@ -294,11 +286,7 @@ module Fontisan
         post = @font.table(Constants::POST_TAG)
         return false unless post
 
-        if post.respond_to?(:is_fixed_pitch)
-          post.is_fixed_pitch
-        else
-          false
-        end
+        post.is_fixed_pitch
       end
 
       # Extract version from name table
@@ -308,9 +296,7 @@ module Fontisan
         name_table = @font.table(Constants::NAME_TAG)
         return nil unless name_table
 
-        if name_table.respond_to?(:version_string)
-          name_table.version_string(1) || name_table.version_string(3)
-        end
+        name_table.english_name(Tables::Name::VERSION)
       end
 
       # Extract copyright from name table
@@ -320,9 +306,7 @@ module Fontisan
         name_table = @font.table(Constants::NAME_TAG)
         return nil unless name_table
 
-        if name_table.respond_to?(:copyright)
-          name_table.copyright(1) || name_table.copyright(3)
-        end
+        name_table.english_name(Tables::Name::COPYRIGHT)
       end
 
       # Extract character mappings from cmap table
@@ -332,30 +316,7 @@ module Fontisan
         cmap = @font.table(Constants::CMAP_TAG)
         return {} unless cmap
 
-        @extract_character_mappings ||= begin
-          mappings = {}
-
-          # Try to get Unicode mappings (most reliable method)
-          if cmap.respond_to?(:unicode_mappings)
-            mappings = cmap.unicode_mappings || {}
-          elsif cmap.respond_to?(:unicode_bmp_mapping)
-            mappings = cmap.unicode_bmp_mapping || {}
-          elsif cmap.respond_to?(:subtables)
-            # Look for Unicode BMP subtable
-            unicode_subtable = cmap.subtables.find do |subtable|
-              subtable.respond_to?(:platform_id) &&
-                subtable.platform_id == 3 &&
-                subtable.respond_to?(:encoding_id) &&
-                subtable.encoding_id == 1
-            end
-
-            if unicode_subtable.respond_to?(:glyph_index_map)
-              mappings = unicode_subtable.glyph_index_map
-            end
-          end
-
-          mappings
-        end
+        @extract_character_mappings ||= cmap.unicode_mappings || {}
       end
 
       # Extract font bounding box
@@ -365,12 +326,7 @@ module Fontisan
         head = @font.table(Constants::HEAD_TAG)
         return nil unless head
 
-        if head.respond_to?(:font_bounding_box)
-          head.font_bounding_box
-        elsif head.respond_to?(:x_min) && head.respond_to?(:y_min) &&
-            head.respond_to?(:x_max) && head.respond_to?(:y_max)
-          [head.x_min, head.y_min, head.x_max, head.y_max]
-        end
+        [head.x_min, head.y_min, head.x_max, head.y_max]
       end
 
       # Extract glyph bounding box
@@ -390,7 +346,7 @@ module Fontisan
         return nil unless head_table
 
         # Ensure loca is parsed with context
-        if loca_table.respond_to?(:parse_with_context) && !loca_table.parsed?
+        if loca_table.is_a?(Tables::Loca) && !loca_table.parsed?
           maxp = @font.table(Constants::MAXP_TAG)
           if maxp
             loca_table.parse_with_context(head_table.index_to_loc_format,
@@ -398,17 +354,8 @@ module Fontisan
           end
         end
 
-        if glyf_table.respond_to?(:glyph_for)
-          glyph = glyf_table.glyph_for(glyph_id, loca_table, head_table)
-          return nil unless glyph
-
-          if glyph.respond_to?(:bounding_box)
-            glyph.bounding_box
-          elsif glyph.respond_to?(:x_min) && glyph.respond_to?(:y_min) &&
-              glyph.respond_to?(:x_max) && glyph.respond_to?(:y_max)
-            [glyph.x_min, glyph.y_min, glyph.x_max, glyph.y_max]
-          end
-        end
+        glyph = glyf_table.glyph_for(glyph_id, loca_table, head_table)
+        glyph&.bounding_box
       end
 
       # Extract kerning pairs from GPOS table

data/lib/fontisan/type1/charstring_converter.rb

@@ -136,29 +136,27 @@ module Fontisan
       # @param seac_data [Hash] seac component data
       # @return [String] CFF CharString bytecode with expanded seac
       def expand_seac(seac_data)
-        # seac format: adx ady bchar achar seac
-        # adx, ady: accent offset
-        # bchar: base character code
-        # achar: accent character code
-        # The accent is positioned at (adx, ady) relative to the base
-
-        seac_data[:base]
-        seac_data[:accent]
-        seac_data[:adx]
-        seac_data[:ady]
-
-        # For now, we'll create a simple placeholder that indicates seac expansion
-        # In a full implementation, we would:
-        # 1. Parse the base glyph's CharString
-        # 2. Parse the accent glyph's CharString
-        # 3. Merge them with the appropriate offset
-        # 4. Convert to CFF format
-
-        # This is a simplified implementation that creates a composite reference
-        # CFF doesn't have native seac, so we need to actually merge the outlines
-
-        # For now, return endchar as placeholder
-        # TODO: Implement full seac expansion by merging glyph outlines
+        return encode_cff_operator(TYPE1_TO_CFF[:endchar]) unless @charstrings
+
+        base_name = @charstrings.encoding[seac_data[:base]]
+        accent_name = @charstrings.encoding[seac_data[:accent]]
+        return encode_cff_operator(TYPE1_TO_CFF[:endchar]) unless base_name && accent_name
+
+        base_cs = @charstrings[base_name]
+        accent_cs = @charstrings[accent_name]
+        return encode_cff_operator(TYPE1_TO_CFF[:endchar]) unless base_cs && accent_cs
+
+        base_cff = convert(base_cs)
+        accent_cff = convert(accent_cs)
+        return base_cff unless accent_cff
+
+        io = String.new(encoding: Encoding::ASCII_8BIT)
+        io << base_cff.delete_suffix("\u000E")
+        io << encode_cff_number(seac_data[:adx].to_i) if seac_data[:adx].to_i != 0
+        io << encode_cff_number(seac_data[:ady].to_i) if seac_data[:ady].to_i != 0
+        io << accent_cff.delete_suffix("\u000E")
+        io << encode_cff_operator(TYPE1_TO_CFF[:endchar])
+      rescue StandardError
         encode_cff_operator(TYPE1_TO_CFF[:endchar])
       end
 

data/lib/fontisan/type1/conversion_options.rb

@@ -99,10 +99,11 @@ module Fontisan
         @autohint
       end
 
-      # Convert to hash
+      # Expose the options as a Hash. Internal accessor for code that
+      # passes options as a plain Hash (e.g., to legacy generators).
       #
       # @return [Hash] Options as hash
-      def to_hash
+      def options_hash
         {
           upm_scale: @upm_scale,
           encoding: @encoding,

data/lib/fontisan/type1/decryptor.rb

@@ -112,7 +112,7 @@ module Fontisan
         return "" if data.nil? || data.empty?
 
         # Ensure binary encoding before concatenation
-        data = data.b if data.respond_to?(:b)
+        data = data.b
 
         # Prepend lenIV random bytes
         if len_iv.positive?