fontisan 0.1.0 → 0.2.1

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF DICT (Dictionary) structure builder
+      #
+      # [`DictBuilder`](lib/fontisan/tables/cff/dict_builder.rb) constructs
+      # binary DICT structures from hash representations. DICTs in CFF use a
+      # compact operand-operator format similar to PostScript.
+      #
+      # The builder encodes operands in various compact formats and writes
+      # operators according to the CFF specification.
+      #
+      # Operand Encoding:
+      # - Small integers (-107 to +107): Single byte (32-246)
+      # - Medium integers (108 to 1131): Two bytes (247-250 + byte)
+      # - Medium integers (-1131 to -108): Two bytes (251-254 + byte)
+      # - Larger integers: Three bytes (28 + 2 bytes) or five bytes (29 + 4 bytes)
+      # - Real numbers: Nibble-encoded (30 + nibbles + 0xF terminator)
+      #
+      # Operators:
+      # - Single-byte: 0-21
+      # - Two-byte: 12 followed by second byte
+      #
+      # Reference: CFF specification section 4 "DICT Data"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Building a DICT
+      #   dict_hash = { version: 391, notice: 392, charset: 0 }
+      #   dict_data = Fontisan::Tables::Cff::DictBuilder.build(dict_hash)
+      class DictBuilder
+        # Operator mapping (name => byte(s))
+        OPERATORS = {
+          version: 0,
+          notice: 1,
+          full_name: 2,
+          family_name: 3,
+          weight: 4,
+          charset: 15,
+          encoding: 16,
+          charstrings: 17,
+          private: 18,
+          copyright: [12, 0],
+          is_fixed_pitch: [12, 1],
+          italic_angle: [12, 2],
+          underline_position: [12, 3],
+          underline_thickness: [12, 4],
+          paint_type: [12, 5],
+          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],
+          base_font_blend: [12, 23],
+          # Private DICT operators
+          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
+        #
+        # @param dict_hash [Hash] Hash of operator => value pairs
+        # @return [String] Binary DICT data
+        # @raise [ArgumentError] If dict_hash is invalid
+        def self.build(dict_hash)
+          validate_dict!(dict_hash)
+
+          return "".b if dict_hash.empty?
+
+          output = StringIO.new("".b)
+
+          # Encode each operator with its operands
+          dict_hash.each do |operator_name, value|
+            # Get operator bytes
+            operator_bytes = operator_for_name(operator_name)
+            raise ArgumentError, "Unknown operator: #{operator_name}" unless operator_bytes
+
+            # Write operands (value can be single value or array)
+            if value.is_a?(Array)
+              value.each { |v| write_operand(output, v) }
+            else
+              write_operand(output, value)
+            end
+
+            # Write operator
+            write_operator(output, operator_bytes)
+          end
+
+          output.string
+        end
+
+        # Validate dict parameter
+        #
+        # @param dict_hash [Object] Dictionary to validate
+        # @raise [ArgumentError] If dict_hash is invalid
+        def self.validate_dict!(dict_hash)
+          unless dict_hash.is_a?(Hash)
+            raise ArgumentError,
+                  "dict_hash must be Hash, got: #{dict_hash.class}"
+          end
+        end
+        private_class_method :validate_dict!
+
+        # Get operator bytes for operator name
+        #
+        # @param operator_name [Symbol] Operator name
+        # @return [Integer, Array<Integer>, nil] Operator byte(s) or nil
+        def self.operator_for_name(operator_name)
+          OPERATORS[operator_name]
+        end
+        private_class_method :operator_for_name
+
+        # Write an operand value to output
+        #
+        # @param io [StringIO] Output stream
+        # @param value [Integer, Float] Operand value
+        def self.write_operand(io, value)
+          if value.is_a?(Float)
+            write_real(io, value)
+          else
+            write_integer(io, value)
+          end
+        end
+        private_class_method :write_operand
+
+        # Write an integer operand
+        #
+        # @param io [StringIO] Output stream
+        # @param value [Integer] Integer value
+        def self.write_integer(io, value)
+          if value >= -107 && value <= 107
+            # Single byte: 32-246 represents -107 to +107
+            io.putc(value + 139)
+          elsif value >= 108 && value <= 1131
+            # Positive two-byte: 247-250
+            adjusted = value - 108
+            b0 = 247 + (adjusted / 256)
+            b1 = adjusted % 256
+            io.putc(b0)
+            io.putc(b1)
+          elsif value >= -1131 && value <= -108
+            # Negative two-byte: 251-254
+            adjusted = -value - 108
+            b0 = 251 + (adjusted / 256)
+            b1 = adjusted % 256
+            io.putc(b0)
+            io.putc(b1)
+          elsif value >= -32768 && value <= 32767
+            # Three-byte signed 16-bit
+            io.putc(28)
+            io.write([value].pack("s>")) # Signed 16-bit big-endian
+          else
+            # Five-byte signed 32-bit
+            io.putc(29)
+            io.write([value].pack("l>")) # Signed 32-bit big-endian
+          end
+        end
+        private_class_method :write_integer
+
+        # Write a real number operand
+        #
+        # Real numbers are encoded using nibbles (4-bit values).
+        # 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-)
+        # - e (14): Minus sign
+        # - f (15): End of number
+        #
+        # @param io [StringIO] Output stream
+        # @param value [Float] Real number value
+        def self.write_real(io, value)
+          io.putc(30) # Real number marker
+
+          # Convert to string representation
+          str = value.to_s
+
+          # Handle special cases
+          str = "0" if str == "0.0"
+
+          # Convert string to nibbles
+          nibbles = []
+
+          str.each_char do |char|
+            case char
+            when "0".."9"
+              nibbles << char.to_i
+            when "."
+              nibbles << 0xa
+            when "-"
+              nibbles << 0xe
+            when "e", "E"
+              # Check if next char is minus
+              nibbles << 0xb # Default to positive exponent
+            end
+          end
+
+          # Handle negative exponent
+          if str.include?("e-") || str.include?("E-")
+            # Replace last 0xb with 0xc
+            exp_index = nibbles.rindex(0xb)
+            nibbles[exp_index] = 0xc if exp_index
+          end
+
+          # Add terminator
+          nibbles << 0xf
+
+          # Pack nibbles into bytes
+          nibbles.each_slice(2) do |high, low|
+            low ||= 0xf # Pad with terminator if odd number
+            byte = (high << 4) | low
+            io.putc(byte)
+          end
+        end
+        private_class_method :write_real
+
+        # Write an operator to output
+        #
+        # @param io [StringIO] Output stream
+        # @param operator_bytes [Integer, Array<Integer>] Operator byte(s)
+        def self.write_operator(io, operator_bytes)
+          if operator_bytes.is_a?(Array)
+            # Two-byte operator
+            operator_bytes.each { |byte| io.putc(byte) }
+          else
+            # Single-byte operator
+            io.putc(operator_bytes)
+          end
+        end
+        private_class_method :write_operator
+      end
+    end
+  end
+end

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

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../../binary/base_record"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF Encoding structure
+      #
+      # Encoding maps character codes to glyph IDs (GIDs).
+      # GID 0 (.notdef) is not encoded.
+      #
+      # Three formats:
+      # - Format 0: Array of codes (one per glyph)
+      # - Format 1: Ranges of consecutive codes
+      # - Format 0/1 with supplement: Format 0 or 1 with additional mappings
+      #
+      # Predefined encodings:
+      # - 0: Standard encoding (Adobe standard character set)
+      # - 1: Expert encoding (Adobe expert character set)
+      #
+      # Reference: CFF specification section 14 "Encodings"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Reading an Encoding
+      #   encoding = Fontisan::Tables::Cff::Encoding.new(data, num_glyphs)
+      #   puts encoding.glyph_id(65)      # => GID for char code 65 ('A')
+      #   puts encoding.char_code(5)      # => char code for GID 5
+      class Encoding
+        # Predefined encoding identifiers
+        PREDEFINED = {
+          0 => :standard,
+          1 => :expert,
+        }.freeze
+
+        # Format mask to extract format type
+        FORMAT_MASK = 0x7F
+
+        # @return [Integer] Encoding format (0 or 1)
+        attr_reader :format_type
+
+        # @return [Hash<Integer, Integer>] Map from character code to GID
+        attr_reader :code_to_gid
+
+        # @return [Hash<Integer, Integer>] Map from GID to character code
+        attr_reader :gid_to_code
+
+        # Initialize an Encoding
+        #
+        # @param data [String, Integer] Binary data or predefined encoding ID
+        # @param num_glyphs [Integer] Number of glyphs in the font
+        def initialize(data, num_glyphs)
+          @num_glyphs = num_glyphs
+          @code_to_gid = {}
+          @gid_to_code = {}
+
+          # GID 0 (.notdef) is always at code 0
+          @code_to_gid[0] = 0
+          @gid_to_code[0] = 0
+
+          if data.is_a?(Integer) && PREDEFINED.key?(data)
+            load_predefined_encoding(data)
+          else
+            @data = data
+            parse!
+          end
+        end
+
+        # Get GID for a character code
+        #
+        # @param code [Integer] Character code (0-255)
+        # @return [Integer, nil] Glyph ID or nil if not mapped
+        def glyph_id(code)
+          @code_to_gid[code]
+        end
+
+        # Get character code for a GID
+        #
+        # @param gid [Integer] Glyph ID
+        # @return [Integer, nil] Character code or nil if not mapped
+        def char_code(gid)
+          @gid_to_code[gid]
+        end
+
+        # Get the format symbol
+        #
+        # @return [Symbol] Format identifier (:array, :range, or :predefined)
+        def format
+          return :predefined unless @format_type
+
+          @format_type.zero? ? :array : :range
+        end
+
+        # Check if encoding has supplement
+        #
+        # @return [Boolean] True if encoding has supplemental mappings
+        def has_supplement?
+          @has_supplement || false
+        end
+
+        private
+
+        # Parse the Encoding from binary data
+        def parse!
+          io = StringIO.new(@data)
+          format_byte = read_uint8(io)
+
+          # Extract format (lower 7 bits) and supplement flag (bit 7)
+          @format_type = format_byte & FORMAT_MASK
+          @has_supplement = (format_byte & 0x80) != 0
+
+          case @format_type
+          when 0
+            parse_format_0(io)
+          when 1
+            parse_format_1(io)
+          else
+            raise CorruptedTableError,
+                  "Invalid Encoding format: #{@format_type}"
+          end
+
+          # Parse supplemental encoding if present
+          parse_supplement(io) if @has_supplement
+        rescue StandardError => e
+          raise CorruptedTableError,
+                "Failed to parse Encoding: #{e.message}"
+        end
+
+        # Parse Format 0: Array of codes
+        #
+        # Format 0 directly lists character codes for each glyph (except
+        # .notdef)
+        #
+        # @param io [StringIO] Input stream positioned after format byte
+        def parse_format_0(io)
+          n_codes = read_uint8(io)
+
+          # Read one code per glyph (GIDs start at 1, skipping .notdef)
+          n_codes.times do |i|
+            code = read_uint8(io)
+            gid = i + 1 # GID 0 is .notdef, so start at 1
+
+            @code_to_gid[code] = gid
+            @gid_to_code[gid] = code
+          end
+        end
+
+        # Parse Format 1: Ranges of codes
+        #
+        # Format 1 uses ranges: first code, nLeft (number of consecutive codes)
+        #
+        # @param io [StringIO] Input stream positioned after format byte
+        def parse_format_1(io)
+          n_ranges = read_uint8(io)
+          gid = 1 # Start at GID 1 (skip .notdef at 0)
+
+          n_ranges.times do
+            first_code = read_uint8(io)
+            n_left = read_uint8(io)
+
+            # Map the range of codes
+            (n_left + 1).times do |i|
+              code = first_code + i
+              @code_to_gid[code] = gid
+              @gid_to_code[gid] = code
+              gid += 1
+            end
+          end
+        end
+
+        # Parse supplemental encoding
+        #
+        # Supplemental encoding provides additional code-to-GID mappings
+        #
+        # @param io [StringIO] Input stream positioned after main encoding data
+        def parse_supplement(io)
+          n_sups = read_uint8(io)
+
+          n_sups.times do
+            read_uint8(io)
+            read_uint16(io)
+
+            # Find GID for this SID (requires charset lookup)
+            # For now, we'll store the code mapping
+            # A full implementation would need charset access to resolve SID to
+            # GID
+            # This is typically used when the charset has glyphs not in the
+            # standard encoding
+          end
+        end
+
+        # Load a predefined encoding
+        #
+        # @param encoding_id [Integer] Predefined encoding ID (0 or 1)
+        def load_predefined_encoding(encoding_id)
+          @format_type = nil # Predefined encodings don't have a format
+
+          case encoding_id
+          when 0
+            load_standard_encoding
+          when 1
+            load_expert_encoding
+          end
+        end
+
+        # Load Standard encoding
+        #
+        # Adobe Standard Encoding is the default encoding for Type 1 fonts
+        # It maps common Latin characters to specific codes
+        def load_standard_encoding
+          # Standard encoding for common characters (codes 0-255)
+          # This is a simplified version - a full implementation would include
+          # all 256 standard encoding mappings from the CFF specification
+          # Appendix B
+
+          # Common ASCII mappings (basic Latin)
+          gid = 1
+          (32..126).each do |code|
+            @code_to_gid[code] = gid
+            @gid_to_code[gid] = code
+            gid += 1
+            break if gid >= @num_glyphs
+          end
+        end
+
+        # Load Expert encoding
+        #
+        # Adobe Expert Encoding is used for expert fonts with special
+        # characters like small caps, old-style figures, ligatures, etc.
+        def load_expert_encoding
+          # Expert encoding for special characters
+          # This is a simplified version - a full implementation would include
+          # all expert encoding mappings from the CFF specification Appendix C
+
+          # Map some common expert characters
+          gid = 1
+          expert_codes = [32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+                          45, 46, 47]
+          expert_codes.each do |code|
+            @code_to_gid[code] = gid if gid < @num_glyphs
+            @gid_to_code[gid] = code if gid < @num_glyphs
+            gid += 1
+            break if gid >= @num_glyphs
+          end
+        end
+
+        # Read an unsigned 8-bit integer
+        #
+        # @param io [StringIO] Input stream
+        # @return [Integer] The value
+        def read_uint8(io)
+          byte = io.read(1)
+          raise CorruptedTableError, "Unexpected end of Encoding data" if
+            byte.nil?
+
+          byte.unpack1("C")
+        end
+
+        # Read an unsigned 16-bit integer (big-endian)
+        #
+        # @param io [StringIO] Input stream
+        # @return [Integer] The value
+        def read_uint16(io)
+          bytes = io.read(2)
+          raise CorruptedTableError, "Unexpected end of Encoding data" if
+            bytes.nil? || bytes.bytesize < 2
+
+          bytes.unpack1("n") # Big-endian unsigned 16-bit
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "../../binary/base_record"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF Header structure
+      #
+      # The CFF header appears at the beginning of the CFF table and contains
+      # basic version and structural information about the CFF data.
+      #
+      # Structure (4 bytes minimum):
+      # - uint8: major version (always 1 for CFF, 2 for CFF2)
+      # - uint8: minor version (always 0)
+      # - uint8: hdr_size (header size in bytes, typically 4)
+      # - uint8: off_size (offset size used throughout CFF, 1-4 bytes)
+      #
+      # Reference: CFF specification section 4 "Header"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Reading a CFF header
+      #   data = File.binread("font.otf", 4, cff_offset)
+      #   header = Fontisan::Tables::Cff::Header.read(data)
+      #   puts header.major  # => 1
+      #   puts header.minor  # => 0
+      #   puts header.off_size  # => 4
+      class Header < Binary::BaseRecord
+        # Major version number (1 for CFF, 2 for CFF2)
+        uint8 :major
+
+        # Minor version number (always 0)
+        uint8 :minor
+
+        # Header size in bytes (typically 4, but can be larger for extensions)
+        uint8 :hdr_size
+
+        # Offset size used throughout the CFF table
+        # Valid values are 1, 2, 3, or 4 bytes
+        #
+        # This determines how offsets are encoded in INDEX structures and
+        # other parts of the CFF table.
+        uint8 :off_size
+
+        # Check if this is a valid CFF version 1.0 header
+        #
+        # @return [Boolean] True if major version is 1 and minor is 0
+        def cff?
+          major == 1 && minor.zero?
+        end
+
+        # Check if this is a CFF2 header (variable CFF fonts)
+        #
+        # @return [Boolean] True if major version is 2
+        def cff2?
+          major == 2
+        end
+
+        # Get the version as a string
+        #
+        # @return [String] Version in "major.minor" format
+        def version
+          "#{major}.#{minor}"
+        end
+
+        # Validate that the header has correct values
+        #
+        # @return [Boolean] True if header is valid
+        def valid?
+          # Major version must be 1 or 2
+          return false unless [1, 2].include?(major)
+
+          # Minor version must be 0
+          return false unless minor.zero?
+
+          # Header size must be at least 4 bytes
+          return false unless hdr_size >= 4
+
+          # Offset size must be between 1 and 4
+          return false unless (1..4).cover?(off_size)
+
+          true
+        end
+
+        # Validate header and raise error if invalid
+        #
+        # @raise [Fontisan::CorruptedTableError] If header is invalid
+        def validate!
+          return if valid?
+
+          message = "Invalid CFF header: " \
+                    "version=#{version}, " \
+                    "hdr_size=#{hdr_size}, " \
+                    "off_size=#{off_size}"
+          error = Fontisan::CorruptedTableError.new(message)
+          error.set_backtrace(caller)
+          Kernel.raise(error)
+        end
+      end
+    end
+  end
+end