fontisan 0.2.0 → 0.2.1

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "charstring_parser"
+require_relative "charstring_builder"
+require_relative "index_builder"
+
+module Fontisan
+  module Tables
+    class Cff
+      # Rebuilds CharStrings INDEX with modified CharStrings
+      #
+      # CharStringRebuilder provides high-level interface for modifying
+      # CharStrings in a CFF font. It extracts all CharStrings from the source
+      # INDEX, allows modifications through a callback, and rebuilds the INDEX
+      # with updated CharString data.
+      #
+      # Use Cases:
+      # - Per-glyph hint injection
+      # - CharString optimization
+      # - Subroutine insertion
+      # - Any operation requiring CharString modification
+      #
+      # @example Inject hints into specific glyphs
+      #   rebuilder = CharStringRebuilder.new(charstrings_index)
+      #   rebuilder.modify_charstring(42) do |operations|
+      #     # Insert hint operations at beginning
+      #     hint_ops = [
+      #       { type: :operator, name: :hstem, operands: [10, 20] }
+      #     ]
+      #     hint_ops + operations
+      #   end
+      #   new_index_data = rebuilder.rebuild
+      class CharStringRebuilder
+        # @return [CharstringsIndex] Source CharStrings INDEX
+        attr_reader :source_index
+
+        # @return [Hash] Modified CharString data by glyph index
+        attr_reader :modifications
+
+        # Initialize rebuilder with source CharStrings INDEX
+        #
+        # @param source_index [CharstringsIndex] Source CharStrings INDEX
+        # @param stem_count [Integer] Number of stem hints (for parsing hintmask)
+        def initialize(source_index, stem_count: 0)
+          @source_index = source_index
+          @stem_count = stem_count
+          @modifications = {}
+        end
+
+        # Modify a CharString by glyph index
+        #
+        # The block receives the parsed operations for the glyph and should
+        # return modified operations.
+        #
+        # @param glyph_index [Integer] Glyph index (0 = .notdef)
+        # @yield [operations] Block to modify operations
+        # @yieldparam operations [Array<Hash>] Parsed operations
+        # @yieldreturn [Array<Hash>] Modified operations
+        def modify_charstring(glyph_index, &block)
+          # Get original CharString data
+          original_data = @source_index[glyph_index]
+          return unless original_data
+
+          # Parse to operations
+          parser = CharStringParser.new(original_data, stem_count: @stem_count)
+          operations = parser.parse
+
+          # Apply modification
+          modified_operations = block.call(operations)
+
+          # Build new CharString
+          new_data = CharStringBuilder.build_from_operations(modified_operations)
+
+          # Store modification
+          @modifications[glyph_index] = new_data
+        end
+
+        # Rebuild CharStrings INDEX with modifications
+        #
+        # Creates new INDEX with modified CharStrings, keeping unmodified
+        # CharStrings unchanged.
+        #
+        # @return [String] Binary CharStrings INDEX data
+        def rebuild
+          # Collect all CharString data (modified and unmodified)
+          charstrings = []
+
+          (0...@source_index.count).each do |i|
+            if @modifications.key?(i)
+              # Use modified CharString
+              charstrings << @modifications[i]
+            else
+              # Use original CharString
+              charstrings << @source_index[i]
+            end
+          end
+
+          # Build INDEX
+          IndexBuilder.build(charstrings)
+        end
+
+        # Batch modify multiple CharStrings
+        #
+        # More efficient than calling modify_charstring multiple times.
+        #
+        # @param glyph_indices [Array<Integer>] Glyph indices to modify
+        # @yield [glyph_index, operations] Block to modify each glyph
+        # @yieldparam glyph_index [Integer] Current glyph index
+        # @yieldparam operations [Array<Hash>] Parsed operations
+        # @yieldreturn [Array<Hash>] Modified operations
+        def batch_modify(glyph_indices, &block)
+          glyph_indices.each do |glyph_index|
+            modify_charstring(glyph_index) do |operations|
+              block.call(glyph_index, operations)
+            end
+          end
+        end
+
+        # Modify all CharStrings
+        #
+        # Applies the same modification to every glyph.
+        #
+        # @yield [glyph_index, operations] Block to modify each glyph
+        # @yieldparam glyph_index [Integer] Current glyph index
+        # @yieldparam operations [Array<Hash>] Parsed operations
+        # @yieldreturn [Array<Hash>] Modified operations
+        def modify_all(&block)
+          (0...@source_index.count).each do |i|
+            modify_charstring(i) do |operations|
+              block.call(i, operations)
+            end
+          end
+        end
+
+        # Get CharString data (modified or original)
+        #
+        # @param glyph_index [Integer] Glyph index
+        # @return [String] CharString binary data
+        def charstring_data(glyph_index)
+          @modifications[glyph_index] || @source_index[glyph_index]
+        end
+
+        # Check if glyph has been modified
+        #
+        # @param glyph_index [Integer] Glyph index
+        # @return [Boolean] True if modified
+        def modified?(glyph_index)
+          @modifications.key?(glyph_index)
+        end
+
+        # Get count of modified glyphs
+        #
+        # @return [Integer] Number of modified glyphs
+        def modification_count
+          @modifications.size
+        end
+
+        # Clear all modifications
+        def clear_modifications
+          @modifications.clear
+        end
+
+        # Update stem count (needed for hintmask parsing)
+        #
+        # @param count [Integer] Number of stem hints
+        def stem_count=(count)
+          @stem_count = count
+        end
+      end
+    end
+  end
+end

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

@@ -52,6 +52,7 @@ module Fontisan
           charstring_type: [12, 6],
           font_matrix: [12, 7],
           stroke_width: [12, 8],
+          font_bbox: 5,
           synthetic_base: [12, 20],
           postscript: [12, 21],
           base_font_name: [12, 22],
@@ -60,6 +61,20 @@ module Fontisan
           subrs: 19,
           default_width_x: 20,
           nominal_width_x: 21,
+          # Hint-related Private DICT operators
+          blue_values: 6,
+          other_blues: 7,
+          family_blues: 8,
+          family_other_blues: 9,
+          std_hw: 10,
+          std_vw: 11,
+          stem_snap_h: [12, 12],
+          stem_snap_v: [12, 13],
+          blue_scale: [12, 9],
+          blue_shift: [12, 10],
+          blue_fuzz: [12, 11],
+          force_bold: [12, 14],
+          language_group: [12, 17],
         }.freeze
 
         # Build DICT structure from hash

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

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative "../../models/hint"
+
+module Fontisan
+  module Tables
+    class Cff
+      # Injects hint operations into CharString operation lists
+      #
+      # HintOperationInjector converts abstract Hint objects into CFF CharString
+      # operations and injects them at the appropriate position. It handles:
+      # - Stem hints (hstem, vstem, hstemhm, vstemhm)
+      # - Hint masks (hintmask with mask data)
+      # - Counter masks (cntrmask with mask data)
+      # - Stack management (hints are stack-neutral)
+      #
+      # **Position Rules:**
+      # - Hints must appear BEFORE any path construction operators
+      # - Width (if present) comes first
+      # - Stem hints come before hintmask/cntrmask
+      # - Once path construction begins, no more hints allowed
+      #
+      # **Stack Neutrality:**
+      # - Hint operators consume their operands
+      # - They don't leave anything on the stack
+      # - Path construction starts with clean stack
+      #
+      # Reference: Type 2 CharString Format Section 4
+      # Adobe Technical Note #5177
+      #
+      # @example Inject hints into a glyph
+      #   injector = HintOperationInjector.new
+      #   hints = [
+      #     Hint.new(type: :stem, data: { position: 100, width: 50, orientation: :horizontal })
+      #   ]
+      #   modified_ops = injector.inject(hints, original_operations)
+      class HintOperationInjector
+        # Initialize injector
+        def initialize
+          @stem_count = 0
+        end
+
+        # Inject hint operations into operation list
+        #
+        # @param hints [Array<Models::Hint>] Hints to inject
+        # @param operations [Array<Hash>] Original CharString operations
+        # @return [Array<Hash>] Modified operations with hints injected
+        def inject(hints, operations)
+          return operations if hints.nil? || hints.empty?
+
+          # Convert hints to operations
+          hint_ops = convert_hints_to_operations(hints)
+          return operations if hint_ops.empty?
+
+          # Find injection point (before first path operator)
+          inject_index = find_injection_point(operations)
+
+          # Insert hint operations
+          operations.dup.insert(inject_index, *hint_ops)
+        end
+
+        # Get stem count after injection (needed for hintmask)
+        #
+        # @return [Integer] Number of stem hints
+        attr_reader :stem_count
+
+        private
+
+        # Convert Hint objects to CharString operations
+        #
+        # @param hints [Array<Models::Hint>] Hints to convert
+        # @return [Array<Hash>] CharString operations
+        def convert_hints_to_operations(hints)
+          operations = []
+          @stem_count = 0
+
+          hints.each do |hint|
+            ops = hint_to_operations(hint)
+            operations.concat(ops)
+          end
+
+          operations
+        end
+
+        # Convert single Hint to operations
+        #
+        # @param hint [Models::Hint] Hint object
+        # @return [Array<Hash>] CharString operations
+        def hint_to_operations(hint)
+          ps_hint = hint.to_postscript
+          return [] if ps_hint.empty?
+
+          case ps_hint[:operator]
+          when :hstem, :vstem
+            stem_operation(ps_hint)
+          when :hstemhm, :vstemhm
+            stem_operation(ps_hint)
+          when :hintmask
+            hintmask_operation(ps_hint)
+          when :counter, :cntrmask
+            # :counter from Hint model maps to :cntrmask in CharStrings
+            cntrmask_operation(ps_hint)
+          else
+            []
+          end
+        end
+
+        # Create stem hint operation
+        #
+        # @param ps_hint [Hash] PostScript hint with :operator and :args
+        # @return [Array<Hash>] CharString operations
+        def stem_operation(ps_hint)
+          operator = ps_hint[:operator]
+          args = ps_hint[:args] || []
+
+          # Each pair of args is one stem
+          @stem_count += args.length / 2
+
+          [{
+            type: :operator,
+            name: operator,
+            operands: args,
+            hint_data: nil
+          }]
+        end
+
+        # Create hintmask operation
+        #
+        # @param ps_hint [Hash] PostScript hint with :operator and :args (mask)
+        # @return [Array<Hash>] CharString operations
+        def hintmask_operation(ps_hint)
+          mask_bytes = ps_hint[:args] || []
+
+          # Convert mask array to binary string
+          hint_data = if mask_bytes.is_a?(Array)
+                        mask_bytes.pack("C*")
+                      elsif mask_bytes.is_a?(String)
+                        mask_bytes
+                      else
+                        ""
+                      end
+
+          [{
+            type: :operator,
+            name: :hintmask,
+            operands: [],
+            hint_data: hint_data
+          }]
+        end
+
+        # Create cntrmask operation
+        #
+        # @param ps_hint [Hash] PostScript hint with :operator and :args (zones)
+        # @return [Array<Hash>] CharString operations
+        def cntrmask_operation(ps_hint)
+          zones = ps_hint[:args] || []
+
+          # Convert zones to binary string
+          hint_data = if zones.is_a?(Array)
+                        zones.pack("C*")
+                      elsif zones.is_a?(String)
+                        zones
+                      else
+                        ""
+                      end
+
+          [{
+            type: :operator,
+            name: :cntrmask,
+            operands: [],
+            hint_data: hint_data
+          }]
+        end
+
+        # Find injection point for hints
+        #
+        # Hints must go before first path construction operator.
+        # Path operators: moveto, lineto, curveto, etc.
+        #
+        # @param operations [Array<Hash>] CharString operations
+        # @return [Integer] Index to insert hints
+        def find_injection_point(operations)
+          # Path construction operators
+          path_operators = %i[
+            rmoveto hmoveto vmoveto
+            rlineto hlineto vlineto
+            rrcurveto rcurveline rlinecurve
+            vvcurveto hhcurveto vhcurveto hvcurveto
+          ]
+
+          # Find first path operator
+          operations.each_with_index do |op, index|
+            return index if path_operators.include?(op[:name])
+          end
+
+          # No path operators found - hints go before endchar
+          operations.each_with_index do |op, index|
+            return index if op[:name] == :endchar
+          end
+
+          # Empty or malformed - inject at start
+          0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff
+      # Recalculates CFF table offsets after structure modifications
+      #
+      # When the Private DICT size changes (e.g., adding hint parameters),
+      # all offsets in the CFF table must be recalculated. This class
+      # computes new offsets based on section sizes.
+      #
+      # CFF Structure (sequential layout):
+      # - Header (fixed size)
+      # - Name INDEX
+      # - Top DICT INDEX (contains offsets to CharStrings and Private DICT)
+      # - String INDEX
+      # - Global Subr INDEX
+      # - CharStrings INDEX
+      # - Private DICT (variable size)
+      # - Local Subr INDEX (optional, within Private DICT)
+      #
+      # Key offsets to recalculate:
+      # - charstrings: Offset from CFF start to CharStrings INDEX
+      # - private: [size, offset] in Top DICT pointing to Private DICT
+      class OffsetRecalculator
+        # Calculate offsets for all CFF sections
+        #
+        # @param sections [Hash] Hash of section_name => binary_data
+        # @return [Hash] Hash of offset information
+        def self.calculate_offsets(sections)
+          offsets = {}
+          pos = 0
+
+          # Track position through CFF structure
+          pos += sections[:header].bytesize
+          pos += sections[:name_index].bytesize
+
+          # Top DICT INDEX starts here
+          offsets[:top_dict_start] = pos
+          pos += sections[:top_dict_index].bytesize
+
+          pos += sections[:string_index].bytesize
+          pos += sections[:global_subr_index].bytesize
+
+          # CharStrings INDEX offset (referenced in Top DICT)
+          offsets[:charstrings] = pos
+          pos += sections[:charstrings_index].bytesize
+
+          # Private DICT offset and size (referenced in Top DICT)
+          offsets[:private] = pos
+          offsets[:private_size] = sections[:private_dict].bytesize
+
+          offsets
+        end
+
+        # Update Top DICT with new offsets
+        #
+        # @param top_dict [Hash] Top DICT data
+        # @param offsets [Hash] Calculated offsets
+        # @return [Hash] Updated Top DICT
+        def self.update_top_dict(top_dict, offsets)
+          updated = top_dict.dup
+          updated[:charstrings] = offsets[:charstrings]
+          updated[:private] = [offsets[:private_size], offsets[:private]]
+          updated
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "dict_builder"
+
+module Fontisan
+  module Tables
+    class Cff
+      # Builds CFF Private DICT with hint parameters
+      #
+      # Private DICT contains font-level hint information used for rendering quality.
+      # This writer validates hint parameters against CFF spec limits and serializes
+      # them into binary DICT format.
+      #
+      # Supported hint parameters:
+      # - blue_values: Alignment zones (max 14 values, pairs)
+      # - other_blues: Additional zones (max 10 values, pairs)
+      # - family_blues: Family alignment zones (max 14 values, pairs)
+      # - family_other_blues: Family zones (max 10 values, pairs)
+      # - std_hw: Standard horizontal stem width
+      # - std_vw: Standard vertical stem width
+      # - stem_snap_h: Horizontal stem snap widths (max 12)
+      # - stem_snap_v: Vertical stem snap widths (max 12)
+      # - blue_scale, blue_shift, blue_fuzz: Overshoot parameters
+      # - force_bold: Bold flag
+      # - language_group: 0=Latin, 1=CJK
+      class PrivateDictWriter
+        # CFF specification limits for hint parameters
+        HINT_LIMITS = {
+          blue_values: { max: 14, pairs: true },
+          other_blues: { max: 10, pairs: true },
+          family_blues: { max: 14, pairs: true },
+          family_other_blues: { max: 10, pairs: true },
+          stem_snap_h: { max: 12 },
+          stem_snap_v: { max: 12 },
+        }.freeze
+
+        # Initialize writer with optional source Private DICT
+        #
+        # @param source_dict [PrivateDict, nil] Source to copy non-hint params from
+        def initialize(source_dict = nil)
+          @params = {}
+          parse_source(source_dict) if source_dict
+        end
+
+        # Update hint parameters
+        #
+        # @param hint_params [Hash] Hint parameters to add/update
+        # @raise [ArgumentError] If parameters are invalid
+        def update_hints(hint_params)
+          validate!(hint_params)
+          @params.merge!(hint_params.transform_keys(&:to_sym))
+        end
+
+        # Serialize to binary DICT format
+        #
+        # @return [String] Binary DICT data
+        def serialize
+          DictBuilder.build(@params)
+        end
+
+        # Get serialized size in bytes
+        #
+        # @return [Integer] Size in bytes
+        def size
+          serialize.bytesize
+        end
+
+        private
+
+        # Parse non-hint parameters from source Private DICT
+        #
+        # @param source_dict [PrivateDict] Source dictionary
+        def parse_source(source_dict)
+          return unless source_dict.respond_to?(:to_h)
+
+          # Extract only non-hint params (subrs, widths)
+          @params = source_dict.to_h.select do |k, _|
+            %i[subrs default_width_x nominal_width_x].include?(k)
+          end
+        end
+
+        # Validate hint parameters against CFF spec
+        #
+        # @param params [Hash] Hint parameters
+        # @raise [ArgumentError] If validation fails
+        def validate!(params)
+          params.each do |key, value|
+            k = key.to_sym
+            validate_hint_param(k, value)
+          end
+        end
+
+        # Validate individual hint parameter
+        #
+        # @param key [Symbol] Parameter name
+        # @param value [Object] Parameter value
+        # @raise [ArgumentError] If validation fails
+        def validate_hint_param(key, value)
+          # Check array limits
+          if HINT_LIMITS[key]
+            raise ArgumentError, "#{key} invalid" unless value.is_a?(Array)
+            raise ArgumentError, "#{key} too long" if value.length > HINT_LIMITS[key][:max]
+            if HINT_LIMITS[key][:pairs] && value.length.odd?
+              raise ArgumentError, "#{key} must be pairs"
+            end
+          end
+
+          # Check value-specific constraints
+          case key
+          when :std_hw, :std_vw
+            raise ArgumentError, "#{key} negative" if value.negative?
+          when :blue_scale
+            raise ArgumentError, "#{key} not positive" if value <= 0
+          when :blue_shift, :blue_fuzz
+            raise ArgumentError, "#{key} invalid" unless value.is_a?(Numeric)
+          when :force_bold
+            raise ArgumentError, "#{key} must be 0 or 1" unless [0, 1].include?(value)
+          when :language_group
+            raise ArgumentError, "#{key} must be 0 or 1" unless [0, 1].include?(value)
+          end
+        end
+      end
+    end
+  end
+end