fontisan 0.2.7 → 0.2.9

data/lib/fontisan/validators/font_book_validator.rb

@@ -36,94 +36,73 @@ module Fontisan
         super
 
         # Check 9: Name table Windows Unicode English encoding
-        check_table :name_windows_encoding, 'name', severity: :error do |table|
+        check_table :name_windows_encoding, "name", severity: :error do |table|
           table.has_valid_platform_combos?([3, 1, 0x0409]) # Windows Unicode English
         end
 
         # Check 10: Name table Mac Roman English encoding
-        check_table :name_mac_encoding, 'name', severity: :warning do |table|
+        check_table :name_mac_encoding, "name", severity: :warning do |table|
           table.has_valid_platform_combos?([1, 0, 0]) # Mac Roman English
         end
 
         # Check 11: OS/2 table version must be valid
-        check_table :os2_version, 'OS/2', severity: :error do |table|
-          table.valid_version?
-        end
+        check_table :os2_version, "OS/2", severity: :error, &:valid_version?
 
         # Check 12: OS/2 weight class must be valid (1-1000)
-        check_table :os2_weight_class, 'OS/2', severity: :error do |table|
-          table.valid_weight_class?
-        end
+        check_table :os2_weight_class, "OS/2", severity: :error,
+                    &:valid_weight_class?
 
         # Check 13: OS/2 width class must be valid (1-9)
-        check_table :os2_width_class, 'OS/2', severity: :error do |table|
-          table.valid_width_class?
-        end
+        check_table :os2_width_class, "OS/2", severity: :error,
+                    &:valid_width_class?
 
         # Check 14: OS/2 vendor ID should be present
-        check_table :os2_vendor_id, 'OS/2', severity: :warning do |table|
-          table.has_vendor_id?
-        end
+        check_table :os2_vendor_id, "OS/2", severity: :warning, &:has_vendor_id?
 
         # Check 15: OS/2 PANOSE classification should be present
-        check_table :os2_panose, 'OS/2', severity: :info do |table|
-          table.has_panose?
-        end
+        check_table :os2_panose, "OS/2", severity: :info, &:has_panose?
 
         # Check 16: OS/2 typographic metrics must be valid
-        check_table :os2_typo_metrics, 'OS/2', severity: :error do |table|
-          table.valid_typo_metrics?
-        end
+        check_table :os2_typo_metrics, "OS/2", severity: :error,
+                    &:valid_typo_metrics?
 
         # Check 17: OS/2 Windows metrics must be valid
-        check_table :os2_win_metrics, 'OS/2', severity: :error do |table|
-          table.valid_win_metrics?
-        end
+        check_table :os2_win_metrics, "OS/2", severity: :error,
+                    &:valid_win_metrics?
 
         # Check 18: OS/2 Unicode ranges should be present
-        check_table :os2_unicode_ranges, 'OS/2', severity: :warning do |table|
-          table.has_unicode_ranges?
-        end
+        check_table :os2_unicode_ranges, "OS/2", severity: :warning,
+                    &:has_unicode_ranges?
 
         # Check 19: Head table bounding box must be valid
-        check_table :head_bounding_box, 'head', severity: :error do |table|
-          table.valid_bounding_box?
-        end
+        check_table :head_bounding_box, "head", severity: :error,
+                    &:valid_bounding_box?
 
         # Check 20: Hhea ascent/descent must be valid
-        check_table :hhea_ascent_descent, 'hhea', severity: :error do |table|
-          table.valid_ascent_descent?
-        end
+        check_table :hhea_ascent_descent, "hhea", severity: :error,
+                    &:valid_ascent_descent?
 
         # Check 21: Hhea line gap should be valid
-        check_table :hhea_line_gap, 'hhea', severity: :warning do |table|
-          table.valid_line_gap?
-        end
+        check_table :hhea_line_gap, "hhea", severity: :warning,
+                    &:valid_line_gap?
 
         # Check 22: Hhea horizontal metrics count must be valid
-        check_table :hhea_metrics_count, 'hhea', severity: :error do |table|
-          table.valid_number_of_h_metrics?
-        end
+        check_table :hhea_metrics_count, "hhea", severity: :error,
+                    &:valid_number_of_h_metrics?
 
         # Check 23: Post table version must be valid
-        check_table :post_version, 'post', severity: :error do |table|
-          table.valid_version?
-        end
+        check_table :post_version, "post", severity: :error, &:valid_version?
 
         # Check 24: Post table italic angle should be valid
-        check_table :post_italic_angle, 'post', severity: :warning do |table|
-          table.valid_italic_angle?
-        end
+        check_table :post_italic_angle, "post", severity: :warning,
+                    &:valid_italic_angle?
 
         # Check 25: Post table underline metrics should be present
-        check_table :post_underline, 'post', severity: :info do |table|
-          table.has_underline_metrics?
-        end
+        check_table :post_underline, "post", severity: :info,
+                    &:has_underline_metrics?
 
         # Check 26: Cmap table must have subtables
-        check_table :cmap_subtables, 'cmap', severity: :error do |table|
-          table.has_subtables?
-        end
+        check_table :cmap_subtables, "cmap", severity: :error, &:has_subtables?
       end
     end
   end

data/lib/fontisan/validators/opentype_validator.rb

@@ -33,45 +33,44 @@ module Fontisan
         super
 
         # Check 27: Maxp TrueType metrics (only for version 1.0)
-        check_table :maxp_truetype_metrics, 'maxp', severity: :warning do |table|
+        check_table :maxp_truetype_metrics, "maxp",
+                    severity: :warning do |table|
           !table.version_1_0? || table.has_truetype_metrics?
         end
 
         # Check 28: Maxp max zones must be valid
-        check_table :maxp_zones, 'maxp', severity: :error do |table|
-          table.valid_max_zones?
-        end
+        check_table :maxp_zones, "maxp", severity: :error, &:valid_max_zones?
 
         # Check 29: Glyf glyphs must be accessible (TrueType fonts only)
         check_glyphs :glyf_accessible, severity: :error do |font|
-          glyf = font.table('glyf')
+          glyf = font.table("glyf")
           next true unless glyf # Skip if CFF font
 
-          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 30: Glyf glyphs should not be clipped
         check_glyphs :glyf_no_clipping, severity: :warning 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.no_clipped_glyphs?(loca, head, maxp.num_glyphs)
         end
 
         # Check 31: Glyf contour counts must be valid
         check_glyphs :glyf_valid_contours, 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")
 
           (0...maxp.num_glyphs).all? do |glyph_id|
             glyf.valid_contour_count?(glyph_id, loca, head)
@@ -79,29 +78,26 @@ module Fontisan
         end
 
         # Check 32: Cmap must have Unicode mapping
-        check_table :cmap_unicode_mapping, 'cmap', severity: :error do |table|
-          table.has_unicode_mapping?
-        end
+        check_table :cmap_unicode_mapping, "cmap", severity: :error,
+                    &:has_unicode_mapping?
 
         # Check 33: Cmap should have BMP coverage
-        check_table :cmap_bmp_coverage, 'cmap', severity: :warning do |table|
-          table.has_bmp_coverage?
-        end
+        check_table :cmap_bmp_coverage, "cmap", severity: :warning,
+                    &:has_bmp_coverage?
 
         # Check 34: Cmap must have format 4 subtable
-        check_table :cmap_format4, 'cmap', severity: :error do |table|
-          table.has_format_4_subtable?
-        end
+        check_table :cmap_format4, "cmap", severity: :error,
+                    &:has_format_4_subtable?
 
         # Check 35: Cmap glyph indices must be valid
         check_structure :cmap_glyph_indices, severity: :error do |font|
-          cmap = font.table('cmap')
-          maxp = font.table('maxp')
+          cmap = font.table("cmap")
+          maxp = font.table("maxp")
           cmap.valid_glyph_indices?(maxp.num_glyphs)
         end
 
         # Check 36: Table checksums (info level - many fonts have mismatches)
-        check_structure :checksum_valid, severity: :info do |font|
+        check_structure :checksum_valid, severity: :info do |_font|
           # Table checksum validation (info level - for reference)
           # Most fonts have checksum mismatches, so we make it info not error
           true # Placeholder - actual checksum validation if desired

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.9"
 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