fontisan 0.2.8 → 0.2.10

data/lib/fontisan/tables/glyf_table.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "glyf"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'glyf' (Glyph Data) table
+    #
+    # The glyf table contains TrueType glyph outline data. Each glyph is
+    # described by either a simple glyph (with contours and points) or a
+    # compound glyph (composed of other glyphs with transformations).
+    #
+    # This class extends SfntTable to provide glyf-specific convenience
+    # methods for accessing glyph data. The glyf table requires context
+    # from the loca and head tables to function properly.
+    #
+    # @example Accessing glyphs
+    #   glyf = font.sfnt_table("glyf")
+    #   loca = font.table("loca")
+    #   head = font.table("head")
+    #
+    #   glyf.parse_with_context(loca, head)
+    #   glyph = glyf.glyph_for(42)  # Get glyph by ID
+    #   glyph.simple?  # => true or false
+    #   glyph.bounding_box  # => [xMin, yMin, xMax, yMax]
+    class GlyfTable < SfntTable
+      # Cache for context tables
+      attr_reader :loca_table, :head_table
+
+      # Parse the glyf table with required context
+      #
+      # The glyf table cannot be used without context from loca and head tables.
+      # This method must be called before accessing glyph data.
+      #
+      # @param loca [Tables::Loca] Parsed loca table
+      # @param head [Tables::Head] Parsed head table
+      # @return [self] Returns self for chaining
+      # @raise [ArgumentError] if context is invalid
+      def parse_with_context(loca, head)
+        unless loca && head
+          raise ArgumentError,
+                "glyf table requires both loca and head tables as context"
+        end
+
+        @loca_table = loca
+        @head_table = head
+
+        # Ensure parsed data is loaded
+        parse
+
+        self
+      end
+
+      # Check if table has been parsed with context
+      #
+      # @return [Boolean] true if context is available
+      def has_context?
+        !@loca_table.nil? && !@head_table.nil?
+      end
+
+      # Get a glyph by ID
+      #
+      # @param glyph_id [Integer] Glyph ID (0-based, 0 is .notdef)
+      # @return [SimpleGlyph, CompoundGlyph, nil] Parsed glyph or nil if empty
+      # @raise [ArgumentError] if context not set
+      def glyph_for(glyph_id)
+        ensure_context!
+        return nil unless parsed
+
+        parsed.glyph_for(glyph_id, @loca_table, @head_table)
+      end
+
+      # Check if a glyph is simple (has contours)
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Boolean] true if glyph is simple
+      def simple_glyph?(glyph_id)
+        glyph = glyph_for(glyph_id)
+        return false if glyph.nil?
+
+        glyph.respond_to?(:num_contours) && glyph.num_contours >= 0
+      end
+
+      # Check if a glyph is compound
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Boolean] true if glyph is compound
+      def compound_glyph?(glyph_id)
+        glyph = glyph_for(glyph_id)
+        return false if glyph.nil?
+
+        glyph.respond_to?(:num_contours) && glyph.num_contours == -1
+      end
+
+      # Check if a glyph is empty
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Boolean] true if glyph has no data
+      def empty_glyph?(glyph_id)
+        glyph_for(glyph_id).nil?
+      end
+
+      # Get glyph bounding box
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Array<Integer>, nil] [xMin, yMin, xMax, yMax] or nil
+      def glyph_bounding_box(glyph_id)
+        glyph = glyph_for(glyph_id)
+        return nil if glyph.nil?
+
+        [glyph.x_min, glyph.y_min, glyph.x_max, glyph.y_max]
+      end
+
+      # Get number of contours for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Integer, nil] Number of contours, or nil
+      def glyph_contour_count(glyph_id)
+        glyph = glyph_for(glyph_id)
+        return nil if glyph.nil?
+
+        glyph.num_contours if glyph.respond_to?(:num_contours)
+      end
+
+      # Get number of points for a simple glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Integer, nil] Number of points, or nil
+      def glyph_point_count(glyph_id)
+        glyph = glyph_for(glyph_id)
+        return nil if glyph.nil? || !glyph.respond_to?(:num_points)
+
+        glyph.num_points
+      end
+
+      # Get glyph cache size
+      #
+      # @return [Integer] Number of cached glyphs
+      def cache_size
+        return 0 unless parsed
+
+        parsed.cache_size
+      end
+
+      # Clear glyph cache
+      #
+      # @return [void]
+      def clear_cache
+        return unless parsed
+
+        parsed.clear_cache
+      end
+
+      # Validate all glyphs are accessible
+      #
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] true if all glyphs can be accessed
+      def all_glyphs_accessible?(num_glyphs)
+        ensure_context!
+        return false unless parsed
+
+        parsed.all_glyphs_accessible?(@loca_table, @head_table, num_glyphs)
+      end
+
+      # Validate no glyphs are clipped
+      #
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] true if no glyphs exceed font bounds
+      def no_clipped_glyphs?(num_glyphs)
+        ensure_context!
+        return false unless parsed
+
+        parsed.no_clipped_glyphs?(@loca_table, @head_table, num_glyphs)
+      end
+
+      # Validate all glyphs have valid contour counts
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] true if contour count is valid
+      def valid_contour_count?(glyph_id)
+        ensure_context!
+        return false unless parsed
+
+        parsed.valid_contour_count?(glyph_id, @loca_table, @head_table)
+      end
+
+      # Validate glyphs have sound instructions
+      #
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] true if all instructions are valid
+      def instructions_sound?(num_glyphs)
+        ensure_context!
+        return false unless parsed
+
+        parsed.instructions_sound?(@loca_table, @head_table, num_glyphs)
+      end
+
+      # Get glyph statistics
+      #
+      # @param num_glyphs [Integer] Total number of glyphs
+      # @return [Hash] Statistics about the glyphs
+      def statistics(num_glyphs)
+        ensure_context!
+        return {} unless parsed
+
+        simple_count = 0
+        compound_count = 0
+        empty_count = 0
+
+        (0...num_glyphs).each do |gid|
+          if empty_glyph?(gid)
+            empty_count += 1
+          elsif simple_glyph?(gid)
+            simple_count += 1
+          elsif compound_glyph?(gid)
+            compound_count += 1
+          end
+        end
+
+        {
+          total_glyphs: num_glyphs,
+          simple_glyphs: simple_count,
+          compound_glyphs: compound_count,
+          empty_glyphs: empty_count,
+          cached_glyphs: cache_size,
+        }
+      end
+
+      private
+
+      # Ensure context tables are set
+      #
+      # @raise [ArgumentError] if context not set
+      def ensure_context!
+        unless has_context?
+          raise ArgumentError,
+                "glyf table requires context. Call parse_with_context(loca, head) first"
+        end
+      end
+
+      protected
+
+      # Validate the parsed glyf table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if glyf table is invalid
+      def validate_parsed_table?
+        # Glyf 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/head_table.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "head"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'head' (Font Header) table
+    #
+    # The head table contains global information about the font, including
+    # metadata about the font file, bounding box, and indexing information.
+    #
+    # This class extends SfntTable to provide head-specific validation and
+    # convenience methods for accessing common head table fields.
+    #
+    # @example Accessing head table data
+    #   head = font.table("head")  # Returns SfntTable instance
+    #   head.magic_number_valid?  # => true
+    #   head.units_per_em  # => 2048
+    #   head.bounding_box  # => {x_min: -123, y_min: -456, ...}
+    class HeadTable < SfntTable
+      # Check if magic number is valid
+      #
+      # @return [Boolean] true if magic number is 0x5F0F3CF5
+      def magic_number_valid?
+        parsed && parsed.magic_number == Tables::Head::MAGIC_NUMBER
+      end
+
+      # Get units per em
+      #
+      # @return [Integer, nil] Units per em value, or nil if not parsed
+      def units_per_em
+        parsed&.units_per_em
+      end
+
+      # Get font bounding box
+      #
+      # @return [Hash, nil] Bounding box hash, or nil if not parsed
+      def bounding_box
+        return nil unless parsed
+
+        {
+          x_min: parsed.x_min,
+          y_min: parsed.y_min,
+          x_max: parsed.x_max,
+          y_max: parsed.y_max,
+        }
+      end
+
+      # Get index to loc format
+      #
+      # @return [Integer, nil] IndexToLocFormat value, or nil if not parsed
+      def index_to_loc_format
+        parsed&.index_to_loc_format
+      end
+
+      # Check if using long loca format
+      #
+      # @return [Boolean] true if using 32-bit loca offsets
+      def long_loca_format?
+        index_to_loc_format == 1
+      end
+
+      # Get font version
+      #
+      # @return [Float, nil] Font version as Fixed-point number
+      def version
+        parsed&.version
+      end
+
+      # Get font revision
+      #
+      # @return [Float, nil] Font revision as Fixed-point number
+      def font_revision
+        parsed&.font_revision
+      end
+
+      protected
+
+      # Validate the parsed head table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if magic number is invalid
+      def validate_parsed_table?
+        return true unless parsed
+
+        unless magic_number_valid?
+          raise InvalidFontError,
+                "Invalid head table magic number: expected 0x#{Tables::Head::MAGIC_NUMBER.to_s(16).upcase}, " \
+                "got 0x#{parsed.magic_number.to_s(16).upcase}"
+        end
+
+        # Validate units_per_em is power of 2
+        upem = parsed.units_per_em
+        unless upem&.positive? && (upem & (upem - 1)).zero?
+          raise InvalidFontError,
+                "Invalid head table units_per_em: #{upem} (must be power of 2)"
+        end
+
+        # Validate index_to_loc_format
+        ilf = parsed.index_to_loc_format
+        unless [0, 1].include?(ilf)
+          raise InvalidFontError,
+                "Invalid head table indexToLocFormat: #{ilf} (must be 0 or 1)"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/fontisan/tables/hhea_table.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "hhea"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'hhea' (Horizontal Header) table
+    #
+    # The hhea table contains horizontal layout metrics for the entire font,
+    # defining font-wide horizontal metrics such as ascent, descent, line gap,
+    # and the number of horizontal metrics in the hmtx table.
+    #
+    # This class extends SfntTable to provide hhea-specific validation and
+    # convenience methods for accessing common hhea table fields.
+    #
+    # @example Accessing hhea table data
+    #   hhea = font.sfnt_table("hhea")
+    #   hhea.ascent            # => 2048
+    #   hhea.descent           # => -512
+    #   hhea.line_gap          # => 0
+    #   hhea.line_height       # => 2560
+    class HheaTable < SfntTable
+      # Fixed value 0x00010000 for version 1.0
+      VERSION_1_0 = 0x00010000
+
+      # Get hhea table version
+      #
+      # @return [Float, nil] Version number (typically 1.0), or nil if not parsed
+      def version
+        return nil unless parsed
+
+        parsed.version
+      end
+
+      # Get typographic ascent
+      #
+      # Distance from baseline to highest ascender (positive value)
+      #
+      # @return [Integer, nil] Ascent in FUnits, or nil if not parsed
+      def ascent
+        parsed&.ascent
+      end
+
+      # Get typographic descent
+      #
+      # Distance from baseline to lowest descender (negative value)
+      #
+      # @return [Integer, nil] Descent in FUnits, or nil if not parsed
+      def descent
+        parsed&.descent
+      end
+
+      # Get typographic line gap
+      #
+      # Additional space between lines (non-negative value)
+      #
+      # @return [Integer, nil] Line gap in FUnits, or nil if not parsed
+      def line_gap
+        parsed&.line_gap
+      end
+
+      # Get total line height
+      #
+      # Calculated as ascent - descent + line_gap
+      #
+      # @return [Integer, nil] Line height in FUnits, or nil if not parsed
+      def line_height
+        return nil unless parsed
+
+        ascent - descent + line_gap
+      end
+
+      # Get maximum advance width
+      #
+      # Maximum advance width value in hmtx table
+      #
+      # @return [Integer, nil] Maximum advance width, or nil if not parsed
+      def advance_width_max
+        parsed&.advance_width_max
+      end
+
+      # Get minimum left sidebearing
+      #
+      # @return [Integer, nil] Minimum lsb value, or nil if not parsed
+      def min_left_side_bearing
+        parsed&.min_left_side_bearing
+      end
+
+      # Get minimum right sidebearing
+      #
+      # @return [Integer, nil] Minimum rsb value, or nil if not parsed
+      def min_right_side_bearing
+        parsed&.min_right_side_bearing
+      end
+
+      # Get maximum x extent
+      #
+      # Maximum of lsb + (xMax - xMin) for all glyphs
+      #
+      # @return [Integer, nil] Maximum extent, or nil if not parsed
+      def x_max_extent
+        parsed&.x_max_extent
+      end
+
+      # Get caret slope rise
+      #
+      # Used to calculate slope of cursor (rise/run)
+      # For vertical text: rise = 1, run = 0
+      #
+      # @return [Integer, nil] Caret slope rise, or nil if not parsed
+      def caret_slope_rise
+        parsed&.caret_slope_rise
+      end
+
+      # Get caret slope run
+      #
+      # Used to calculate slope of cursor (rise/run)
+      # For vertical text: run = 0
+      #
+      # @return [Integer, nil] Caret slope run, or nil if not parsed
+      def caret_slope_run
+        parsed&.caret_slope_run
+      end
+
+      # Get caret offset
+      #
+      # Amount by which slanted highlight should be shifted
+      #
+      # @return [Integer, nil] Caret offset, or nil if not parsed
+      def caret_offset
+        parsed&.caret_offset
+      end
+
+      # Get metric data format
+      #
+      # Format of metric data (0 for current format)
+      #
+      # @return [Integer, nil] Metric data format, or nil if not parsed
+      def metric_data_format
+        parsed&.metric_data_format
+      end
+
+      # Get number of hmetrics
+      #
+      # Number of hMetric entries in hmtx table
+      #
+      # @return [Integer, nil] Number of metrics (must be >= 1), or nil if not parsed
+      def number_of_h_metrics
+        parsed&.number_of_h_metrics
+      end
+
+      # Check if caret is vertical
+      #
+      # @return [Boolean] true if caret is vertical (rise != 0, run == 0)
+      def vertical_caret?
+        return false unless parsed
+
+        caret_slope_rise != 0 && caret_slope_run.zero?
+      end
+
+      # Check if caret is italic
+      #
+      # @return [Boolean] true if caret is slanted (both rise and run non-zero)
+      def italic_caret?
+        return false unless parsed
+
+        caret_slope_rise != 0 && caret_slope_run != 0
+      end
+
+      # Check if caret is horizontal
+      #
+      # @return [Boolean] true if caret is horizontal (rise == 0, run != 0)
+      def horizontal_caret?
+        return false unless parsed
+
+        caret_slope_rise.zero? && caret_slope_run != 0
+      end
+
+      # Get caret angle in degrees
+      #
+      # @return [Float, nil] Caret angle in degrees, or nil if not parsed
+      def caret_angle
+        return nil unless parsed
+
+        return 0.0 if caret_slope_run.zero?
+
+        Math.atan2(caret_slope_rise, caret_slope_run) * (180.0 / Math::PI)
+      end
+
+      protected
+
+      # Validate the parsed hhea table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if hhea table is invalid
+      def validate_parsed_table?
+        return true unless parsed
+
+        # Validate version
+        unless parsed.valid_version?
+          raise InvalidFontError,
+                "Invalid hhea table version: expected 0x00010000 (1.0), " \
+                "got 0x#{parsed.version_raw.to_s(16).upcase}"
+        end
+
+        # Validate metric data format
+        unless parsed.valid_metric_data_format?
+          raise InvalidFontError,
+                "Invalid hhea metric data format: #{parsed.metric_data_format} (must be 0)"
+        end
+
+        # Validate number of h metrics
+        unless parsed.valid_number_of_h_metrics?
+          raise InvalidFontError,
+                "Invalid hhea number_of_h_metrics: #{parsed.number_of_h_metrics} (must be >= 1)"
+        end
+
+        # Validate ascent/descent
+        unless parsed.valid_ascent_descent?
+          raise InvalidFontError,
+                "Invalid hhea ascent/descent: ascent=#{parsed.ascent}, " \
+                "descent=#{parsed.descent} (ascent must be positive, descent must be negative)"
+        end
+
+        # Validate line gap
+        unless parsed.valid_line_gap?
+          raise InvalidFontError,
+                "Invalid hhea line_gap: #{parsed.line_gap} (must be >= 0)"
+        end
+
+        # Validate advance width max
+        unless parsed.valid_advance_width_max?
+          raise InvalidFontError,
+                "Invalid hhea advance_width_max: #{parsed.advance_width_max} (must be > 0)"
+        end
+
+        # Validate caret slope
+        unless parsed.valid_caret_slope?
+          raise InvalidFontError,
+                "Invalid hhea caret slope: rise=#{parsed.caret_slope_rise}, " \
+                "run=#{parsed.caret_slope_run} (at least one must be non-zero)"
+        end
+
+        # Validate x max extent
+        unless parsed.valid_x_max_extent?
+          raise InvalidFontError,
+                "Invalid hhea x_max_extent: #{parsed.x_max_extent} (must be > 0)"
+        end
+
+        true
+      end
+    end
+  end
+end