fontisan 0.1.0 → 0.2.1

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require_relative "dict"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF Private DICT structure
+      #
+      # The Private DICT contains glyph-specific hinting and width data.
+      # Each font has its own Private DICT (or multiple for CIDFonts).
+      #
+      # Private DICT Operators:
+      # - blue_values: Alignment zones for overshoot suppression
+      # - other_blues: Additional alignment zones
+      # - family_blues: Family-wide alignment zones
+      # - family_other_blues: Family-wide additional alignment zones
+      # - blue_scale: Point size for overshoot suppression
+      # - blue_shift: Pixels to shift alignment zones
+      # - blue_fuzz: Tolerance for alignment zones
+      # - std_hw: Standard horizontal stem width
+      # - std_vw: Standard vertical stem width
+      # - stem_snap_h: Horizontal stem snap widths
+      # - stem_snap_v: Vertical stem snap widths
+      # - force_bold: Force bold flag
+      # - language_group: Language group (0=Latin, 1=CJK)
+      # - expansion_factor: Expansion factor for counters
+      # - initial_random_seed: Random seed for Type 1 hinting
+      # - subrs: Offset to Local Subr INDEX (relative to Private DICT)
+      # - default_width_x: Default glyph width
+      # - nominal_width_x: Nominal glyph width
+      #
+      # Reference: CFF specification section 10 "Private DICT"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Parsing a Private DICT
+      #   private_size, private_offset = top_dict.private
+      #   private_data = cff.raw_data[private_offset, private_size]
+      #   private_dict = Fontisan::Tables::Cff::PrivateDict.new(private_data)
+      #   puts private_dict[:blue_values]  # => [array of blue values]
+      #   puts private_dict.default_width_x  # => default glyph width
+      class PrivateDict < Dict
+        # Private DICT specific operators
+        #
+        # These extend the common operators defined in the base Dict class
+        PRIVATE_DICT_OPERATORS = {
+          6 => :blue_values,
+          7 => :other_blues,
+          8 => :family_blues,
+          9 => :family_other_blues,
+          [12, 9] => :blue_scale,
+          [12, 10] => :blue_shift,
+          [12, 11] => :blue_fuzz,
+          10 => :std_hw,
+          11 => :std_vw,
+          [12, 12] => :stem_snap_h,
+          [12, 13] => :stem_snap_v,
+          [12, 14] => :force_bold,
+          [12, 17] => :language_group,
+          [12, 18] => :expansion_factor,
+          [12, 19] => :initial_random_seed,
+          19 => :subrs,
+          20 => :default_width_x,
+          21 => :nominal_width_x,
+        }.freeze
+
+        # Default values for Private DICT operators
+        #
+        # These are used when an operator is not present in the DICT
+        DEFAULTS = {
+          blue_scale: 0.039625,
+          blue_shift: 7,
+          blue_fuzz: 1,
+          force_bold: false,
+          language_group: 0,
+          expansion_factor: 0.06,
+          initial_random_seed: 0,
+          default_width_x: 0,
+          nominal_width_x: 0,
+        }.freeze
+
+        # Get a value with default fallback
+        #
+        # @param key [Symbol] Operator name
+        # @return [Object] Value or default value
+        def fetch(key, default = nil)
+          @dict.fetch(key, DEFAULTS.fetch(key, default))
+        end
+
+        # Get the blue values (alignment zones)
+        #
+        # Blue values define vertical zones for overshoot suppression
+        #
+        # @return [Array<Integer>, nil] Array of blue values (pairs of bottom/top)
+        def blue_values
+          @dict[:blue_values]
+        end
+
+        # Get the other blue values
+        #
+        # Additional alignment zones beyond the baseline and cap height
+        #
+        # @return [Array<Integer>, nil] Array of other blue values
+        def other_blues
+          @dict[:other_blues]
+        end
+
+        # Get the family blue values
+        #
+        # Family-wide alignment zones shared across fonts in a family
+        #
+        # @return [Array<Integer>, nil] Array of family blue values
+        def family_blues
+          @dict[:family_blues]
+        end
+
+        # Get the family other blue values
+        #
+        # @return [Array<Integer>, nil] Array of family other blue values
+        def family_other_blues
+          @dict[:family_other_blues]
+        end
+
+        # Get the blue scale
+        #
+        # Point size at which overshoot suppression is maximum
+        #
+        # @return [Float] Blue scale value
+        def blue_scale
+          fetch(:blue_scale)
+        end
+
+        # Get the blue shift
+        #
+        # Number of device pixels to shift alignment zones
+        #
+        # @return [Integer] Blue shift in pixels
+        def blue_shift
+          fetch(:blue_shift)
+        end
+
+        # Get the blue fuzz
+        #
+        # Tolerance for alignment zone matching
+        #
+        # @return [Integer] Blue fuzz in font units
+        def blue_fuzz
+          fetch(:blue_fuzz)
+        end
+
+        # Get the standard horizontal width
+        #
+        # Dominant horizontal stem width
+        #
+        # @return [Integer, nil] Standard horizontal width
+        def std_hw
+          value = @dict[:std_hw]
+          # std_hw is stored as an array with one element
+          value.is_a?(Array) ? value.first : value
+        end
+
+        # Get the standard vertical width
+        #
+        # Dominant vertical stem width
+        #
+        # @return [Integer, nil] Standard vertical width
+        def std_vw
+          value = @dict[:std_vw]
+          # std_vw is stored as an array with one element
+          value.is_a?(Array) ? value.first : value
+        end
+
+        # Get the horizontal stem snap widths
+        #
+        # Array of horizontal stem widths for stem snapping
+        #
+        # @return [Array<Integer>, nil] Horizontal stem snap widths
+        def stem_snap_h
+          @dict[:stem_snap_h]
+        end
+
+        # Get the vertical stem snap widths
+        #
+        # Array of vertical stem widths for stem snapping
+        #
+        # @return [Array<Integer>, nil] Vertical stem snap widths
+        def stem_snap_v
+          @dict[:stem_snap_v]
+        end
+
+        # Check if force bold is enabled
+        #
+        # @return [Boolean] True if force bold is enabled
+        def force_bold?
+          fetch(:force_bold)
+        end
+
+        # Get the language group
+        #
+        # 0 = Latin/Greek/Cyrillic, 1 = CJK
+        #
+        # @return [Integer] Language group (0 or 1)
+        def language_group
+          fetch(:language_group)
+        end
+
+        # Get the expansion factor
+        #
+        # Controls horizontal counter expansion
+        #
+        # @return [Float] Expansion factor
+        def expansion_factor
+          fetch(:expansion_factor)
+        end
+
+        # Get the initial random seed
+        #
+        # Seed for pseudo-random number generation in Type 1 hinting
+        #
+        # @return [Integer] Initial random seed
+        def initial_random_seed
+          fetch(:initial_random_seed)
+        end
+
+        # Get the Local Subr INDEX offset
+        #
+        # Offset is relative to the beginning of the Private DICT
+        #
+        # @return [Integer, nil] Offset to Local Subr INDEX
+        def subrs
+          @dict[:subrs]
+        end
+
+        # Get the default glyph width
+        #
+        # Used when width is not explicitly specified in CharString
+        #
+        # @return [Integer] Default width in font units
+        def default_width_x
+          fetch(:default_width_x)
+        end
+
+        # Get the nominal glyph width
+        #
+        # Base value for width calculations in CharStrings
+        #
+        # @return [Integer] Nominal width in font units
+        def nominal_width_x
+          fetch(:nominal_width_x)
+        end
+
+        # Check if this Private DICT has local subroutines
+        #
+        # @return [Boolean] True if subrs offset is present
+        def has_local_subrs?
+          !subrs.nil?
+        end
+
+        # Check if this Private DICT has blue values defined
+        #
+        # @return [Boolean] True if blue values are present
+        def has_blue_values?
+          !blue_values.nil? && !blue_values.empty?
+        end
+
+        # Check if this is for CJK language group
+        #
+        # @return [Boolean] True if language group is 1 (CJK)
+        def cjk?
+          language_group == 1
+        end
+
+        private
+
+        # Get Private DICT specific operators
+        #
+        # @return [Hash] Private DICT operators merged with base operators
+        def derived_operators
+          PRIVATE_DICT_OPERATORS
+        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

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