fontisan 0.2.4 → 0.2.6

data/lib/fontisan/tables/name.rb

@@ -199,6 +199,82 @@ module Fontisan
         false
       end
 
+      # Validation helper: Check if version is valid (0 or 1)
+      #
+      # @return [Boolean] True if version is 0 or 1
+      def valid_version?
+        format == 0 || format == 1
+      end
+
+      # Validation helper: Check if encoding combinations are valid
+      #
+      # According to OpenType spec, certain platform/encoding combinations are valid:
+      # - Platform 0 (Unicode): encoding 0-6
+      # - Platform 1 (Mac): encoding 0-32
+      # - Platform 3 (Windows): encoding 0-10
+      #
+      # @return [Boolean] True if all encoding heuristics are valid
+      def valid_encoding_heuristics?
+        name_records.all? do |rec|
+          case rec.platform_id
+          when PLATFORM_UNICODE
+            rec.encoding_id.between?(0, 6)
+          when PLATFORM_MACINTOSH
+            rec.encoding_id.between?(0, 32)
+          when PLATFORM_WINDOWS
+            rec.encoding_id.between?(0, 10)
+          else
+            # Unknown platform - consider invalid
+            false
+          end
+        end
+      end
+
+      # Validation helper: Check if required platform combinations exist
+      #
+      # @param combos [Array<Array<Integer>>] Array of [platform_id, encoding_id, language_id] arrays
+      # @return [Boolean] True if all required combinations are present
+      #
+      # @example Check for Windows English name
+      #   name.has_valid_platform_combos?([3, 1, 0x0409])
+      def has_valid_platform_combos?(*combos)
+        combos.all? do |platform_id, encoding_id, language_id|
+          name_records.any? do |rec|
+            rec.platform_id == platform_id &&
+              rec.encoding_id == encoding_id &&
+              rec.language_id == language_id
+          end
+        end
+      end
+
+      # Validation helper: Check if family name is present and non-empty
+      #
+      # @return [Boolean] True if family name exists and is not empty
+      def family_name_present?
+        name = english_name(FAMILY)
+        !name.nil? && !name.empty?
+      end
+
+      # Validation helper: Check if PostScript name is present and non-empty
+      #
+      # @return [Boolean] True if PostScript name exists and is not empty
+      def postscript_name_present?
+        name = english_name(POSTSCRIPT_NAME)
+        !name.nil? && !name.empty?
+      end
+
+      # Validation helper: Check if PostScript name is valid
+      #
+      # PostScript names must contain only ASCII alphanumerics and hyphens
+      #
+      # @return [Boolean] True if PostScript name matches the required pattern
+      def postscript_name_valid?
+        name = english_name(POSTSCRIPT_NAME)
+        return false if name.nil? || name.empty?
+
+        name.match?(/^[A-Za-z0-9-]+$/)
+      end
+
       private
 
       # Find a name record matching the criteria

data/lib/fontisan/tables/os2.rb

@@ -170,6 +170,119 @@ module Fontisan
 
         us_upper_optical_point_size / 20.0
       end
+
+      # Validation helper: Check if version is valid
+      #
+      # Valid versions are 0 through 5
+      #
+      # @return [Boolean] True if version is 0-5
+      def valid_version?
+        version && version.between?(0, 5)
+      end
+
+      # Validation helper: Check if weight class is valid
+      #
+      # Valid values are 1-1000, common values are multiples of 100
+      #
+      # @return [Boolean] True if weight class is valid
+      def valid_weight_class?
+        us_weight_class && us_weight_class.between?(1, 1000)
+      end
+
+      # Validation helper: Check if width class is valid
+      #
+      # Valid values are 1-9
+      #
+      # @return [Boolean] True if width class is 1-9
+      def valid_width_class?
+        us_width_class && us_width_class.between?(1, 9)
+      end
+
+      # Validation helper: Check if vendor ID is present
+      #
+      # Vendor ID should be a 4-character code
+      #
+      # @return [Boolean] True if vendor ID exists and is non-empty
+      def has_vendor_id?
+        !vendor_id.empty?
+      end
+
+      # Validation helper: Check if typo metrics are reasonable
+      #
+      # Ascent should be positive, descender negative, line gap non-negative
+      #
+      # @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
+      end
+
+      # Validation helper: Check if Win metrics are valid
+      #
+      # Both should be positive (unsigned in spec)
+      #
+      # @return [Boolean] True if Win ascent and descent are positive
+      def valid_win_metrics?
+        us_win_ascent > 0 && us_win_descent > 0
+      end
+
+      # Validation helper: Check if Unicode ranges are set
+      #
+      # At least one Unicode range bit should be set
+      #
+      # @return [Boolean] True if any Unicode range bits are set
+      def has_unicode_ranges?
+        (ul_unicode_range1 | ul_unicode_range2 | ul_unicode_range3 | ul_unicode_range4) != 0
+      end
+
+      # Validation helper: Check if PANOSE data is present
+      #
+      # All PANOSE values should not be zero
+      #
+      # @return [Boolean] True if PANOSE seems to be set
+      def has_panose?
+        panose && panose.any? { |val| val != 0 }
+      end
+
+      # Validation helper: Check if embedding permissions are set
+      #
+      # fs_type indicates embedding and subsetting permissions
+      #
+      # @return [Boolean] True if embedding permissions are defined
+      def has_embedding_permissions?
+        !fs_type.nil?
+      end
+
+      # Validation helper: Check if selection flags are valid
+      #
+      # Checks for valid combinations of selection flags
+      #
+      # @return [Boolean] True if fs_selection has valid flags
+      def valid_selection_flags?
+        return false if fs_selection.nil?
+
+        # Bits 0-9 are defined, others should be zero
+        (fs_selection & 0xFC00).zero?
+      end
+
+      # Validation helper: Check if x_height and cap_height are present (v2+)
+      #
+      # For version 2+, these should be set
+      #
+      # @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
+
+        !sx_height.nil? && !s_cap_height.nil? && sx_height > 0 && s_cap_height > 0
+      end
+
+      # Validation helper: Check if first/last char indices are reasonable
+      #
+      # first should be <= last
+      #
+      # @return [Boolean] True if character range is valid
+      def valid_char_range?
+        us_first_char_index <= us_last_char_index
+      end
     end
   end
 end

data/lib/fontisan/tables/post.rb

@@ -143,6 +143,63 @@ module Fontisan
         end
       end
       # rubocop:enable Metrics/PerceivedComplexity
+
+      public
+
+      # Validation helper: Check if version is valid
+      #
+      # Common versions: 1.0, 2.0, 2.5, 3.0, 4.0
+      #
+      # @return [Boolean] True if version is recognized
+      def valid_version?
+        [1.0, 2.0, 2.5, 3.0, 4.0].include?(version)
+      end
+
+      # Validation helper: Check if italic angle is reasonable
+      #
+      # Italic angle should be between -60 and 60 degrees
+      #
+      # @return [Boolean] True if italic angle is within reasonable bounds
+      def valid_italic_angle?
+        italic_angle.abs <= 60.0
+      end
+
+      # Validation helper: Check if underline values are present
+      #
+      # Both position and thickness should be non-zero for valid underline
+      #
+      # @return [Boolean] True if underline metrics exist
+      def has_underline_metrics?
+        underline_position != 0 && underline_thickness != 0
+      end
+
+      # Validation helper: Check if fixed pitch flag is consistent
+      #
+      # @return [Boolean] True if is_fixed_pitch is 0 or 1
+      def valid_fixed_pitch_flag?
+        is_fixed_pitch == 0 || is_fixed_pitch == 1
+      end
+
+      # Validation helper: Check if glyph names are available
+      #
+      # For versions 1.0 and 2.0, glyph names should be accessible
+      #
+      # @return [Boolean] True if glyph names can be retrieved
+      def has_glyph_names?
+        names = glyph_names
+        !names.nil? && !names.empty?
+      end
+
+      # Validation helper: Check if version 2.0 data is complete
+      #
+      # For version 2.0, we should have glyph count and name data
+      #
+      # @return [Boolean] True if version 2.0 data is present and complete
+      def complete_version_2_data?
+        return true unless version == 2.0
+
+        !num_glyphs_v2.nil? && num_glyphs_v2 > 0 && !remaining_data.empty?
+      end
     end
   end
 end

data/lib/fontisan/true_type_font.rb

@@ -69,12 +69,6 @@ module Fontisan
     # Whether lazy loading is enabled
     attr_accessor :lazy_load_enabled
 
-    # Page cache for lazy loading (maps page_start_offset => page_data)
-    attr_accessor :page_cache
-
-    # Page size for lazy loading alignment (typical filesystem page size)
-    PAGE_SIZE = 4096
-
     # Read TrueType Font from a file
     #
     # @param path [String] Path to the TTF file
@@ -101,8 +95,9 @@ module Fontisan
         font.lazy_load_enabled = lazy
 
         if lazy
-          # Keep file handle open for lazy loading
-          font.io_source = File.open(path, "rb")
+          # Reuse existing IO handle by duplicating it to prevent double file open
+          # The dup ensures the handle stays open after this block closes
+          font.io_source = io.dup
           font.setup_finalizer
         else
           # Read tables upfront
@@ -141,7 +136,6 @@ module Fontisan
       @loading_mode = LoadingModes::FULL
       @lazy_load_enabled = false
       @io_source = nil
-      @page_cache = {}
     end
 
     # Read table data for all tables
@@ -450,8 +444,8 @@ module Fontisan
 
     # Load a single table's data on demand
     #
-    # Uses page-aligned reads and caches pages to ensure lazy loading
-    # performance is not slower than eager loading.
+    # Uses direct seek-and-read for minimal overhead. This ensures lazy loading
+    # performance is comparable to eager loading when accessing all tables.
     #
     # @param tag [String] The table tag to load
     # @return [void]
@@ -461,42 +455,10 @@ module Fontisan
       entry = find_table_entry(tag)
       return nil unless entry
 
-      # Use page-aligned reading with caching
-      table_start = entry.offset
-      table_end = entry.offset + entry.table_length
-
-      # Calculate page boundaries
-      page_start = (table_start / PAGE_SIZE) * PAGE_SIZE
-      page_end = ((table_end + PAGE_SIZE - 1) / PAGE_SIZE) * PAGE_SIZE
-
-      # Read all required pages (or use cached pages)
-      table_data_parts = []
-      current_page = page_start
-
-      while current_page < page_end
-        page_data = @page_cache[current_page]
-
-        unless page_data
-          # Read page from disk and cache it
-          @io_source.seek(current_page)
-          page_data = @io_source.read(PAGE_SIZE) || ""
-          @page_cache[current_page] = page_data
-        end
-
-        # Calculate which part of this page we need
-        chunk_start = [table_start - current_page, 0].max
-        chunk_end = [table_end - current_page, PAGE_SIZE].min
-
-        if chunk_end > chunk_start
-          table_data_parts << page_data[chunk_start...chunk_end]
-        end
-
-        current_page += PAGE_SIZE
-      end
-
-      # Combine parts and store
+      # Direct seek and read - same as eager loading but on-demand
+      @io_source.seek(entry.offset)
       tag_key = tag.dup.force_encoding("UTF-8")
-      @table_data[tag_key] = table_data_parts.join
+      @table_data[tag_key] = @io_source.read(entry.table_length)
     end
 
     # Parse a table from raw data (Fontisan extension)

data/lib/fontisan/validation/collection_validator.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative "../error"
+
+module Fontisan
+  module Validation
+    # CollectionValidator validates font compatibility for collection formats
+    #
+    # Main responsibility: Enforce format-specific compatibility rules for
+    # TTC, OTC, and dfont collections according to OpenType spec and Apple standards.
+    #
+    # Rules:
+    # - TTC: TrueType fonts ONLY (per OpenType spec)
+    # - OTC: CFF fonts required, mixed TTF+OTF allowed (Fontisan extension)
+    # - dfont: Any SFNT fonts (TTF, OTF, or mixed)
+    # - All: Web fonts (WOFF/WOFF2) are NEVER allowed in collections
+    #
+    # @example Validate TTC compatibility
+    #   validator = CollectionValidator.new
+    #   validator.validate!([font1, font2], :ttc)
+    #
+    # @example Check compatibility without raising
+    #   validator = CollectionValidator.new
+    #   result = validator.compatible?([font1, font2], :otc)
+    class CollectionValidator
+      # Validate fonts are compatible with collection format
+      #
+      # @param fonts [Array<TrueTypeFont, OpenTypeFont>] Fonts to validate
+      # @param format [Symbol] Collection format (:ttc, :otc, or :dfont)
+      # @return [Boolean] true if valid
+      # @raise [Error] if validation fails
+      def validate!(fonts, format)
+        validate_not_empty!(fonts)
+        validate_format!(format)
+
+        case format
+        when :ttc
+          validate_ttc!(fonts)
+        when :otc
+          validate_otc!(fonts)
+        when :dfont
+          validate_dfont!(fonts)
+        else
+          raise Error, "Unknown collection format: #{format}"
+        end
+
+        true
+      end
+
+      # Check if fonts are compatible with format (without raising)
+      #
+      # @param fonts [Array] Fonts to check
+      # @param format [Symbol] Collection format
+      # @return [Boolean] true if compatible
+      def compatible?(fonts, format)
+        validate!(fonts, format)
+        true
+      rescue Error
+        false
+      end
+
+      # Get compatibility issues for fonts and format
+      #
+      # @param fonts [Array] Fonts to check
+      # @param format [Symbol] Collection format
+      # @return [Array<String>] Array of issue descriptions (empty if compatible)
+      def compatibility_issues(fonts, format)
+        issues = []
+
+        return ["Font array cannot be empty"] if fonts.nil? || fonts.empty?
+        return ["Invalid format: #{format}"] unless %i[ttc otc dfont].include?(format)
+
+        case format
+        when :ttc
+          issues.concat(ttc_issues(fonts))
+        when :otc
+          issues.concat(otc_issues(fonts))
+        when :dfont
+          issues.concat(dfont_issues(fonts))
+        end
+
+        issues
+      end
+
+      private
+
+      # Validate fonts array is not empty
+      #
+      # @param fonts [Array] Fonts
+      # @raise [ArgumentError] if empty or nil
+      def validate_not_empty!(fonts)
+        if fonts.nil? || fonts.empty?
+          raise ArgumentError, "Font array cannot be empty"
+        end
+      end
+
+      # Validate format is supported
+      #
+      # @param format [Symbol] Format
+      # @raise [ArgumentError] if invalid
+      def validate_format!(format)
+        unless %i[ttc otc dfont].include?(format)
+          raise ArgumentError, "Invalid format: #{format}. Must be :ttc, :otc, or :dfont"
+        end
+      end
+
+      # Validate TTC compatibility
+      #
+      # Per OpenType spec: TTC = TrueType outlines ONLY
+      # "CFF rasterizer does not currently support TTC files"
+      #
+      # @param fonts [Array] Fonts
+      # @raise [Error] if incompatible
+      def validate_ttc!(fonts)
+        fonts.each_with_index do |font, index|
+          # Check for web fonts
+          if web_font?(font)
+            raise Error,
+                  "Font #{index} is a web font (WOFF/WOFF2). " \
+                  "Web fonts cannot be packed into collections."
+          end
+
+          # Check for TrueType outline format
+          unless truetype_font?(font)
+            raise Error,
+                  "Font #{index} is not TrueType. " \
+                  "TTC requires TrueType fonts only (per OpenType spec)."
+          end
+        end
+      end
+
+      # Validate OTC compatibility
+      #
+      # Per OpenType 1.8: OTC for CFF collections
+      # Fontisan extension: Also allows mixed TTF+OTF for flexibility
+      #
+      # @param fonts [Array] Fonts
+      # @raise [Error] if incompatible
+      def validate_otc!(fonts)
+        has_cff = false
+
+        fonts.each_with_index do |font, index|
+          # Check for web fonts
+          if web_font?(font)
+            raise Error,
+                  "Font #{index} is a web font (WOFF/WOFF2). " \
+                  "Web fonts cannot be packed into collections."
+          end
+
+          # Track if any font has CFF
+          has_cff = true if cff_font?(font)
+        end
+
+        # OTC should have at least one CFF font
+        unless has_cff
+          raise Error,
+                "OTC requires at least one CFF/OpenType font. " \
+                "All fonts are TrueType - use TTC instead."
+        end
+      end
+
+      # Validate dfont compatibility
+      #
+      # Apple dfont suitcase: Any SFNT fonts OK (TTF, OTF, or mixed)
+      # dfont stores complete Mac resources (FOND, NFNT, sfnt)
+      #
+      # @param fonts [Array] Fonts
+      # @raise [Error] if incompatible
+      def validate_dfont!(fonts)
+        fonts.each_with_index do |font, index|
+          # Only check for web fonts - dfont accepts any SFNT
+          if web_font?(font)
+            raise Error,
+                  "Font #{index} is a web font (WOFF/WOFF2). " \
+                  "Web fonts cannot be packed into dfont."
+          end
+        end
+      end
+
+      # Get TTC compatibility issues
+      #
+      # @param fonts [Array] Fonts
+      # @return [Array<String>] Issues
+      def ttc_issues(fonts)
+        issues = []
+
+        fonts.each_with_index do |font, index|
+          if web_font?(font)
+            issues << "Font #{index} is WOFF/WOFF2 (not allowed in collections)"
+          elsif !truetype_font?(font)
+            issues << "Font #{index} is not TrueType (TTC requires TrueType only)"
+          end
+        end
+
+        issues
+      end
+
+      # Get OTC compatibility issues
+      #
+      # @param fonts [Array] Fonts
+      # @return [Array<String>] Issues
+      def otc_issues(fonts)
+        issues = []
+        has_cff = false
+
+        fonts.each_with_index do |font, index|
+          if web_font?(font)
+            issues << "Font #{index} is WOFF/WOFF2 (not allowed in collections)"
+          end
+          has_cff = true if cff_font?(font)
+        end
+
+        unless has_cff
+          issues << "OTC requires at least one CFF font (all fonts are TrueType)"
+        end
+
+        issues
+      end
+
+      # Get dfont compatibility issues
+      #
+      # @param fonts [Array] Fonts
+      # @return [Array<String>] Issues
+      def dfont_issues(fonts)
+        issues = []
+
+        fonts.each_with_index do |font, index|
+          if web_font?(font)
+            issues << "Font #{index} is WOFF/WOFF2 (not allowed in dfont)"
+          end
+        end
+
+        issues
+      end
+
+      # Check if font is a web font
+      #
+      # @param font [Object] Font object
+      # @return [Boolean] true if WOFF or WOFF2
+      def web_font?(font)
+        font.class.name.include?("Woff")
+      end
+
+      # Check if font is TrueType
+      #
+      # @param font [Object] Font object
+      # @return [Boolean] true if TrueType
+      def truetype_font?(font)
+        return false unless font.respond_to?(:has_table?)
+
+        font.has_table?("glyf")
+      end
+
+      # Check if font is CFF/OpenType
+      #
+      # @param font [Object] Font object
+      # @return [Boolean] true if CFF
+      def cff_font?(font)
+        return false unless font.respond_to?(:has_table?)
+
+        font.has_table?("CFF ") || font.has_table?("CFF2")
+      end
+    end
+  end
+end

data/lib/fontisan/validators/basic_validator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "validator"
+
+module Fontisan
+  module Validators
+    # BasicValidator provides minimal validation for fast font indexing
+    #
+    # This validator implements only essential checks needed for font discovery
+    # and indexing systems (e.g., Fontist). It is optimized for speed with a
+    # target performance of < 50ms per font.
+    #
+    # The validator checks only critical font identification and structural
+    # integrity, making it suitable for:
+    # - Font discovery and indexing
+    # - Quick font database updates
+    # - Large-scale font scanning
+    #
+    # @example Using BasicValidator
+    #   validator = BasicValidator.new
+    #   report = validator.validate(font)
+    #   puts "Font is valid for indexing" if report.valid?
+    #
+    # @example Target performance
+    #   # Should complete in < 50ms
+    #   start_time = Time.now
+    #   report = BasicValidator.new.validate(font)
+    #   elapsed = Time.now - start_time
+    #   puts "Validated in #{elapsed * 1000}ms"
+    class BasicValidator < Validator
+      private
+
+      # Define essential validation checks
+      #
+      # This validator implements 8 checks covering:
+      # - Required tables presence
+      # - Name table identification
+      # - Head table integrity
+      # - Maxp table glyph count
+      #
+      # All checks use helpers from Week 1 table implementations.
+      def define_checks
+        # Check 1: Required tables must be present
+        check_structure :required_tables, severity: :error do |font|
+          %w[name head maxp hhea].all? { |tag| font.table(tag) }
+        end
+
+        # Check 2: Name table version must be valid (0 or 1)
+        check_table :name_version, "name", severity: :error do |table|
+          table.valid_version?
+        end
+
+        # Check 3: Family name must be present and non-empty
+        check_table :family_name, "name", severity: :error do |table|
+          table.family_name_present?
+        end
+
+        # Check 4: PostScript name must be valid (alphanumeric + hyphens)
+        check_table :postscript_name, "name", severity: :error do |table|
+          table.postscript_name_valid?
+        end
+
+        # Check 5: Head table magic number must be correct
+        check_table :head_magic, "head", severity: :error do |table|
+          table.valid_magic?
+        end
+
+        # Check 6: Units per em must be valid (16-16384)
+        check_table :units_per_em, "head", severity: :error do |table|
+          table.valid_units_per_em?
+        end
+
+        # Check 7: Number of glyphs must be at least 1 (.notdef)
+        check_table :num_glyphs, "maxp", severity: :error do |table|
+          table.valid_num_glyphs?
+        end
+
+        # Check 8: Maxp metrics should be reasonable (not absurd values)
+        check_table :reasonable_metrics, "maxp", severity: :warning do |table|
+          table.reasonable_metrics?
+        end
+      end
+    end
+  end
+end