fontisan 0.2.0 → 0.2.2

data/lib/fontisan/converters/outline_converter.rb

@@ -131,7 +131,7 @@ module Fontisan
       # @param font [TrueTypeFont] Source font
       # @param options [Hash] Conversion options (currently unused)
       # @return [Hash<String, String>] Target tables
-      def convert_ttf_to_otf(font, options = {})
+      def convert_ttf_to_otf(font, _options = {})
         # Extract all glyphs from glyf table
         outlines = extract_ttf_outlines(font)
 
@@ -153,6 +153,22 @@ module Fontisan
         # Update head table for CFF
         tables["head"] = update_head_for_cff(font)
 
+        # Convert and apply hints if preservation is enabled
+        if @preserve_hints && hints_per_glyph.any?
+          # Extract font-level hints separately
+          hint_set = extract_ttf_hint_set(font)
+
+          unless hint_set.empty?
+            # Convert TrueType hints to PostScript format
+            converter = Hints::HintConverter.new
+            ps_hint_set = converter.convert_hint_set(hint_set, :postscript)
+
+            # Apply PostScript hints (validation mode - CFF modification pending)
+            applier = Hints::PostScriptHintApplier.new
+            tables = applier.apply(ps_hint_set, tables)
+          end
+        end
+
         tables
       end
 
@@ -168,7 +184,8 @@ module Fontisan
         hints_per_glyph = @preserve_hints ? extract_cff_hints(font) : {}
 
         # Build glyf and loca tables
-        glyf_data, loca_data, loca_format = build_glyf_loca_tables(outlines, hints_per_glyph)
+        glyf_data, loca_data, loca_format = build_glyf_loca_tables(outlines,
+                                                                   hints_per_glyph)
 
         # Copy all tables except CFF
         tables = copy_tables(font, ["CFF ", "CFF2"])
@@ -183,6 +200,22 @@ module Fontisan
         # Update head table for TrueType
         tables["head"] = update_head_for_truetype(font, loca_format)
 
+        # Convert and apply hints if preservation is enabled
+        if @preserve_hints && hints_per_glyph.any?
+          # Extract font-level hints separately
+          hint_set = extract_cff_hint_set(font)
+
+          unless hint_set.empty?
+            # Convert PostScript hints to TrueType format
+            converter = Hints::HintConverter.new
+            tt_hint_set = converter.convert_hint_set(hint_set, :truetype)
+
+            # Apply TrueType hints (writes fpgm/prep/cvt tables)
+            applier = Hints::TrueTypeHintApplier.new
+            tables = applier.apply(tt_hint_set, tables)
+          end
+        end
+
         tables
       end
 
@@ -325,7 +358,7 @@ module Fontisan
       # @param outlines [Array<Outline>] Glyph outlines
       # @param font [TrueTypeFont] Source font (for metadata)
       # @return [String] CFF table binary data
-      def build_cff_table(outlines, font, hints_per_glyph)
+      def build_cff_table(outlines, font, _hints_per_glyph)
         # Build CharStrings INDEX from outlines
         begin
           charstrings = outlines.map do |outline|
@@ -446,7 +479,8 @@ module Fontisan
           top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
           top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
         rescue StandardError => e
-          raise Fontisan::Error, "Failed to calculate CFF table offsets: #{e.message}"
+          raise Fontisan::Error,
+                "Failed to calculate CFF table offsets: #{e.message}"
         end
 
         # Build CFF Header
@@ -480,7 +514,7 @@ module Fontisan
       #
       # @param outlines [Array<Outline>] Glyph outlines
       # @return [Array<String, String, Integer>] [glyf_data, loca_data, loca_format]
-      def build_glyf_loca_tables(outlines, hints_per_glyph)
+      def build_glyf_loca_tables(outlines, _hints_per_glyph)
         glyf_data = "".b
         offsets = []
 
@@ -493,19 +527,8 @@ module Fontisan
             next
           end
 
-          # Convert outline to TrueType contours
-          contours = outline.to_truetype_contours
-
-          # Build glyph data
-          builder = Tables::Glyf::GlyphBuilder.new(
-            contours: contours,
-            x_min: outline.bbox[:x_min],
-            y_min: outline.bbox[:y_min],
-            x_max: outline.bbox[:x_max],
-            y_max: outline.bbox[:y_max],
-          )
-
-          glyph_data = builder.build
+          # Build glyph data using GlyphBuilder class method
+          glyph_data = Fontisan::Tables::GlyphBuilder.build_simple_glyph(outline)
           glyf_data << glyph_data
 
           # Add padding to 4-byte boundary
@@ -666,7 +689,7 @@ module Fontisan
         # Analyze patterns
         analyzer = Optimizers::PatternAnalyzer.new(
           min_length: 10,
-          stack_aware: true
+          stack_aware: true,
         )
         patterns = analyzer.analyze(charstrings_hash)
 
@@ -674,7 +697,8 @@ module Fontisan
         return [charstrings, []] if patterns.empty?
 
         # Optimize selection
-        optimizer = Optimizers::SubroutineOptimizer.new(patterns, max_subrs: 65_535)
+        optimizer = Optimizers::SubroutineOptimizer.new(patterns,
+                                                        max_subrs: 65_535)
         selected_patterns = optimizer.optimize_selection
 
         # Optimize ordering
@@ -684,7 +708,8 @@ module Fontisan
         return [charstrings, []] if selected_patterns.empty?
 
         # Build subroutines
-        builder = Optimizers::SubroutineBuilder.new(selected_patterns, type: :local)
+        builder = Optimizers::SubroutineBuilder.new(selected_patterns,
+                                                    type: :local)
         local_subrs = builder.build
 
         # Build subroutine map
@@ -697,7 +722,9 @@ module Fontisan
         rewriter = Optimizers::CharstringRewriter.new(subroutine_map, builder)
         optimized_charstrings = charstrings.map.with_index do |charstring, glyph_id|
           # Find patterns for this glyph
-          glyph_patterns = selected_patterns.select { |p| p.glyphs.include?(glyph_id) }
+          glyph_patterns = selected_patterns.select do |p|
+            p.glyphs.include?(glyph_id)
+          end
 
           if glyph_patterns.empty?
             charstring
@@ -722,13 +749,16 @@ module Fontisan
       def generate_static_instance(font, source_format, target_format)
         # Generate instance at specified coordinates
         fvar = font.table("fvar")
-        axes = fvar ? fvar.axes : []
+        fvar ? fvar.axes : []
 
-        generator = Variation::InstanceGenerator.new(font, @instance_coordinates)
+        generator = Variation::InstanceGenerator.new(font,
+                                                     @instance_coordinates)
         instance_tables = generator.generate
 
         # If target format differs from source, convert outlines
-        if source_format != target_format
+        if source_format == target_format
+          instance_tables
+        else
           # Create temporary font with instance tables
           temp_font = font.class.new
           temp_font.instance_variable_set(:@table_data, instance_tables)
@@ -742,8 +772,6 @@ module Fontisan
           else
             instance_tables
           end
-        else
-          instance_tables
         end
       end
 
@@ -780,8 +808,6 @@ module Fontisan
                  when %i[otf ttf], %i[cff2 ttf]
                    # blend → gvar
                    converter.blend_to_gvar(glyph_id)
-                 else
-                   nil
                  end
 
           variation_data[glyph_id] = data if data
@@ -835,19 +861,31 @@ module Fontisan
       def validate_source_tables(font, format)
         case format
         when :ttf
-          unless font.has_table?("glyf") && font.has_table?("loca") &&
-              font.table("glyf") && font.table("loca")
+          unless font.has_table?("glyf") && font.has_table?("loca")
+            raise Fontisan::MissingTableError,
+                  "TrueType font missing required glyf or loca table"
+          end
+          # Also verify tables can actually be loaded
+          unless font.table("glyf") && font.table("loca")
             raise Fontisan::MissingTableError,
                   "TrueType font missing required glyf or loca table"
           end
         when :cff2
-          unless font.has_table?("CFF2") && font.table("CFF2")
+          unless font.has_table?("CFF2")
+            raise Fontisan::MissingTableError,
+                  "CFF2 font missing required CFF2 table"
+          end
+          unless font.table("CFF2")
             raise Fontisan::MissingTableError,
                   "CFF2 font missing required CFF2 table"
           end
         when :otf
-          unless (font.has_table?("CFF ") && font.table("CFF ")) ||
-              (font.has_table?("CFF2") && font.table("CFF2"))
+          unless font.has_table?("CFF ") || font.has_table?("CFF2")
+            raise Fontisan::MissingTableError,
+                  "OpenType font missing required CFF or CFF2 table"
+          end
+          # Verify at least one can be loaded
+          unless font.table("CFF ") || font.table("CFF2")
             raise Fontisan::MissingTableError,
                   "OpenType font missing required CFF or CFF2 table"
           end
@@ -855,6 +893,11 @@ module Fontisan
 
         # Common required tables
         %w[head hhea maxp].each do |tag|
+          unless font.has_table?(tag)
+            raise Fontisan::MissingTableError,
+                  "Font missing required #{tag} table"
+          end
+          # Verify table can actually be loaded
           unless font.table(tag)
             raise Fontisan::MissingTableError,
                   "Font missing required #{tag} table"
@@ -924,6 +967,30 @@ module Fontisan
         {}
       end
 
+      # Extract complete TrueType hint set from font
+      #
+      # @param font [TrueTypeFont] Source font
+      # @return [HintSet] Complete hint set
+      def extract_ttf_hint_set(font)
+        extractor = Hints::TrueTypeHintExtractor.new
+        extractor.extract_from_font(font)
+      rescue StandardError => e
+        warn "Failed to extract TrueType hint set: #{e.message}"
+        Models::HintSet.new(format: :truetype)
+      end
+
+      # Extract complete PostScript hint set from font
+      #
+      # @param font [OpenTypeFont] Source font
+      # @return [HintSet] Complete hint set
+      def extract_cff_hint_set(font)
+        extractor = Hints::PostScriptHintExtractor.new
+        extractor.extract_from_font(font)
+      rescue StandardError => e
+        warn "Failed to extract PostScript hint set: #{e.message}"
+        Models::HintSet.new(format: :postscript)
+      end
+
       # Check if font is a variable font
       #
       # @param font [TrueTypeFont, OpenTypeFont] Font to check

data/lib/fontisan/converters/woff_writer.rb

@@ -128,7 +128,8 @@ module Fontisan
       # @raise [ArgumentError] if compression level is invalid
       def validate_compression_level!
         unless @compression_level.between?(0, 9)
-          raise ArgumentError, "Compression level must be between 0 and 9, got #{@compression_level}"
+          raise ArgumentError,
+                "Compression level must be between 0 and 9, got #{@compression_level}"
         end
       end
 
@@ -235,7 +236,9 @@ module Fontisan
         metadata_size = compressed_metadata ? compressed_metadata[:compressed_length] : 0
 
         # Calculate total compressed data size
-        total_compressed_size = compressed_tables.values.sum { |table| table[:compressed_length] }
+        total_compressed_size = compressed_tables.values.sum do |table|
+          table[:compressed_length]
+        end
 
         # Calculate private data offset (after table data + metadata)
         private_offset = data_offset + total_compressed_size + metadata_size
@@ -245,7 +248,9 @@ module Fontisan
         total_size = private_offset + private_size
 
         # Calculate total SFNT size (uncompressed)
-        total_sfnt_size = compressed_tables.values.sum { |table| table[:original_length] } +
+        total_sfnt_size = compressed_tables.values.sum do |table|
+          table[:original_length]
+        end +
           header_size + table_dir_size
 
         # Write WOFF header
@@ -364,7 +369,7 @@ module Fontisan
         # Sort tables by tag for consistent output (same order as directory)
         sorted_tables = compressed_tables.sort_by { |tag, _| tag }
 
-        sorted_tables.each_value do |table_info|
+        sorted_tables.each do |_tag, table_info|
           io.write(table_info[:compressed_data])
         end
       end

data/lib/fontisan/font_loader.rb

@@ -46,7 +46,11 @@ module Fontisan
 
       # Resolve mode and lazy parameters with environment variables
       resolved_mode = mode || env_mode || LoadingModes::FULL
-      resolved_lazy = lazy.nil? ? (env_lazy.nil? ? false : env_lazy) : lazy
+      resolved_lazy = if lazy.nil?
+                        env_lazy.nil? ? false : env_lazy
+                      else
+                        lazy
+                      end
 
       # Validate mode
       LoadingModes.validate_mode!(resolved_mode)
@@ -57,20 +61,19 @@ module Fontisan
 
         case signature
         when Constants::TTC_TAG
-          load_from_collection(io, path, font_index, mode: resolved_mode, lazy: resolved_lazy)
+          load_from_collection(io, path, font_index, mode: resolved_mode,
+                                                     lazy: resolved_lazy)
         when pack_uint32(Constants::SFNT_VERSION_TRUETYPE)
           TrueTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "OTTO"
           OpenTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "wOFF"
-          raise UnsupportedFormatError,
-                "Unsupported font format: WOFF. Please convert to TTF/OTF first."
+          WoffFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "wOF2"
-          raise UnsupportedFormatError,
-                "Unsupported font format: WOFF2. Please convert to TTF/OTF first."
+          Woff2Font.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         else
           raise InvalidFontError,
-                "Unknown font format. Expected TTF, OTF, TTC, or OTC file."
+                "Unknown font format. Expected TTF, OTF, TTC, OTC, WOFF, or WOFF2 file."
         end
       end
     end
@@ -171,7 +174,8 @@ module Fontisan
     # @param lazy [Boolean] If true, load tables on demand
     # @return [TrueTypeFont, OpenTypeFont] The loaded font object
     # @raise [InvalidFontError] if collection type cannot be determined
-    def self.load_from_collection(io, path, font_index, mode: LoadingModes::FULL, lazy: true)
+    def self.load_from_collection(io, path, font_index,
+mode: LoadingModes::FULL, lazy: true)
       # Read collection header to get font offsets
       io.seek(12) # Skip tag (4) + major_version (2) + minor_version (2) + num_fonts marker (4)
       num_fonts = io.read(4).unpack1("N")
@@ -213,6 +217,7 @@ module Fontisan
       [value].pack("N")
     end
 
-    private_class_method :load_from_collection, :pack_uint32, :env_mode, :env_lazy
+    private_class_method :load_from_collection, :pack_uint32, :env_mode,
+                         :env_lazy
   end
 end

data/lib/fontisan/font_writer.rb

@@ -113,6 +113,7 @@ module Fontisan
       # Write offset table (sfnt header)
       font_data << write_offset_table(table_entries.size)
 
+      # rubocop:disable Style/CombinableLoops
       # Write table directory (ALL entries first)
       table_entries.each do |entry|
         font_data << write_table_entry(entry)
@@ -123,6 +124,7 @@ module Fontisan
         font_data << entry[:data]
         font_data << entry[:padding]
       end
+      # rubocop:enable Style/CombinableLoops
 
       # Calculate and update head table checksum adjustment
       update_checksum_adjustment!(font_data, table_entries)
@@ -263,17 +265,18 @@ module Fontisan
       head_entry = table_entries.find { |e| e[:tag] == "head" }
       return unless head_entry
 
-      # Calculate font checksum (with head checksumAdjustment set to 0)
-      # The head table at offset 8 should already be 0 from original table
+      # Zero out checksumAdjustment field (offset 8 in head table) before calculating
+      # This ensures we calculate the correct checksum regardless of source font's value
+      head_offset = head_entry[:offset]
+      checksum_offset = head_offset + 8
+      font_data[checksum_offset, 4] = "\x00\x00\x00\x00"
+
+      # Calculate font checksum (with head checksumAdjustment zeroed)
       font_checksum = calculate_font_checksum(font_data)
 
       # Calculate adjustment
       adjustment = (Constants::CHECKSUM_ADJUSTMENT_MAGIC - font_checksum) & 0xFFFFFFFF
 
-      # Update head table checksumAdjustment field (offset 8 in head table)
-      head_offset = head_entry[:offset]
-      checksum_offset = head_offset + 8
-
       # Write adjustment as uint32 big-endian
       font_data[checksum_offset, 4] = [adjustment].pack("N")
     end

data/lib/fontisan/formatters/text_formatter.rb

@@ -42,6 +42,8 @@ module Fontisan
           format_font_summary(model)
         when Models::CollectionInfo
           format_collection_info(model)
+        when Models::CollectionBriefInfo
+          format_collection_brief_info(model)
         else
           model.to_s
         end
@@ -312,7 +314,8 @@ module Fontisan
                  font_format
                end
 
-        type += " (Variable)" if is_variable
+        # Always show variable status explicitly
+        type += is_variable ? " (Variable)" : " (Not Variable)"
         type
       end
 
@@ -396,6 +399,47 @@ module Fontisan
         lines.join("\n")
       end
 
+      # Format CollectionBriefInfo as human-readable text.
+      #
+      # @param info [Models::CollectionBriefInfo] Collection brief information to format
+      # @return [String] Formatted text with collection header and each font's brief info
+      def format_collection_brief_info(info)
+        lines = []
+
+        # Collection header
+        lines << "Collection: #{info.collection_path}"
+        lines << "Fonts: #{info.num_fonts}"
+        lines << ""
+
+        # 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 << ""
+
+          # Format each font using same structure as individual fonts
+          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)
+          add_line(lines, "Full name", font_info.full_name)
+          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, "Units per em", font_info.units_per_em)
+
+          # Blank line between fonts (except after last)
+          lines << "" unless index == info.num_fonts - 1
+        end
+
+        lines.join("\n")
+      end
+
       # Format bytes for human-readable display.
       #
       # @param bytes [Integer] Number of bytes

data/lib/fontisan/hints/hint_converter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "../models/hint"
 
 module Fontisan
@@ -67,6 +68,59 @@ module Fontisan
         remove_conflicts(unique_hints)
       end
 
+      # Convert entire HintSet between formats
+      #
+      # @param hint_set [Models::HintSet] Source hint set
+      # @param target_format [Symbol] Target format (:truetype or :postscript)
+      # @return [Models::HintSet] Converted hint set
+      def convert_hint_set(hint_set, target_format)
+        return hint_set if hint_set.format == target_format.to_s
+
+        result = Models::HintSet.new(format: target_format.to_s)
+
+        case target_format
+        when :postscript
+          # Convert font-level TT → PS
+          if hint_set.font_program || hint_set.control_value_program ||
+              hint_set.control_values&.any?
+            ps_dict = convert_tt_programs_to_ps_dict(
+              hint_set.font_program,
+              hint_set.control_value_program,
+              hint_set.control_values,
+            )
+            result.private_dict_hints = ps_dict.to_json
+          end
+
+          # Convert per-glyph hints
+          hint_set.hinted_glyph_ids.each do |glyph_id|
+            glyph_hints = hint_set.get_glyph_hints(glyph_id)
+            ps_hints = to_postscript(glyph_hints)
+            result.add_glyph_hints(glyph_id, ps_hints) unless ps_hints.empty?
+          end
+
+        when :truetype
+          # Convert font-level PS → TT
+          if hint_set.private_dict_hints && hint_set.private_dict_hints != "{}"
+            tt_programs = convert_ps_dict_to_tt_programs(
+              JSON.parse(hint_set.private_dict_hints),
+            )
+            result.font_program = tt_programs[:fpgm]
+            result.control_value_program = tt_programs[:prep]
+            result.control_values = tt_programs[:cvt]
+          end
+
+          # Convert per-glyph hints
+          hint_set.hinted_glyph_ids.each do |glyph_id|
+            glyph_hints = hint_set.get_glyph_hints(glyph_id)
+            tt_hints = to_truetype(glyph_hints)
+            result.add_glyph_hints(glyph_id, tt_hints) unless tt_hints.empty?
+          end
+        end
+
+        result.has_hints = !result.empty?
+        result
+      end
+
       private
 
       # Convert a single hint to PostScript format
@@ -83,7 +137,7 @@ module Fontisan
         Models::Hint.new(
           type: hint.type,
           data: ps_data,
-          source_format: :postscript
+          source_format: :postscript,
         )
       rescue StandardError => e
         warn "Failed to convert hint to PostScript: #{e.message}"
@@ -104,7 +158,7 @@ module Fontisan
         Models::Hint.new(
           type: hint.type,
           data: { instructions: tt_instructions },
-          source_format: :truetype
+          source_format: :truetype,
         )
       rescue StandardError => e
         warn "Failed to convert hint to TrueType: #{e.message}"
@@ -172,6 +226,81 @@ module Fontisan
 
         pos1 < end2 && pos2 < end1
       end
+
+      # Convert TrueType font programs to PostScript Private dict
+      #
+      # Analyzes TrueType fpgm, prep, and cvt to extract semantic intent
+      # and generate corresponding PostScript hint parameters using the
+      # TrueTypeInstructionAnalyzer.
+      #
+      # @param fpgm [String] Font program bytecode
+      # @param prep [String] Control value program bytecode
+      # @param cvt [Array<Integer>] Control values
+      # @return [Hash] PostScript Private dict hint parameters
+      def convert_tt_programs_to_ps_dict(fpgm, prep, cvt)
+        hints = {}
+
+        # Extract stem widths from CVT if present
+        # 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
+          # Second CVT value often represents standard vertical stem
+          hints[:std_vw] = cvt[1].abs if cvt.length > 1
+        end
+
+        # Use the instruction analyzer to extract additional hint parameters
+        analyzer = TrueTypeInstructionAnalyzer.new
+
+        # Analyze prep program if present
+        prep_hints = if prep && !prep.empty?
+                       analyzer.analyze_prep(prep, cvt)
+                     else
+                       {}
+                     end
+
+        # Analyze fpgm program complexity
+        fpgm_hints = if fpgm && !fpgm.empty?
+                       analyzer.analyze_fpgm(fpgm)
+                     else
+                       {}
+                     end
+
+        # Extract blue zones from CVT if present
+        blue_zones = if cvt && !cvt.empty?
+                       analyzer.extract_blue_zones_from_cvt(cvt)
+                     else
+                       {}
+                     end
+
+        # Merge all extracted hints (prep_hints and fpgm_hints override stem widths if present)
+        hints.merge!(prep_hints).merge!(fpgm_hints).merge!(blue_zones)
+
+        # Provide default blue_values if none were detected
+        # These are standard values that work for most Latin fonts
+        hints[:blue_values] ||= [-20, 0, 706, 726]
+
+        hints
+      rescue StandardError => e
+        warn "Error converting TT programs to PS dict: #{e.message}"
+        {}
+      end
+
+      # Convert PostScript Private dict to TrueType font programs
+      #
+      # Generates TrueType control values and programs from PostScript
+      # hint parameters using the TrueTypeInstructionGenerator.
+      #
+      # @param ps_dict [Hash] PostScript Private dict parameters
+      # @return [Hash] TrueType programs ({ fpgm:, prep:, cvt: })
+      def convert_ps_dict_to_tt_programs(ps_dict)
+        # Use the instruction generator to create real TrueType programs
+        generator = TrueTypeInstructionGenerator.new
+        generator.generate(ps_dict)
+      rescue StandardError => e
+        warn "Error converting PS dict to TT programs: #{e.message}"
+        { fpgm: "".b, prep: "".b, cvt: [] }
+      end
     end
   end
 end