fontisan 0.4.43 → 0.4.45

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
-          unless glyph.nil?
+          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

@@ -117,7 +117,7 @@ module Fontisan
         glyph = glyph_for(glyph_id)
         return nil if glyph.nil?
 
-        glyph.num_contours unless glyph.nil?
+        glyph&.num_contours
       end
 
       # Get number of points for a simple glyph

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

@@ -151,10 +151,10 @@ module Fontisan
         return base_cff unless accent_cff
 
         io = String.new(encoding: Encoding::ASCII_8BIT)
-        io << base_cff.sub(/\x0e\z/, "")
+        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.sub(/\x0e\z/, "")
+        io << accent_cff.delete_suffix("\u000E")
         io << encode_cff_operator(TYPE1_TO_CFF[:endchar])
       rescue StandardError
         encode_cff_operator(TYPE1_TO_CFF[:endchar])
@@ -170,7 +170,7 @@ module Fontisan
         !parser.seac_components.nil?
       end
 
-      private
+      # Methods below were private; made public for testability (TODO 30)
 
       # Encode number in CFF format
       #

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?

data/lib/fontisan/type1/generator.rb

@@ -139,32 +139,37 @@ module Fontisan
       def generate
         result = {}
 
+        opts = options_hash
+
         # Always generate AFM
-        result[:afm] = AFMGenerator.generate(@font, to_hash)
+        result[:afm] = AFMGenerator.generate(@font, opts)
 
         # Always generate PFM (for Windows compatibility)
-        result[:pfm] = PFMGenerator.generate(@font, to_hash)
+        result[:pfm] = PFMGenerator.generate(@font, opts)
 
         # Generate PFB or PFA based on format option
         format = @options.format || :pfb
         if format == :pfa
-          result[:pfa] = PFAGenerator.generate(@font, to_hash)
+          result[:pfa] = PFAGenerator.generate(@font, opts)
         else
-          result[:pfb] = PFBGenerator.generate(@font, to_hash)
+          result[:pfb] = PFBGenerator.generate(@font, opts)
         end
 
         # Generate INF for Windows installation
-        result[:inf] = INFGenerator.generate(@font, to_hash)
+        result[:inf] = INFGenerator.generate(@font, opts)
 
         result
       end
 
       private
 
-      # Convert options to hash
+      # Build the options hash forwarded to the per-format generators.
+      # This is an internal adapter — ConversionOptions exposes typed
+      # accessors; the per-format generators accept a Hash for historical
+      # reasons.
       #
       # @return [Hash] Options as hash
-      def to_hash
+      def options_hash
         {
           upm_scale: @options.upm_scale || 1000,
           encoding: @options.encoding || Encodings::AdobeStandard,
@@ -200,8 +205,8 @@ module Fontisan
       # @return [String] Base filename
       def self.extract_base_name(font)
         name_table = font.table(Constants::NAME_TAG)
-        if name_table.respond_to?(:postscript_name)
-          name = name_table.postscript_name(1) || name_table.postscript_name(3)
+        if name_table
+          name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
           return name if name
         end