fontisan 0.2.7 → 0.2.8

data/lib/fontisan/validators/validator.rb

@@ -80,7 +80,8 @@ module Fontisan
       # @param block [Proc] Check logic that receives (table, value) as parameters
       def check_field(check_id, field_key, severity: :error, &block)
         unless @current_table_context
-          raise ArgumentError, "check_field must be called within check_table block"
+          raise ArgumentError,
+                "check_field must be called within check_table block"
         end
 
         @checks << {
@@ -194,7 +195,7 @@ module Fontisan
             issues: [],
           }
         end
-      rescue => e
+      rescue StandardError => e
         {
           check_id: check_def[:id],
           passed: false,
@@ -239,7 +240,7 @@ module Fontisan
 
         begin
           result = check_def[:block].call(table)
-          passed = result != false && result != nil
+          passed = result != false && !result.nil?
 
           {
             check_id: check_def[:id],
@@ -247,12 +248,16 @@ module Fontisan
             severity: check_def[:severity].to_s,
             messages: passed ? [] : ["Table '#{table_tag}' validation failed"],
             table: table_tag,
-            issues: passed ? [] : [{
-              severity: check_def[:severity].to_s,
-              category: "table_validation",
-              table: table_tag,
-              message: "Table '#{table_tag}' failed validation",
-            }],
+            issues: if passed
+                      []
+                    else
+                      [{
+                        severity: check_def[:severity].to_s,
+                        category: "table_validation",
+                        table: table_tag,
+                        message: "Table '#{table_tag}' failed validation",
+                      }]
+                    end,
           }
         ensure
           @current_table_context = old_context
@@ -290,12 +295,10 @@ module Fontisan
         # Get field value
         value = if table.respond_to?(field_key)
                   table.public_send(field_key)
-                else
-                  nil
                 end
 
         result = check_def[:block].call(table, value)
-        passed = result != false && result != nil
+        passed = result != false && !result.nil?
 
         {
           check_id: check_def[:id],
@@ -304,13 +307,17 @@ module Fontisan
           messages: passed ? [] : ["Field '#{field_key}' validation failed"],
           table: table_tag,
           field: field_key.to_s,
-          issues: passed ? [] : [{
-            severity: check_def[:severity].to_s,
-            category: "field_validation",
-            table: table_tag,
-            field: field_key.to_s,
-            message: "Field '#{field_key}' in table '#{table_tag}' failed validation",
-          }],
+          issues: if passed
+                    []
+                  else
+                    [{
+                      severity: check_def[:severity].to_s,
+                      category: "field_validation",
+                      table: table_tag,
+                      field: field_key.to_s,
+                      message: "Field '#{field_key}' in table '#{table_tag}' failed validation",
+                    }]
+                  end,
         }
       end
 
@@ -321,18 +328,22 @@ module Fontisan
       # @return [Hash] Check result
       def execute_structure_check(font, check_def)
         result = check_def[:block].call(font)
-        passed = result != false && result != nil
+        passed = result != false && !result.nil?
 
         {
           check_id: check_def[:id],
           passed: passed,
           severity: check_def[:severity].to_s,
           messages: passed ? [] : ["Structure validation failed"],
-          issues: passed ? [] : [{
-            severity: check_def[:severity].to_s,
-            category: "structure",
-            message: "Font structure validation failed for check '#{check_def[:id]}'",
-          }],
+          issues: if passed
+                    []
+                  else
+                    [{
+                      severity: check_def[:severity].to_s,
+                      category: "structure",
+                      message: "Font structure validation failed for check '#{check_def[:id]}'",
+                    }]
+                  end,
         }
       end
 
@@ -343,18 +354,22 @@ module Fontisan
       # @return [Hash] Check result
       def execute_usability_check(font, check_def)
         result = check_def[:block].call(font)
-        passed = result != false && result != nil
+        passed = result != false && !result.nil?
 
         {
           check_id: check_def[:id],
           passed: passed,
           severity: check_def[:severity].to_s,
           messages: passed ? [] : ["Usability check failed"],
-          issues: passed ? [] : [{
-            severity: check_def[:severity].to_s,
-            category: "usability",
-            message: "Font usability check failed for '#{check_def[:id]}'",
-          }],
+          issues: if passed
+                    []
+                  else
+                    [{
+                      severity: check_def[:severity].to_s,
+                      category: "usability",
+                      message: "Font usability check failed for '#{check_def[:id]}'",
+                    }]
+                  end,
         }
       end
 
@@ -365,18 +380,22 @@ module Fontisan
       # @return [Hash] Check result
       def execute_instruction_check(font, check_def)
         result = check_def[:block].call(font)
-        passed = result != false && result != nil
+        passed = result != false && !result.nil?
 
         {
           check_id: check_def[:id],
           passed: passed,
           severity: check_def[:severity].to_s,
           messages: passed ? [] : ["Instruction validation failed"],
-          issues: passed ? [] : [{
-            severity: check_def[:severity].to_s,
-            category: "instructions",
-            message: "TrueType instruction check failed for '#{check_def[:id]}'",
-          }],
+          issues: if passed
+                    []
+                  else
+                    [{
+                      severity: check_def[:severity].to_s,
+                      category: "instructions",
+                      message: "TrueType instruction check failed for '#{check_def[:id]}'",
+                    }]
+                  end,
         }
       end
 
@@ -387,18 +406,22 @@ module Fontisan
       # @return [Hash] Check result
       def execute_glyph_check(font, check_def)
         result = check_def[:block].call(font)
-        passed = result != false && result != nil
+        passed = result != false && !result.nil?
 
         {
           check_id: check_def[:id],
           passed: passed,
           severity: check_def[:severity].to_s,
           messages: passed ? [] : ["Glyph validation failed"],
-          issues: passed ? [] : [{
-            severity: check_def[:severity].to_s,
-            category: "glyphs",
-            message: "Glyph validation failed for check '#{check_def[:id]}'",
-          }],
+          issues: if passed
+                    []
+                  else
+                    [{
+                      severity: check_def[:severity].to_s,
+                      category: "glyphs",
+                      message: "Glyph validation failed for check '#{check_def[:id]}'",
+                    }]
+                  end,
         }
       end
 
@@ -408,7 +431,7 @@ module Fontisan
       # @param all_results [Array<Hash>] All check results
       # @param elapsed [Float] Elapsed time in seconds
       # @return [ValidationReport] Complete report
-      def build_report(font, all_results, elapsed)
+      def build_report(font, all_results, _elapsed)
         # Extract font path from font object
         font_path = if font.respond_to?(:path)
                       font.path
@@ -438,28 +461,26 @@ module Fontisan
           report.check_results << check_result
 
           # Add issues to main report
-          if result[:issues]
-            result[:issues].each do |issue_data|
-              case issue_data[:severity]
-              when "error", "fatal"
-                report.add_error(
-                  issue_data[:category] || "validation",
-                  issue_data[:message],
-                  issue_data[:table] || issue_data[:field],
-                )
-              when "warning"
-                report.add_warning(
-                  issue_data[:category] || "validation",
-                  issue_data[:message],
-                  issue_data[:table] || issue_data[:field],
-                )
-              when "info"
-                report.add_info(
-                  issue_data[:category] || "validation",
-                  issue_data[:message],
-                  issue_data[:table] || issue_data[:field],
-                )
-              end
+          result[:issues]&.each do |issue_data|
+            case issue_data[:severity]
+            when "error", "fatal"
+              report.add_error(
+                issue_data[:category] || "validation",
+                issue_data[:message],
+                issue_data[:table] || issue_data[:field],
+              )
+            when "warning"
+              report.add_warning(
+                issue_data[:category] || "validation",
+                issue_data[:message],
+                issue_data[:table] || issue_data[:field],
+              )
+            when "info"
+              report.add_info(
+                issue_data[:category] || "validation",
+                issue_data[:message],
+                issue_data[:table] || issue_data[:field],
+              )
             end
           end
         end

data/lib/fontisan/validators/web_font_validator.rb

@@ -33,18 +33,16 @@ module Fontisan
         super
 
         # Check 9: OS/2 embedding permissions must allow web use
-        check_table :embedding_permissions, 'OS/2', severity: :error do |table|
-          table.has_embedding_permissions?
-        end
+        check_table :embedding_permissions, "OS/2", severity: :error,
+                    &:has_embedding_permissions?
 
         # Check 10: OS/2 version should be present
-        check_table :os2_version_web, 'OS/2', severity: :warning do |table|
-          table.valid_version?
-        end
+        check_table :os2_version_web, "OS/2", severity: :warning,
+                    &:valid_version?
 
         # Check 11: Glyph complexity should be reasonable for web
         check_glyphs :no_complex_glyphs, severity: :warning do |font|
-          maxp = font.table('maxp')
+          maxp = font.table("maxp")
           next true unless maxp.version_1_0?
 
           # Check max points and contours are reasonable for web rendering
@@ -53,33 +51,30 @@ module Fontisan
         end
 
         # Check 12: Cmap must have Unicode mapping for web
-        check_table :character_coverage, 'cmap', severity: :error do |table|
-          table.has_unicode_mapping?
-        end
+        check_table :character_coverage, "cmap", severity: :error,
+                    &:has_unicode_mapping?
 
         # Check 13: Cmap should have BMP coverage
-        check_table :cmap_bmp_web, 'cmap', severity: :warning do |table|
-          table.has_bmp_coverage?
-        end
+        check_table :cmap_bmp_web, "cmap", severity: :warning,
+                    &:has_bmp_coverage?
 
         # Check 14: Glyf glyphs must be accessible (web browsers need this)
         check_glyphs :glyph_accessible_web, severity: :error do |font|
-          glyf = font.table('glyf')
+          glyf = font.table("glyf")
           next true unless glyf
 
-          loca = font.table('loca')
-          head = font.table('head')
-          maxp = font.table('maxp')
+          loca = font.table("loca")
+          head = font.table("head")
+          maxp = font.table("maxp")
           glyf.all_glyphs_accessible?(loca, head, maxp.num_glyphs)
         end
 
         # Check 15: Head table must have valid bounding box
-        check_table :head_bbox_web, 'head', severity: :error do |table|
-          table.valid_bounding_box?
-        end
+        check_table :head_bbox_web, "head", severity: :error,
+                    &:valid_bounding_box?
 
         # Check 16: Hhea metrics must be valid for web rendering
-        check_table :hhea_metrics_web, 'hhea', severity: :error do |table|
+        check_table :hhea_metrics_web, "hhea", severity: :error do |table|
           table.valid_ascent_descent? && table.valid_number_of_h_metrics?
         end
 

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

data/lib/fontisan/woff2/glyf_transformer.rb

@@ -265,16 +265,33 @@ module Fontisan
                                         glyph_io, bbox_io, instruction_io)
         # Read end points of contours
         end_pts_of_contours = []
+        max_points_per_glyph = 100000 # Sanity limit
+
         num_contours.times do
           if end_pts_of_contours.empty?
-            end_pts_of_contours << read_255_uint16(n_points_io)
+            val = read_255_uint16(n_points_io)
+            end_pts_of_contours << val
           else
             delta = read_255_uint16(n_points_io)
-            end_pts_of_contours << end_pts_of_contours.last + delta + 1
+            next_end_pt = end_pts_of_contours.last + delta + 1
+
+            # Sanity check to prevent explosion from corrupted data
+            if delta > 10000 || next_end_pt > max_points_per_glyph
+              # Data appears corrupted, stop reading
+              break
+            end
+
+            end_pts_of_contours << next_end_pt
           end
         end
 
-        total_points = end_pts_of_contours.last + 1
+        # Handle case where stream was corrupted
+        if end_pts_of_contours.empty?
+          # Return minimal empty glyph
+          return ["\x00\x00"].pack("n") * 5 # Empty glyph: num_contours=0, bbox=0
+        end
+
+        total_points = [end_pts_of_contours.last + 1, max_points_per_glyph].min
 
         # Read flags
         flags = read_flags(flag_io, total_points)
@@ -517,6 +534,15 @@ instruction_io, variable_font: false)
         flags = []
 
         while flags.size < count
+          # Safety check to prevent infinite loops with corrupted streams
+          if flags.size > 200000
+            # Stream appears corrupted, pad with zeros
+            while flags.size < count
+              flags << 0
+            end
+            break
+          end
+
           # EOF protection for variable fonts
           break if io.eof? || (io.size - io.pos) < 1
 
@@ -527,15 +553,12 @@ instruction_io, variable_font: false)
             break if io.eof? || (io.size - io.pos) < 1
 
             repeat_count = read_uint8(io)
+            # Safety check on repeat count
+            repeat_count = [repeat_count, 100].min
             repeat_count.times { flags << flag }
           end
         end
 
-        # Pad with zero flags if needed
-        while flags.size < count
-          flags << 0
-        end
-
         flags
       end
 

data/lib/fontisan/woff2/hmtx_transformer.rb

@@ -33,7 +33,8 @@ module Fontisan
       # @param glyf_lsbs [Array<Integer>, nil] LSB values from glyf bboxes (optional)
       # @return [String] Standard hmtx table data
       # @raise [InvalidFontError] If data is corrupted or invalid
-      def self.reconstruct(transformed_data, num_glyphs, num_h_metrics, glyf_lsbs = nil)
+      def self.reconstruct(transformed_data, num_glyphs, num_h_metrics,
+glyf_lsbs = nil)
         io = StringIO.new(transformed_data)
 
         # Read transformation flags

data/lib/fontisan/woff2/table_transformer.rb

@@ -138,7 +138,8 @@ module Fontisan
         num_glyphs = maxp_table.num_glyphs
 
         # Parse hmtx table
-        advance_widths, lsbs = parse_hmtx_table(hmtx_data, num_h_metrics, num_glyphs)
+        advance_widths, lsbs = parse_hmtx_table(hmtx_data, num_h_metrics,
+                                                num_glyphs)
 
         # Build transformed hmtx table
         build_transformed_hmtx(advance_widths, lsbs, num_h_metrics, num_glyphs)
@@ -388,7 +389,8 @@ module Fontisan
       # @param num_h_metrics [Integer] Number of hMetric entries
       # @param num_glyphs [Integer] Total number of glyphs
       # @return [String] Transformed hmtx data
-      def build_transformed_hmtx(advance_widths, lsbs, num_h_metrics, num_glyphs)
+      def build_transformed_hmtx(advance_widths, lsbs, num_h_metrics,
+num_glyphs)
         data = String.new(encoding: Encoding::BINARY)
 
         # Flags: Use proportional encoding (not explicit) and explicit LSBs

data/lib/fontisan/woff2_font.rb

@@ -666,7 +666,8 @@ module Fontisan
         offset += padding
       end
 
-      # Write table directory
+      # Write table directory (all entries first)
+      # rubocop:disable Style/CombinableLoops - Must write directory entries first, then data
       table_records.each do |record|
         sfnt_data << record[:tag].ljust(4, "\x00")
         sfnt_data << [record[:checksum]].pack("N")
@@ -674,7 +675,7 @@ module Fontisan
         sfnt_data << [record[:length]].pack("N")
       end
 
-      # Write table data with padding
+      # Then write all table data with padding
       table_records.each do |record|
         sfnt_data << record[:data]
 
@@ -683,6 +684,7 @@ module Fontisan
           Constants::TABLE_ALIGNMENT
         sfnt_data << ("\x00" * padding) if padding.positive?
       end
+      # rubocop:enable Style/CombinableLoops
 
       # Update checksumAdjustment in head table
       update_checksum_in_memory(sfnt_data, table_records)

data/lib/fontisan/woff_font.rb

@@ -485,9 +485,9 @@ module Fontisan
 
       return unless head_offset
 
-      # Use tempfile-based checksum calculation for Windows compatibility
+      # Calculate checksum directly from IO to avoid Windows Tempfile issues
       File.open(path, "r+b") do |io|
-        checksum, _tmpfile = Utilities::ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
+        checksum = Utilities::ChecksumCalculator.calculate_checksum_from_io(io)
 
         # Calculate adjustment
         adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)

data/lib/fontisan.rb

@@ -112,6 +112,8 @@ require_relative "fontisan/models/scripts_info"
 require_relative "fontisan/models/features_info"
 require_relative "fontisan/models/all_scripts_features_info"
 require_relative "fontisan/models/validation_report"
+require_relative "fontisan/models/font_report"
+require_relative "fontisan/models/collection_validation_report"
 require_relative "fontisan/models/font_export"
 require_relative "fontisan/models/collection_font_summary"
 require_relative "fontisan/models/collection_info"
@@ -319,8 +321,6 @@ module Fontisan
   end
 
   class << self
-    private
-
     # Get loading mode for validation profile
     #
     # Temporarily disabled - will be reimplemented with new DSL framework

data/scripts/compare_stack_aware.rb

@@ -153,7 +153,7 @@ def main
     puts "\nStack-Aware Efficiency: #{efficiency_ratio}% of normal optimization"
   end
 
-  time_overhead = ((stack_aware[:time] / unoptimized[:time] - 1) * 100).round(2)
+  time_overhead = (((stack_aware[:time] / unoptimized[:time]) - 1) * 100).round(2)
   puts "\nProcessing Time Overhead:"
   puts "  Stack-Aware vs Unoptimized: +#{time_overhead}%"
 

data/scripts/measure_optimization.rb

@@ -96,8 +96,7 @@ def print_summary(results)
   puts "\n\n#{'=' * 80}"
   puts "SUMMARY TABLE"
   puts "=" * 80
-  puts format("%-30s %8s %12s %12s %10s %8s",
-              "Font", "Glyphs", "Before", "After", "Saved", "Reduction")
+  puts "Font                             Glyphs       Before        After      Saved Reduction"
   puts "-" * 80
 
   results.each do |r|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-06 00:00:00.000000000 Z
+date: 2026-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -203,12 +203,14 @@ files:
 - lib/fontisan/models/collection_font_summary.rb
 - lib/fontisan/models/collection_info.rb
 - lib/fontisan/models/collection_list_info.rb
+- lib/fontisan/models/collection_validation_report.rb
 - lib/fontisan/models/color_glyph.rb
 - lib/fontisan/models/color_layer.rb
 - lib/fontisan/models/color_palette.rb
 - lib/fontisan/models/features_info.rb
 - lib/fontisan/models/font_export.rb
 - lib/fontisan/models/font_info.rb
+- lib/fontisan/models/font_report.rb
 - lib/fontisan/models/font_summary.rb
 - lib/fontisan/models/glyph_info.rb
 - lib/fontisan/models/glyph_outline.rb