fontisan 0.1.0 → 0.2.0

data/lib/fontisan/tables/mvar.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "../binary/base_record"
+require_relative "variation_common"
+
+module Fontisan
+  module Tables
+    # Parser for the 'MVAR' (Metrics Variations) table
+    #
+    # The MVAR table provides variation data for global font metrics such as:
+    # - Ascender and descender
+    # - Line gap
+    # - Caret offsets
+    # - Strikeout and underline positions/sizes
+    # - Subscript and superscript sizes
+    #
+    # Each metric is identified by a tag and references delta sets in the
+    # ItemVariationStore.
+    #
+    # Reference: OpenType specification, MVAR table
+    #
+    # @example Reading an MVAR table
+    #   data = font.table_data("MVAR")
+    #   mvar = Fontisan::Tables::Mvar.read(data)
+    #   hasc_deltas = mvar.metric_deltas("hasc")
+    class Mvar < Binary::BaseRecord
+      uint16 :major_version
+      uint16 :minor_version
+      uint16 :reserved
+      uint16 :value_record_size
+      uint16 :value_record_count
+      uint32 :item_variation_store_offset
+
+      # Value tags for standard metrics
+      METRIC_TAGS = {
+        "hasc" => :horizontal_ascender,
+        "hdsc" => :horizontal_descender,
+        "hlgp" => :horizontal_line_gap,
+        "hcla" => :horizontal_caret_ascender,
+        "hcld" => :horizontal_caret_descender,
+        "hcof" => :horizontal_caret_offset,
+        "vasc" => :vertical_ascender,
+        "vdsc" => :vertical_descender,
+        "vlgp" => :vertical_line_gap,
+        "vcof" => :vertical_caret_offset,
+        "xhgt" => :x_height,
+        "cpht" => :cap_height,
+        "sbxs" => :subscript_em_x_size,
+        "sbys" => :subscript_em_y_size,
+        "sbxo" => :subscript_em_x_offset,
+        "sbyo" => :subscript_em_y_offset,
+        "spxs" => :superscript_em_x_size,
+        "spys" => :superscript_em_y_size,
+        "spxo" => :superscript_em_x_offset,
+        "spyo" => :superscript_em_y_offset,
+        "strs" => :strikeout_size,
+        "stro" => :strikeout_offset,
+        "unds" => :underline_size,
+        "undo" => :underline_offset,
+      }.freeze
+
+      # Value record structure
+      class ValueRecord < Binary::BaseRecord
+        string :value_tag, length: 4
+        uint32 :delta_set_outer_index
+        uint32 :delta_set_inner_index
+
+        # Get the metric name for this value tag
+        #
+        # @return [Symbol, nil] Metric name or nil
+        def metric_name
+          METRIC_TAGS[value_tag]
+        end
+      end
+
+      # Get version as a float
+      #
+      # @return [Float] Version number (e.g., 1.0)
+      def version
+        major_version + (minor_version / 10.0)
+      end
+
+      # Parse the item variation store
+      #
+      # @return [VariationCommon::ItemVariationStore, nil] Variation store
+      def item_variation_store
+        return @item_variation_store if defined?(@item_variation_store)
+        return @item_variation_store = nil if item_variation_store_offset.zero?
+
+        data = raw_data
+        offset = item_variation_store_offset
+
+        return @item_variation_store = nil if offset >= data.bytesize
+
+        store_data = data.byteslice(offset..-1)
+        @item_variation_store = VariationCommon::ItemVariationStore.read(store_data)
+      rescue StandardError => e
+        warn "Failed to parse MVAR item variation store: #{e.message}"
+        @item_variation_store = nil
+      end
+
+      # Parse value records
+      #
+      # @return [Array<ValueRecord>] Value records
+      def value_records
+        return @value_records if @value_records
+        return @value_records = [] if value_record_count.zero?
+
+        data = raw_data
+        # Value records start after the header (14 bytes: 2+2+2+2+2+4)
+        offset = 14
+
+        @value_records = Array.new(value_record_count) do |i|
+          record_offset = offset + (i * value_record_size)
+
+          next nil if record_offset + value_record_size > data.bytesize
+
+          record_data = data.byteslice(record_offset, value_record_size)
+          ValueRecord.read(record_data)
+        end.compact
+      end
+
+      # Get value record by tag
+      #
+      # @param tag [String] Value tag (e.g., "hasc", "hdsc")
+      # @return [ValueRecord, nil] Value record or nil
+      def value_record(tag)
+        value_records.find { |record| record.value_tag.to_s == tag }
+      end
+
+      # Get delta set for a specific metric tag
+      #
+      # @param tag [String] Value tag (e.g., "hasc", "hdsc")
+      # @return [Array<Integer>, nil] Delta values or nil
+      def metric_delta_set(tag)
+        return nil unless item_variation_store
+
+        record = value_record(tag)
+        return nil if record.nil?
+
+        item_variation_store.delta_set(
+          record.delta_set_outer_index,
+          record.delta_set_inner_index,
+        )
+      end
+
+      # Get all metric tags present in this table
+      #
+      # @return [Array<String>] Array of metric tags
+      def metric_tags
+        value_records.map { |record| record.value_tag.to_s }
+      end
+
+      # Get all metrics as a hash
+      #
+      # @return [Hash<String, Hash>] Hash of metric tag to record info
+      def metrics
+        value_records.each_with_object({}) do |record, hash|
+          # Strip trailing nulls from value_tag
+          tag = record.value_tag.delete("\x00")
+          hash[tag] = {
+            name: record.metric_name,
+            outer_index: record.delta_set_outer_index,
+            inner_index: record.delta_set_inner_index,
+          }
+        end
+      end
+
+      # Check if a specific metric is present
+      #
+      # @param tag [String] Value tag
+      # @return [Boolean] True if metric is present
+      def has_metric?(tag)
+        !value_record(tag).nil?
+      end
+
+      # Check if table is valid
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        major_version == 1 && minor_version.zero?
+      end
+    end
+  end
+end

data/lib/fontisan/tables/name.rb

@@ -107,9 +107,13 @@ module Fontisan
       array :name_records, type: :name_record, initial_length: :record_count
       rest :string_storage
 
+      # Cache for decoded names
+      attr_accessor :decoded_names_cache
+
       # Hook that gets called after all fields are read
       def after_read_hook
-        decode_all_strings
+        # Don't decode anything yet - wait for request
+        @decoded_names_cache = {}
       end
 
       # Make sure we call our hook after BinData finishes reading
@@ -125,6 +129,35 @@ module Fontisan
         record_count
       end
 
+      # Decode all strings from the string storage area
+      #
+      # This method can be called explicitly to decode all name records upfront.
+      # Useful for testing or when you know you'll need all strings.
+      # By default, strings are decoded lazily on demand.
+      #
+      # @return [void]
+      def decode_all_strings
+        # Get the raw string storage as a plain Ruby binary string
+        storage_bytes = string_storage.to_s.b
+
+        return if storage_bytes.empty?
+
+        name_records.each do |record|
+          # Extract string data from storage using offset and length
+          offset = record.string_offset
+          length = record.string_length
+
+          # Validate bounds
+          next if offset.nil? || length.nil?
+          next if offset + length > storage_bytes.bytesize
+          next if length.zero?
+
+          # Slice the bytes from storage
+          string_data = storage_bytes.byteslice(offset, length)
+          record.decode_string(string_data) if string_data && !string_data.empty?
+        end
+      end
+
       # Find an English name for the given name ID
       #
       # Priority: Platform 3 (Windows) with language 0x0409 (US English)
@@ -133,21 +166,28 @@ module Fontisan
       # @param name_id [Integer] The name ID to search for
       # @return [String, nil] The decoded string or nil if not found
       def english_name(name_id)
-        # First try Windows English
-        record = name_records.find do |rec|
-          rec.name_id == name_id &&
-            rec.platform_id == PLATFORM_WINDOWS &&
-            rec.language_id == WINDOWS_LANGUAGE_EN_US
-        end
+        # Check cache first
+        return @decoded_names_cache[name_id] if @decoded_names_cache.key?(name_id)
 
-        # Fallback to Mac English
-        record ||= name_records.find do |rec|
-          rec.name_id == name_id &&
-            rec.platform_id == PLATFORM_MACINTOSH &&
-            rec.language_id == MAC_LANGUAGE_ENGLISH
-        end
+        # Find record (don't decode yet)
+        record = find_name_record(
+          name_id,
+          platform: PLATFORM_WINDOWS,
+          language: WINDOWS_LANGUAGE_EN_US
+        )
 
-        record&.string
+        record ||= find_name_record(
+          name_id,
+          platform: PLATFORM_MACINTOSH,
+          language: MAC_LANGUAGE_ENGLISH
+        )
+
+        return nil unless record
+
+        # Decode only this one record
+        decoded = decode_name_record(record)
+        @decoded_names_cache[name_id] = decoded
+        decoded
       end
 
       # Validate the table
@@ -161,27 +201,56 @@ module Fontisan
 
       private
 
-      # Decode all strings from the string storage area
-      def decode_all_strings
-        # Get the raw string storage as a plain Ruby binary string
+      # Find a name record matching the criteria
+      #
+      # @param name_id [Integer] The name ID to search for
+      # @param platform [Integer] The platform ID
+      # @param language [Integer] The language ID
+      # @return [NameRecord, nil] The matching record or nil
+      def find_name_record(name_id, platform:, language:)
+        name_records.find do |rec|
+          rec.name_id == name_id &&
+            rec.platform_id == platform &&
+            rec.language_id == language
+        end
+      end
+
+      # Decode a single name record on demand
+      #
+      # @param record [NameRecord] The record to decode
+      # @return [String] The decoded string
+      def decode_name_record(record)
+        # Get raw string storage
         storage_bytes = string_storage.to_s.b
 
-        return if storage_bytes.empty?
+        # Extract this record's string
+        offset = record.string_offset
+        length = record.string_length
 
-        name_records.each do |record|
-          # Extract string data from storage using offset and length
-          offset = record.string_offset
-          length = record.string_length
+        return nil if offset + length > storage_bytes.bytesize
+        return nil if length.zero?
 
-          # Validate bounds
-          next if offset.nil? || length.nil?
-          next if offset + length > storage_bytes.bytesize
-          next if length.zero?
+        string_data = storage_bytes.byteslice(offset, length)
 
-          # Slice the bytes from storage
-          string_data = storage_bytes.byteslice(offset, length)
-          record.decode_string(string_data) if string_data && !string_data.empty?
-        end
+        # Decode based on platform
+        decoded = case record.platform_id
+                  when PLATFORM_WINDOWS, PLATFORM_UNICODE
+                    string_data.dup.force_encoding("UTF-16BE")
+                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                  when PLATFORM_MACINTOSH
+                    string_data.dup.force_encoding("ASCII-8BIT")
+                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                  else
+                    string_data.dup.force_encoding("UTF-8")
+                  end
+
+        # Intern common strings to reduce memory usage
+        interned = Fontisan::Constants.intern_string(decoded)
+
+        # Also populate the record's string attribute for backward compatibility
+        record.string = interned
+
+        interned
       end
     end
   end

data/lib/fontisan/tables/variation_common.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # Shared structures for OpenType variation tables (HVAR, VVAR, MVAR, etc.)
+    #
+    # These structures are used across multiple variation tables to define
+    # variation regions in design space and organize delta values that are
+    # applied based on axis coordinates.
+    #
+    # Reference: OpenType specification, Variation Common Table Formats
+    module VariationCommon
+      # Variation region in design space
+      #
+      # A region is defined by ranges on one or more axes. Each region has a
+      # scalar value (0.0 to 1.0) that determines how much its deltas contribute
+      # based on the current design coordinates.
+      class RegionAxisCoordinates < Binary::BaseRecord
+        int16 :start_coord  # Start of region range (F2DOT14)
+        int16 :peak_coord   # Peak value in range (F2DOT14)
+        int16 :end_coord    # End of region range (F2DOT14)
+
+        # Convert start coordinate from F2DOT14 to float
+        #
+        # @return [Float] Start coordinate value
+        def start
+          f2dot14_to_float(start_coord)
+        end
+
+        # Convert peak coordinate from F2DOT14 to float
+        #
+        # @return [Float] Peak coordinate value
+        def peak
+          f2dot14_to_float(peak_coord)
+        end
+
+        # Convert end coordinate from F2DOT14 to float
+        #
+        # @return [Float] End coordinate value
+        def end_value
+          f2dot14_to_float(end_coord)
+        end
+
+        private
+
+        # Convert F2DOT14 fixed-point (2.14) to float
+        #
+        # @param value [Integer] F2DOT14 value
+        # @return [Float] Floating-point value
+        def f2dot14_to_float(value)
+          # Handle signed 16-bit value
+          signed = value > 0x7FFF ? value - 0x10000 : value
+          signed / 16384.0
+        end
+      end
+
+      # Variation region definition
+      #
+      # Defines a region in design space with coordinate ranges for each axis.
+      class VariationRegion < Binary::BaseRecord
+        # Region axis coordinates array - length determined by axis count
+        # This is manually parsed by the parent VariationRegionList
+
+        # Parse region axis coordinates
+        #
+        # @param data [String] Binary data
+        # @param axis_count [Integer] Number of axes
+        # @return [Array<RegionAxisCoordinates>] Axis coordinates
+        def self.parse_coordinates(data, axis_count)
+          io = StringIO.new(data)
+          io.set_encoding(Encoding::BINARY)
+
+          Array.new(axis_count) do
+            coord_data = io.read(6) # 3 * int16
+            next nil if coord_data.nil? || coord_data.bytesize < 6
+
+            RegionAxisCoordinates.read(coord_data)
+          end.compact
+        end
+      end
+
+      # Variation region list
+      #
+      # Contains the regions used by variation data. Multiple variation tables
+      # can reference the same region list.
+      class VariationRegionList < Binary::BaseRecord
+        uint16 :axis_count
+        uint16 :region_count
+
+        # Parse all variation regions
+        #
+        # @return [Array<Array<RegionAxisCoordinates>>] Array of regions
+        def regions
+          return @regions if @regions
+          return @regions = [] if region_count.zero?
+
+          data = raw_data
+          offset = 4 # After axis_count and region_count
+
+          @regions = Array.new(region_count) do |i|
+            region_offset = offset + (i * axis_count * 6)
+            region_size = axis_count * 6
+
+            next nil if region_offset + region_size > data.bytesize
+
+            region_data = data.byteslice(region_offset, region_size)
+            VariationRegion.parse_coordinates(region_data, axis_count)
+          end.compact
+        end
+      end
+
+      # Item variation data
+      #
+      # Contains delta values for a set of items. Each item can have deltas
+      # for multiple regions.
+      class ItemVariationData < Binary::BaseRecord
+        uint16 :item_count
+        uint16 :short_delta_count
+        uint16 :region_index_count
+
+        # Parse region indices
+        #
+        # @return [Array<Integer>] Region indices
+        def region_indices
+          return @region_indices if @region_indices
+          return @region_indices = [] if region_index_count.zero?
+
+          data = raw_data
+          offset = 6 # After header fields
+
+          @region_indices = Array.new(region_index_count) do |i|
+            idx_offset = offset + (i * 2)
+            next nil if idx_offset + 2 > data.bytesize
+
+            data.byteslice(idx_offset, 2).unpack1("n")
+          end.compact
+        end
+
+        # Parse delta sets for all items
+        #
+        # @return [Array<Array<Integer>>] Delta sets for each item
+        def delta_sets
+          return @delta_sets if @delta_sets
+          return @delta_sets = [] if item_count.zero?
+
+          data = raw_data
+          # Delta data starts after header and region indices
+          offset = 6 + (region_index_count * 2)
+
+          # Each item has region_index_count deltas
+          # short_delta_count are int16, rest are int8
+          long_count = region_index_count - short_delta_count
+
+          # Safety check: long_count should not be negative
+          if long_count.negative?
+            warn "ItemVariationData parsing error: short_delta_count (#{short_delta_count}) > region_index_count (#{region_index_count})"
+            return @delta_sets = []
+          end
+
+          @delta_sets = Array.new(item_count) do |i|
+            item_offset = offset + (i * (short_delta_count * 2 + long_count))
+
+            # Read short deltas (int16)
+            shorts = Array.new(short_delta_count) do |j|
+              delta_offset = item_offset + (j * 2)
+              next nil if delta_offset + 2 > data.bytesize
+
+              # Signed 16-bit
+              value = data.byteslice(delta_offset, 2).unpack1("n")
+              value > 0x7FFF ? value - 0x10000 : value
+            end.compact
+
+            # Read long deltas (int8)
+            longs = Array.new(long_count) do |j|
+              delta_offset = item_offset + (short_delta_count * 2) + j
+              next nil if delta_offset + 1 > data.bytesize
+
+              # Signed 8-bit
+              value = data.byteslice(delta_offset, 1).unpack1("C")
+              value > 0x7F ? value - 0x100 : value
+            end.compact
+
+            shorts + longs
+          end
+        end
+      end
+
+      # Item variation store
+      #
+      # Hierarchical storage for delta values. Contains variation data entries
+      # and a region list that defines variation regions in design space.
+      #
+      # Used by: HVAR, VVAR, MVAR tables
+      class ItemVariationStore < Binary::BaseRecord
+        uint16 :format
+        uint32 :variation_region_list_offset
+        uint16 :item_variation_data_count
+
+        # Parse variation region list
+        #
+        # @return [VariationRegionList, nil] Region list or nil
+        def variation_region_list
+          return @variation_region_list if defined?(@variation_region_list)
+          return @variation_region_list = nil if variation_region_list_offset.zero?
+
+          data = raw_data
+          offset = variation_region_list_offset
+
+          return @variation_region_list = nil if offset >= data.bytesize
+
+          region_data = data.byteslice(offset..-1)
+          @variation_region_list = VariationRegionList.read(region_data)
+        rescue StandardError
+          @variation_region_list = nil
+        end
+
+        # Parse item variation data offsets
+        #
+        # @return [Array<Integer>] Offsets to ItemVariationData
+        def item_variation_data_offsets
+          return @data_offsets if @data_offsets
+          return @data_offsets = [] if item_variation_data_count.zero?
+
+          data = raw_data
+          offset = 8 # After header fields
+
+          @data_offsets = Array.new(item_variation_data_count) do |i|
+            offset_pos = offset + (i * 4)
+            next nil if offset_pos + 4 > data.bytesize
+
+            data.byteslice(offset_pos, 4).unpack1("N")
+          end.compact
+        end
+
+        # Parse all item variation data entries
+        #
+        # @return [Array<ItemVariationData>] Variation data entries
+        def item_variation_data_entries
+          return @data_entries if @data_entries
+          return @data_entries = [] if item_variation_data_count.zero?
+
+          data = raw_data
+          offsets = item_variation_data_offsets
+
+          @data_entries = offsets.map do |data_offset|
+            next nil if data_offset >= data.bytesize
+
+            entry_data = data.byteslice(data_offset..-1)
+            ItemVariationData.read(entry_data)
+          end.compact
+        rescue StandardError
+          @data_entries = []
+        end
+
+        # Get delta set for specific item
+        #
+        # @param outer_index [Integer] Outer index (data entry)
+        # @param inner_index [Integer] Inner index (item within entry)
+        # @return [Array<Integer>, nil] Delta values or nil
+        def delta_set(outer_index, inner_index)
+          return nil if outer_index >= item_variation_data_count
+
+          entry = item_variation_data_entries[outer_index]
+          return nil if entry.nil? || inner_index >= entry.item_count
+
+          entry.delta_sets[inner_index]
+        end
+      end
+
+      # Delta set index mapping
+      #
+      # Maps glyph IDs to delta set indices in an ItemVariationStore.
+      # Used for efficient lookup of variation data.
+      class DeltaSetIndexMap < Binary::BaseRecord
+        uint8 :format
+        uint8 :entry_format
+
+        # Get map data based on format
+        #
+        # @return [Array<Integer>] Map data
+        def map_data
+          return @map_data if @map_data
+
+          data = raw_data
+
+          case format
+          when 0
+            parse_format0(data)
+          when 1
+            parse_format1(data)
+          else
+            @map_data = []
+          end
+        end
+
+        private
+
+        # Parse format 0 map data
+        def parse_format0(data)
+          # Format 0: mapCount + mapData array
+          return [] if data.bytesize < 4
+
+          map_count = data.byteslice(2, 2).unpack1("n")
+
+          # entry_format bits 4-5: outer size - 1, bits 0-3: inner size - 1
+          outer_size = ((entry_format >> 4) & 0x3) + 1
+          inner_size = (entry_format & 0xF) + 1
+          entry_size = outer_size + inner_size
+
+          @map_data = Array.new(map_count) do |i|
+            offset = 4 + (i * entry_size)
+            next nil if offset + entry_size > data.bytesize
+
+            # Read entry and combine outer and inner indices
+            # For simplicity, treat as combined integer
+            case entry_size
+            when 1
+              data.byteslice(offset, 1).unpack1("C")
+            when 2
+              data.byteslice(offset, 2).unpack1("n")
+            when 3
+              bytes = data.byteslice(offset, 3).unpack("C3")
+              (bytes[0] << 16) | (bytes[1] << 8) | bytes[2]
+            when 4
+              data.byteslice(offset, 4).unpack1("N")
+            else
+              # For larger sizes, read as big-endian integer
+              bytes = data.byteslice(offset, entry_size).unpack("C*")
+              bytes.reduce(0) { |acc, b| (acc << 8) | b }
+            end
+          end.compact
+        end
+
+        # Parse format 1 map data
+        def parse_format1(_data)
+          # Format 1: More complex with map count and data
+          # Simplified implementation
+          @map_data = []
+        end
+      end
+    end
+  end
+end