fontisan 0.2.7 → 0.2.9

data/lib/fontisan/commands/validate_command.rb

@@ -3,6 +3,7 @@
 require_relative "base_command"
 require_relative "../validators/profile_loader"
 require_relative "../font_loader"
+require_relative "../tables/name"
 
 module Fontisan
   module Commands
@@ -70,12 +71,40 @@ module Fontisan
         # Load font with appropriate mode
         profile_config = Validators::ProfileLoader.profile_info(@profile)
         unless profile_config
-          puts "Error: Unknown profile '#{@profile}'" unless @suppress_warnings
+          unless @suppress_warnings
+            puts "Error: Unknown profile '#{@profile}'"
+            puts ""
+            puts "Available profiles:"
+            Validators::ProfileLoader.all_profiles.each do |name, config|
+              puts "  #{name.to_s.ljust(20)} - #{config[:description]}"
+            end
+            puts ""
+            puts "Use --list to see all available profiles"
+          end
           return 1
         end
 
         mode = profile_config[:loading_mode].to_sym
 
+        # Check if input is a collection
+        if FontLoader.collection?(@input)
+          validate_collection(mode)
+        else
+          validate_single_font(mode)
+        end
+      rescue StandardError => e
+        puts "Error: #{e.message}" unless @suppress_warnings
+        puts e.backtrace.join("\n") if @verbose && !@suppress_warnings
+        1
+      end
+
+      private
+
+      # Validate a single font file
+      #
+      # @param mode [Symbol] Loading mode
+      # @return [Integer] Exit code
+      def validate_single_font(mode)
         font = FontLoader.load(@input, mode: mode)
 
         # Select validator
@@ -102,13 +131,134 @@ module Fontisan
 
         # Return exit code
         exit_code(report)
-      rescue => e
-        puts "Error: #{e.message}" unless @suppress_warnings
-        puts e.backtrace.join("\n") if @verbose && !@suppress_warnings
-        1
       end
 
-      private
+      # Validate all fonts in a collection
+      #
+      # @param mode [Symbol] Loading mode
+      # @return [Integer] Exit code
+      def validate_collection(mode)
+        require_relative "../models/collection_validation_report"
+        require_relative "../models/font_report"
+
+        # Load collection metadata
+        collection = FontLoader.load_collection(@input)
+
+        # Create collection report
+        collection_report = Models::CollectionValidationReport.new(
+          collection_path: @input,
+          collection_type: collection.class.collection_format,
+          num_fonts: collection.num_fonts,
+        )
+
+        # Get validator
+        validator = Validators::ProfileLoader.load(@profile)
+
+        # Validate each font
+        collection.num_fonts.times do |index|
+          font = FontLoader.load(@input, font_index: index, mode: mode)
+          font_report = validator.validate(font)
+
+          # Set font_path to indicate collection file with index
+          # Fonts in collections don't have individual file paths
+          font_report.font_path = "#{@input}:#{index}"
+
+          # Extract font name
+          font_name = extract_font_name(font, index)
+
+          # Create and add font report
+          collection_report.add_font_report(
+            Models::FontReport.new(
+              font_index: index,
+              font_name: font_name,
+              report: font_report,
+            ),
+          )
+        rescue StandardError => e
+          # Create error report for failed font loading
+          # Use collection file path with index for fonts in collections
+          error_report = Models::ValidationReport.new(
+            font_path: "#{@input}:#{index}",
+            valid: false,
+          )
+          error_report.add_error("font_loading",
+                                 "Failed to load font #{index}: #{e.message}", nil)
+
+          collection_report.add_font_report(
+            Models::FontReport.new(
+              font_index: index,
+              font_name: "Font #{index}",
+              report: error_report,
+            ),
+          )
+        end
+
+        # Generate output based on format
+        output = case @format
+                 when :yaml
+                   collection_report.to_yaml
+                 when :json
+                   collection_report.to_json
+                 else
+                   collection_report.text_summary
+                 end
+
+        # Write to file or stdout
+        if @output
+          File.write(@output, output)
+          puts "Validation report written to #{@output}" if @verbose && !@suppress_warnings
+        else
+          puts output unless @suppress_warnings
+        end
+
+        # Return exit code based on worst status
+        collection_exit_code(collection_report)
+      end
+
+      # Extract font name from font object
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font object
+      # @param index [Integer] Font index (fallback)
+      # @return [String] Font name
+      def extract_font_name(font, index)
+        return "Font #{index}" unless font.respond_to?(:table)
+
+        name_table = font.table("name")
+        return "Font #{index}" unless name_table
+
+        full_name = name_table.english_name(Tables::Name::FULL_NAME)
+        return full_name if full_name && !full_name.empty?
+
+        postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+        return postscript_name if postscript_name && !postscript_name.empty?
+
+        "Font #{index}"
+      end
+
+      # Calculate exit code for collection validation
+      #
+      # Uses worst status across all fonts
+      #
+      # @param report [CollectionValidationReport] Collection report
+      # @return [Integer] Exit code
+      def collection_exit_code(report)
+        return 0 unless @return_value_results
+
+        # Check for fatal errors first
+        return 2 if report.font_reports.any? do |fr|
+          fr.report.fatal_errors.any?
+        end
+        # Then check for errors
+        return 3 if report.font_reports.any? { |fr| fr.report.errors_only.any? }
+        # Then check for warnings
+        return 4 if report.font_reports.any? do |fr|
+          fr.report.warnings_only.any?
+        end
+        # Then check for info
+        return 5 if report.font_reports.any? { |fr| fr.report.info_only.any? }
+
+        0
+      end
 
       # Generate output based on requested format
       #
@@ -155,6 +305,7 @@ module Fontisan
         return 3 if report.errors_only.any?
         return 4 if report.warnings_only.any?
         return 5 if report.info_only.any?
+
         0
       end
     end

data/lib/fontisan/converters/collection_converter.rb

@@ -59,11 +59,12 @@ module Fontisan
 
         verbose = options.fetch(:verbose, false)
         output_path = options[:output]
-        target_format = options.fetch(:target_format, 'preserve').to_s
+        target_format = options.fetch(:target_format, "preserve").to_s
 
         # Validate target_format
         unless %w[preserve ttf otf].include?(target_format)
-          raise ArgumentError, "Invalid target_format: #{target_format}. Must be 'preserve', 'ttf', or 'otf'"
+          raise ArgumentError,
+                "Invalid target_format: #{target_format}. Must be 'preserve', 'ttf', or 'otf'"
         end
 
         puts "Converting collection to #{target_type.to_s.upcase}..." if verbose
@@ -76,19 +77,22 @@ module Fontisan
         if source_type == target_type
           puts "  Source and target formats are the same, copying collection..." if verbose
           FileUtils.cp(collection_path, output_path)
-          return build_result(collection_path, output_path, source_type, target_type, fonts.size, [])
+          return build_result(collection_path, output_path, source_type,
+                              target_type, fonts.size, [])
         end
 
         # Step 2: Convert - transform fonts if requested
         puts "  Converting #{fonts.size} font(s)..." if verbose
-        converted_fonts, conversions = convert_fonts(fonts, source_type, target_type, options.merge(target_format: target_format))
+        converted_fonts, conversions = convert_fonts(fonts, source_type,
+                                                     target_type, options.merge(target_format: target_format))
 
         # Step 3: Repack - build target collection
         puts "  Repacking into #{target_type.to_s.upcase} format..." if verbose
         repack_fonts(converted_fonts, target_type, output_path, options)
 
         # Build result
-        result = build_result(collection_path, output_path, source_type, target_type, fonts.size, conversions)
+        result = build_result(collection_path, output_path, source_type,
+                              target_type, fonts.size, conversions)
 
         if verbose
           display_result(result)
@@ -111,7 +115,8 @@ module Fontisan
         end
 
         unless %i[ttc otc dfont].include?(target_type)
-          raise ArgumentError, "Invalid target type: #{target_type}. Must be :ttc, :otc, or :dfont"
+          raise ArgumentError,
+                "Invalid target type: #{target_type}. Must be :ttc, :otc, or :dfont"
         end
 
         unless options[:output]
@@ -202,20 +207,21 @@ module Fontisan
       # @param target_type [Symbol] Target collection type
       # @param options [Hash] Conversion options
       # @return [Array<(Array<Font>, Array<Hash>)>] [converted_fonts, conversions]
-      def convert_fonts(fonts, source_type, target_type, options)
+      def convert_fonts(fonts, _source_type, target_type, options)
         converted_fonts = []
         conversions = []
 
         # Determine if outline conversion is needed
-        target_format = options.fetch(:target_format, 'preserve').to_s
+        target_format = options.fetch(:target_format, "preserve").to_s
 
         fonts.each_with_index do |font, index|
           source_format = detect_font_format(font)
-          needs_conversion = outline_conversion_needed?(source_format, target_format)
+          needs_conversion = outline_conversion_needed?(source_format,
+                                                        target_format)
 
           if needs_conversion
             # Convert outline format
-            desired_format = target_format == 'preserve' ? source_format : target_format.to_sym
+            desired_format = target_format == "preserve" ? source_format : target_format.to_sym
             converter = FormatConverter.new
 
             begin
@@ -266,7 +272,7 @@ module Fontisan
       # @return [Boolean] true if conversion needed
       def outline_conversion_needed?(source_format, target_format)
         # 'preserve' means keep original format
-        return false if target_format == 'preserve'
+        return false if target_format == "preserve"
 
         # Convert if target format differs from source
         target_format.to_sym != source_format
@@ -401,7 +407,8 @@ module Fontisan
       # @param num_fonts [Integer] Number of fonts
       # @param conversions [Array<Hash>] Conversion details
       # @return [Hash] Result
-      def build_result(input, output, source_type, target_type, num_fonts, conversions)
+      def build_result(input, output, source_type, target_type, num_fonts,
+conversions)
         {
           input: input,
           output: output,
@@ -425,7 +432,9 @@ module Fontisan
         puts "Fonts: #{result[:num_fonts]}"
 
         if result[:conversions].any?
-          converted_count = result[:conversions].count { |c| c[:status] == :converted }
+          converted_count = result[:conversions].count do |c|
+            c[:status] == :converted
+          end
           if converted_count.positive?
             puts "Outline conversions: #{converted_count}"
           end

data/lib/fontisan/converters/svg_generator.rb

@@ -107,7 +107,8 @@ module Fontisan
       # @param extractor [OutlineExtractor] Outline extractor for layer glyphs
       # @param palette_index [Integer] Palette index to use (default: 0)
       # @return [String, nil] SVG path data with color layers, or nil if not color glyph
-      def generate_color_glyph(glyph_id, colr_table, cpal_table, extractor, palette_index: 0)
+      def generate_color_glyph(glyph_id, colr_table, cpal_table, extractor,
+palette_index: 0)
         # Get layers for this glyph
         layers = colr_table.layers_for_glyph(glyph_id)
         return nil if layers.empty?

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