fontisan 0.2.0 → 0.2.2

data/lib/fontisan/tables/cff/table_builder.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative "private_dict_writer"
+require_relative "offset_recalculator"
+require_relative "index_builder"
+require_relative "dict_builder"
+require_relative "charstring_rebuilder"
+require_relative "hint_operation_injector"
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # Rebuilds CFF table with modifications
+      #
+      # This builder extracts sections from a source CFF table, applies
+      # modifications (e.g., hint parameters to Private DICT), recalculates
+      # offsets, and assembles a new CFF table.
+      #
+      # Process:
+      # 1. Extract all CFF sections (header, indexes, dicts)
+      # 2. Apply modifications to Private DICT
+      # 3. Recalculate offsets (charstrings, private)
+      # 4. Rebuild Top DICT INDEX with new offsets
+      # 5. Reassemble all sections into new CFF table
+      #
+      # @example Rebuild with hints
+      #   new_cff = TableBuilder.rebuild(source_cff, {
+      #     private_dict_hints: { blue_values: [-15, 0], std_hw: 70 }
+      #   })
+      class TableBuilder
+        # Rebuild CFF table with modifications
+        #
+        # @param source_cff [Cff] Source CFF table
+        # @param modifications [Hash] Modifications to apply
+        # @return [String] Binary CFF table data
+        def self.rebuild(source_cff, modifications = {})
+          new(source_cff).tap do |builder|
+            builder.apply_modifications(modifications)
+          end.serialize
+        end
+
+        # Initialize with source CFF
+        #
+        # @param source_cff [Cff] Source CFF table
+        def initialize(source_cff)
+          @source = source_cff
+          @sections = extract_sections
+        end
+
+        # Apply modifications to CFF structure
+        #
+        # @param mods [Hash] Modifications hash
+        def apply_modifications(mods)
+          update_private_dict(mods[:private_dict_hints]) if mods[:private_dict_hints]
+          update_charstrings(mods[:per_glyph_hints]) if mods[:per_glyph_hints]
+        end
+
+        # Serialize to binary CFF table
+        #
+        # @return [String] Binary CFF data
+        def serialize
+          # Calculate initial offsets
+          offsets = OffsetRecalculator.calculate_offsets(@sections)
+          top_dict = extract_top_dict_data
+          updated = OffsetRecalculator.update_top_dict(top_dict, offsets)
+          rebuild_top_dict_index(updated)
+
+          # Recalculate after Top DICT rebuild (size may change)
+          offsets = OffsetRecalculator.calculate_offsets(@sections)
+          updated = OffsetRecalculator.update_top_dict(top_dict, offsets)
+          rebuild_top_dict_index(updated)
+
+          assemble
+        end
+
+        private
+
+        # Extract all CFF sections from source
+        #
+        # @return [Hash] Hash of section_name => binary_data
+        def extract_sections
+          {
+            header: extract_header,
+            name_index: extract_index(@source.name_index),
+            top_dict_index: extract_index(@source.top_dict_index),
+            string_index: extract_index(@source.string_index),
+            global_subr_index: extract_index(@source.global_subr_index),
+            charstrings_index: extract_index(@source.charstrings_index(0)),
+            private_dict: extract_private_dict,
+          }
+        end
+
+        # Extract header bytes
+        #
+        # @return [String] Binary header data
+        def extract_header
+          @source.raw_data[0, @source.header.hdr_size]
+        end
+
+        # Extract INDEX as binary data
+        #
+        # @param index [Index] INDEX object
+        # @return [String] Binary INDEX data
+        def extract_index(index)
+          return [0].pack("n") if index.nil? || index.count.zero?
+
+          start = index.instance_variable_get(:@start_offset)
+          io = StringIO.new(@source.raw_data)
+          io.seek(start)
+
+          count = io.read(2).unpack1("n")
+          return [0].pack("n") if count.zero?
+
+          off_size = io.read(1).unpack1("C")
+          offset_array_size = (count + 1) * off_size
+
+          # Read last offset to determine data size
+          io.seek(start + 3 + count * off_size)
+          last_offset = read_offset(io, off_size)
+          data_size = last_offset - 1
+
+          # Read entire INDEX
+          io.seek(start)
+          io.read(3 + offset_array_size + data_size)
+        end
+
+        # Extract Private DICT bytes
+        #
+        # @return [String] Binary Private DICT data
+        def extract_private_dict
+          priv_info = @source.top_dict(0).private
+          return "".b unless priv_info
+
+          size, offset = priv_info
+          @source.raw_data[offset, size]
+        end
+
+        # Update Private DICT with hints
+        #
+        # @param hints [Hash] Hint parameters
+        def update_private_dict(hints)
+          source_priv = @source.private_dict(0)
+          writer = PrivateDictWriter.new(source_priv)
+          writer.update_hints(hints)
+          @sections[:private_dict] = writer.serialize
+        end
+
+        # Update CharStrings with per-glyph hints
+        #
+        # @param per_glyph_hints [Hash] Hash of glyph_id => Array<Hint>
+        def update_charstrings(per_glyph_hints)
+          return if per_glyph_hints.nil? || per_glyph_hints.empty?
+
+          # Create CharStringRebuilder
+          charstrings_index = @source.charstrings_index(0)
+          rebuilder = CharStringRebuilder.new(charstrings_index)
+
+          # Inject hints for each glyph
+          per_glyph_hints.each do |glyph_id, hints|
+            injector = HintOperationInjector.new
+
+            rebuilder.modify_charstring(glyph_id) do |operations|
+              # Inject hint operations
+              injector.inject(hints, operations)
+            end
+          end
+
+          # Rebuild CharStrings INDEX
+          @sections[:charstrings_index] = rebuilder.rebuild
+        end
+
+        # Extract Top DICT data as hash
+        #
+        # @return [Hash] Top DICT parameters
+        def extract_top_dict_data
+          @source.top_dict(0).to_h
+        end
+
+        # Rebuild Top DICT INDEX with updated data
+        #
+        # @param data [Hash] Top DICT parameters
+        def rebuild_top_dict_index(data)
+          dict_bytes = DictBuilder.build(data)
+          @sections[:top_dict_index] = IndexBuilder.build([dict_bytes])
+        end
+
+        # Assemble all sections into CFF table
+        #
+        # @return [String] Binary CFF table
+        def assemble
+          output = StringIO.new("".b)
+          output.write(@sections[:header])
+          output.write(@sections[:name_index])
+          output.write(@sections[:top_dict_index])
+          output.write(@sections[:string_index])
+          output.write(@sections[:global_subr_index])
+          output.write(@sections[:charstrings_index])
+          output.write(@sections[:private_dict])
+          output.string
+        end
+
+        # Read offset of specified size
+        #
+        # @param io [IO] IO object
+        # @param size [Integer] Offset size (1-4 bytes)
+        # @return [Integer] Offset value
+        def read_offset(io, size)
+          case size
+          when 1 then io.read(1).unpack1("C")
+          when 2 then io.read(2).unpack1("n")
+          when 3
+            bytes = io.read(3).unpack("C*")
+            (bytes[0] << 16) | (bytes[1] << 8) | bytes[2]
+          when 4 then io.read(4).unpack1("N")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff.rb

@@ -479,6 +479,8 @@ module Fontisan
     require_relative "cff/top_dict"
     require_relative "cff/private_dict"
     require_relative "cff/charstring"
+    require_relative "cff/charstring_parser"
+    require_relative "cff/charstring_rebuilder"
     require_relative "cff/charstrings_index"
     require_relative "cff/charset"
     require_relative "cff/encoding"

data/lib/fontisan/tables/cff2/charstring_parser.rb

@@ -68,7 +68,8 @@ module Fontisan
         # @param global_subrs [Cff::Index, nil] Global subroutines INDEX
         # @param local_subrs [Cff::Index, nil] Local subroutines INDEX
         # @param vsindex [Integer] Variation store index (default 0)
-        def initialize(data, num_axes = 0, global_subrs = nil, local_subrs = nil, vsindex = 0)
+        def initialize(data, num_axes = 0, global_subrs = nil,
+local_subrs = nil, vsindex = 0)
           @data = data
           @num_axes = num_axes
           @global_subrs = global_subrs
@@ -123,7 +124,8 @@ module Fontisan
             when :line_to
               [:line_to, cmd[:x], cmd[:y]]
             when :curve_to
-              [:curve_to, cmd[:x1], cmd[:y1], cmd[:x2], cmd[:y2], cmd[:x], cmd[:y]]
+              [:curve_to, cmd[:x1], cmd[:y1], cmd[:x2], cmd[:y2], cmd[:x],
+               cmd[:y]]
             end
           end
         end
@@ -146,7 +148,8 @@ module Fontisan
             end
           end
         rescue StandardError => e
-          raise CorruptedTableError, "Failed to parse CFF2 CharString: #{e.message}"
+          raise CorruptedTableError,
+                "Failed to parse CFF2 CharString: #{e.message}"
         end
 
         # Check if byte is an operator
@@ -165,7 +168,10 @@ module Fontisan
           if first_byte == 12
             # Two-byte operator
             second_byte = @io.getbyte
-            raise CorruptedTableError, "Unexpected end of CharString" if second_byte.nil?
+            if second_byte.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString"
+            end
 
             [12, second_byte]
           else
@@ -305,7 +311,7 @@ module Fontisan
         # @param blend_op [Hash] Blend operation data
         # @param coordinates [Hash<String, Float>] Axis coordinates
         # @return [Array<Float>] Blended values
-        def apply_blend(blend_op, coordinates)
+        def apply_blend(blend_op, _coordinates)
           blend_op[:blends].map do |blend|
             base = blend[:base]
             deltas = blend[:deltas]
@@ -313,7 +319,7 @@ module Fontisan
             # Apply deltas based on coordinates
             # This will be enhanced when we have proper coordinate interpolation
             blended_value = base
-            deltas.each_with_index do |delta, axis_index|
+            deltas.each_with_index do |delta, _axis_index|
               # Placeholder: use normalized coordinate (will be replaced with proper interpolation)
               scalar = 0.0 # Will be calculated by interpolator
               blended_value += delta * scalar
@@ -573,7 +579,7 @@ module Fontisan
         def callsubr
           return if @local_subrs.nil? || @stack.empty?
 
-          subr_index = @stack.pop
+          @stack.pop
           # Implement subroutine call (placeholder)
           @stack.clear
         end
@@ -581,7 +587,7 @@ module Fontisan
         def callgsubr
           return if @global_subrs.nil? || @stack.empty?
 
-          subr_index = @stack.pop
+          @stack.pop
           # Implement global subroutine call (placeholder)
           @stack.clear
         end

data/lib/fontisan/tables/cff2/private_dict_blend_handler.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Private DICT blend handler for CFF2
+      #
+      # Handles blend operators in Private DICT which allow hint parameters
+      # to vary across the design space in variable fonts.
+      #
+      # Blend in Private DICT format:
+      #   base_value delta1 delta2 ... deltaN num_axes blend
+      #
+      # Example for BlueValues with 2 axes:
+      #   -10 2 1   0 1 0   500 10 5   510 12 6   2 blend
+      #   This creates BlueValues that vary across the design space.
+      #
+      # Reference: Adobe Technical Note #5177 (CFF2)
+      #
+      # @example Parsing blend in Private DICT
+      #   handler = PrivateDictBlendHandler.new(private_dict)
+      #   blue_values = handler.parse_blend_array(:blue_values, num_axes: 2)
+      class PrivateDictBlendHandler
+        # @return [Hash] Private DICT data
+        attr_reader :private_dict
+
+        # Initialize handler with Private DICT data
+        #
+        # @param private_dict [Hash] Parsed Private DICT
+        def initialize(private_dict)
+          @private_dict = private_dict
+        end
+
+        # Check if Private DICT contains blend data
+        #
+        # @return [Boolean] True if blend operators are present
+        def has_blend?
+          # In a DICT with blend, values are arrays with blend data
+          @private_dict.values.any? { |v| blend_value?(v) }
+        end
+
+        # Parse blended array (like BlueValues)
+        #
+        # @param key [Symbol, Integer] DICT operator key
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Hash, nil] Parsed blend data or nil if not present
+        def parse_blend_array(key, num_axes:)
+          value = @private_dict[key]
+          return nil unless value.is_a?(Array)
+
+          # Check if this is blend data
+          # Format: base1 delta1_1 ... delta1_N base2 delta2_1 ... delta2_N ...
+          # The array must be divisible by (num_axes + 1)
+          return nil unless value.size % (num_axes + 1) == 0
+
+          num_values = value.size / (num_axes + 1)
+          blends = []
+
+          num_values.times do |i|
+            offset = i * (num_axes + 1)
+            base = value[offset]
+            deltas = value[offset + 1, num_axes] || []
+
+            blends << {
+              base: base,
+              deltas: deltas,
+            }
+          end
+
+          {
+            num_values: num_values,
+            num_axes: num_axes,
+            blends: blends,
+          }
+        end
+
+        # Parse single blended value
+        #
+        # @param key [Symbol, Integer] DICT operator key
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Hash, nil] Parsed blend data or nil if not present
+        def parse_blend_value(key, num_axes:)
+          value = @private_dict[key]
+          return nil unless value.is_a?(Array)
+
+          # Single value format: base delta1 delta2 ... deltaN
+          expected_size = num_axes + 1
+          return nil unless value.size == expected_size
+
+          {
+            base: value[0],
+            deltas: value[1..num_axes],
+            num_axes: num_axes,
+          }
+        end
+
+        # Apply blend at specific coordinates
+        #
+        # @param blend_data [Hash] Parsed blend data
+        # @param scalars [Array<Float>] Region scalars for each axis
+        # @return [Array<Float>, Float] Blended values
+        def apply_blend(blend_data, scalars)
+          return nil unless blend_data
+
+          if blend_data.key?(:blends)
+            # Array of blended values
+            blend_data[:blends].map do |blend|
+              apply_single_blend(blend, scalars)
+            end
+          else
+            # Single blended value
+            apply_single_blend(blend_data, scalars)
+          end
+        end
+
+        # Apply blend to a single value
+        #
+        # @param blend [Hash] Single blend with :base and :deltas
+        # @param scalars [Array<Float>] Region scalars
+        # @return [Float] Blended value
+        def apply_single_blend(blend, scalars)
+          base = blend[:base].to_f
+          deltas = blend[:deltas]
+
+          # Apply formula: result = base + Σ(delta[i] * scalar[i])
+          result = base
+          deltas.each_with_index do |delta, i|
+            scalar = scalars[i] || 0.0
+            result += delta.to_f * scalar
+          end
+
+          result
+        end
+
+        # Get blended Private DICT values at coordinates
+        #
+        # @param num_axes [Integer] Number of variation axes
+        # @param scalars [Array<Float>] Region scalars
+        # @return [Hash] Private DICT with blended values
+        def blended_dict(num_axes:, scalars:)
+          result = {}
+
+          @private_dict.each do |key, value|
+            if value.is_a?(Array) && blend_value?(value)
+              # Try parsing as blend array
+              blend_data = parse_blend_array(key, num_axes: num_axes)
+              if blend_data
+                result[key] = apply_blend(blend_data, scalars)
+              else
+                # Try as single blend value
+                blend_data = parse_blend_value(key, num_axes: num_axes)
+                result[key] =
+                  blend_data ? apply_blend(blend_data, scalars) : value
+              end
+            else
+              # Non-blend value, copy as-is
+              result[key] = value
+            end
+          end
+
+          result
+        end
+
+        # Check if value looks like blend data
+        #
+        # @param value [Object] Value to check
+        # @return [Boolean] True if value could be blend data
+        def blend_value?(value)
+          # Blend values are arrays with multiple elements
+          value.is_a?(Array) && value.size > 1
+        end
+
+        # Rebuild Private DICT with hints injected
+        #
+        # This method prepares Private DICT for rebuilding, preserving
+        # blend operators while incorporating new hint values.
+        #
+        # @param hints [Hash] Hint values to inject
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Hash] Modified Private DICT
+        def rebuild_with_hints(hints, num_axes:)
+          result = @private_dict.dup
+
+          # Inject hint values
+          hints.each do |key, value|
+            if value.is_a?(Hash) && (value.key?(:base) || value.key?("base")) && (value.key?(:deltas) || value.key?("deltas"))
+              # Hint with blend data - normalize and flatten for DICT storage
+              normalized_value = {
+                base: value[:base] || value["base"],
+                deltas: value[:deltas] || value["deltas"],
+              }
+              result[key] = flatten_blend(normalized_value, num_axes: num_axes)
+            else
+              # Simple hint value
+              result[key] = value
+            end
+          end
+
+          result
+        end
+
+        # Flatten blend data to array format
+        #
+        # @param blend_data [Hash] Blend data with :base and :deltas
+        # @param num_axes [Integer] Number of variation axes
+        # @return [Array] Flattened array
+        def flatten_blend(blend_data, num_axes:)
+          if blend_data.key?(:blends)
+            # Array of blends
+            blend_data[:blends].flat_map do |blend|
+              [blend[:base]] + blend[:deltas]
+            end
+          else
+            # Single blend
+            [blend_data[:base]] + blend_data[:deltas]
+          end
+        end
+
+        # Validate blend data structure
+        #
+        # @param num_axes [Integer] Expected number of axes
+        # @return [Array<String>] Validation errors (empty if valid)
+        def validate(num_axes:)
+          errors = []
+
+          @private_dict.each do |key, value|
+            next unless value.is_a?(Array)
+            next unless blend_value?(value)
+
+            # Try parsing as blend array
+            blend_data = parse_blend_array(key, num_axes: num_axes)
+            unless blend_data
+              # Try as single blend value
+              blend_data = parse_blend_value(key, num_axes: num_axes)
+              unless blend_data
+                errors << "Key #{key} has array value that doesn't match " \
+                          "blend format for #{num_axes} axes"
+              end
+            end
+          end
+
+          errors
+        end
+      end
+    end
+  end
+end