fontisan 0.2.3 → 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/open_type_font.rb

@@ -512,6 +512,12 @@ module Fontisan
         Constants::GPOS_TAG => Tables::Gpos,
         Constants::GLYF_TAG => Tables::Glyf,
         Constants::LOCA_TAG => Tables::Loca,
+        "SVG " => Tables::Svg,
+        "COLR" => Tables::Colr,
+        "CPAL" => Tables::Cpal,
+        "CBDT" => Tables::Cbdt,
+        "CBLC" => Tables::Cblc,
+        "sbix" => Tables::Sbix,
       }[tag]
     end
 

data/lib/fontisan/optimizers/charstring_rewriter.rb

@@ -30,12 +30,13 @@ module Fontisan
       #
       # @param charstring [String] original CharString bytes
       # @param patterns [Array<Pattern>] patterns to replace in this CharString
+      # @param glyph_id [Integer, nil] glyph ID being rewritten (for position filtering)
       # @return [String] rewritten CharString with subroutine calls
-      def rewrite(charstring, patterns)
+      def rewrite(charstring, patterns, glyph_id = nil)
         return charstring if patterns.empty?
 
         # Build list of all replacements: [position, pattern]
-        replacements = build_replacement_list(charstring, patterns)
+        replacements = build_replacement_list(charstring, patterns, glyph_id)
 
         # Remove overlapping replacements
         replacements = remove_overlaps(replacements)
@@ -120,16 +121,26 @@ module Fontisan
       # Build list of all pattern replacements with their positions
       # @param charstring [String] CharString being rewritten
       # @param patterns [Array<Pattern>] patterns to find
+      # @param glyph_id [Integer, nil] glyph ID being rewritten (for position filtering)
       # @return [Array<Array>] array of [position, pattern] pairs
-      def build_replacement_list(charstring, patterns)
+      def build_replacement_list(charstring, patterns, glyph_id = nil)
         replacements = []
 
         patterns.each do |pattern|
-          # Find all positions where this pattern occurs
-          positions = find_pattern_positions(charstring, pattern)
+          if glyph_id && pattern.respond_to?(:positions) && pattern.positions.is_a?(Hash)
+            # Use exact positions from pattern analysis for this glyph
+            glyph_positions = pattern.positions[glyph_id] || []
 
-          positions.each do |position|
-            replacements << [position, pattern]
+            glyph_positions.each do |position|
+              replacements << [position, pattern]
+            end
+          else
+            # Fallback for backward compatibility (unit tests without glyph_id)
+            positions = find_pattern_positions(charstring, pattern)
+
+            positions.each do |position|
+              replacements << [position, pattern]
+            end
           end
         end
 
@@ -140,7 +151,7 @@ module Fontisan
       # @param charstring [String] CharString to search
       # @param pattern [Pattern] pattern to find
       # @return [Array<Integer>] array of start positions
-      def find_pattern_positions(charstring, pattern)
+      def find_pattern_positions(charstring, pattern, glyph_id = nil)
         positions = []
         offset = 0
 

data/lib/fontisan/optimizers/pattern_analyzer.rb

@@ -160,7 +160,9 @@ module Fontisan
                         charstrings.length
                       end
 
-        sampled_glyphs = charstrings.keys.sample(sample_size)
+        # Use deterministic selection instead of random sampling
+        # Sort keys first to ensure consistent ordering across platforms
+        sampled_glyphs = charstrings.keys.sort.take(sample_size)
 
         # NEW: Pre-compute boundaries for sampled glyphs
         # Check if boundaries are useful (more than just start position)
@@ -249,7 +251,7 @@ module Fontisan
           # Build positions hash
           positions = {}
           by_glyph.each do |glyph_id, glyph_occurrences|
-            positions[glyph_id] = glyph_occurrences.map(&:last)
+            positions[glyph_id] = glyph_occurrences.map(&:last).uniq
           end
 
           @patterns[bytes] = Pattern.new(

data/lib/fontisan/optimizers/subroutine_builder.rb

@@ -95,22 +95,23 @@ module Fontisan
       # @return [String] encoded bytes
       def encode_integer(num)
         # Range 1: -107 to 107 (single byte)
+        # CFF spec: byte value = 139 + number
         if num >= -107 && num <= 107
-          return [32 + num].pack("c")
+          return [139 + num].pack("C")
         end
 
         # Range 2: 108 to 1131 (two bytes)
         if num >= 108 && num <= 1131
           b0 = 247 + ((num - 108) >> 8)
           b1 = (num - 108) & 0xff
-          return [b0, b1].pack("c*")
+          return [b0, b1].pack("C*")
         end
 
         # Range 3: -1131 to -108 (two bytes)
         if num >= -1131 && num <= -108
           b0 = 251 - ((num + 108) >> 8)
           b1 = -(num + 108) & 0xff
-          return [b0, b1].pack("c*")
+          return [b0, b1].pack("C*")
         end
 
         # Range 4: -32768 to 32767 (three bytes)
@@ -118,7 +119,7 @@ module Fontisan
           b0 = 29
           b1 = (num >> 8) & 0xff
           b2 = num & 0xff
-          return [b0, b1, b2].pack("c*")
+          return [b0, b1, b2].pack("C*")
         end
 
         # Range 5: Larger numbers (five bytes)
@@ -127,7 +128,7 @@ module Fontisan
         b2 = (num >> 16) & 0xff
         b3 = (num >> 8) & 0xff
         b4 = num & 0xff
-        [b0, b1, b2, b3, b4].pack("c*")
+        [b0, b1, b2, b3, b4].pack("C*")
       end
     end
   end

data/lib/fontisan/optimizers/subroutine_optimizer.rb

@@ -30,7 +30,9 @@ module Fontisan
       # @return [Array<Pattern>] selected patterns
       def optimize_selection
         selected = []
-        remaining = @patterns.sort_by { |p| -p.savings }
+        # Sort by savings (descending), then by length (descending), then by min glyph ID,
+        # then by byte values for complete determinism across platforms
+        remaining = @patterns.sort_by { |p| [-p.savings, -p.length, p.glyphs.min, p.bytes.bytes] }
 
         remaining.each do |pattern|
           break if selected.length >= @max_subrs
@@ -50,7 +52,8 @@ module Fontisan
       # @return [Array<Pattern>] ordered subroutines
       def optimize_ordering(subroutines)
         # Higher frequency = lower ID (shorter encoding)
-        subroutines.sort_by { |subr| -subr.frequency }
+        # Use same comprehensive sort keys as optimize_selection for consistency
+        subroutines.sort_by { |subr| [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes] }
       end
 
       # Check if nesting would be beneficial

data/lib/fontisan/pipeline/output_writer.rb

@@ -96,9 +96,9 @@ module Fontisan
 
         writer = Converters::WoffWriter.new
         font = build_font_from_tables(tables)
-        result = writer.convert(font, @options)
+        woff_data = writer.convert(font, @options)
 
-        File.binwrite(@output_path, result[:woff_data])
+        File.binwrite(@output_path, woff_data)
       end
 
       # Write WOFF2 format

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # CBDT (Color Bitmap Data) table parser
+    #
+    # The CBDT table contains the actual bitmap data for color glyphs. It works
+    # together with the CBLC table which provides the location information for
+    # finding bitmaps in this table.
+    #
+    # CBDT Table Structure:
+    # ```
+    # CBDT Table = Header (8 bytes)
+    #            + Bitmap Data (variable length)
+    # ```
+    #
+    # Header (8 bytes):
+    # - majorVersion (uint16): Major version (2 or 3)
+    # - minorVersion (uint16): Minor version (0)
+    # - reserved (uint32): Reserved, set to 0
+    #
+    # The bitmap data format depends on the index subtable format in CBLC.
+    # Common formats include:
+    # - Format 17: Small metrics, PNG data
+    # - Format 18: Big metrics, PNG data
+    # - Format 19: Metrics in CBLC, PNG data
+    #
+    # This parser provides low-level access to bitmap data. For proper bitmap
+    # extraction, use together with CBLC table which contains the index.
+    #
+    # Reference: OpenType CBDT specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt
+    #
+    # @example Reading a CBDT table
+    #   data = font.table_data['CBDT']
+    #   cbdt = Fontisan::Tables::Cbdt.read(data)
+    #   bitmap_data = cbdt.bitmap_data_at(offset, length)
+    class Cbdt < Binary::BaseRecord
+      # OpenType table tag for CBDT
+      TAG = "CBDT"
+
+      # Supported CBDT versions
+      VERSION_2_0 = 0x0002_0000
+      VERSION_3_0 = 0x0003_0000
+
+      # @return [Integer] Major version (2 or 3)
+      attr_reader :major_version
+
+      # @return [Integer] Minor version (0)
+      attr_reader :minor_version
+
+      # @return [String] Raw binary data for the entire CBDT table
+      attr_reader :raw_data
+
+      # Override read to parse CBDT structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Cbdt] Parsed CBDT table
+      def self.read(io)
+        cbdt = new
+        return cbdt if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        cbdt.parse!(data)
+        cbdt
+      end
+
+      # Parse the CBDT table structure
+      #
+      # @param data [String] Binary data for the CBDT table
+      # @raise [CorruptedTableError] If CBDT structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse CBDT header (8 bytes)
+        parse_header(io)
+        validate_header!
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse CBDT table: #{e.message}"
+      end
+
+      # Get bitmap data at specific offset and length
+      #
+      # Used together with CBLC index to extract bitmap data.
+      #
+      # @param offset [Integer] Offset from start of table
+      # @param length [Integer] Length of bitmap data
+      # @return [String, nil] Binary bitmap data or nil
+      def bitmap_data_at(offset, length)
+        return nil if offset.nil? || length.nil?
+        return nil if offset.negative? || length.negative?
+        return nil if offset + length > raw_data.length
+
+        raw_data[offset, length]
+      end
+
+      # Get combined version number
+      #
+      # @return [Integer] Combined version (e.g., 0x00020000 for v2.0)
+      def version
+        return nil if major_version.nil? || minor_version.nil?
+
+        (major_version << 16) | minor_version
+      end
+
+      # Get table data size
+      #
+      # @return [Integer] Size of CBDT table in bytes
+      def data_size
+        raw_data&.length || 0
+      end
+
+      # Check if offset is valid for this table
+      #
+      # @param offset [Integer] Offset to check
+      # @return [Boolean] True if offset is within table bounds
+      def valid_offset?(offset)
+        return false if offset.nil? || offset.negative?
+        return false if raw_data.nil?
+
+        offset < raw_data.length
+      end
+
+      # Validate the CBDT table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if major_version.nil? || minor_version.nil?
+        return false unless [2, 3].include?(major_version)
+        return false unless minor_version.zero?
+        return false unless raw_data
+
+        true
+      end
+
+      private
+
+      # Parse CBDT header (8 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @major_version = io.read(2).unpack1("n")
+        @minor_version = io.read(2).unpack1("n")
+        @reserved = io.read(4).unpack1("N")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless [2, 3].include?(major_version)
+          raise CorruptedTableError,
+                "Unsupported CBDT major version: #{major_version} " \
+                "(only versions 2 and 3 supported)"
+        end
+
+        unless minor_version.zero?
+          raise CorruptedTableError,
+                "Unsupported CBDT minor version: #{minor_version} " \
+                "(only version 0 supported)"
+        end
+      end
+    end
+  end
+end