fontisan 0.1.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/charstrings_index.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "index"
+require_relative "charstring"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CharStrings INDEX wrapper
+      #
+      # This class wraps the CharStrings INDEX to provide convenient access
+      # to individual CharString objects. The CharStrings INDEX contains the
+      # glyph outline programs (Type 2 CharStrings) for each glyph in the font.
+      #
+      # CharStrings Format:
+      # - INDEX structure containing binary CharString data
+      # - Each entry is a Type 2 CharString program
+      # - Number of entries typically matches the number of glyphs
+      # - Index 0 is typically .notdef glyph
+      #
+      # Usage:
+      # 1. Create from raw CharStrings INDEX data
+      # 2. Provide Private DICT and subroutine INDEXes for interpretation
+      # 3. Access individual CharStrings by glyph index
+      #
+      # Reference: CFF specification section 16 "Local/Global Subrs INDEXes"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Using CharStringsIndex
+      #   # Get CharStrings INDEX from CFF table
+      #   charstrings_offset = top_dict.charstrings
+      #   io = StringIO.new(cff.raw_data)
+      #   io.seek(charstrings_offset)
+      #   charstrings_index = CharstringsIndex.new(io, start_offset:
+      #                                             charstrings_offset)
+      #
+      #   # Get a specific CharString
+      #   charstring = charstrings_index.charstring_at(
+      #     glyph_index,
+      #     private_dict,
+      #     global_subrs,
+      #     local_subrs
+      #   )
+      #
+      #   # Access CharString properties
+      #   puts charstring.width
+      #   puts charstring.bounding_box
+      #   charstring.to_commands.each { |cmd| puts cmd.inspect }
+      class CharstringsIndex < Index
+        # Get a CharString object at the specified glyph index
+        #
+        # This method retrieves the binary CharString data at the given index
+        # and interprets it as a Type 2 CharString program.
+        #
+        # @param index [Integer] Glyph index (0-based, 0 is typically .notdef)
+        # @param private_dict [PrivateDict] Private DICT for width defaults
+        # @param global_subrs [Index] Global subroutines INDEX
+        # @param local_subrs [Index, nil] Local subroutines INDEX (optional)
+        # @return [CharString, nil] Interpreted CharString object, or nil if
+        #   index is out of bounds
+        #
+        # @example Getting a CharString
+        #   charstring = charstrings_index.charstring_at(
+        #     42,
+        #     private_dict,
+        #     global_subrs,
+        #     local_subrs
+        #   )
+        #   puts "Width: #{charstring.width}"
+        #   puts "Bounding box: #{charstring.bounding_box.inspect}"
+        def charstring_at(index, private_dict, global_subrs, local_subrs = nil)
+          data = self[index]
+          return nil unless data
+
+          CharString.new(data, private_dict, global_subrs, local_subrs)
+        end
+
+        # Get all CharStrings as an array of CharString objects
+        #
+        # This method interprets all CharStrings in the INDEX. Use with
+        # caution for fonts with many glyphs as this can be memory-intensive.
+        #
+        # @param private_dict [PrivateDict] Private DICT for width defaults
+        # @param global_subrs [Index] Global subroutines INDEX
+        # @param local_subrs [Index, nil] Local subroutines INDEX (optional)
+        # @return [Array<CharString>] Array of interpreted CharString objects
+        #
+        # @example Getting all CharStrings
+        #   charstrings = charstrings_index.all_charstrings(
+        #     private_dict,
+        #     global_subrs,
+        #     local_subrs
+        #   )
+        #   charstrings.each_with_index do |cs, i|
+        #     puts "Glyph #{i}: width=#{cs.width}, bbox=#{cs.bounding_box}"
+        #   end
+        def all_charstrings(private_dict, global_subrs, local_subrs = nil)
+          Array.new(count) do |i|
+            charstring_at(i, private_dict, global_subrs, local_subrs)
+          end
+        end
+
+        # Iterate over each CharString in the INDEX
+        #
+        # This method yields each CharString as it is interpreted, which is
+        # more memory-efficient than loading all at once.
+        #
+        # @param private_dict [PrivateDict] Private DICT for width defaults
+        # @param global_subrs [Index] Global subroutines INDEX
+        # @param local_subrs [Index, nil] Local subroutines INDEX (optional)
+        # @yield [CharString, Integer] Interpreted CharString and its index
+        # @return [Enumerator] If no block given
+        #
+        # @example Iterating over CharStrings
+        #   charstrings_index.each_charstring(private_dict, global_subrs,
+        #                                     local_subrs) do |cs, index|
+        #     puts "Glyph #{index}: #{cs.bounding_box}"
+        #   end
+        def each_charstring(private_dict, global_subrs, local_subrs = nil)
+          unless block_given?
+            return enum_for(:each_charstring, private_dict, global_subrs,
+                            local_subrs)
+          end
+
+          count.times do |i|
+            charstring = charstring_at(i, private_dict, global_subrs,
+                                       local_subrs)
+            yield charstring, i if charstring
+          end
+        end
+
+        # Get the number of glyphs (CharStrings) in this INDEX
+        #
+        # This is typically the same as the number of glyphs in the font.
+        #
+        # @return [Integer] Number of glyphs
+        def glyph_count
+          count
+        end
+
+        # Check if a glyph index is valid
+        #
+        # @param index [Integer] Glyph index to check
+        # @return [Boolean] True if index is valid
+        def valid_glyph_index?(index)
+          index >= 0 && index < count
+        end
+
+        # Get the size of a CharString in bytes
+        #
+        # This returns the size of the binary CharString data without
+        # interpreting it.
+        #
+        # @param index [Integer] Glyph index
+        # @return [Integer, nil] Size in bytes, or nil if index is invalid
+        def charstring_size(index)
+          item_size(index)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../../binary/base_record"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF DICT (Dictionary) structure parser
+      #
+      # DICTs in CFF use a compact operand-operator format similar to PostScript.
+      # Operands are pushed onto a stack, then an operator consumes them.
+      #
+      # Operand Encoding:
+      # - 32-247: Small integers (values -107 to +107)
+      # - 28: 3-byte signed integer follows
+      # - 29: 5-byte signed integer follows
+      # - 30: Real number (nibble-encoded)
+      # - 247-254: 2-byte signed integers
+      # - 255: Reserved
+      # - 0-21, 22-27: Operators (single or two-byte)
+      #
+      # Reference: CFF specification section 4 "DICT Data"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Parsing a DICT
+      #   data = top_dict_index[0]
+      #   dict = Fontisan::Tables::Cff::Dict.new(data)
+      #   puts dict[:charset]  # => offset to charset
+      #   puts dict[:version]  # => version SID
+      class Dict
+        # Common DICT operators shared across Top DICT and Private DICT
+        #
+        # Key: operator byte(s), Value: operator name symbol
+        OPERATORS = {
+          0 => :version,
+          1 => :notice,
+          2 => :full_name,
+          3 => :family_name,
+          4 => :weight,
+          [12, 0] => :copyright,
+          [12, 1] => :is_fixed_pitch,
+          [12, 2] => :italic_angle,
+          [12, 3] => :underline_position,
+          [12, 4] => :underline_thickness,
+          [12, 5] => :paint_type,
+          [12, 6] => :charstring_type,
+          [12, 7] => :font_matrix,
+          [12, 8] => :stroke_width,
+          [12, 20] => :synthetic_base,
+          [12, 21] => :postscript,
+          [12, 22] => :base_font_name,
+          [12, 23] => :base_font_blend,
+        }.freeze
+
+        # @return [Hash] Parsed dictionary as key-value pairs
+        attr_reader :dict
+
+        # @return [String] Raw binary data of the DICT
+        attr_reader :data
+
+        # Initialize and parse a DICT from binary data
+        #
+        # @param data [String, IO, StringIO] Binary DICT data
+        def initialize(data)
+          @data = data.is_a?(String) ? data : data.read
+          @dict = {}
+          @io = StringIO.new(@data)
+          parse!
+        end
+
+        # Get a value from the dictionary by operator name
+        #
+        # @param key [Symbol] Operator name (e.g., :charset, :encoding)
+        # @return [Object, nil] Value for the operator, or nil if not present
+        def [](key)
+          @dict[key]
+        end
+
+        # Set a value in the dictionary
+        #
+        # @param key [Symbol] Operator name
+        # @param value [Object] Value to set
+        def []=(key, value)
+          @dict[key] = value
+        end
+
+        # Check if the dictionary contains a specific operator
+        #
+        # @param key [Symbol] Operator name
+        # @return [Boolean] True if operator is present
+        def has_key?(key)
+          @dict.key?(key)
+        end
+
+        # Get all operator names in this DICT
+        #
+        # @return [Array<Symbol>] Array of operator names
+        def keys
+          @dict.keys
+        end
+
+        # Get all values in this DICT
+        #
+        # @return [Array<Object>] Array of values
+        def values
+          @dict.values
+        end
+
+        # Convert DICT to Hash
+        #
+        # @return [Hash] Dictionary as hash
+        def to_h
+          @dict.dup
+        end
+
+        # Number of entries in the DICT
+        #
+        # @return [Integer] Entry count
+        def size
+          @dict.size
+        end
+
+        # Check if DICT is empty
+        #
+        # @return [Boolean] True if no entries
+        def empty?
+          @dict.empty?
+        end
+
+        private
+
+        # Parse the DICT structure
+        #
+        # DICTs use a stack-based format:
+        # 1. Read operands and push onto operand stack
+        # 2. When operator is encountered, pop operands and process
+        # 3. Store result in dictionary
+        def parse!
+          operand_stack = []
+
+          until @io.eof?
+            byte = read_byte
+
+            if operator?(byte)
+              # Process operator with current operand stack
+              operator = read_operator(byte)
+              process_operator(operator, operand_stack)
+              operand_stack.clear
+            else
+              # Read operand and push onto stack
+              @io.pos -= 1 # Unread the byte
+              operand = read_operand
+              operand_stack << operand
+            end
+          end
+        end
+
+        # Check if a byte is an operator
+        #
+        # @param byte [Integer] Byte value
+        # @return [Boolean] True if operator byte
+        def operator?(byte)
+          # Operators are 0-21 or escape (12) followed by another byte
+          byte <= 21 || byte == 12
+        end
+
+        # Read an operator (single or two-byte)
+        #
+        # @param first_byte [Integer] First operator byte
+        # @return [Integer, Array<Integer>] Operator identifier
+        def read_operator(first_byte)
+          if first_byte == 12
+            # Two-byte operator (escape operator)
+            second_byte = read_byte
+            [first_byte, second_byte]
+          else
+            # Single-byte operator
+            first_byte
+          end
+        end
+
+        # Process an operator with its operands
+        #
+        # @param operator [Integer, Array<Integer>] Operator identifier
+        # @param operands [Array] Operand stack
+        def process_operator(operator, operands)
+          operator_name = operator_name_for(operator)
+          return unless operator_name
+
+          # Store the operand(s) in the dictionary
+          # Most operators take a single operand, some take arrays
+          value = operands.size == 1 ? operands.first : operands.dup
+          @dict[operator_name] = value
+        end
+
+        # Get the operator name for an operator byte(s)
+        #
+        # @param operator [Integer, Array<Integer>] Operator identifier
+        # @return [Symbol, nil] Operator name or nil if unknown
+        def operator_name_for(operator)
+          # Check in the OPERATORS table (common operators)
+          self.class::OPERATORS[operator] || derived_operators[operator]
+        end
+
+        # Get derived class-specific operators
+        #
+        # Subclasses override this to add their specific operators
+        #
+        # @return [Hash] Additional operators for this DICT type
+        def derived_operators
+          {}
+        end
+
+        # Read a single operand from the DICT data
+        #
+        # Operands can be:
+        # - Small integers (1 byte: 32-246 or 247-254 with next byte)
+        # - Medium integers (3 bytes: 28 + 2 bytes)
+        # - Large integers (5 bytes: 29 + 4 bytes)
+        # - Real numbers (30 + nibble-encoded decimal)
+        #
+        # @return [Integer, Float] The operand value
+        def read_operand
+          byte = read_byte
+
+          case byte
+          when 28
+            # 3-byte signed integer
+            read_int16
+          when 29
+            # 5-byte signed integer
+            read_int32
+          when 30
+            # Real number (nibble-encoded)
+            read_real
+          when 32..246
+            # Small integer: -107 to +107
+            byte - 139
+          when 247..250
+            # Positive 2-byte integer
+            second_byte = read_byte
+            (byte - 247) * 256 + second_byte + 108
+          when 251..254
+            # Negative 2-byte integer
+            second_byte = read_byte
+            -(byte - 251) * 256 - second_byte - 108
+          else
+            raise CorruptedTableError,
+                  "Invalid DICT operand byte: #{byte}"
+          end
+        end
+
+        # Read a 16-bit signed integer (big-endian)
+        #
+        # @return [Integer] Signed 16-bit value
+        def read_int16
+          bytes = @io.read(2)
+          if bytes.nil? || bytes.bytesize < 2
+            raise CorruptedTableError,
+                  "Unexpected end of DICT"
+          end
+
+          value = bytes.unpack1("n") # Unsigned 16-bit big-endian
+          # Convert to signed
+          value > 0x7FFF ? value - 0x10000 : value
+        end
+
+        # Read a 32-bit signed integer (big-endian)
+        #
+        # @return [Integer] Signed 32-bit value
+        def read_int32
+          bytes = @io.read(4)
+          if bytes.nil? || bytes.bytesize < 4
+            raise CorruptedTableError,
+                  "Unexpected end of DICT"
+          end
+
+          value = bytes.unpack1("N") # Unsigned 32-bit big-endian
+          # Convert to signed
+          value > 0x7FFFFFFF ? value - 0x100000000 : value
+        end
+
+        # Read a real number (nibble-encoded)
+        #
+        # Real numbers in CFF are encoded as a sequence of nibbles (4-bit values)
+        # where each nibble represents a digit or special character.
+        #
+        # Nibble values:
+        # - 0-9: Decimal digits
+        # - a (10): Decimal point
+        # - b (11): Positive exponent (E)
+        # - c (12): Negative exponent (E-)
+        # - d (13): Reserved
+        # - e (14): Minus sign
+        # - f (15): End of number
+        #
+        # @return [Float] The decoded real number
+        def read_real
+          nibbles = []
+
+          loop do
+            byte = read_byte
+            high_nibble = (byte >> 4) & 0x0F
+            low_nibble = byte & 0x0F
+
+            break if high_nibble == 0xF
+
+            nibbles << high_nibble
+
+            break if low_nibble == 0xF
+
+            nibbles << low_nibble
+          end
+
+          # Convert nibbles to string representation
+          str = +""
+          nibbles.each do |nibble|
+            case nibble
+            when 0..9
+              str << nibble.to_s
+            when 0xa # Decimal point
+              str << "."
+            when 0xb # Positive exponent (E)
+              str << "e"
+            when 0xc # Negative exponent (E-)
+              str << "e-"
+            when 0xe # Minus sign
+              str << "-"
+            when 0xd, 0xf # Reserved or end marker
+              # Skip
+            end
+          end
+
+          # Convert to float
+          str.to_f
+        end
+
+        # Read a single byte from the IO
+        #
+        # @return [Integer] Byte value (0-255)
+        def read_byte
+          byte = @io.getbyte
+          raise CorruptedTableError, "Unexpected end of DICT" if byte.nil?
+
+          byte
+        end
+      end
+    end
+  end
+end