fontisan 0.2.7 → 0.2.9

data/lib/fontisan/tables/hmtx_table.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "hmtx"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'hmtx' (Horizontal Metrics) table
+    #
+    # The hmtx table contains horizontal metrics for each glyph in the font,
+    # providing advance width and left sidebearing values needed for proper
+    # glyph positioning and text layout.
+    #
+    # This class extends SfntTable to provide hmtx-specific convenience
+    # methods for accessing glyph metrics. The hmtx table requires context
+    # from the hhea and maxp tables to function properly.
+    #
+    # @example Accessing horizontal metrics
+    #   hmtx = font.sfnt_table("hmtx")
+    #   hhea = font.table("hhea")
+    #   maxp = font.table("maxp")
+    #
+    #   hmtx.parse_with_context(hhea.number_of_h_metrics, maxp.num_glyphs)
+    #   metric = hmtx.metric_for(42)  # Get glyph metrics
+    #   metric[:advance_width] # => 1000
+    #   metric[:lsb]         # => 50
+    class HmtxTable < SfntTable
+      # Cache for context tables
+      attr_reader :hhea_table, :maxp_table
+
+      # Parse the hmtx table with required context
+      #
+      # The hmtx table cannot be used without context from hhea and maxp tables.
+      #
+      # @param number_of_h_metrics [Integer] Number of LongHorMetric records (from hhea)
+      # @param num_glyphs [Integer] Total number of glyphs (from maxp)
+      # @return [self] Returns self for chaining
+      # @raise [ArgumentError] if context is invalid
+      def parse_with_context(number_of_h_metrics, num_glyphs)
+        unless number_of_h_metrics && num_glyphs
+          raise ArgumentError,
+                "hmtx table requires number_of_h_metrics and num_glyphs"
+        end
+
+        @number_of_h_metrics = number_of_h_metrics
+        @num_glyphs = num_glyphs
+
+        # Ensure parsed data is loaded
+        parse
+
+        # Parse with context
+        parsed.parse_with_context(number_of_h_metrics, num_glyphs)
+
+        self
+      end
+
+      # Check if table has been parsed with context
+      #
+      # @return [Boolean] true if context is available
+      def has_context?
+        !@number_of_h_metrics.nil? && !@num_glyphs.nil?
+      end
+
+      # Get horizontal metrics for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID (0-based)
+      # @return [Hash, nil] Hash with :advance_width and :lsb keys, or nil
+      # @raise [ArgumentError] if context not set
+      def metric_for(glyph_id)
+        ensure_context!
+        return nil unless parsed
+
+        parsed.metric_for(glyph_id)
+      end
+
+      # Get advance width for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Integer, nil] Advance width in FUnits, or nil
+      def advance_width_for(glyph_id)
+        metric = metric_for(glyph_id)
+        metric&.dig(:advance_width)
+      end
+
+      # Get left sidebearing for a glyph
+      #
+      # @param glyph_id [integer] Glyph ID
+      # @return [Integer, nil] Left sidebearing in FUnits, or nil
+      def lsb_for(glyph_id)
+        metric = metric_for(glyph_id)
+        metric&.dig(:lsb)
+      end
+
+      # Get number of horizontal metrics
+      #
+      # @return [Integer, nil] Number of hMetrics, or nil if not parsed
+      def number_of_h_metrics
+        return @number_of_h_metrics if @number_of_h_metrics
+        return nil unless parsed
+
+        parsed.number_of_h_metrics
+      end
+
+      # Get total number of glyphs
+      #
+      # @return [Integer, nil] Total glyph count, or nil if not parsed
+      def num_glyphs
+        return @num_glyphs if @num_glyphs
+        return nil unless parsed
+
+        parsed.num_glyphs
+      end
+
+      # Check if a glyph has its own metrics
+      #
+      # Glyphs with ID < numberOfHMetrics have their own advance width
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Boolean] true if glyph has unique metrics
+      def has_unique_metrics?(glyph_id)
+        num = number_of_h_metrics
+        return false if num.nil?
+
+        glyph_id < num
+      end
+
+      # Get all advance widths
+      #
+      # @return [Array<Integer>] Array of advance widths
+      def all_advance_widths
+        return [] unless has_context?
+
+        (0...num_glyphs).map { |gid| advance_width_for(gid) || 0 }
+      end
+
+      # Get all left sidebearings
+      #
+      # @return [Array<Integer>] Array of LSB values
+      def all_lsbs
+        return [] unless has_context?
+
+        (0...num_glyphs).map { |gid| lsb_for(gid) || 0 }
+      end
+
+      # Get metrics statistics
+      #
+      # @return [Hash] Statistics about horizontal metrics
+      def statistics
+        return {} unless has_context?
+
+        widths = all_advance_widths
+        lsbs = all_lsbs
+
+        {
+          num_glyphs: num_glyphs,
+          number_of_h_metrics: number_of_h_metrics,
+          min_advance_width: widths.min,
+          max_advance_width: widths.max,
+          avg_advance_width: widths.sum.fdiv(widths.size).round(2),
+          min_lsb: lsbs.min,
+          max_lsb: lsbs.max,
+        }
+      end
+
+      private
+
+      # Ensure context tables are set
+      #
+      # @raise [ArgumentError] if context not set
+      def ensure_context!
+        unless has_context?
+          raise ArgumentError,
+                "hmtx table requires context. " \
+                "Call parse_with_context(number_of_h_metrics, num_glyphs) first"
+        end
+      end
+
+      protected
+
+      # Validate the parsed hmtx table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if hmtx table is invalid
+      def validate_parsed_table?
+        # Hmtx table validation requires context, so we can't validate here
+        # Validation is deferred until context is provided
+        true
+      end
+    end
+  end
+end

data/lib/fontisan/tables/loca_table.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "loca"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'loca' (Index to Location) table
+    #
+    # The loca table provides offsets to glyph data in the glyf table.
+    # Each glyph has an entry indicating where its data begins in the glyf table.
+    #
+    # This class extends SfntTable to provide loca-specific convenience
+    # methods for accessing glyph locations. The loca table requires context
+    # from the head and maxp tables to function properly.
+    #
+    # @example Accessing glyph locations
+    #   loca = font.sfnt_table("loca")
+    #   head = font.table("head")
+    #   maxp = font.table("maxp")
+    #
+    #   loca.parse_with_context(head.index_to_loc_format, maxp.num_glyphs)
+    #   offset = loca.offset_for(42)  # Get offset for glyph 42
+    #   size = loca.size_of(42)       # Get size of glyph 42
+    #   loca.empty?(32)              # Check if glyph 32 is empty
+    class LocaTable < SfntTable
+      # Short format constant
+      FORMAT_SHORT = 0
+
+      # Long format constant
+      FORMAT_LONG = 1
+
+      # Cache for context
+      attr_reader :index_to_loc_format, :num_glyphs
+
+      # Parse the loca table with required context
+      #
+      # The loca table cannot be used without context from head and maxp tables.
+      #
+      # @param index_to_loc_format [Integer] Format (0 = short, 1 = long) from head
+      # @param num_glyphs [Integer] Total number of glyphs from maxp
+      # @return [self] Returns self for chaining
+      # @raise [ArgumentError] if context is invalid
+      def parse_with_context(index_to_loc_format, num_glyphs)
+        unless index_to_loc_format && num_glyphs
+          raise ArgumentError,
+                "loca table requires index_to_loc_format and num_glyphs"
+        end
+
+        @index_to_loc_format = index_to_loc_format
+        @num_glyphs = num_glyphs
+
+        # Ensure parsed data is loaded
+        parse
+
+        # Parse with context
+        parsed.parse_with_context(index_to_loc_format, num_glyphs)
+
+        self
+      end
+
+      # Check if table has been parsed with context
+      #
+      # @return [Boolean] true if context is available
+      def has_context?
+        !@index_to_loc_format.nil? && !@num_glyphs.nil?
+      end
+
+      # Get the offset for a glyph ID in the glyf table
+      #
+      # @param glyph_id [Integer] Glyph ID (0-based)
+      # @return [Integer, nil] Byte offset in glyf table, or nil if invalid
+      # @raise [ArgumentError] if context not set
+      def offset_for(glyph_id)
+        ensure_context!
+        return nil unless parsed
+
+        parsed.offset_for(glyph_id)
+      end
+
+      # Calculate the size of glyph data for a glyph ID
+      #
+      # @param glyph_id [Integer] Glyph ID (0-based)
+      # @return [Integer, nil] Size in bytes, or nil if invalid
+      # @raise [ArgumentError] if context not set
+      def size_of(glyph_id)
+        ensure_context!
+        return nil unless parsed
+
+        parsed.size_of(glyph_id)
+      end
+
+      # Check if a glyph has no outline data
+      #
+      # @param glyph_id [Integer] Glyph ID (0-based)
+      # @return [Boolean, nil] True if empty, false if has data, nil if invalid
+      # @raise [ArgumentError] if context not set
+      def empty?(glyph_id)
+        ensure_context!
+        return nil unless parsed
+
+        parsed.empty?(glyph_id)
+      end
+
+      # Check if using short format (format 0)
+      #
+      # @return [Boolean] true if short format
+      def short_format?
+        return false unless parsed?
+
+        @index_to_loc_format == FORMAT_SHORT
+      end
+
+      # Check if using long format (format 1)
+      #
+      # @return [Boolean] true if long format
+      def long_format?
+        return false unless parsed?
+
+        @index_to_loc_format == FORMAT_LONG
+      end
+
+      # Get format name
+      #
+      # @return [String] "short" or "long"
+      def format_name
+        short_format? ? "short" : "long"
+      end
+
+      # Get all offsets
+      #
+      # @return [Array<Integer>] Array of glyph offsets
+      def all_offsets
+        return [] unless parsed?
+
+        parsed.offsets || []
+      end
+
+      # Get all glyph sizes
+      #
+      # @return [Array<Integer>] Array of glyph sizes
+      def all_sizes
+        return [] unless has_context?
+
+        (0...num_glyphs).map { |gid| size_of(gid) || 0 }
+      end
+
+      # Get empty glyph IDs
+      #
+      # @return [Array<Integer>] Array of empty glyph IDs
+      def empty_glyph_ids
+        return [] unless has_context?
+
+        (0...num_glyphs).select { |gid| empty?(gid) }
+      end
+
+      # Get non-empty glyph IDs
+      #
+      # @return [Array<Integer>] Array of glyph IDs with data
+      def non_empty_glyph_ids
+        return [] unless has_context?
+
+        (0...num_glyphs).reject { |gid| empty?(gid) }
+      end
+
+      # Get statistics about glyph locations
+      #
+      # @return [Hash] Statistics about loca table
+      def statistics
+        return {} unless has_context?
+
+        sizes = all_sizes
+        offsets = all_offsets
+
+        {
+          num_glyphs: num_glyphs,
+          format: format_name,
+          empty_glyph_count: empty_glyph_ids.length,
+          non_empty_glyph_count: non_empty_glyph_ids.length,
+          min_size: sizes.compact.min,
+          max_size: sizes.compact.max,
+          total_data_size: sizes.sum,
+          glyf_table_size: offsets.last || 0,
+        }
+      end
+
+      private
+
+      # Ensure context tables are set
+      #
+      # @raise [ArgumentError] if context not set
+      def ensure_context!
+        unless has_context?
+          raise ArgumentError,
+                "loca table requires context. " \
+                "Call parse_with_context(index_to_loc_format, num_glyphs) first"
+        end
+      end
+
+      protected
+
+      # Validate the parsed loca table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if loca table is invalid
+      def validate_parsed_table?
+        # Loca table validation requires context, so we can't validate here
+        true
+      end
+    end
+  end
+end

data/lib/fontisan/tables/maxp.rb

@@ -179,9 +179,9 @@ module Fontisan
       #
       # @return [Boolean] True if maxZones is valid or not applicable
       def valid_max_zones?
-        return true if version_0_5?  # Not applicable for CFF
+        return true if version_0_5? # Not applicable for CFF
 
-        max_zones && max_zones.between?(1, 2)
+        max_zones&.between?(1, 2)
       end
 
       # Validation helper: Check if all TrueType metrics are present

data/lib/fontisan/tables/maxp_table.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "maxp"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'maxp' (Maximum Profile) table
+    #
+    # The maxp table contains memory and complexity limits for the font,
+    # providing the number of glyphs and various maximum values needed
+    # for font rendering and processing.
+    #
+    # This class extends SfntTable to provide maxp-specific validation and
+    # convenience methods for accessing font complexity metrics.
+    #
+    # @example Accessing maxp table data
+    #   maxp = font.sfnt_table("maxp")
+    #   maxp.num_glyphs        # => 512
+    #   maxp.version           # => 1.0 or 0.5
+    #   maxp.truetype?         # => true or false
+    class MaxpTable < SfntTable
+      # Version 0.5 constant (CFF fonts)
+      VERSION_0_5 = 0x00005000
+
+      # Version 1.0 constant (TrueType fonts)
+      VERSION_1_0 = 0x00010000
+
+      # Get maxp table version
+      #
+      # @return [Float, nil] Version number (0.5 or 1.0), or nil if not parsed
+      def version
+        return nil unless parsed
+
+        parsed.version
+      end
+
+      # Get number of glyphs
+      #
+      # @return [Integer, nil] Total number of glyphs, or nil if not parsed
+      def num_glyphs
+        parsed&.num_glyphs
+      end
+
+      # Check if this is a TrueType font (version 1.0)
+      #
+      # @return [Boolean] true if version 1.0
+      def truetype?
+        return false unless parsed
+
+        parsed.truetype?
+      end
+
+      # Check if this is a CFF font (version 0.5)
+      #
+      # @return [Boolean] true if version 0.5
+      def cff?
+        return false unless parsed
+
+        parsed.cff?
+      end
+
+      # Get maximum points in a non-composite glyph (version 1.0)
+      #
+      # @return [Integer, nil] Maximum points, or nil if not available
+      def max_points
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_points
+      end
+
+      # Get maximum contours in a non-composite glyph (version 1.0)
+      #
+      # @return [Integer, nil] Maximum contours, or nil if not available
+      def max_contours
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_contours
+      end
+
+      # Get maximum points in a composite glyph (version 1.0)
+      #
+      # @return [Integer, nil] Maximum composite points, or nil if not available
+      def max_composite_points
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_composite_points
+      end
+
+      # Get maximum contours in a composite glyph (version 1.0)
+      #
+      # @return [Integer, nil] Maximum composite contours, or nil if not available
+      def max_composite_contours
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_composite_contours
+      end
+
+      # Get maximum zones (version 1.0)
+      #
+      # @return [Integer, nil] Maximum zones (1 or 2), or nil if not available
+      def max_zones
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_zones
+      end
+
+      # Get maximum twilight zone points (version 1.0)
+      #
+      # @return [Integer, nil] Maximum twilight points, or nil if not available
+      def max_twilight_points
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_twilight_points
+      end
+
+      # Get maximum storage area locations (version 1.0)
+      #
+      # @return [Integer, nil] Maximum storage, or nil if not available
+      def max_storage
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_storage
+      end
+
+      # Get maximum function definitions (version 1.0)
+      #
+      # @return [Integer, nil] Maximum function defs, or nil if not available
+      def max_function_defs
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_function_defs
+      end
+
+      # Get maximum instruction definitions (version 1.0)
+      #
+      # @return [Integer, nil] Maximum instruction defs, or nil if not available
+      def max_instruction_defs
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_instruction_defs
+      end
+
+      # Get maximum stack depth (version 1.0)
+      #
+      # @return [Integer, nil] Maximum stack elements, or nil if not available
+      def max_stack_elements
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_stack_elements
+      end
+
+      # Get maximum byte count for glyph instructions (version 1.0)
+      #
+      # @return [Integer, nil] Maximum instruction size, or nil if not available
+      def max_size_of_instructions
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_size_of_instructions
+      end
+
+      # Get maximum component elements in composite glyph (version 1.0)
+      #
+      # @return [Integer, nil] Maximum component elements, or nil if not available
+      def max_component_elements
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_component_elements
+      end
+
+      # Get maximum levels of recursion in composite glyphs (version 1.0)
+      #
+      # @return [Integer, nil] Maximum component depth, or nil if not available
+      def max_component_depth
+        return nil unless parsed&.version_1_0?
+
+        parsed.max_component_depth
+      end
+
+      # Check if font uses composite glyphs
+      #
+      # @return [Boolean] true if max_component_elements > 0
+      def has_composite_glyphs?
+        max_comp = max_component_elements
+        !max_comp.nil? && max_comp.positive?
+      end
+
+      # Check if font uses twilight zone
+      #
+      # @return [Boolean] true if max_zones == 2
+      def has_twilight_zone?
+        max_zones == 2
+      end
+
+      # Get complexity statistics
+      #
+      # @return [Hash] Statistics about font complexity
+      def statistics
+        stats = {
+          num_glyphs: num_glyphs,
+          version: version,
+          truetype: truetype?,
+          cff: cff?,
+        }
+
+        if truetype?
+          stats[:max_points] = max_points
+          stats[:max_contours] = max_contours
+          stats[:max_composite_points] = max_composite_points
+          stats[:max_composite_contours] = max_composite_contours
+          stats[:max_component_elements] = max_component_elements
+          stats[:max_component_depth] = max_component_depth
+          stats[:has_composite_glyphs] = has_composite_glyphs?
+          stats[:has_twilight_zone] = has_twilight_zone?
+        end
+
+        stats
+      end
+
+      protected
+
+      # Validate the parsed maxp table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if maxp table is invalid
+      def validate_parsed_table?
+        return true unless parsed
+
+        # Validate version
+        unless parsed.valid_version?
+          raise InvalidFontError,
+                "Invalid maxp table version: #{parsed.version} " \
+                "(must be 0.5 or 1.0)"
+        end
+
+        # Validate number of glyphs
+        unless parsed.valid_num_glyphs?
+          raise InvalidFontError,
+                "Invalid maxp num_glyphs: #{parsed.num_glyphs} (must be >= 1)"
+        end
+
+        # Validate max zones
+        unless parsed.valid_max_zones?
+          raise InvalidFontError,
+                "Invalid maxp max_zones: #{parsed.max_zones} (must be 1 or 2)"
+        end
+
+        # Validate metrics are reasonable
+        unless parsed.reasonable_metrics?
+          raise InvalidFontError,
+                "Invalid maxp metrics: values exceed reasonable limits"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/fontisan/tables/name.rb

@@ -203,7 +203,7 @@ module Fontisan
       #
       # @return [Boolean] True if version is 0 or 1
       def valid_version?
-        format == 0 || format == 1
+        [0, 1].include?(format)
       end
 
       # Validation helper: Check if encoding combinations are valid