fontisan 0.2.8 → 0.2.9

data/lib/fontisan/tables/name_table.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "name"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'name' (Naming) table
+    #
+    # The name table contains all naming strings for the font, including
+    # font family name, style name, designer, license, etc.
+    #
+    # This class extends SfntTable to provide name-specific convenience
+    # methods for accessing common name records.
+    #
+    # @example Accessing name table data
+    #   name = font.table("name")  # Returns SfntTable instance
+    #   name.family_name  # => "Noto Sans"
+    #   name.subfamily_name  # => "Regular"
+    #   name.full_name  # => "Noto Sans Regular"
+    #   name.postscript_name  # => "NotoSans-Regular"
+    class NameTable < SfntTable
+      # Name record identifiers
+      #
+      # These are the name IDs defined in the OpenType spec
+      FAMILY = 1
+      SUBFAMILY = 2
+      FULL_NAME = 4
+      POSTSCRIPT_NAME = 6
+      PREFERRED_FAMILY = 16
+      PREFERRED_SUBFAMILY = 17
+      WWS_FAMILY = 21
+      WWS_SUBFAMILY = 22
+
+      # Platform IDs
+      PLATFORM_UNICODE = 0
+      PLATFORM_MACINTOSH = 1
+      PLATFORM_WINDOWS = 3
+
+      # Get font family name
+      #
+      # Attempts to get the preferred family name, falling back to the
+      # standard family name if preferred is not available.
+      #
+      # @return [String, nil] Family name or nil if not found
+      def family_name
+        english_name(PREFERRED_FAMILY) || english_name(FAMILY)
+      end
+
+      # Get font subfamily name
+      #
+      # Attempts to get the preferred subfamily name, falling back to the
+      # standard subfamily name if preferred is not available.
+      #
+      # @return [String, nil] Subfamily name or nil if not found
+      def subfamily_name
+        english_name(PREFERRED_SUBFAMILY) || english_name(SUBFAMILY)
+      end
+
+      # Get full font name
+      #
+      # @return [String, nil] Full name or nil if not found
+      def full_name
+        english_name(FULL_NAME)
+      end
+
+      # Get PostScript name
+      #
+      # @return [String, nil] PostScript name or nil if not found
+      def postscript_name
+        english_name(POSTSCRIPT_NAME)
+      end
+
+      # Get preferred family name
+      #
+      # @return [String, nil] Preferred family name or nil if not found
+      def preferred_family_name
+        english_name(PREFERRED_FAMILY)
+      end
+
+      # Get preferred subfamily name
+      #
+      # @return [String, nil] Preferred subfamily name or nil if not found
+      def preferred_subfamily_name
+        english_name(PREFERRED_SUBFAMILY)
+      end
+
+      # Get English name for a specific name ID
+      #
+      # Searches for an English name record with the given name ID.
+      # Prefers Windows (platform 3) over Mac (platform 1) over Unicode (platform 0).
+      #
+      # @param name_id [Integer] The name record ID
+      # @return [String, nil] The name string, or nil if not found
+      def english_name(name_id)
+        return nil unless parsed
+
+        # Find all name records with this name_id
+        records = parsed.name_records.select { |nr| nr.name_id == name_id }
+        return nil if records.empty?
+
+        # Try to find English Windows name first (platform 3, language 0x409)
+        windows = records.find do |nr|
+          nr.platform_id == PLATFORM_WINDOWS && nr.language_id == 0x409
+        end
+        return windows.string if windows&.string
+
+        # Try Mac English (platform 1, language 0)
+        mac = records.find do |nr|
+          nr.platform_id == PLATFORM_MACINTOSH && nr.language_id.zero?
+        end
+        return mac.string if mac&.string
+
+        # Try any English Unicode name (platform 0, language 0)
+        unicode = records.find do |nr|
+          nr.platform_id == PLATFORM_UNICODE && nr.language_id.zero?
+        end
+        return unicode.string if unicode&.string
+
+        # Fallback to first record with this name_id
+        first = records.first
+        first&.string
+      end
+
+      # Get all name records
+      #
+      # @return [Array<NameRecord>, nil] Array of name records, or nil if not parsed
+      def name_records
+        parsed&.name_records
+      end
+
+      # Get all names for a specific name ID
+      #
+      # @param name_id [Integer] The name record ID
+      # @return [Array<Hash>] Array of hashes with platform, encoding, language, and string
+      def all_names_for(name_id)
+        return [] unless parsed
+
+        parsed.name_records
+          .select { |nr| nr.name_id == name_id }
+          .map do |nr|
+            {
+              platform_id: nr.platform_id,
+              encoding_id: nr.encoding_id,
+              language_id: nr.language_id,
+              string: nr.string,
+            }
+          end
+      end
+
+      protected
+
+      # Validate the parsed name table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if format identifier is invalid
+      def validate_parsed_table?
+        return true unless parsed
+
+        # Validate format selector
+        unless [0, 1].include?(parsed.format)
+          raise InvalidFontError,
+                "Invalid name table format: #{parsed.format} (must be 0 or 1)"
+        end
+
+        # Validate that we have at least some name records
+        if parsed.name_records.empty?
+          raise InvalidFontError,
+                "Name table has no name records"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/fontisan/tables/os2_table.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "os2"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'OS/2' (OS/2 and Windows Metrics) table
+    #
+    # The OS/2 table contains OS/2 and Windows-specific metrics required by
+    # Windows and OS/2, including font metrics, character ranges, vendor
+    # information, and embedding permissions.
+    #
+    # This class extends SfntTable to provide OS/2-specific validation and
+    # convenience methods for accessing common OS/2 table fields.
+    #
+    # @example Accessing OS/2 table data
+    #   os2 = font.sfnt_table("OS/2")
+    #   os2.weight_class      # => 400 (Normal)
+    #   os2.width_class       # => 5 (Medium)
+    #   os2.vendor_id         # => "APPL"
+    #   os2.embedding_allowed? # => true
+    class Os2Table < SfntTable
+      # Weight class names (from OpenType spec)
+      WEIGHT_NAMES = {
+        100 => "Thin",
+        200 => "Extra-light (Ultra-light)",
+        300 => "Light",
+        400 => "Normal (Regular)",
+        500 => "Medium",
+        600 => "Semi-bold (Demi-bold)",
+        700 => "Bold",
+        800 => "Extra-bold (Ultra-bold)",
+        900 => "Black (Heavy)",
+      }.freeze
+
+      # Width class names (from OpenType spec)
+      WIDTH_NAMES = {
+        1 => "Ultra-condensed",
+        2 => "Extra-condensed",
+        3 => "Condensed",
+        4 => "Semi-condensed",
+        5 => "Medium (Normal)",
+        6 => "Semi-expanded",
+        7 => "Expanded",
+        8 => "Extra-expanded",
+        9 => "Ultra-expanded",
+      }.freeze
+
+      # Selection flags (bit field)
+      FS_ITALIC = 1 << 0
+      FS_UNDERSCORE = 1 << 1
+      FS_NEGATIVE = 1 << 2
+      FS_OUTLINED = 1 << 3
+      FS_STRIKEOUT = 1 << 4
+      FS_BOLD = 1 << 5
+      FS_REGULAR = 1 << 6
+      FS_USE_TYPO_METRICS = 1 << 7
+      FS_WWS = 1 << 8
+      FS_OBLIQUE = 1 << 9
+
+      # Get OS/2 table version
+      #
+      # @return [Integer, nil] Version number (0-5), or nil if not parsed
+      def version
+        parsed&.version
+      end
+
+      # Get weight class
+      #
+      # @return [Integer, nil] Weight class (100-900), or nil if not parsed
+      def weight_class
+        parsed&.us_weight_class
+      end
+
+      # Get weight class name
+      #
+      # @return [String, nil] Human-readable weight name, or nil if not parsed
+      def weight_class_name
+        return nil unless parsed
+
+        WEIGHT_NAMES[parsed.us_weight_class] || "Unknown"
+      end
+
+      # Get width class
+      #
+      # @return [Integer, nil] Width class (1-9), or nil if not parsed
+      def width_class
+        parsed&.us_width_class
+      end
+
+      # Get width class name
+      #
+      # @return [String, nil] Human-readable width name, or nil if not parsed
+      def width_class_name
+        return nil unless parsed
+
+        WIDTH_NAMES[parsed.us_width_class] || "Unknown"
+      end
+
+      # Get vendor ID
+      #
+      # @return [String, nil] 4-character vendor identifier, or nil if not parsed
+      def vendor_id
+        parsed&.vendor_id
+      end
+
+      # Check if font is italic
+      #
+      # @return [Boolean] true if italic flag is set
+      def italic?
+        parsed && (parsed.fs_selection & FS_ITALIC) != 0
+      end
+
+      # Check if font is bold
+      #
+      # @return [Boolean] true if bold flag is set
+      def bold?
+        parsed && (parsed.fs_selection & FS_BOLD) != 0
+      end
+
+      # Check if font uses regular style
+      #
+      # @return [Boolean] true if regular flag is set
+      def regular?
+        parsed && (parsed.fs_selection & FS_REGULAR) != 0
+      end
+
+      # Check if font uses typographic metrics
+      #
+      # @return [Boolean] true if use typo metrics flag is set
+      def use_typo_metrics?
+        parsed && (parsed.fs_selection & FS_USE_TYPO_METRICS) != 0
+      end
+
+      # Check if font is oblique
+      #
+      # @return [Boolean] true if oblique flag is set
+      def oblique?
+        parsed && (parsed.fs_selection & FS_OBLIQUE) != 0
+      end
+
+      # Get typographic ascent
+      #
+      # @return [Integer, nil] Typographic ascender, or nil if not parsed
+      def typo_ascender
+        parsed&.s_typo_ascender
+      end
+
+      # Get typographic descent
+      #
+      # @return [Integer, nil] Typographic descender (negative value), or nil if not parsed
+      def typo_descender
+        parsed&.s_typo_descender
+      end
+
+      # Get typographic line gap
+      #
+      # @return [Integer, nil] Line gap, or nil if not parsed
+      def typo_line_gap
+        parsed&.s_typo_line_gap
+      end
+
+      # Get Windows ascent
+      #
+      # @return [Integer, nil] Windows ascender, or nil if not parsed
+      def win_ascent
+        parsed&.us_win_ascent
+      end
+
+      # Get Windows descent
+      #
+      # @return [Integer, nil] Windows descender, or nil if not parsed
+      def win_descent
+        parsed&.us_win_descent
+      end
+
+      # Get x-height (version 2+)
+      #
+      # @return [Integer, nil] x-height value, or nil if not available
+      def x_height
+        parsed&.sx_height
+      end
+
+      # Get cap height (version 2+)
+      #
+      # @return [Integer, nil] Cap height value, or nil if not available
+      def cap_height
+        parsed&.s_cap_height
+      end
+
+      # Check if embedding is allowed
+      #
+      # @return [Boolean] true if embedding is permitted (fs_type & 0x8 == 0)
+      def embedding_allowed?
+        return false unless parsed
+
+        # fs_type bit 3 (0x8) = Embedding must not be allowed
+        # If bit 3 is NOT set, embedding is allowed
+        (parsed.fs_type & 0x8).zero?
+      end
+
+      # Check if embedding is restricted
+      #
+      # @return [Boolean] true if embedding is restricted
+      def embedding_restricted?
+        !embedding_allowed?
+      end
+
+      # Check if preview/print embedding is allowed
+      #
+      # @return [Boolean] true if preview and print embedding is permitted
+      def preview_print_allowed?
+        return false unless parsed
+
+        # fs_type bit 1 (0x2) = Preview & Print embedding allowed
+        (parsed.fs_type & 0x2) != 0
+      end
+
+      # Check if editable embedding is allowed
+      #
+      # @return [Boolean] true if editable embedding is permitted
+      def editable_allowed?
+        return false unless parsed
+
+        # fs_type bit 2 (0x4) = Editable embedding allowed
+        (parsed.fs_type & 0x4) != 0
+      end
+
+      # Check if subsetting is allowed
+      #
+      # @return [Boolean] true if subsetting is permitted (fs_type bit 8 is NOT set)
+      def subsetting_allowed?
+        return false unless parsed
+
+        # fs_type bit 8 (0x100) = No subsetting
+        (parsed.fs_type & 0x100).zero?
+      end
+
+      # Check if bitmap embedding only is allowed
+      #
+      # @return [Boolean] true if only bitmaps can be embedded
+      def bitmap_embedding_only?
+        return false unless parsed
+
+        # fs_type bit 9 (0x200) = Bitmap embedding only
+        (parsed.fs_type & 0x200) != 0
+      end
+
+      # Get PANOSE classification
+      #
+      # @return [Array<Integer>, nil] Array of 10 PANOSE bytes, or nil if not parsed
+      def panose
+        parsed&.panose&.to_a
+      end
+
+      # Get first character index
+      #
+      # @return [Integer, nil] First character Unicode value, or nil if not parsed
+      def first_char_index
+        parsed&.us_first_char_index
+      end
+
+      # Get last character index
+      #
+      # @return [Integer, nil] Last character Unicode value, or nil if not parsed
+      def last_char_index
+        parsed&.us_last_char_index
+      end
+
+      protected
+
+      # Validate the parsed OS/2 table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if OS/2 table is invalid
+      def validate_parsed_table?
+        return true unless parsed
+
+        # Validate version
+        unless parsed.valid_version?
+          raise InvalidFontError,
+                "Invalid OS/2 table version: #{parsed.version} (must be 0-5)"
+        end
+
+        # Validate weight class
+        unless parsed.valid_weight_class?
+          raise InvalidFontError,
+                "Invalid OS/2 weight class: #{parsed.us_weight_class} (must be 1-1000)"
+        end
+
+        # Validate width class
+        unless parsed.valid_width_class?
+          raise InvalidFontError,
+                "Invalid OS/2 width class: #{parsed.us_width_class} (must be 1-9)"
+        end
+
+        # Validate vendor ID
+        unless parsed.has_vendor_id?
+          raise InvalidFontError,
+                "Invalid OS/2 vendor ID: empty or missing"
+        end
+
+        # Validate typo metrics
+        unless parsed.valid_typo_metrics?
+          raise InvalidFontError,
+                "Invalid OS/2 typo metrics: ascent=#{parsed.s_typo_ascender}, " \
+                "descent=#{parsed.s_typo_descender}, line_gap=#{parsed.s_typo_line_gap}"
+        end
+
+        # Validate Win metrics
+        unless parsed.valid_win_metrics?
+          raise InvalidFontError,
+                "Invalid OS/2 Win metrics: win_ascent=#{parsed.us_win_ascent}, " \
+                "win_descent=#{parsed.us_win_descent} (both must be positive)"
+        end
+
+        # Validate character range
+        unless parsed.valid_char_range?
+          raise InvalidFontError,
+                "Invalid OS/2 character range: first=#{parsed.us_first_char_index}, " \
+                "last=#{parsed.us_last_char_index} (first must be <= last)"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/fontisan/tables/post_table.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative "../sfnt_table"
+require_relative "post"
+
+module Fontisan
+  module Tables
+    # OOP representation of the 'post' (PostScript) table
+    #
+    # The post table contains PostScript information, primarily glyph names.
+    # Different versions exist (1.0, 2.0, 2.5, 3.0, 4.0) with varying
+    # glyph name storage strategies.
+    #
+    # This class extends SfntTable to provide post-specific validation and
+    # convenience methods for accessing PostScript metrics and glyph names.
+    #
+    # @example Accessing post table data
+    #   post = font.sfnt_table("post")
+    #   post.italic_angle      # => 0.0
+    #   post.underline_position # => -100
+    #   post.underline_thickness # => 50
+    #   post.glyph_name_for(42) # => "A"
+    class PostTable < SfntTable
+      # Get post table version
+      #
+      # @return [Float, nil] Version number (1.0, 2.0, 2.5, 3.0, or 4.0)
+      def version
+        return nil unless parsed
+
+        parsed.version
+      end
+
+      # Get italic angle in degrees
+      #
+      # Positive value means counter-clockwise tilt
+      #
+      # @return [Float, nil] Italic angle in degrees, or nil if not parsed
+      def italic_angle
+        return nil unless parsed
+
+        parsed.italic_angle
+      end
+
+      # Check if font is italic
+      #
+      # @return [Boolean] true if italic_angle != 0
+      def italic?
+        angle = italic_angle
+        !angle.nil? && angle != 0
+      end
+
+      # Get underline position
+      #
+      # Distance from baseline to top of underline (negative for under baseline)
+      #
+      # @return [Integer, nil] Underline position in FUnits, or nil if not parsed
+      def underline_position
+        parsed&.underline_position
+      end
+
+      # Get underline thickness
+      #
+      # @return [Integer, nil] Underline thickness in FUnits, or nil if not parsed
+      def underline_thickness
+        parsed&.underline_thickness
+      end
+
+      # Check if font is fixed pitch (monospaced)
+      #
+      # @return [Boolean] true if font is monospaced
+      def fixed_pitch?
+        return false unless parsed
+
+        parsed.is_fixed_pitch == 1
+      end
+
+      # Get minimum memory for Type 42 fonts
+      #
+      # @return [Integer, nil] Minimum memory in bytes, or nil if not parsed
+      def min_mem_type42
+        parsed&.min_mem_type42
+      end
+
+      # Get maximum memory for Type 42 fonts
+      #
+      # @return [Integer, nil] Maximum memory in bytes, or nil if not parsed
+      def max_mem_type42
+        parsed&.max_mem_type42
+      end
+
+      # Get minimum memory for Type 1 fonts
+      #
+      # @return [Integer, nil] Minimum memory in bytes, or nil if not parsed
+      def min_mem_type1
+        parsed&.min_mem_type1
+      end
+
+      # Get maximum memory for Type 1 fonts
+      #
+      # @return [Integer, nil] Maximum memory in bytes, or nil if not parsed
+      def max_mem_type1
+        parsed&.max_mem_type1
+      end
+
+      # Get all glyph names
+      #
+      # Only available for version 1.0 and 2.0
+      #
+      # @return [Array<String>] Array of glyph names
+      def glyph_names
+        return [] unless parsed
+
+        parsed.glyph_names || []
+      end
+
+      # Get glyph name by ID
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [String, nil] Glyph name, or nil if not found
+      def glyph_name_for(glyph_id)
+        names = glyph_names
+        return nil if glyph_id.negative? || glyph_id >= names.length
+
+        names[glyph_id]
+      end
+
+      # Check if glyph names are available
+      #
+      # @return [Boolean] true if glyph names can be retrieved
+      def has_glyph_names?
+        return false unless parsed
+
+        parsed.has_glyph_names?
+      end
+
+      # Get the number of glyphs with names
+      #
+      # @return [Integer] Number of named glyphs
+      def named_glyph_count
+        glyph_names.length
+      end
+
+      protected
+
+      # Validate the parsed post table
+      #
+      # @return [Boolean] true if valid
+      # @raise [InvalidFontError] if post table is invalid
+      def validate_parsed_table?
+        return true unless parsed
+
+        # Validate version
+        unless parsed.valid_version?
+          raise InvalidFontError,
+                "Invalid post table version: #{parsed.version} " \
+                "(must be 1.0, 2.0, 2.5, 3.0, or 4.0)"
+        end
+
+        # Validate italic angle
+        unless parsed.valid_italic_angle?
+          raise InvalidFontError,
+                "Invalid post italic angle: #{parsed.italic_angle} " \
+                "(must be between -60 and 60 degrees)"
+        end
+
+        # Validate fixed pitch flag
+        unless parsed.valid_fixed_pitch_flag?
+          raise InvalidFontError,
+                "Invalid post is_fixed_pitch: #{parsed.is_fixed_pitch} " \
+                "(must be 0 or 1)"
+        end
+
+        # Validate version 2.0 data completeness
+        unless parsed.complete_version_2_data?
+          raise InvalidFontError,
+                "Invalid post version 2.0 table: incomplete data"
+        end
+
+        true
+      end
+    end
+  end
+end