fontisan 0.4.46 → 0.4.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1866983941321f8342976513ef0fb988454641cd88e677c9f8ea5c5811fe4368
-  data.tar.gz: 959ca2b7cec09514b960b1f9c649ca9b6f3d9716dfd87c31dfa8155ae54d6ac2
+  metadata.gz: 999790a5a5e57d822deee3a86f540b3dac9b8bef06c234c883cfaacb87e9f0b1
+  data.tar.gz: c376a3129b02bec87f5754656a66bef27695e0f445ef5740a60dc8a60013b71e
 SHA512:
-  metadata.gz: 8515b8d576d88acd19737ccfb14fc5aea468c7ac94b1242beb09757a6a45c11f9846caf8e64df1558ccd472f31a74ceee3fae415471861c8fe0b0520802d86fd
-  data.tar.gz: b025f9cb74a3a4059367d33453113838fbde355ff434f51879a97d19a134e5753d640b6b2460741d3999a69b79ce16e5bc78db3e5e6e929e85974a77e5cebca2
+  metadata.gz: 481c4a053c4aece81d321e5bc6f76abb7633f6f2d987c901bcba4587dbed9a40462dd192a9f9cd71166114b0a5c0fc6bbc628e7cb71b1c043423cf321bca19ec
+  data.tar.gz: b367817e918c9ec6de0e346180c9e45f2a2afa73d4c223997357e7b2d38ed445ce04aff98b05da36e1d297d63a71c29728c0e8e9807a79c2567a2c47b9544645

data/lib/fontisan/pipeline/transformation_pipeline.rb

@@ -216,7 +216,7 @@ module Fontisan
         return tables if source_format == target
 
         # Use FormatConverter for outline conversion
-        if needs_outline_conversion?(source_format, target) || target == :svg
+        if needs_outline_conversion?(tables, target) || target == :svg
           converter = Converters::FormatConverter.new
           # Create temporary font object from tables
           font = build_font_from_tables(tables, source_format)
@@ -229,16 +229,18 @@ module Fontisan
 
       # Check if outline conversion is needed
       #
-      # @param source [Symbol] Source format
+      # TTF <-> OTF changes the outline format. WOFF/WOFF2 targets only
+      # repackage whichever outlines the font already has.
+      #
+      # @param tables [Hash] Font tables (their outlines decide the source)
       # @param target [Symbol] Target format
       # @return [Boolean] True if outline conversion needed
-      def needs_outline_conversion?(source, target)
-        # TTF ↔ OTF requires outline conversion
-        ttf_formats = %i[ttf ttc woff woff2]
-        otf_formats = %i[otf otc]
+      def needs_outline_conversion?(tables, target)
+        target_outline = { ttf: :glyf, ttc: :glyf, otf: :cff, otc: :cff }[target]
+        return false unless target_outline
 
-        (ttf_formats.include?(source) && otf_formats.include?(target)) ||
-          (otf_formats.include?(source) && ttf_formats.include?(target))
+        source_outline = tables.key?("glyf") ? :glyf : :cff
+        source_outline != target_outline
       end
 
       # Write output font file

data/lib/fontisan/pipeline.rb

@@ -6,7 +6,7 @@ module Fontisan
   module Pipeline
     autoload :FormatDetector, "fontisan/pipeline/format_detector"
     autoload :OutputWriter, "fontisan/pipeline/output_writer"
-    autoload :Strategies, "fontisan/pipeline/strategies/base_strategy"
+    autoload :Strategies, "fontisan/pipeline/strategies"
     autoload :TransformationPipeline,
              "fontisan/pipeline/transformation_pipeline"
     autoload :VariationResolver, "fontisan/pipeline/variation_resolver"

data/lib/fontisan/tables/glyf.rb

@@ -241,13 +241,11 @@ module Fontisan
         glyph = glyph_for(glyph_id, loca, head)
         return true if glyph.nil? # Empty glyphs are OK
 
-        # Simple glyphs: contours should be >= 0
-        # Compound glyphs: numberOfContours = -1
+        # Simple glyphs: contours must be >= 0. Compound glyphs always have
+        # numberOfContours = -1; CompoundGlyph.parse rejects anything else.
         case glyph
-        when SimpleGlyph, CompoundGlyph
-          glyph.num_contours >= -1
-        else
-          true
+        when SimpleGlyph then glyph.num_contours >= 0
+        else true
         end
       rescue StandardError
         false

data/lib/fontisan/validators/opentype_validator.rb

@@ -44,7 +44,7 @@ module Fontisan
           glyf = font.table("glyf")
           next true unless glyf # Skip if CFF font
 
-          loca = font.table("loca")
+          loca = parsed_loca(font)
           head = font.table("head")
           maxp = font.table("maxp")
           glyf.all_glyphs_accessible?(loca, head, maxp.num_glyphs)
@@ -55,7 +55,7 @@ module Fontisan
           glyf = font.table("glyf")
           next true unless glyf
 
-          loca = font.table("loca")
+          loca = parsed_loca(font)
           head = font.table("head")
           maxp = font.table("maxp")
           glyf.no_clipped_glyphs?(loca, head, maxp.num_glyphs)
@@ -66,7 +66,7 @@ module Fontisan
           glyf = font.table("glyf")
           next true unless glyf
 
-          loca = font.table("loca")
+          loca = parsed_loca(font)
           head = font.table("head")
           maxp = font.table("maxp")
 
@@ -101,6 +101,16 @@ module Fontisan
           true # Placeholder - actual checksum validation if desired
         end
       end
+
+      # loca must be parsed with head/maxp context before glyf can read it.
+      def parsed_loca(font)
+        loca = font.table("loca")
+        return loca if loca.parsed?
+
+        loca.parse_with_context(font.table("head").index_to_loc_format,
+                                font.table("maxp").num_glyphs)
+        loca
+      end
     end
   end
 end

data/lib/fontisan/variable/instancer.rb

@@ -25,12 +25,6 @@ module Fontisan
       # @return [Object] The variable font object
       attr_reader :font
 
-      # @return [DeltaApplicator] Delta applicator
-      attr_reader :delta_applicator
-
-      # @return [StaticFontBuilder] Static font builder
-      attr_reader :static_font_builder
-
       # Initialize the instancer
       #
       # @param font [TrueTypeFont, OpenTypeFont] Variable font object
@@ -38,9 +32,6 @@ module Fontisan
       def initialize(font)
         @font = font
         validate_variable_font!
-
-        @delta_applicator = DeltaApplicator.new(font)
-        @static_font_builder = StaticFontBuilder.new(font)
       end
 
       # Generate static font instance at specified coordinates
@@ -53,21 +44,10 @@ module Fontisan
       #
       # @example
       #   binary = instancer.instance({ "wght" => 700, "wdth" => 100 })
-      def instance(user_coords, options = {})
-        # Apply deltas to get all varied data
-        delta_result = @delta_applicator.apply(user_coords)
-
-        # Collect varied metrics for all glyphs
-        varied_metrics = collect_varied_glyph_metrics(
-          delta_result[:normalized_coords],
-          delta_result[:region_scalars],
-        )
-
-        # Extract font-level metrics
-        font_metrics = delta_result[:font_metrics]
-
-        # Build static font
-        @static_font_builder.build(varied_metrics, font_metrics, options)
+      def instance(user_coords, _options = {})
+        tables = Variation::Instancing::TrueTypeInstancer
+          .new(@font.table_data, user_coords).call
+        FontWriter.write_font(tables)
       end
 
       # Generate static font instance and write to file
@@ -117,23 +97,16 @@ module Fontisan
       # @return [Array<Hash>] Array of named instance information
       #   [{ name: "Bold", coords: { "wght" => 700 } }, ...]
       def named_instances
-        fvar = load_fvar_table
-        return [] unless fvar
-
-        # Get name table for instance names
-        name_table = load_name_table
-
-        fvar.instances.map do |instance|
-          coords = extract_instance_coords(instance, fvar)
-          name = if name_table
-                   get_instance_name(instance[:name_id],
-                                     name_table)
-                 end
-
+        fvar = @font.table_data["fvar"]
+        names = if @font.table_data["name"]
+                  Variation::Instancing::NameRewriter.new(@font.table_data["name"])
+                end
+        tags = axis_tags
+        Variation::Instancing::AxisSpace.named_instances(fvar).map do |inst|
           {
-            name_id: instance[:name_id],
-            name: name || "Instance #{instance[:name_id]}",
-            coordinates: coords,
+            name_id: inst[:name_id],
+            name: names&.lookup(inst[:name_id]) || "Instance #{inst[:name_id]}",
+            coordinates: tags.zip(inst[:values]).to_h,
           }
         end
       end
@@ -142,21 +115,21 @@ module Fontisan
       #
       # @return [Boolean] True if variable font
       def variable_font?
-        @delta_applicator.variable_font?
+        true
       end
 
       # Get available axis information
       #
-      # @return [Hash] Axis information
+      # @return [Array<Variation::Instancing::AxisSpace::Axis>]
       def axes
-        @delta_applicator.axes
+        axis_space.axes
       end
 
       # Get available axis tags
       #
       # @return [Array<String>] Array of axis tags
       def axis_tags
-        @delta_applicator.axis_tags
+        axis_space.tags
       end
 
       private
@@ -165,60 +138,16 @@ module Fontisan
       #
       # @raise [ArgumentError] If not a variable font
       def validate_variable_font!
-        fvar_data = @font.table_data("fvar")
+        fvar_data = @font.table_data["fvar"]
         return unless fvar_data.nil? || fvar_data.empty?
 
         raise ArgumentError, "Font is not a variable font (missing fvar table)"
       end
 
-      # Collect varied metrics for all glyphs
-      #
-      # @param normalized_coords [Hash] Normalized coordinates
-      # @param region_scalars [Array<Float>] Region scalars
-      # @return [Hash<Integer, Hash>] Varied metrics by glyph ID
-      def collect_varied_glyph_metrics(normalized_coords, _region_scalars)
-        varied_metrics = {}
-
-        # Get number of glyphs
-        maxp = load_maxp_table
-        return varied_metrics unless maxp
-
-        num_glyphs = maxp.num_glyphs
-
-        # Get original hmtx metrics
-        hmtx = load_hmtx_table
-        return varied_metrics unless hmtx
-
-        # For each glyph, calculate varied metrics
-        num_glyphs.times do |glyph_id|
-          original_metric = hmtx.metric_for(glyph_id)
-          next unless original_metric
-
-          # Get deltas from delta applicator
-          deltas = @delta_applicator.apply_glyph(glyph_id, normalized_coords)
-          metric_deltas = deltas[:metric_deltas]
-
-          # Calculate varied values
-          varied_metric = {
-            advance_width: original_metric[:advance_width],
-            lsb: original_metric[:lsb],
-          }
-
-          # Apply horizontal deltas if present
-          if metric_deltas[:horizontal]
-            if metric_deltas[:horizontal][:advance_width]
-              varied_metric[:advance_width] += metric_deltas[:horizontal][:advance_width]
-            end
-
-            if metric_deltas[:horizontal][:lsb]
-              varied_metric[:lsb] += metric_deltas[:horizontal][:lsb]
-            end
-          end
-
-          varied_metrics[glyph_id] = varied_metric
-        end
-
-        varied_metrics
+      def axis_space
+        @axis_space ||= Variation::Instancing::AxisSpace.new(
+          @font.table_data["fvar"], @font.table_data["avar"]
+        )
       end
 
       # Find coordinates for a named instance
@@ -237,105 +166,6 @@ module Fontisan
 
         instance[:coordinates]
       end
-
-      # Extract coordinates from instance record
-      #
-      # @param instance [Hash] Instance record
-      # @param fvar [Fvar] fvar table
-      # @return [Hash<String, Float>] Coordinates by axis tag
-      def extract_instance_coords(instance, fvar)
-        coords = {}
-        instance[:coordinates].each_with_index do |value, index|
-          axis = fvar.axes[index]
-          coords[axis.axis_tag.to_s] = value if axis
-        end
-        coords
-      end
-
-      # Get instance name from name table
-      #
-      # @param name_id [Integer] Name table ID
-      # @param name_table [Name] name table
-      # @return [String, nil] Instance name
-      def get_instance_name(name_id, name_table)
-        # Try to get English name
-        record = name_table.records.find do |r|
-          r.name_id == name_id && r.language_id == 0x0409 # English (US)
-        end
-
-        record ||= name_table.records.find { |r| r.name_id == name_id }
-        record&.value
-      rescue StandardError
-        nil
-      end
-
-      # Load fvar table
-      #
-      # @return [Fvar, nil] fvar table or nil
-      def load_fvar_table
-        data = @font.table_data("fvar")
-        return nil if data.nil? || data.empty?
-
-        Tables::Fvar.read(data)
-      rescue StandardError
-        nil
-      end
-
-      # Load name table
-      #
-      # @return [Name, nil] name table or nil
-      def load_name_table
-        data = @font.table_data("name")
-        return nil if data.nil? || data.empty?
-
-        Tables::Name.read(data)
-      rescue StandardError
-        nil
-      end
-
-      # Load maxp table
-      #
-      # @return [Maxp, nil] maxp table or nil
-      def load_maxp_table
-        data = @font.table_data("maxp")
-        return nil if data.nil? || data.empty?
-
-        Tables::Maxp.read(data)
-      rescue StandardError
-        nil
-      end
-
-      # Load hmtx table
-      #
-      # @return [Hmtx, nil] hmtx table or nil
-      def load_hmtx_table
-        data = @font.table_data("hmtx")
-        return nil if data.nil? || data.empty?
-
-        hmtx = Tables::Hmtx.read(data)
-
-        # Parse with context
-        hhea = load_hhea_table
-        maxp = load_maxp_table
-        return nil unless hhea && maxp
-
-        hmtx.parse_with_context(hhea.number_of_h_metrics, maxp.num_glyphs)
-        hmtx
-      rescue StandardError
-        nil
-      end
-
-      # Load hhea table
-      #
-      # @return [Hhea, nil] hhea table or nil
-      def load_hhea_table
-        data = @font.table_data("hhea")
-        return nil if data.nil? || data.empty?
-
-        Tables::Hhea.read(data)
-      rescue StandardError
-        nil
-      end
     end
   end
 end

data/lib/fontisan/variation/instance_generator.rb

@@ -54,29 +54,12 @@ module Fontisan
 
       # Generate static font instance
       #
-      # Applies variation deltas and returns static font tables.
+      # Applies gvar/HVAR deltas at the coordinates to the outlines and
+      # metrics and drops the variation tables. TrueType (gvar) fonts only.
       #
       # @return [Hash<String, String>] Map of table tags to binary data
       def generate
-        # Start with base font tables
-        tables = @font.table_data.dup
-
-        # Determine variation type
-        if has_variation_table?("gvar")
-          # TrueType outlines with gvar
-          apply_gvar_deltas(tables)
-        elsif has_variation_table?("CFF2")
-          # PostScript outlines with CFF2 blend
-          apply_cff2_blend(tables)
-        end
-
-        # Apply metrics variations if present
-        apply_metrics_deltas(tables) if @context.has_metrics_variations?
-
-        # Remove variation-specific tables to create static font
-        remove_variation_tables(tables)
-
-        tables
+        Instancing::TrueTypeInstancer.new(@font.table_data, @coordinates).call
       end
 
       # Generate a named instance
@@ -96,135 +79,6 @@ module Fontisan
         generate
       end
 
-      # Apply gvar deltas to TrueType outlines
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_gvar_deltas(_tables)
-        gvar = variation_table("gvar")
-        glyf = @font.table("glyf")
-        return unless gvar && glyf
-
-        # Get glyph count
-        maxp = @font.table("maxp")
-        glyph_count = maxp ? maxp.num_glyphs : gvar.glyph_count
-
-        # Process each glyph
-        glyph_count.times do |glyph_id|
-          apply_glyph_deltas(glyph_id, gvar, glyf)
-        end
-
-        # Rebuild glyf and loca tables with adjusted outlines
-        # This is a placeholder - full implementation would reconstruct tables
-      end
-
-      # Apply deltas to a specific glyph
-      #
-      # @param glyph_id [Integer] Glyph ID
-      # @param gvar [Gvar] Gvar table
-      # @param glyf [Glyf] Glyf table
-      def apply_glyph_deltas(glyph_id, gvar, _glyf)
-        # Get tuple variations for this glyph
-        tuple_data = gvar.glyph_tuple_variations(glyph_id)
-        return unless tuple_data
-
-        # Match tuples to current coordinates
-        matches = @context.region_matcher.match_tuples(
-          coordinates: @coordinates,
-          tuples: tuple_data[:tuples],
-        )
-
-        nil if matches.empty?
-
-        # Get base glyph outline
-        # Apply matched deltas with their scalars
-        # This is a placeholder - full implementation would:
-        # 1. Parse glyph outline points
-        # 2. Parse delta data for each tuple
-        # 3. Apply: new_point = base_point + Σ(delta * scalar)
-        # 4. Update glyph outline
-      end
-
-      # Apply CFF2 blend operators
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_cff2_blend(_tables)
-        cff2 = variation_table("CFF2")
-        return unless cff2
-
-        # Set number of axes for CFF2
-        cff2.num_axes = @context.axis_count
-
-        # Process each glyph's CharString
-        glyph_count = cff2.glyph_count
-        return if glyph_count.zero?
-
-        # Calculate variation scalars once
-        calculate_variation_scalars
-
-        # Apply blend to each glyph
-        # This is a placeholder - full implementation would:
-        # 1. Parse CharString with blend operators
-        # 2. Apply scalars to blend operands
-        # 3. Rebuild CharStrings without blend operators
-        # 4. Update CFF2 table
-      end
-
-      # Calculate variation scalars for current coordinates
-      #
-      # @return [Array<Float>] Scalars for each axis
-      def calculate_variation_scalars
-        @context.axes.map do |axis|
-          coord = @coordinates[axis.axis_tag] || axis.default_value
-          @context.interpolator.normalize_coordinate(coord, axis.axis_tag)
-        end
-      end
-
-      # Apply metrics variations
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_metrics_deltas(tables)
-        # Apply HVAR (horizontal metrics)
-        apply_hvar_deltas(tables) if has_variation_table?("HVAR")
-
-        # Apply VVAR (vertical metrics)
-        apply_vvar_deltas(tables) if has_variation_table?("VVAR")
-
-        # Apply MVAR (font-wide metrics)
-        apply_mvar_deltas(tables) if has_variation_table?("MVAR")
-      end
-
-      # Apply HVAR deltas to horizontal metrics
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_hvar_deltas(_tables)
-        adjuster = MetricsAdjuster.new(@font, @context.interpolator)
-        adjuster.apply_hvar_deltas(@coordinates)
-      end
-
-      # Apply VVAR deltas to vertical metrics
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_vvar_deltas(_tables)
-        adjuster = MetricsAdjuster.new(@font, @context.interpolator)
-        adjuster.apply_vvar_deltas(@coordinates)
-      end
-
-      # Apply MVAR deltas to font-wide metrics
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def apply_mvar_deltas(_tables)
-        adjuster = MetricsAdjuster.new(@font, @context.interpolator)
-        adjuster.apply_mvar_deltas(@coordinates)
-      end
-
-      # Remove variation tables from static font
-      #
-      # @param tables [Hash<String, String>] Font tables
-      def remove_variation_tables(tables)
-        variation_tables = %w[fvar gvar cvar HVAR VVAR MVAR avar STAT]
-        variation_tables.each { |tag| tables.delete(tag) }
-      end
-
       # Interpolate a single value
       #
       # @param base_value [Numeric] Base value