fontisan 0.4.43 → 0.4.44

data/TODO.bug-fixes/27-table-class-registry.md

@@ -0,0 +1,50 @@
+# 27 — Table class registry (OCP: eliminate case/when tag dispatch)
+
+## Priority
+P2
+
+## Problem
+The codebase has 8+ `case tag` dispatches that map a string tag like
+`"HVAR"` to a Ruby class like `Tables::Hvar`. Each new table requires
+updating every dispatch site. This violates OCP and DRY.
+
+## Sites
+- `lib/fontisan/variable/delta_applicator.rb:269` — case tag → table class
+- `lib/fontisan/variable/static_font_builder.rb:91` — case tag → update method
+- `lib/fontisan/variable/static_font_builder.rb:185` — case tag → table class
+- `lib/fontisan/woff2/table_transformer.rb:36` — case tag → transform strategy
+- `lib/fontisan/woff2/table_transformer.rb:62` — case tag → inverse transform
+- `lib/fontisan/export/ttx_generator.rb:100` — case tag → transformer
+- `lib/fontisan/variation/metrics_adjuster.rb:221` — case tag → metric
+- `lib/fontisan/variation/instance_writer.rb:259` — case tag → writer
+
+## Approach
+Create `Tables::Registry` as a single source of truth for tag → class.
+Each table file registers itself via a `register_tag` call:
+
+```ruby
+# lib/fontisan/tables/hvar.rb
+module Fontisan
+  module Tables
+    class Hvar < Binary::BaseRecord
+      register_tag "HVAR"
+      ...
+    end
+  end
+end
+```
+
+`Tables::Registry.for(tag)` returns the class. Dispatch sites become:
+
+```ruby
+table_class = Tables::Registry.for(tag)
+return nil unless table_class
+```
+
+This is OCP-compliant: adding a new table means adding `register_tag`
+in the table's file, not modifying dispatch sites.
+
+## Acceptance criteria
+- 0 `case tag` dispatches in `lib/fontisan/`
+- All callers use `Tables::Registry.for(tag)` instead
+- All existing specs pass

data/TODO.bug-fixes/28-spec-doubles-cleanup.md

@@ -0,0 +1,40 @@
+# 28 — Spec doubles cleanup
+
+## Priority
+P3
+
+## Problem
+**343 `double()` / `instance_double()` calls remain in specs** despite
+the absolute rule "NEVER use `double()` in specs". Per file:
+
+| File | Count |
+|------|-------|
+| spec/fontisan/converters/type1_converter_spec.rb | 58 |
+| spec/fontisan/converters/format_converter_spec.rb | 33 |
+| spec/fontisan/converters/type1_property_spec.rb | 28 |
+| spec/fontisan/tables/cff2/table_builder_spec.rb | 25 |
+| spec/fontisan/variation/validator_spec.rb | 24 |
+| spec/fontisan/variation/subsetter_spec.rb | 17 |
+| spec/fontisan/variation/metrics_adjuster_spec.rb | 15 |
+| spec/fontisan/variation/converter_spec.rb | 14 |
+| spec/fontisan/collection/variable_font_builder_spec.rb | 12 |
+| spec/fontisan/converters/woff2_encoder_spec.rb | 11 |
+| spec/fontisan/collection/table_deduplicator_spec.rb | 9 |
+| spec/fontisan/collection/table_analyzer_spec.rb | 7 |
+| spec/fontisan/tables/cff/cff_glyph_spec.rb | 6 |
+| spec/fontisan/hints/truetype_hint_extractor_spec.rb | 6 |
+| spec/fontisan/commands/unpack_command_spec.rb | 6 |
+| (other files, 5 or fewer each) | ~74 |
+
+## Approach
+Each spec migration replaces `double("Foo", attr: value)` with either:
+1. A real instance of the doubled class, OR
+2. A `Struct`-based fake in a uniquely-named module (e.g., `XxxFakes::Foo`).
+3. The shared `SpecHelpers::FakeFont` where the double is font-shaped.
+
+PR #135/#136/#137 migrated ~10 spec files this way. The pattern is
+established; remaining files are mechanical work.
+
+## Acceptance criteria
+- 0 `double()` / `instance_double()` in `spec/fontisan/`
+- All specs pass

data/TODO.bug-fixes/29-strategy-registries.md

@@ -0,0 +1,30 @@
+# 29 — Strategy registries for per-tag dispatch (OCP completion)
+
+## Priority
+P2
+
+## Problem
+6 remaining `case tag` dispatches map a table tag to per-table
+behavior (update, transform, emit, etc.). These are OCP violations:
+adding a new table's behavior requires editing every dispatch site.
+
+## Sites
+- `export/ttx_generator.rb:100` — 13-way case → generate_X_table
+- `variable/static_font_builder.rb:91` — 4-way case → update_X_table
+- `variation/instance_writer.rb:259` — 5-way case → table class parse
+- `variation/metrics_adjuster.rb:221` — 5-way case → MVAR metric
+- `woff2/table_transformer.rb:36` — 3-way case → transform_X
+- `woff2/table_transformer.rb:62` — 3-way case → transform version
+
+## Approach
+Each case/when becomes a class-level dispatch hash mapping tag →
+method name. The dispatch site reads from the hash. Adding a new
+table means adding one line to the hash in the same file.
+
+For dispatches that use `Tables::Registry.for(tag)` to look up a
+class (like instance_writer), extend the Registry to also know how
+to construct from raw data.
+
+## Acceptance criteria
+- 0 `case tag` dispatches in `lib/fontisan/`
+- All specs pass

data/TODO.bug-fixes/README.md

@@ -23,3 +23,27 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 - [x] ~~[07 — Encapsulation violations (instance_variable_get/set, send to private)](07-encapsulation-violations.md)~~ ✓ Done (v0.4.42)
 - [x] ~~[08 — respond_to? duck typing violations](08-respond-to-violations.md)~~ ✓ Done (v0.4.42)
 - [x] ~~[11 — Remaining respond_to? violations](11-remaining-respond-to.md)~~ ✓ Done
+
+### P3 — Encapsulation and architecture cleanup (post-#135 audit)
+- [x] ~~[12 — Type 1 generators duck-typing](12-type1-generators-duck-typing.md)~~ ✓ Done (#136)
+- [x] ~~[13 — Hint extractor duck-typing](13-hint-extractor-duck-typing.md)~~ ✓ Done (#136)
+- [x] ~~[14 — Font interface type checks](14-font-interface-type-checks.md)~~ ✓ Done (#136)
+- [x] ~~[15 — Glyph type checks + SimpleGlyph#points bug](15-glyph-type-checks-and-simple-glyph-points-bug.md)~~ ✓ Done (#136)
+- [x] ~~[16 — Variation table checks](16-variation-table-checks.md)~~ ✓ Done (#137)
+- [x] ~~[17 — UFO and Stitcher cleanup](17-ufo-and-stitcher-cleanup.md)~~ ✓ Done (#136)
+- [x] ~~[18 — Generic value and IO checks](18-generic-value-and-io-checks.md)~~ ✓ Done (#137)
+- [x] ~~[19 — Hand-rolled serialization migration to lutaml-model](19-serialization-migration.md)~~ ✓ Done (#137)
+
+### P3 — Final encapsulation cleanup (post-#136 audit)
+- [x] ~~[20 — Variation validator type checks](20-variation-validator-type-checks.md)~~ ✓ Done (#137)
+- [x] ~~[21 — XML builder send() → tag!](21-xml-builder-send.md)~~ ✓ Done (#137)
+- [x] ~~[22 — Type1Converter font_info fields](22-type1-converter-font-info.md)~~ ✓ Done (#137)
+- [x] ~~[23 — Boundary type checks (padding, base_record)](23-boundary-type-checks.md)~~ ✓ Done (#137)
+- [x] ~~[24 — Validator dynamic field_key](24-validator-dynamic-field-key.md)~~ ✓ Done (#137)
+- [x] ~~[25 — Serialization migration to lutaml-model](25-serialization-migration.md)~~ ✓ Done (#137)
+- [x] ~~[26 — Variation preserver spec migration](26-variation-preserver-spec-migration.md)~~ ✓ Done (#137)
+
+### P3 — Architecture polish (post-#137 audit)
+- [x] ~~[27 — Table class registry (OCP: eliminate case/when tag dispatch)](27-table-class-registry.md)~~ ✓ Done (#138)
+- [ ] [28 — Spec doubles cleanup](28-spec-doubles-cleanup.md)
+- [x] ~~[29 — Strategy registries for per-tag dispatch](29-strategy-registries.md)~~ ✓ Done

data/lib/fontisan/binary/base_record.rb

@@ -22,21 +22,22 @@ module Fontisan
     class BaseRecord < BinData::Record
       endian :big # OpenType uses big-endian byte order
 
-      # Override read to handle nil data gracefully
+      # Override read to handle nil/empty/String inputs gracefully.
+      #
+      # String inputs are wrapped in a StringIO so the rest of the
+      # read path always works against an IO-like object.
+      #
+      # @param io [String, IO, StringIO, nil] binary data or IO source
       def self.read(io)
-        return new if io.nil? || (io.respond_to?(:empty?) && io.empty?)
+        return new if io.nil?
+
+        io = StringIO.new(io) if io.is_a?(String)
+        return new if io.is_a?(StringIO) && io.eof?
 
         # Store the original data for later parsing
-        # Convert IO to string if needed
-        if io.is_a?(String)
-          data = io
-          instance = super(StringIO.new(data))
-        else
-          # For IO objects, read to string first
-          data = io.read
-          io.rewind if io.respond_to?(:rewind)
-          instance = super(io)
-        end
+        data = io.read
+        io.rewind
+        instance = super(io)
 
         instance.raw_data = data
         instance

data/lib/fontisan/collection/builder.rb

@@ -56,11 +56,9 @@ module Fontisan
         end
         raise ArgumentError, "fonts must be an array" unless fonts.is_a?(Array)
 
-        unless fonts.all? do |f|
-          f.respond_to?(:table_data)
-        end
+        unless fonts.all?(SfntSource)
           raise ArgumentError,
-                "all fonts must respond to table_data"
+                "all fonts must be SfntSource instances (TrueTypeFont, OpenTypeFont, WoffFont, Woff2Font)"
         end
 
         @fonts = fonts
@@ -320,7 +318,7 @@ module Fontisan
         return [] unless font.has_table?("fvar")
 
         fvar_table = font.table("fvar")
-        return [] unless fvar_table.respond_to?(:axes)
+        return [] unless fvar_table&.axes
 
         fvar_table.axes.map(&:axis_tag).sort
       end

data/lib/fontisan/collection/dfont_builder.rb

@@ -42,8 +42,8 @@ module Fontisan
         end
         raise ArgumentError, "fonts must be an array" unless fonts.is_a?(Array)
 
-        unless fonts.all? { |f| f.respond_to?(:table_data) }
-          raise ArgumentError, "all fonts must respond to table_data"
+        unless fonts.all?(SfntSource)
+          raise ArgumentError, "all fonts must be SfntSource instances"
         end
 
         @fonts = fonts
@@ -150,17 +150,10 @@ module Fontisan
 
       # Detect sfnt version from font
       #
-      # @param font [TrueTypeFont, OpenTypeFont] Font object
+      # @param font [SfntFont] Font object
       # @return [Integer] sfnt version
       def detect_sfnt_version(font)
-        if font.respond_to?(:header) && font.header.respond_to?(:sfnt_version)
-          font.header.sfnt_version
-        elsif font.respond_to?(:table_data)
-          # Auto-detect from tables
-          FontWriter.detect_sfnt_version(font.table_data)
-        else
-          0x00010000 # Default to TrueType
-        end
+        FontWriter.detect_sfnt_version(font.table_data)
       end
 
       # Build resource fork header (16 bytes)

data/lib/fontisan/collection/writer.rb

@@ -213,7 +213,7 @@ module Fontisan
           binary << table_info[:data]
 
           # Pad to 4-byte boundary
-          padding = Utilities::Padding.boundary(table_info[:data])
+          padding = Utilities::Padding.boundary(table_info[:data].bytesize)
           binary << ("\x00" * padding) if padding.positive?
         end
       end

data/lib/fontisan/commands/pack_command.rb

@@ -174,9 +174,9 @@ module Fontisan
       # @param font [Object] Font object
       # @return [Boolean]
       def truetype_font?(font)
-        return false unless font.respond_to?(:header)
+        return false unless font.is_a?(SfntSource)
 
-        sfnt = font.header.sfnt_version
+        sfnt = font.sfnt_version
         [0x00010000, 0x74727565].include?(sfnt) # 0x74727565 = 'true'
       end
 
@@ -185,9 +185,9 @@ module Fontisan
       # @param font [Object] Font object
       # @return [Boolean]
       def opentype_font?(font)
-        return false unless font.respond_to?(:header)
+        return false unless font.is_a?(SfntSource)
 
-        sfnt = font.header.sfnt_version
+        sfnt = font.sfnt_version
         sfnt == 0x4F54544F # 'OTTO'
       end
 

data/lib/fontisan/commands/unpack_command.rb

@@ -207,7 +207,7 @@ module Fontisan
       def generate_filename(font, index)
         # Try to get font name from name table
         base_name = nil
-        if font.respond_to?(:table) && font.table("name")
+        if font.is_a?(SfntSource) && font.table("name")
           name_table = font.table("name")
           # Try to get PostScript name, then family name
           base_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME) ||

data/lib/fontisan/commands/validate_command.rb

@@ -213,7 +213,7 @@ module Fontisan
       # @param index [Integer] Font index (fallback)
       # @return [String] Font name
       def extract_font_name(font, index)
-        return "Font #{index}" unless font.respond_to?(:table)
+        return "Font #{index}" unless font.is_a?(SfntSource)
 
         name_table = font.table("name")
         return "Font #{index}" unless name_table

data/lib/fontisan/converters/format_converter.rb

@@ -412,9 +412,9 @@ _options)
         # rather than the SFNT table interface
         is_type1 = font.is_a?(Type1Font)
 
-        unless is_type1 || font.respond_to?(:table)
+        unless is_type1 || font.is_a?(SfntSource)
           raise ArgumentError,
-                "Font must respond to :table method or be a Type1Font"
+                "Font must be an SfntSource instance or a Type1Font"
         end
 
         unless target_format.is_a?(Symbol)

data/lib/fontisan/converters/glyf_table_builder.rb

@@ -34,7 +34,7 @@ module Fontisan
           glyf_data << glyph_data
 
           # Add padding to 4-byte boundary
-          padding = Utilities::Padding.boundary(glyf_data)
+          padding = Utilities::Padding.boundary(glyf_data.bytesize)
           glyf_data << ("\x00" * padding) if padding.positive?
         end
 

data/lib/fontisan/converters/outline_converter.rb

@@ -275,12 +275,8 @@ module Fontisan
       def validate(font, target_format)
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:tables)
-          raise ArgumentError, "Font must respond to :tables"
-        end
-
-        unless font.respond_to?(:table)
-          raise ArgumentError, "Font must respond to :table"
+        unless font.is_a?(SfntSource)
+          raise ArgumentError, "Font must be an SfntSource instance"
         end
 
         source_format = detect_format(font)

data/lib/fontisan/converters/table_copier.rb

@@ -30,12 +30,8 @@ module Fontisan
       def convert(font, _options = {})
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:tables)
-          raise ArgumentError, "Font must respond to :tables"
-        end
-
-        unless font.respond_to?(:table_data)
-          raise ArgumentError, "Font must respond to :table_data"
+        unless font.is_a?(SfntSource)
+          raise ArgumentError, "Font must be an SfntSource instance"
         end
 
         target_format = detect_format(font)
@@ -73,12 +69,8 @@ module Fontisan
       def validate(font, target_format)
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:tables)
-          raise ArgumentError, "Font must respond to :tables"
-        end
-
-        unless font.respond_to?(:table_data)
-          raise ArgumentError, "Font must respond to :table_data"
+        unless font.is_a?(SfntSource)
+          raise ArgumentError, "Font must be an SfntSource instance"
         end
 
         # Detect source format and verify it matches target

data/lib/fontisan/converters/type1_converter.rb

@@ -112,9 +112,9 @@ module Fontisan
       def validate(font, target_format)
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:font_dictionary) || font.respond_to?(:tables)
+        unless font.is_a?(Type1Font) || font.is_a?(SfntSource)
           raise ArgumentError,
-                "Font must be Type1Font or have :tables method"
+                "Font must be a Type1Font or SfntSource instance"
         end
 
         source_format = detect_format(font)
@@ -156,10 +156,9 @@ module Fontisan
           decompose_seac_glyphs(font)
         end
 
-        # Read all font dictionary records if requested
-        if conv_options.opening_option?(:read_all_records) && font.font_dictionary.respond_to?(:reload)
-          # Ensure full font dictionary is loaded
-          font.font_dictionary.reload
+        # Read all font dictionary records if requested.
+        if conv_options.opening_option?(:read_all_records) && font.font_dictionary
+          font.font_dictionary.parse(font.font_dictionary.raw_data)
         end
       end
 
@@ -219,7 +218,7 @@ module Fontisan
           :otf
         else
           # Try to detect from tables
-          if font.respond_to?(:tables)
+          if font.is_a?(SfntSource)
             if font.tables.key?("glyf")
               :ttf
             elsif font.tables.key?("CFF ") || font.tables.key?("CFF2")
@@ -720,37 +719,13 @@ module Fontisan
 
         # Extract font names with fallbacks
         font_name = font.font_name || font_dict&.font_name || "Unnamed"
-        family_name = if font_info.respond_to?(:family_name)
-                        font_info.family_name || font_dict&.family_name || font_name
-                      else
-                        font_dict&.family_name || font_name
-                      end
-        full_name = if font_info.respond_to?(:full_name)
-                      font_info.full_name || font_dict&.full_name || family_name
-                    else
-                      font_dict&.full_name || family_name
-                    end
-        version = if font_info.respond_to?(:version)
-                    font_info.version || font.version || "001.000"
-                  else
-                    font.version || "001.000"
-                  end
-        copyright = if font_info.respond_to?(:copyright)
-                      font_info.copyright || font_dict&.raw_data&.dig(:copyright) || ""
-                    else
-                      font_dict&.raw_data&.dig(:copyright) || ""
-                    end
+        family_name = font_info&.family_name || font_dict&.family_name || font_name
+        full_name = font_info&.full_name || font_dict&.full_name || family_name
+        version = font_info&.version || font.version || "001.000"
+        copyright = font_info&.copyright || font_dict&.raw_data&.dig(:copyright) || ""
         postscript_name = font_name
-        weight = if font_info.respond_to?(:weight)
-                   font_info.weight
-                 else
-                   "Regular"
-                 end
-        notice = if font_info.respond_to?(:notice)
-                   font_info.notice
-                 else
-                   ""
-                 end
+        weight = font_info&.weight || "Regular"
+        notice = font_info&.notice || ""
 
         # Build name records (Windows Unicode, English US)
         # Platform ID 3 (Windows), Encoding ID 1 (Unicode BMP), Language ID 0x0409 (US English)

data/lib/fontisan/converters/woff2_encoder.rb

@@ -218,7 +218,7 @@ module Fontisan
       # are applied by `Woff2::EncoderRules`, not here — this method is a
       # pure reader.
       def collect_tables(font, _options = {})
-        table_names = if font.respond_to?(:table_names)
+        table_names = if font.is_a?(SfntSource)
                         font.table_names
                       else
                         %w[head hhea maxp OS/2 name cmap post hmtx glyf loca
@@ -247,7 +247,7 @@ module Fontisan
       #
       # @return [Hash{Symbol => Object}, nil]
       def apply_glyf_loca_transform!(table_data, font)
-        return nil unless font.respond_to?(:has_table?)
+        return nil unless font.is_a?(SfntSource)
         return nil unless font.has_table?("glyf") && font.has_table?("loca")
 
         glyf_data = table_data["glyf"]
@@ -310,12 +310,10 @@ module Fontisan
       end
 
       def get_table_data(font, tag)
-        if font.respond_to?(:table_data)
-          font.table_data[tag]
-        elsif font.respond_to?(:table)
-          table = font.table(tag)
-          table&.to_binary_s if table.respond_to?(:to_binary_s)
-        end
+        return font.table_data[tag] if font.is_a?(SfntSource)
+
+        table = font.table(tag)
+        table&.to_binary_s
       end
 
       # Build table directory entries.
@@ -418,7 +416,7 @@ module Fontisan
         size += 16 if glyf_transform # synthetic loca directory entry
 
         table_data.each_value do |data|
-          size += Utilities::Padding.aligned_size(data)
+          size += Utilities::Padding.aligned_size(data.bytesize)
         end
 
         if glyf_transform
@@ -506,7 +504,7 @@ module Fontisan
         # font block MUST be padded with null bytes so the total file
         # length is a multiple of 4. fontTools' WOFF2Writer does the
         # same: `pad(directory + compressedFont, size=4)`.
-        pad = Utilities::Padding.boundary(woff2_data)
+        pad = Utilities::Padding.boundary(woff2_data.bytesize)
         woff2_data << ("\x00" * pad) if pad.positive?
         update_woff2_length!(woff2_data)
         woff2_data

data/lib/fontisan/converters/woff_writer.rb

@@ -113,8 +113,8 @@ module Fontisan
 
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:tables) && font.respond_to?(:table_data)
-          raise ArgumentError, "Font must respond to :tables and :table_data"
+        unless font.is_a?(SfntSource)
+          raise ArgumentError, "Font must be an SfntSource instance"
         end
       end
 
@@ -302,7 +302,7 @@ module Fontisan
       def write_woff_header(io, font, total_size, total_sfnt_size, num_tables,
                            compressed_metadata, metadata_offset, metadata_size,
                            private_offset, private_size)
-        flavor = if font.respond_to?(:cff?) && font.cff?
+        flavor = if font.is_a?(SfntSource) && font.cff?
                    Constants::SFNT_VERSION_OTTO
                  else
                    Constants::SFNT_VERSION_TRUETYPE

data/lib/fontisan/export/exporter.rb

@@ -181,7 +181,7 @@ module Fontisan
       # @return [void]
       def export_binary_fallback(export_model, tag, error)
         table = @font.table(tag)
-        binary_data = table.respond_to?(:to_binary_s) ? table.to_binary_s : ""
+        binary_data = table ? table.to_binary_s : ""
         checksum = calculate_table_checksum(tag)
 
         export_model.add_table(
@@ -201,14 +201,13 @@ module Fontisan
         table_entry = @font.tables.find { |entry| entry.tag == tag }
         return 0 unless table_entry
 
-        if table_entry.respond_to?(:checksum)
-          table_entry.checksum.to_i
-        else
-          # Calculate from binary data
-          table = @font.table(tag)
-          data = table.respond_to?(:to_binary_s) ? table.to_binary_s : ""
-          Utilities::ChecksumCalculator.calculate(data)
-        end
+        checksum = table_entry.checksum
+        return checksum.to_i if checksum
+
+        # Calculate from binary data
+        table = @font.table(tag)
+        data = table ? table.to_binary_s : ""
+        Utilities::ChecksumCalculator.calculate(data)
       end
 
       # Format checksum as hex string