fontisan 0.2.7 → 0.2.8

data/lib/fontisan/converters/woff2_encoder.rb

@@ -109,7 +109,7 @@ module Fontisan
         woff2_binary = assemble_woff2(header, entries, compressed_data)
 
         # Prepare result
-        result = { woff2_binary: woff2_binary }
+        { woff2_binary: woff2_binary }
 
         # Optional validation
         # Temporarily disabled - will be reimplemented with new DSL framework
@@ -117,8 +117,6 @@ module Fontisan
         #   validation_report = validate_encoding(woff2_binary, options)
         #   result[:validation_report] = validation_report
         # end
-
-        result
       end
 
       # Get list of supported conversions
@@ -185,14 +183,16 @@ module Fontisan
           end
 
           # Read table directory
-          woff2.table_entries = Woff2Font.read_table_directory_from_io(io, woff2.header)
+          woff2.table_entries = Woff2Font.read_table_directory_from_io(io,
+                                                                       woff2.header)
 
           # Decompress tables
           woff2.decompressed_tables = Woff2Font.decompress_tables(io, woff2.header,
-                                                                   woff2.table_entries)
+                                                                  woff2.table_entries)
 
           # Apply transformations
-          Woff2Font.apply_transformations!(woff2.table_entries, woff2.decompressed_tables)
+          Woff2Font.apply_transformations!(woff2.table_entries,
+                                           woff2.decompressed_tables)
 
           woff2
         end

data/lib/fontisan/converters/woff_writer.rb

@@ -369,9 +369,11 @@ module Fontisan
         # Sort tables by tag for consistent output (same order as directory)
         sorted_tables = compressed_tables.sort_by { |tag, _| tag }
 
-        sorted_tables.each do |_tag, table_info|
+        # rubocop:disable Style/HashEachMethods - sorted_tables is an Array, not a Hash
+        sorted_tables.each do |_, table_info|
           io.write(table_info[:compressed_data])
         end
+        # rubocop:enable Style/HashEachMethods
       end
 
       # Write metadata to output

data/lib/fontisan/font_loader.rb

@@ -72,7 +72,8 @@ module Fontisan
         when "wOF2"
           Woff2Font.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when Constants::DFONT_RESOURCE_HEADER
-          extract_and_load_dfont(io, path, font_index, resolved_mode, resolved_lazy)
+          extract_and_load_dfont(io, path, font_index, resolved_mode,
+                                 resolved_lazy)
         else
           raise InvalidFontError,
                 "Unknown font format. Expected TTF, OTF, TTC, OTC, WOFF, or WOFF2 file."
@@ -185,7 +186,7 @@ module Fontisan
         num_fonts = io.read(4).unpack1("N")
 
         # Read all font offsets
-        font_offsets = num_fonts.times.map { io.read(4).unpack1("N") }
+        font_offsets = Array.new(num_fonts) { io.read(4).unpack1("N") }
 
         # Scan all fonts to determine collection type (not just first)
         truetype_count = 0
@@ -212,7 +213,7 @@ module Fontisan
         # Determine collection type based on what fonts are inside
         # If ANY font is OpenType, use OpenTypeCollection (more general format)
         # Only use TrueTypeCollection if ALL fonts are TrueType
-        if opentype_count > 0
+        if opentype_count.positive?
           OpenTypeCollection.from_file(path)
         else
           # All fonts are TrueType
@@ -282,7 +283,7 @@ mode: LoadingModes::FULL, lazy: true)
       end
 
       # Read all font offsets
-      font_offsets = num_fonts.times.map { io.read(4).unpack1("N") }
+      font_offsets = Array.new(num_fonts) { io.read(4).unpack1("N") }
 
       # Scan all fonts to determine collection type (not just first)
       truetype_count = 0
@@ -308,7 +309,7 @@ mode: LoadingModes::FULL, lazy: true)
 
       # If ANY font is OpenType, use OpenTypeCollection (more general format)
       # Only use TrueTypeCollection if ALL fonts are TrueType
-      if opentype_count > 0
+      if opentype_count.positive?
         # OpenType Collection
         otc = OpenTypeCollection.from_file(path)
         File.open(path, "rb") { |f| otc.font(font_index, f, mode: mode) }
@@ -328,7 +329,7 @@ mode: LoadingModes::FULL, lazy: true)
     # @param lazy [Boolean] Lazy loading flag
     # @return [TrueTypeFont, OpenTypeFont] Loaded font
     # @api private
-    def self.extract_and_load_dfont(io, path, font_index, mode, lazy)
+    def self.extract_and_load_dfont(io, _path, font_index, mode, lazy)
       require_relative "parsers/dfont_parser"
 
       # Extract SFNT data from resource fork

data/lib/fontisan/formatters/text_formatter.rb

@@ -410,15 +410,16 @@ module Fontisan
 
           info.fonts.each_with_index do |font_info, index|
             # Show font index with offset
-            if font_info.collection_offset
-              lines << "Font #{index} (offset: #{font_info.collection_offset}):"
-            else
-              lines << "Font #{index}:"
-            end
+            lines << if font_info.collection_offset
+                       "Font #{index} (offset: #{font_info.collection_offset}):"
+                     else
+                       "Font #{index}:"
+                     end
             lines << ""
 
             # Format each font using same structure as brief mode
-            font_type_display = format_font_type_display(font_info.font_format, font_info.is_variable)
+            font_type_display = format_font_type_display(font_info.font_format,
+                                                         font_info.is_variable)
             add_line(lines, "Font type", font_type_display)
             add_line(lines, "Family", font_info.family_name)
             add_line(lines, "Subfamily", font_info.subfamily_name)
@@ -426,7 +427,8 @@ module Fontisan
             add_line(lines, "PostScript name", font_info.postscript_name)
             add_line(lines, "Version", font_info.version)
             add_line(lines, "Vendor ID", font_info.vendor_id)
-            add_line(lines, "Font revision", format_float(font_info.font_revision))
+            add_line(lines, "Font revision",
+                     format_float(font_info.font_revision))
             add_line(lines, "Units per em", font_info.units_per_em)
 
             # Blank line between fonts (except after last)
@@ -467,15 +469,16 @@ module Fontisan
         # Each font's brief info
         info.fonts.each_with_index do |font_info, index|
           # Show font index with offset
-          if font_info.collection_offset
-            lines << "Font #{index} (offset: #{font_info.collection_offset}):"
-          else
-            lines << "Font #{index}:"
-          end
+          lines << if font_info.collection_offset
+                     "Font #{index} (offset: #{font_info.collection_offset}):"
+                   else
+                     "Font #{index}:"
+                   end
           lines << ""
 
           # Format each font using same structure as individual fonts
-          font_type_display = format_font_type_display(font_info.font_format, font_info.is_variable)
+          font_type_display = format_font_type_display(font_info.font_format,
+                                                       font_info.is_variable)
           add_line(lines, "Font type", font_type_display)
           add_line(lines, "Family", font_info.family_name)
           add_line(lines, "Subfamily", font_info.subfamily_name)
@@ -483,7 +486,8 @@ module Fontisan
           add_line(lines, "PostScript name", font_info.postscript_name)
           add_line(lines, "Version", font_info.version)
           add_line(lines, "Vendor ID", font_info.vendor_id)
-          add_line(lines, "Font revision", format_float(font_info.font_revision))
+          add_line(lines, "Font revision",
+                   format_float(font_info.font_revision))
           add_line(lines, "Units per em", font_info.units_per_em)
 
           # Blank line between fonts (except after last)

data/lib/fontisan/hints/hint_converter.rb

@@ -244,7 +244,7 @@ module Fontisan
         # CVT values typically contain standard widths at the beginning
         if cvt && !cvt.empty?
           # First CVT value often represents standard horizontal stem
-          hints[:std_hw] = cvt[0].abs if cvt.length > 0
+          hints[:std_hw] = cvt[0].abs if cvt.length.positive?
           # Second CVT value often represents standard vertical stem
           hints[:std_vw] = cvt[1].abs if cvt.length > 1
         end

data/lib/fontisan/hints/hint_validator.rb

@@ -40,7 +40,10 @@ module Fontisan
       # @param instructions [String] Binary instruction bytes
       # @return [Hash] Validation result with :valid, :errors, :warnings keys
       def validate_truetype_instructions(instructions)
-        return { valid: true, errors: [], warnings: [] } if instructions.nil? || instructions.empty?
+        if instructions.nil? || instructions.empty?
+          return { valid: true, errors: [],
+                   warnings: [] }
+        end
 
         errors = []
         warnings = []
@@ -114,7 +117,6 @@ module Fontisan
           if stack_depth != 0
             warnings << "Stack not neutral: #{stack_depth} value(s) remaining"
           end
-
         rescue StandardError => e
           errors << "Exception during validation: #{e.message}"
         end
@@ -162,14 +164,14 @@ module Fontisan
         end
 
         # Validate stem widths
-        [:std_hw, :std_vw].each do |key|
+        %i[std_hw std_vw].each do |key|
           if hints[key] && hints[key] <= 0
             errors << "#{key} must be positive: #{hints[key]}"
           end
         end
 
         # Validate stem snaps
-        [:stem_snap_h, :stem_snap_v].each do |key|
+        %i[stem_snap_h stem_snap_v].each do |key|
           if hints[key]
             if hints[key].length > MAX_STEM_SNAP
               errors << "#{key} exceeds maximum (#{MAX_STEM_SNAP}): #{hints[key].length}"
@@ -191,10 +193,8 @@ module Fontisan
         end
 
         # Validate language_group
-        if hints[:language_group]
-          unless [0, 1].include?(hints[:language_group])
-            errors << "language_group must be 0 (Latin) or 1 (CJK): #{hints[:language_group]}"
-          end
+        if hints[:language_group] && ![0, 1].include?(hints[:language_group])
+          errors << "language_group must be 0 (Latin) or 1 (CJK): #{hints[:language_group]}"
         end
 
         {
@@ -212,7 +212,10 @@ module Fontisan
       # @param instructions [String] Binary instruction bytes
       # @return [Hash] Result with :neutral, :stack_depth, :errors keys
       def validate_stack_neutrality(instructions)
-        return { neutral: true, stack_depth: 0, errors: [] } if instructions.nil? || instructions.empty?
+        if instructions.nil? || instructions.empty?
+          return { neutral: true, stack_depth: 0,
+                   errors: [] }
+        end
 
         errors = []
         stack_depth = 0
@@ -257,7 +260,7 @@ module Fontisan
         end
 
         {
-          neutral: stack_depth == 0,
+          neutral: stack_depth.zero?,
           stack_depth: stack_depth,
           errors: errors,
         }

data/lib/fontisan/hints/truetype_instruction_analyzer.rb

@@ -29,7 +29,7 @@ module Fontisan
       RCVT = 0x45     # Read CVT
       WCVTP = 0x44    # Write CVT (in Pixels)
       WCVTF = 0x70    # Write CVT (in FUnits)
-      MDAP = [0x2E, 0x2F].freeze  # Move Direct Absolute Point
+      MDAP = [0x2E, 0x2F].freeze # Move Direct Absolute Point
       SCVTCI = 0x1D   # Set Control Value Table Cut In
       SSWCI = 0x1E    # Set Single Width Cut In
       SSW = 0x1F      # Set Single Width
@@ -106,7 +106,7 @@ module Fontisan
               # Pattern: value cvt_index WCVTP (stack top to bottom)
               if stack.length >= 2
                 value = stack.pop
-                cvt_index = stack.pop
+                stack.pop
                 # Track CVT modifications (useful for understanding setup)
               end
 
@@ -168,7 +168,7 @@ module Fontisan
 
         {
           fpgm_size: size,
-          has_functions: size > 0,
+          has_functions: size.positive?,
           complexity: complexity,
         }
       rescue StandardError
@@ -208,13 +208,19 @@ module Fontisan
         xheight_min = (450 * scale_factor).to_i
         xheight_max = (600 * scale_factor).to_i
         capheight_min = (650 * scale_factor).to_i
-        capheight_max = (1500 * scale_factor).to_i  # Wider range for large UPM
+        capheight_max = (1500 * scale_factor).to_i # Wider range for large UPM
 
         # Group CVT values by typical alignment zones
-        descender_values = cvt.select { |v| v < descender_max && v > descender_min }
-        baseline_values = cvt.select { |v| v >= -baseline_range && v <= baseline_range }
-        xheight_values = cvt.select { |v| v >= xheight_min && v <= xheight_max }
-        capheight_values = cvt.select { |v| v >= capheight_min && v <= capheight_max }
+        descender_values = cvt.select do |v|
+          v < descender_max && v > descender_min
+        end
+        baseline_values = cvt.select do |v|
+          v >= -baseline_range && v <= baseline_range
+        end
+        cvt.select { |v| v >= xheight_min && v <= xheight_max }
+        capheight_values = cvt.select do |v|
+          v >= capheight_min && v <= capheight_max
+        end
 
         # Build blue_values (baseline and top zones)
         blue_values = []
@@ -254,6 +260,7 @@ module Fontisan
       def estimate_complexity(bytes)
         return :simple if bytes.length < 50
         return :moderate if bytes.length < 200
+
         :complex
       end
     end

data/lib/fontisan/hints/truetype_instruction_generator.rb

@@ -65,7 +65,7 @@ module Fontisan
         {
           fpgm: generate_fpgm(ps_params),
           prep: generate_prep(ps_params),
-          cvt: generate_cvt(ps_params)
+          cvt: generate_cvt(ps_params),
         }
       end
 

data/lib/fontisan/models/collection_validation_report.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "font_report"
+require_relative "validation_report"
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # CollectionValidationReport aggregates validation results for all fonts
+    # in a TTC/OTC/dfont collection.
+    #
+    # Provides collection-level summary statistics and per-font validation
+    # details with clear formatting.
+    class CollectionValidationReport < Lutaml::Model::Serializable
+      attribute :collection_path, :string
+      attribute :collection_type, :string
+      attribute :num_fonts, :integer
+      attribute :font_reports, FontReport, collection: true,
+                                           initialize_empty: true
+      attribute :valid, :boolean, default: -> { true }
+
+      key_value do
+        map "collection_path", to: :collection_path
+        map "collection_type", to: :collection_type
+        map "num_fonts", to: :num_fonts
+        map "font_reports", to: :font_reports
+        map "valid", to: :valid
+      end
+
+      # Add a font report to the collection
+      #
+      # @param font_report [FontReport] The font report to add
+      # @return [void]
+      def add_font_report(font_report)
+        font_reports << font_report
+        # Mark that we're no longer using the default value
+        value_set_for(:font_reports)
+        # Update overall validity
+        self.valid = valid && font_report.report.valid?
+      end
+
+      # Get overall validation status for the collection
+      #
+      # @return [String] "valid", "invalid", or "valid_with_warnings"
+      def overall_status
+        return "invalid" unless font_reports.all? { |fr| fr.report.valid? }
+        return "valid_with_warnings" if font_reports.any? do |fr|
+          fr.report.has_warnings?
+        end
+
+        "valid"
+      end
+
+      # Generate text summary with collection header and per-font sections
+      #
+      # @return [String] Formatted validation report
+      def text_summary
+        lines = []
+        lines << "Collection: #{collection_path}"
+        lines << "Type: #{collection_type}"
+        lines << "Fonts: #{num_fonts}"
+        lines << ""
+        lines << "Summary:"
+        lines << "  Total Errors: #{total_errors}"
+        lines << "  Total Warnings: #{total_warnings}"
+        lines << "  Total Info: #{total_info}"
+
+        if font_reports.any?
+          lines << ""
+          font_reports.each do |font_report|
+            lines << "=== Font #{font_report.font_index}: #{font_report.font_name} ==="
+            # Indent each line of the font's report
+            font_lines = font_report.report.text_summary.split("\n")
+            lines.concat(font_lines)
+            lines << "" unless font_report == font_reports.last
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      # Calculate total errors across all fonts
+      #
+      # @return [Integer] Total error count
+      def total_errors
+        font_reports.sum { |fr| fr.report.summary.errors }
+      end
+
+      # Calculate total warnings across all fonts
+      #
+      # @return [Integer] Total warning count
+      def total_warnings
+        font_reports.sum { |fr| fr.report.summary.warnings }
+      end
+
+      # Calculate total info messages across all fonts
+      #
+      # @return [Integer] Total info count
+      def total_info
+        font_reports.sum { |fr| fr.report.summary.info }
+      end
+    end
+  end
+end

data/lib/fontisan/models/font_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "validation_report"
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # FontReport wraps a single font's validation report with collection context
+    #
+    # Used within CollectionValidationReport to associate validation results
+    # with a specific font index and name in the collection.
+    class FontReport < Lutaml::Model::Serializable
+      attribute :font_index, :integer
+      attribute :font_name, :string
+      attribute :report, ValidationReport
+
+      key_value do
+        map "font_index", to: :font_index
+        map "font_name", to: :font_name
+        map "report", to: :report
+      end
+    end
+  end
+end

data/lib/fontisan/models/validation_report.rb

@@ -101,7 +101,9 @@ module Fontisan
       attribute :status, :string
       attribute :use_case, :string
       attribute :checks_performed, :string, collection: true, default: -> { [] }
-      attribute :check_results, CheckResult, collection: true, default: -> { [] }
+      attribute :check_results, CheckResult, collection: true, default: -> {
+        []
+      }
 
       yaml do
         map "font_path", to: :font_path
@@ -340,7 +342,9 @@ module Fontisan
       # @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 }
+        check_results.select do |cr|
+          cr.table == table_tag.to_s && cr.field == field_name.to_s
+        end
       end
 
       # Check filtering methods
@@ -374,6 +378,7 @@ module Fontisan
       # @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
 

data/lib/fontisan/open_type_font.rb

@@ -581,10 +581,9 @@ module Fontisan
     # @param path [String] Path to the OTF file
     # @return [void]
     def update_checksum_adjustment_in_file(path)
-      # Use tempfile-based checksum calculation for Windows compatibility
-      # This keeps the tempfile alive until we're done with the checksum
       File.open(path, "r+b") do |io|
-        checksum, _tmpfile = Utilities::ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
+        # Calculate checksum directly from IO to avoid Windows Tempfile issues
+        checksum = Utilities::ChecksumCalculator.calculate_checksum_from_io(io)
 
         # Calculate adjustment
         adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)

data/lib/fontisan/optimizers/charstring_rewriter.rb

@@ -151,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, glyph_id = nil)
+      def find_pattern_positions(charstring, pattern, _glyph_id = nil)
         positions = []
         offset = 0
 

data/lib/fontisan/optimizers/subroutine_optimizer.rb

@@ -32,7 +32,9 @@ module Fontisan
         selected = []
         # 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 = @patterns.sort_by do |p|
+          [-p.savings, -p.length, p.glyphs.min, p.bytes.bytes]
+        end
 
         remaining.each do |pattern|
           break if selected.length >= @max_subrs
@@ -53,7 +55,9 @@ module Fontisan
       def optimize_ordering(subroutines)
         # Higher frequency = lower ID (shorter encoding)
         # Use same comprehensive sort keys as optimize_selection for consistency
-        subroutines.sort_by { |subr| [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes] }
+        subroutines.sort_by do |subr|
+          [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes]
+        end
       end
 
       # Check if nesting would be beneficial

data/lib/fontisan/subset/glyph_mapping.rb

@@ -30,6 +30,8 @@ module Fontisan
     #   mapping = Fontisan::Subset::GlyphMapping.new([0, 5, 10])
     #   mapping.old_id(1) # => 5
     class GlyphMapping
+      include Enumerable
+
       # @return [Hash<Integer, Integer>] mapping from old GIDs to new GIDs
       attr_reader :old_to_new
 

data/lib/fontisan/subset/table_subsetter.rb

@@ -152,7 +152,7 @@ module Fontisan
         # Build new hmtx data
         data = String.new(encoding: Encoding::BINARY)
 
-        mapping.each do |old_id, _new_id|
+        mapping.old_ids.each do |old_id|
           metric = table.metric_for(old_id)
           next unless metric
 
@@ -319,7 +319,7 @@ module Fontisan
         current_offset = 0
 
         # Process glyphs in mapping order
-        mapping.each do |old_id, _new_id|
+        mapping.old_ids.each do |old_id|
           @loca_offsets << current_offset
 
           # Get offset and size from original loca

data/lib/fontisan/tables/cblc.rb

@@ -86,9 +86,12 @@ module Fontisan
           size = new
 
           io = StringIO.new(data)
-          size.instance_variable_set(:@index_subtable_array_offset, io.read(4).unpack1("N"))
-          size.instance_variable_set(:@index_tables_size, io.read(4).unpack1("N"))
-          size.instance_variable_set(:@number_of_index_subtables, io.read(4).unpack1("N"))
+          size.instance_variable_set(:@index_subtable_array_offset,
+                                     io.read(4).unpack1("N"))
+          size.instance_variable_set(:@index_tables_size,
+                                     io.read(4).unpack1("N"))
+          size.instance_variable_set(:@number_of_index_subtables,
+                                     io.read(4).unpack1("N"))
           size.instance_variable_set(:@color_ref, io.read(4).unpack1("N"))
 
           # Parse hori and vert metrics (12 bytes each)
@@ -98,7 +101,8 @@ module Fontisan
           size.instance_variable_set(:@vert, SbitLineMetrics.read(vert_data))
 
           # Parse remaining fields
-          size.instance_variable_set(:@start_glyph_index, io.read(2).unpack1("n"))
+          size.instance_variable_set(:@start_glyph_index,
+                                     io.read(2).unpack1("n"))
           size.instance_variable_set(:@end_glyph_index, io.read(2).unpack1("n"))
           size.instance_variable_set(:@ppem_x, io.read(1).unpack1("C"))
           size.instance_variable_set(:@ppem_y, io.read(1).unpack1("C"))

data/lib/fontisan/tables/cff/index.rb

@@ -35,6 +35,8 @@ module Fontisan
       #   puts index[0]  # => first item data
       #   index.each { |item| puts item }
       class Index
+        include Enumerable
+
         # @return [Integer] Number of items in the INDEX
         attr_reader :count
 

data/lib/fontisan/tables/cff.rb

@@ -299,7 +299,8 @@ module Fontisan
         io.seek(absolute_offset)
         Index.new(io, start_offset: absolute_offset)
       rescue StandardError => e
-        raise CorruptedTableError, "Failed to parse Local Subr INDEX: #{e.message}"
+        raise CorruptedTableError,
+              "Failed to parse Local Subr INDEX: #{e.message}"
       end
 
       # Get the CharStrings INDEX for a specific font
@@ -320,7 +321,8 @@ module Fontisan
         io.seek(charstrings_offset)
         CharstringsIndex.new(io, start_offset: charstrings_offset)
       rescue StandardError => e
-        raise CorruptedTableError, "Failed to parse CharStrings INDEX: #{e.message}"
+        raise CorruptedTableError,
+              "Failed to parse CharStrings INDEX: #{e.message}"
       end
 
       # Get a CharString for a specific glyph
@@ -355,7 +357,8 @@ module Fontisan
           local_subr_index,
         )
       rescue StandardError => e
-        raise CorruptedTableError, "Failed to get CharString for glyph #{glyph_index}: #{e.message}"
+        raise CorruptedTableError,
+              "Failed to get CharString for glyph #{glyph_index}: #{e.message}"
       end
 
       # Get the number of glyphs in a font

data/lib/fontisan/tables/cff2/private_dict_blend_handler.rb

@@ -51,7 +51,7 @@ module Fontisan
           # Check if this is blend data
           # Format: base1 delta1_1 ... delta1_N base2 delta2_1 ... delta2_N ...
           # The array must be divisible by (num_axes + 1)
-          return nil unless value.size % (num_axes + 1) == 0
+          return nil unless (value.size % (num_axes + 1)).zero?
 
           num_values = value.size / (num_axes + 1)
           blends = []

data/lib/fontisan/tables/cff2.rb

@@ -121,7 +121,7 @@ module Fontisan
       def charstrings
         return [] unless @charstrings_index
 
-        @charstrings_index.count.times.map do |glyph_id|
+        Array.new(@charstrings_index.count) do |glyph_id|
           charstring_for_glyph(glyph_id)
         end.compact
       end