fontisan 0.2.4 → 0.2.5

data/lib/fontisan/models/validation_report.rb

@@ -46,6 +46,34 @@ module Fontisan
         end
       end
 
+      # Individual check result from DSL-based validation
+      class CheckResult < Lutaml::Model::Serializable
+        attribute :check_id, :string
+        attribute :passed, :boolean
+        attribute :severity, :string
+        attribute :messages, :string, collection: true, default: -> { [] }
+        attribute :table, :string
+        attribute :field, :string
+
+        yaml do
+          map "check_id", to: :check_id
+          map "passed", to: :passed
+          map "severity", to: :severity
+          map "messages", to: :messages
+          map "table", to: :table
+          map "field", to: :field
+        end
+
+        json do
+          map "check_id", to: :check_id
+          map "passed", to: :passed
+          map "severity", to: :severity
+          map "messages", to: :messages
+          map "table", to: :table
+          map "field", to: :field
+        end
+      end
+
       # Validation summary counts
       class Summary < Lutaml::Model::Serializable
         attribute :errors, :integer, default: -> { 0 }
@@ -69,12 +97,22 @@ module Fontisan
       attribute :valid, :boolean
       attribute :issues, Issue, collection: true, default: -> { [] }
       attribute :summary, Summary, default: -> { Summary.new }
+      attribute :profile, :string
+      attribute :status, :string
+      attribute :use_case, :string
+      attribute :checks_performed, :string, collection: true, default: -> { [] }
+      attribute :check_results, CheckResult, collection: true, default: -> { [] }
 
       yaml do
         map "font_path", to: :font_path
         map "valid", to: :valid
         map "summary", to: :summary
         map "issues", to: :issues
+        map "profile", to: :profile
+        map "status", to: :status
+        map "use_case", to: :use_case
+        map "checks_performed", to: :checks_performed
+        map "check_results", to: :check_results
       end
 
       json do
@@ -82,6 +120,11 @@ module Fontisan
         map "valid", to: :valid
         map "summary", to: :summary
         map "issues", to: :issues
+        map "profile", to: :profile
+        map "status", to: :status
+        map "use_case", to: :use_case
+        map "checks_performed", to: :checks_performed
+        map "check_results", to: :check_results
       end
 
       # Add an error to the report
@@ -198,6 +241,190 @@ module Fontisan
 
         lines.join("\n")
       end
+
+      # Check if font passed validation (alias for valid)
+      #
+      # @return [Boolean] true if font passed validation
+      def passed?
+        valid
+      end
+
+      # Check if font is valid (alias for valid attribute)
+      #
+      # @return [Boolean] true if font is valid
+      def valid?
+        valid
+      end
+
+      # Get result for a specific check by ID
+      #
+      # @param check_id [Symbol, String] The check identifier
+      # @return [CheckResult, nil] The check result or nil if not found
+      def result_of(check_id)
+        check_results.find { |cr| cr.check_id == check_id.to_s }
+      end
+
+      # Get all passed checks
+      #
+      # @return [Array<CheckResult>] Array of passed checks
+      def passed_checks
+        check_results.select(&:passed)
+      end
+
+      # Get all failed checks
+      #
+      # @return [Array<CheckResult>] Array of failed checks
+      def failed_checks
+        check_results.reject(&:passed)
+      end
+
+      # Severity filtering methods
+
+      # Get issues by severity level
+      #
+      # @param severity [Symbol, String] Severity level
+      # @return [Array<Issue>] Array of issues with the specified severity
+      def issues_by_severity(severity)
+        issues.select { |issue| issue.severity == severity.to_s }
+      end
+
+      # Get fatal error issues
+      #
+      # @return [Array<Issue>] Array of fatal error issues
+      def fatal_errors
+        issues_by_severity(:fatal)
+      end
+
+      # Get error issues only
+      #
+      # @return [Array<Issue>] Array of error issues
+      def errors_only
+        issues_by_severity(:error)
+      end
+
+      # Get warning issues only
+      #
+      # @return [Array<Issue>] Array of warning issues
+      def warnings_only
+        issues_by_severity(:warning)
+      end
+
+      # Get info issues only
+      #
+      # @return [Array<Issue>] Array of info issues
+      def info_only
+        issues_by_severity(:info)
+      end
+
+      # Category filtering methods
+
+      # Get issues by category
+      #
+      # @param category [String] Category name
+      # @return [Array<Issue>] Array of issues in the specified category
+      def issues_by_category(category)
+        issues.select { |issue| issue.category == category.to_s }
+      end
+
+      # Get check results for a specific table
+      #
+      # @param table_tag [String] Table tag (e.g., 'name', 'head')
+      # @return [Array<CheckResult>] Array of check results for the table
+      def table_issues(table_tag)
+        check_results.select { |cr| cr.table == table_tag.to_s }
+      end
+
+      # Get check results for a specific field in a table
+      #
+      # @param table_tag [String] Table tag
+      # @param field_name [String, Symbol] Field name
+      # @return [Array<CheckResult>] Array of check results for the field
+      def field_issues(table_tag, field_name)
+        check_results.select { |cr| cr.table == table_tag.to_s && cr.field == field_name.to_s }
+      end
+
+      # Check filtering methods
+
+      # Get checks by status
+      #
+      # @param passed [Boolean] true for passed checks, false for failed checks
+      # @return [Array<CheckResult>] Array of checks with the specified status
+      def checks_by_status(passed:)
+        check_results.select { |cr| cr.passed == passed }
+      end
+
+      # Get IDs of failed checks
+      #
+      # @return [Array<String>] Array of failed check IDs
+      def failed_check_ids
+        failed_checks.map(&:check_id)
+      end
+
+      # Get IDs of passed checks
+      #
+      # @return [Array<String>] Array of passed check IDs
+      def passed_check_ids
+        passed_checks.map(&:check_id)
+      end
+
+      # Statistics methods
+
+      # Calculate failure rate as percentage
+      #
+      # @return [Float] Failure rate (0.0 to 1.0)
+      def failure_rate
+        return 0.0 if check_results.empty?
+        failed_checks.length.to_f / check_results.length
+      end
+
+      # Calculate pass rate as percentage
+      #
+      # @return [Float] Pass rate (0.0 to 1.0)
+      def pass_rate
+        1.0 - failure_rate
+      end
+
+      # Get severity distribution
+      #
+      # @return [Hash] Hash with :errors, :warnings, :info counts
+      def severity_distribution
+        {
+          errors: summary.errors,
+          warnings: summary.warnings,
+          info: summary.info,
+        }
+      end
+
+      # Export format methods
+
+      # Generate full detailed text report
+      #
+      # @return [String] Detailed text report
+      def to_text_report
+        text_summary
+      end
+
+      # Generate brief summary
+      #
+      # @return [String] Brief summary string
+      def to_summary
+        "#{summary.errors} errors, #{summary.warnings} warnings, #{summary.info} info"
+      end
+
+      # Generate tabular format for CLI
+      #
+      # @return [String] Tabular format output
+      def to_table_format
+        lines = []
+        lines << "CHECK_ID | STATUS | SEVERITY | TABLE"
+        lines << "-" * 60
+        check_results.each do |cr|
+          status = cr.passed ? "PASS" : "FAIL"
+          table = cr.table || "N/A"
+          lines << "#{cr.check_id} | #{status} | #{cr.severity} | #{table}"
+        end
+        lines.join("\n")
+      end
     end
   end
 end

data/lib/fontisan/pipeline/transformation_pipeline.rb

@@ -263,16 +263,12 @@ module Fontisan
       def validate_output
         return unless File.exist?(@output_path)
 
-        require_relative "../validation/validator"
+        # Use new validation framework with production profile
+        report = Fontisan.validate(@output_path, profile: :production)
 
-        # Load font for validation
-        font = FontLoader.load(@output_path, mode: :full)
-        validator = Validation::Validator.new
-        result = validator.validate(font, @output_path)
+        return if report.valid?
 
-        return if result.valid
-
-        error_messages = result.errors.map(&:message).join(", ")
+        error_messages = report.errors.map(&:message).join(", ")
         raise Error, "Output validation failed: #{error_messages}"
       end
 

data/lib/fontisan/tables/cmap.rb

@@ -36,8 +36,6 @@ module Fontisan
         @unicode_mappings ||= parse_mappings
       end
 
-      private
-
       # Parse all encoding records and extract Unicode mappings
       def parse_mappings
         mappings = {}
@@ -279,6 +277,88 @@ module Fontisan
           mappings[code] = glyph_index if glyph_index != 0
         end
       end
+
+      public
+
+      # Validation helper: Check if version is valid
+      #
+      # cmap version should be 0
+      #
+      # @return [Boolean] True if version is 0
+      def valid_version?
+        version == 0
+      end
+
+      # Validation helper: Check if at least one subtable exists
+      #
+      # @return [Boolean] True if num_tables > 0
+      def has_subtables?
+        num_tables && num_tables > 0
+      end
+
+      # Validation helper: Check if Unicode mapping exists
+      #
+      # @return [Boolean] True if Unicode mappings are present
+      def has_unicode_mapping?
+        !unicode_mappings.nil? && !unicode_mappings.empty?
+      end
+
+      # Validation helper: Check if BMP coverage exists
+      #
+      # Checks if the Basic Multilingual Plane (U+0000-U+FFFF) has mappings
+      #
+      # @return [Boolean] True if BMP characters are mapped
+      def has_bmp_coverage?
+        mappings = unicode_mappings
+        return false if mappings.nil? || mappings.empty?
+
+        # Check if any BMP characters (0x0000-0xFFFF) are mapped
+        mappings.keys.any? { |code| code.between?(0x0000, 0xFFFF) }
+      end
+
+      # Validation helper: Check if required characters are mapped
+      #
+      # Checks for essential characters like space (U+0020)
+      #
+      # @param required_chars [Array<Integer>] Character codes that must be present
+      # @return [Boolean] True if all required characters are mapped
+      def has_required_characters?(*required_chars)
+        mappings = unicode_mappings
+        return false if mappings.nil?
+
+        required_chars.all? { |code| mappings.key?(code) }
+      end
+
+      # Validation helper: Check if format 4 subtable exists
+      #
+      # Format 4 is the minimum requirement for Unicode BMP support
+      #
+      # @return [Boolean] True if format 4 subtable is found
+      def has_format_4_subtable?
+        data = to_binary_s
+        records = read_encoding_records(data)
+
+        records.any? do |record|
+          subtable_data = extract_subtable_data(record, data)
+          next false unless subtable_data && subtable_data.length >= 2
+
+          format = subtable_data[0, 2].unpack1("n")
+          format == 4
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if glyph indices are within bounds
+      #
+      # @param max_glyph_id [Integer] Maximum valid glyph ID from maxp table
+      # @return [Boolean] True if all mapped glyph IDs are valid
+      def valid_glyph_indices?(max_glyph_id)
+        mappings = unicode_mappings
+        return true if mappings.nil? || mappings.empty?
+
+        mappings.values.all? { |glyph_id| glyph_id >= 0 && glyph_id < max_glyph_id }
+      end
     end
   end
 end

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