fontisan 0.1.0 → 0.2.0

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

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../../binary/base_record"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF INDEX structure
+      #
+      # INDEX is a fundamental data structure used throughout CFF for storing
+      # arrays of variable-length data items. It's used for:
+      # - Name INDEX (font names)
+      # - String INDEX (string data)
+      # - Global Subr INDEX (global subroutines)
+      # - Local Subr INDEX (local subroutines)
+      # - CharStrings INDEX (glyph programs)
+      #
+      # Structure:
+      # - count (Card16): Number of objects stored in INDEX
+      # - offSize (OffSize): Size of offset values (1-4 bytes)
+      # - offset[count+1] (Offset): Array of offsets to data
+      # - data: The actual data bytes
+      #
+      # Offsets are relative to the byte before the data array. The first
+      # offset is always 1, not 0. The last offset points one byte past the
+      # end of the data.
+      #
+      # Reference: CFF specification section 5 "INDEX Data"
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+      #
+      # @example Reading an INDEX
+      #   index = Fontisan::Tables::Cff::Index.new(data)
+      #   puts index.count  # => 3
+      #   puts index[0]  # => first item data
+      #   index.each { |item| puts item }
+      class Index
+        # @return [Integer] Number of items in the INDEX
+        attr_reader :count
+
+        # @return [Integer] Size of offset values (1-4 bytes)
+        attr_reader :off_size
+
+        # @return [Array<Integer>] Array of offsets (count + 1 elements)
+        attr_reader :offsets
+
+        # @return [String] Binary string containing all data
+        attr_reader :data
+
+        # Initialize an INDEX from binary data
+        #
+        # @param io [IO, StringIO, String] Binary data to parse
+        # @param start_offset [Integer] Starting byte offset in the data
+        def initialize(io, start_offset: 0)
+          @io = io.is_a?(String) ? StringIO.new(io) : io
+          @start_offset = start_offset
+          @io.seek(start_offset) if @io.respond_to?(:seek)
+
+          parse!
+        end
+
+        # Get the item at the specified index
+        #
+        # @param index [Integer] Zero-based index of item to retrieve
+        # @return [String, nil] Binary data for the item, or nil if out of bounds
+        def [](index)
+          return nil if index.negative? || index >= count
+          return "" if count.zero?
+
+          # Offsets are 1-based in the data array
+          start_pos = offsets[index] - 1
+          end_pos = offsets[index + 1] - 1
+          length = end_pos - start_pos
+
+          data[start_pos, length]
+        end
+
+        # Iterate over each item in the INDEX
+        #
+        # @yield [String] Binary data for each item
+        # @return [Enumerator] If no block given
+        def each
+          return enum_for(:each) unless block_given?
+
+          count.times do |i|
+            yield self[i]
+          end
+        end
+
+        # Get all items as an array
+        #
+        # @return [Array<String>] Array of binary data strings
+        def to_a
+          Array.new(count) { |i| self[i] }
+        end
+
+        # Check if the INDEX is empty
+        #
+        # @return [Boolean] True if count is 0
+        def empty?
+          count.zero?
+        end
+
+        # Get the size of a specific item
+        #
+        # @param index [Integer] Zero-based index of item
+        # @return [Integer, nil] Size in bytes, or nil if out of bounds
+        def item_size(index)
+          return nil if index.negative? || index >= count
+          return 0 if count.zero?
+
+          offsets[index + 1] - offsets[index]
+        end
+
+        # Calculate total size of the INDEX in bytes
+        #
+        # This includes the count, offSize, offset array, and data.
+        #
+        # @return [Integer] Total size in bytes
+        def total_size
+          return 2 if count.zero? # Just the count field
+
+          # count (2) + offSize (1) + offset array + data
+          2 + 1 + ((count + 1) * off_size) + data.bytesize
+        end
+
+        private
+
+        # Parse the INDEX structure from the IO
+        def parse!
+          # Read count (Card16)
+          @count = read_uint16
+
+          # Empty INDEX has only count field
+          if @count.zero?
+            @off_size = 0
+            @offsets = []
+            @data = "".b
+            return
+          end
+
+          # Read offSize (OffSize)
+          @off_size = read_uint8
+
+          # Validate offSize
+          unless (1..4).cover?(@off_size)
+            raise CorruptedTableError,
+                  "Invalid INDEX offSize: #{@off_size} (must be 1-4)"
+          end
+
+          # Read offset array (count + 1 offsets)
+          @offsets = Array.new(@count + 1) do
+            read_offset(@off_size)
+          end
+
+          # Validate offsets
+          validate_offsets!
+
+          # Read data section
+          # Size is (last offset - 1) since offsets are 1-based
+          data_size = @offsets.last - 1
+          @data = read_bytes(data_size)
+        end
+
+        # Read an unsigned 16-bit integer
+        #
+        # @return [Integer] The value
+        def read_uint16
+          bytes = read_bytes(2)
+          bytes.unpack1("n") # Big-endian unsigned 16-bit
+        end
+
+        # Read an unsigned 8-bit integer
+        #
+        # @return [Integer] The value
+        def read_uint8
+          read_bytes(1).unpack1("C")
+        end
+
+        # Read an offset value of specified size
+        #
+        # @param size [Integer] Number of bytes (1-4)
+        # @return [Integer] The offset value
+        def read_offset(size)
+          bytes = read_bytes(size)
+
+          case size
+          when 1
+            bytes.unpack1("C")
+          when 2
+            bytes.unpack1("n")
+          when 3
+            # 24-bit big-endian
+            bytes.unpack("C3").inject(0) { |sum, byte| (sum << 8) | byte }
+          when 4
+            bytes.unpack1("N")
+          else
+            raise ArgumentError, "Invalid offset size: #{size}"
+          end
+        end
+
+        # Read specified number of bytes from IO
+        #
+        # @param count [Integer] Number of bytes to read
+        # @return [String] Binary string
+        def read_bytes(count)
+          return "".b if count.zero?
+
+          bytes = @io.read(count)
+          if bytes.nil? || bytes.bytesize < count
+            raise CorruptedTableError,
+                  "Unexpected end of INDEX data"
+          end
+
+          bytes
+        end
+
+        # Validate that offsets are in ascending order and within bounds
+        def validate_offsets!
+          # First offset must be 1
+          unless @offsets.first == 1
+            raise CorruptedTableError,
+                  "Invalid INDEX: first offset must be 1, got #{@offsets.first}"
+          end
+
+          # Check ascending order
+          @offsets.each_cons(2) do |prev, curr|
+            if curr < prev
+              raise CorruptedTableError,
+                    "Invalid INDEX: offsets are not in ascending order"
+            end
+          end
+        end
+      end
+    end
+  end
+end