fontisan 0.2.7 → 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.rb

@@ -177,7 +177,7 @@ module Fontisan
       #
       # @return [Boolean] True if version is 0-5
       def valid_version?
-        version && version.between?(0, 5)
+        version&.between?(0, 5)
       end
 
       # Validation helper: Check if weight class is valid
@@ -186,7 +186,7 @@ module Fontisan
       #
       # @return [Boolean] True if weight class is valid
       def valid_weight_class?
-        us_weight_class && us_weight_class.between?(1, 1000)
+        us_weight_class&.between?(1, 1000)
       end
 
       # Validation helper: Check if width class is valid
@@ -195,7 +195,7 @@ module Fontisan
       #
       # @return [Boolean] True if width class is 1-9
       def valid_width_class?
-        us_width_class && us_width_class.between?(1, 9)
+        us_width_class&.between?(1, 9)
       end
 
       # Validation helper: Check if vendor ID is present
@@ -213,7 +213,7 @@ module Fontisan
       #
       # @return [Boolean] True if typo metrics have correct signs
       def valid_typo_metrics?
-        s_typo_ascender > 0 && s_typo_descender < 0 && s_typo_line_gap >= 0
+        s_typo_ascender.positive? && s_typo_descender.negative? && s_typo_line_gap >= 0
       end
 
       # Validation helper: Check if Win metrics are valid
@@ -222,7 +222,7 @@ module Fontisan
       #
       # @return [Boolean] True if Win ascent and descent are positive
       def valid_win_metrics?
-        us_win_ascent > 0 && us_win_descent > 0
+        us_win_ascent.positive? && us_win_descent.positive?
       end
 
       # Validation helper: Check if Unicode ranges are set
@@ -240,7 +240,7 @@ module Fontisan
       #
       # @return [Boolean] True if PANOSE seems to be set
       def has_panose?
-        panose && panose.any? { |val| val != 0 }
+        panose&.any? { |val| val != 0 }
       end
 
       # Validation helper: Check if embedding permissions are set
@@ -270,9 +270,9 @@ module Fontisan
       #
       # @return [Boolean] True if metrics are present (or not required)
       def has_x_height_cap_height?
-        return true if version < 2  # Not required for v0-1
+        return true if version < 2 # Not required for v0-1
 
-        !sx_height.nil? && !s_cap_height.nil? && sx_height > 0 && s_cap_height > 0
+        !sx_height.nil? && !s_cap_height.nil? && sx_height.positive? && s_cap_height.positive?
       end
 
       # Validation helper: Check if first/last char indices are reasonable

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.rb

@@ -177,7 +177,7 @@ module Fontisan
       #
       # @return [Boolean] True if is_fixed_pitch is 0 or 1
       def valid_fixed_pitch_flag?
-        is_fixed_pitch == 0 || is_fixed_pitch == 1
+        [0, 1].include?(is_fixed_pitch)
       end
 
       # Validation helper: Check if glyph names are available
@@ -198,7 +198,7 @@ module Fontisan
       def complete_version_2_data?
         return true unless version == 2.0
 
-        !num_glyphs_v2.nil? && num_glyphs_v2 > 0 && !remaining_data.empty?
+        !num_glyphs_v2.nil? && num_glyphs_v2.positive? && !remaining_data.empty?
       end
     end
   end