fontisan 0.2.3 → 0.2.5

data/lib/fontisan/tables/glyf.rb

@@ -158,6 +158,124 @@ module Fontisan
         @glyphs_cache ||= {}
       end
 
+      # Validation helper: Check if all non-special glyphs have contours
+      #
+      # The .notdef glyph (ID 0) can be empty, but other glyphs should have geometry
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] True if all non-special glyphs have contours
+      def no_empty_glyphs_except_special?(loca, head, num_glyphs)
+        # Check glyphs 1 through num_glyphs-1 (.notdef at 0 can be empty)
+        (1...num_glyphs).all? do |glyph_id|
+          size = loca.size_of(glyph_id)
+          # Empty glyphs (like space) are allowed, but check if they should be empty
+          # This is a basic check - we just ensure non-control glyphs have data
+          size.nil? || size.positive?
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if any glyphs are clipped (exceed bounds)
+      #
+      # Validates that glyph coordinates don't exceed head table's bounding box
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for bounds reference
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] True if no glyphs exceed the font's bounding box
+      def no_clipped_glyphs?(loca, head, num_glyphs)
+        font_x_min = head.x_min
+        font_y_min = head.y_min
+        font_x_max = head.x_max
+        font_y_max = head.y_max
+
+        (0...num_glyphs).all? do |glyph_id|
+          glyph = glyph_for(glyph_id, loca, head)
+          next true if glyph.nil?  # Empty glyphs are OK
+
+          # Check if glyph bounds are within font bounds
+          glyph.x_min >= font_x_min &&
+            glyph.y_min >= font_y_min &&
+            glyph.x_max <= font_x_max &&
+            glyph.y_max <= font_y_max
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if TrueType instructions are sound
+      #
+      # Validates that glyph instructions (if present) are parseable
+      # This is a basic check that ensures instructions exist and have valid length
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] True if all instructions are valid or absent
+      def instructions_sound?(loca, head, num_glyphs)
+        (0...num_glyphs).all? do |glyph_id|
+          glyph = glyph_for(glyph_id, loca, head)
+          next true if glyph.nil?  # Empty glyphs are OK
+
+          # Simple glyphs have instructions
+          if glyph.respond_to?(:instruction_length)
+            inst_len = glyph.instruction_length
+            # If instructions present, length should be reasonable
+            inst_len.nil? || inst_len >= 0
+          else
+            # Compound glyphs may have instructions too
+            true
+          end
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if glyph has valid number of contours
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @return [Boolean] True if contour count is valid
+      def valid_contour_count?(glyph_id, loca, head)
+        glyph = glyph_for(glyph_id, loca, head)
+        return true if glyph.nil?  # Empty glyphs are OK
+
+        # Simple glyphs: contours should be >= 0
+        # Compound glyphs: numberOfContours = -1
+        if glyph.respond_to?(:num_contours)
+          glyph.num_contours >= -1
+        else
+          true
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if all glyphs are accessible
+      #
+      # Attempts to access each glyph to ensure no corruption
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @param num_glyphs [Integer] Total number of glyphs
+      # @return [Boolean] True if all glyphs can be accessed
+      def all_glyphs_accessible?(loca, head, num_glyphs)
+        (0...num_glyphs).all? do |glyph_id|
+          begin
+            glyph_for(glyph_id, loca, head)
+            true
+          rescue Fontisan::CorruptedTableError
+            false
+          end
+        end
+      rescue StandardError
+        false
+      end
+
       private
 
       # Validate context and glyph ID

data/lib/fontisan/tables/head.rb

@@ -82,6 +82,66 @@ module Fontisan
         magic_number == MAGIC_NUMBER
       end
 
+      # Validation helper: Check if magic number is valid
+      #
+      # @return [Boolean] True if magic number equals 0x5F0F3CF5
+      def valid_magic?
+        magic_number == MAGIC_NUMBER
+      end
+
+      # Validation helper: Check if version is valid
+      #
+      # OpenType spec requires version to be 1.0
+      #
+      # @return [Boolean] True if version is 1.0
+      def valid_version?
+        version_raw == 0x00010000  # Version 1.0
+      end
+
+      # Validation helper: Check if units per em is valid
+      #
+      # Units per em should be a power of 2 between 16 and 16384
+      #
+      # @return [Boolean] True if units_per_em is valid
+      def valid_units_per_em?
+        return false if units_per_em.nil? || units_per_em.zero?
+
+        # Must be between 16 and 16384
+        return false unless units_per_em.between?(16, 16384)
+
+        # Should be a power of 2 (recommended but not required)
+        # Common values: 1000, 1024, 2048
+        # We'll allow any value in range for flexibility
+        true
+      end
+
+      # Validation helper: Check if bounding box is valid
+      #
+      # The bounding box should have xMin < xMax and yMin < yMax
+      #
+      # @return [Boolean] True if bounding box coordinates are valid
+      def valid_bounding_box?
+        x_min < x_max && y_min < y_max
+      end
+
+      # Validation helper: Check if index_to_loc_format is valid
+      #
+      # Must be 0 (short) or 1 (long)
+      #
+      # @return [Boolean] True if format is 0 or 1
+      def valid_index_to_loc_format?
+        index_to_loc_format == 0 || index_to_loc_format == 1
+      end
+
+      # Validation helper: Check if glyph_data_format is valid
+      #
+      # Must be 0 for current format
+      #
+      # @return [Boolean] True if format is 0
+      def valid_glyph_data_format?
+        glyph_data_format == 0
+      end
+
       # Validate magic number and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If magic number is invalid

data/lib/fontisan/tables/hhea.rb

@@ -97,6 +97,80 @@ module Fontisan
         true
       end
 
+      # Validation helper: Check if version is valid
+      #
+      # OpenType spec requires version to be 1.0
+      #
+      # @return [Boolean] True if version is 1.0
+      def valid_version?
+        version_raw == 0x00010000
+      end
+
+      # Validation helper: Check if metric data format is valid
+      #
+      # Must be 0 for current format
+      #
+      # @return [Boolean] True if format is 0
+      def valid_metric_data_format?
+        metric_data_format == 0
+      end
+
+      # Validation helper: Check if number of h metrics is valid
+      #
+      # Must be at least 1
+      #
+      # @return [Boolean] True if number_of_h_metrics >= 1
+      def valid_number_of_h_metrics?
+        number_of_h_metrics && number_of_h_metrics >= 1
+      end
+
+      # Validation helper: Check if ascent/descent values are reasonable
+      #
+      # Ascent should be positive, descent should be negative
+      #
+      # @return [Boolean] True if ascent/descent have correct signs
+      def valid_ascent_descent?
+        ascent > 0 && descent < 0
+      end
+
+      # Validation helper: Check if line gap is non-negative
+      #
+      # Line gap should be >= 0
+      #
+      # @return [Boolean] True if line_gap >= 0
+      def valid_line_gap?
+        line_gap >= 0
+      end
+
+      # Validation helper: Check if advance width max is positive
+      #
+      # Maximum advance width should be > 0
+      #
+      # @return [Boolean] True if advance_width_max > 0
+      def valid_advance_width_max?
+        advance_width_max && advance_width_max > 0
+      end
+
+      # Validation helper: Check if caret slope is valid
+      #
+      # For vertical text: rise=1, run=0
+      # For horizontal italic: both should be non-zero
+      #
+      # @return [Boolean] True if caret slope values are sensible
+      def valid_caret_slope?
+        # At least one should be non-zero
+        caret_slope_rise != 0 || caret_slope_run != 0
+      end
+
+      # Validation helper: Check if extent is reasonable
+      #
+      # x_max_extent should be positive
+      #
+      # @return [Boolean] True if x_max_extent > 0
+      def valid_x_max_extent?
+        x_max_extent > 0
+      end
+
       # Validate the table and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If table is invalid

data/lib/fontisan/tables/maxp.rb

@@ -157,6 +157,66 @@ module Fontisan
         true
       end
 
+      # Validation helper: Check if version is valid (0.5 or 1.0)
+      #
+      # @return [Boolean] True if version is 0.5 or 1.0
+      def valid_version?
+        version_0_5? || version_1_0?
+      end
+
+      # Validation helper: Check if number of glyphs is valid
+      #
+      # Must be at least 1 (.notdef glyph must exist)
+      #
+      # @return [Boolean] True if num_glyphs >= 1
+      def valid_num_glyphs?
+        num_glyphs && num_glyphs >= 1
+      end
+
+      # Validation helper: Check if maxZones is valid (version 1.0 only)
+      #
+      # For TrueType fonts, maxZones must be 1 or 2
+      #
+      # @return [Boolean] True if maxZones is valid or not applicable
+      def valid_max_zones?
+        return true if version_0_5?  # Not applicable for CFF
+
+        max_zones && max_zones.between?(1, 2)
+      end
+
+      # Validation helper: Check if all TrueType metrics are present
+      #
+      # For version 1.0, all max* fields should be present
+      #
+      # @return [Boolean] True if all required fields are present
+      def has_truetype_metrics?
+        version_1_0? &&
+          !max_points.nil? &&
+          !max_contours.nil? &&
+          !max_composite_points.nil? &&
+          !max_composite_contours.nil?
+      end
+
+      # Validation helper: Check if metrics are reasonable
+      #
+      # Checks that values don't exceed reasonable limits
+      #
+      # @return [Boolean] True if metrics are within reasonable bounds
+      def reasonable_metrics?
+        # num_glyphs should not exceed 65535
+        return false if num_glyphs > 65535
+
+        if version_1_0?
+          # Check reasonable limits for TrueType metrics
+          # These are generous limits to allow for complex fonts
+          return false if max_points && max_points > 50000
+          return false if max_contours && max_contours > 10000
+          return false if max_stack_elements && max_stack_elements > 1000
+        end
+
+        true
+      end
+
       # Validate the table and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If table is invalid

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