fontisan 0.2.3 → 0.2.4

data/lib/fontisan/commands/base_command.rb

@@ -58,30 +58,13 @@ module Fontisan
       # Load the font using FontLoader.
       #
       # Uses FontLoader for automatic format detection and loading.
-      # Returns either TrueTypeFont or OpenTypeFont depending on file format.
+      # Returns TrueTypeFont, OpenTypeFont, WoffFont, or Woff2Font depending on file format.
       #
-      # @return [TrueTypeFont, OpenTypeFont] The loaded font
+      # @return [TrueTypeFont, OpenTypeFont, WoffFont, Woff2Font] The loaded font
       # @raise [Errno::ENOENT] if file does not exist
-      # @raise [UnsupportedFormatError] for WOFF/WOFF2 or other unsupported formats
       # @raise [InvalidFontError] for corrupted or unknown formats
       # @raise [Error] for other loading failures
       def load_font
-        # BaseCommand is for inspection - reject compressed formats first
-        # Check file signature before attempting to load
-        File.open(@font_path, "rb") do |io|
-          signature = io.read(4)
-
-          if signature == "wOFF"
-            raise UnsupportedFormatError,
-                  "Unsupported font format: WOFF files must be decompressed first. " \
-                  "Use ConvertCommand to convert WOFF to TTF/OTF."
-          elsif signature == "wOF2"
-            raise UnsupportedFormatError,
-                  "Unsupported font format: WOFF2 files must be decompressed first. " \
-                  "Use ConvertCommand to convert WOFF2 to TTF/OTF."
-          end
-        end
-
         # Brief mode uses metadata loading for 5x faster parsing
         mode = @options[:brief] ? LoadingModes::METADATA : (@options[:mode] || LoadingModes::FULL)
 

data/lib/fontisan/commands/convert_command.rb

@@ -51,22 +51,26 @@ module Fontisan
       # @option options [Boolean] :verbose Verbose output
       def initialize(font_path, options = {})
         super(font_path, options)
-        @output_path = options[:output]
+
+        # Convert string keys to symbols for Thor compatibility
+        opts = options.transform_keys(&:to_sym)
+
+        @output_path = opts[:output]
 
         # Parse target format
-        @target_format = parse_target_format(options[:to])
+        @target_format = parse_target_format(opts[:to])
 
         # Parse coordinates if string provided
-        @coordinates = if options[:coordinates]
-                         parse_coordinates(options[:coordinates])
-                       elsif options[:instance_coordinates]
-                         options[:instance_coordinates]
+        @coordinates = if opts[:coordinates]
+                         parse_coordinates(opts[:coordinates])
+                       elsif opts[:instance_coordinates]
+                         opts[:instance_coordinates]
                        end
 
-        @instance_index = options[:instance_index]
-        @preserve_variation = options[:preserve_variation]
-        @preserve_hints = options.fetch(:preserve_hints, false)
-        @validate = !options[:no_validate]
+        @instance_index = opts[:instance_index]
+        @preserve_variation = opts[:preserve_variation]
+        @preserve_hints = opts.fetch(:preserve_hints, false)
+        @validate = !opts[:no_validate]
       end
 
       # Execute the conversion
@@ -193,14 +197,13 @@ module Fontisan
         when "svg"
           :svg
         when "woff"
-          raise ArgumentError,
-                "WOFF format conversion is not supported yet. Use woff2 instead."
+          :woff
         when "woff2"
           :woff2
         else
           raise ArgumentError,
                 "Unknown target format: #{format}. " \
-                "Supported: ttf, otf, svg, woff2"
+                "Supported: ttf, otf, svg, woff, woff2"
         end
       end
 

data/lib/fontisan/commands/info_command.rb

@@ -202,6 +202,9 @@ module Fontisan
         populate_from_name_table(info) if font.has_table?(Constants::NAME_TAG)
         populate_from_os2_table(info) if font.has_table?(Constants::OS2_TAG)
         populate_from_head_table(info) if font.has_table?(Constants::HEAD_TAG)
+        populate_color_info(info) if font.has_table?("COLR") && font.has_table?("CPAL")
+        populate_svg_info(info) if font.has_table?("SVG ")
+        populate_bitmap_info(info) if font.has_table?("CBLC") || font.has_table?("sbix")
       end
 
       # Populate FontInfo from the name table.
@@ -255,6 +258,91 @@ module Fontisan
         info.units_per_em = head_table.units_per_em
       end
 
+      # Populate FontInfo with color font information from COLR/CPAL tables
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_color_info(info)
+        colr_table = font.table("COLR")
+        cpal_table = font.table("CPAL")
+
+        return unless colr_table && cpal_table
+
+        info.is_color_font = true
+        info.color_glyphs = colr_table.num_color_glyphs
+        info.color_palettes = cpal_table.num_palettes
+        info.colors_per_palette = cpal_table.num_palette_entries
+      rescue StandardError => e
+        warn "Failed to populate color font info: #{e.message}"
+        info.is_color_font = false
+      end
+
+      # Populate FontInfo with SVG table information
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_svg_info(info)
+        svg_table = font.table("SVG ")
+
+        return unless svg_table
+
+        info.has_svg_table = true
+        info.svg_glyph_count = svg_table.glyph_ids_with_svg.length
+      rescue StandardError => e
+        warn "Failed to populate SVG info: #{e.message}"
+        info.has_svg_table = false
+      end
+
+      # Populate FontInfo with bitmap table information (CBDT/CBLC, sbix)
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_bitmap_info(info)
+        bitmap_strikes = []
+        ppem_sizes = []
+        formats = []
+
+        # Check for CBDT/CBLC (Google format)
+        if font.has_table?("CBLC") && font.has_table?("CBDT")
+          cblc = font.table("CBLC")
+          info.has_bitmap_glyphs = true
+          ppem_sizes.concat(cblc.ppem_sizes)
+
+          cblc.strikes.each do |strike_rec|
+            bitmap_strikes << Models::BitmapStrike.new(
+              ppem: strike_rec.ppem,
+              start_glyph_id: strike_rec.start_glyph_index,
+              end_glyph_id: strike_rec.end_glyph_index,
+              bit_depth: strike_rec.bit_depth,
+              num_glyphs: strike_rec.glyph_range.size
+            )
+          end
+          formats << "PNG" # CBDT typically contains PNG data
+        end
+
+        # Check for sbix (Apple format)
+        if font.has_table?("sbix")
+          sbix = font.table("sbix")
+          info.has_bitmap_glyphs = true
+          ppem_sizes.concat(sbix.ppem_sizes)
+          formats.concat(sbix.supported_formats)
+
+          sbix.strikes.each do |strike|
+            bitmap_strikes << Models::BitmapStrike.new(
+              ppem: strike[:ppem],
+              start_glyph_id: 0,
+              end_glyph_id: strike[:num_glyphs] - 1,
+              bit_depth: 32,  # sbix is typically 32-bit
+              num_glyphs: strike[:num_glyphs]
+            )
+          end
+        end
+
+        info.bitmap_strikes = bitmap_strikes unless bitmap_strikes.empty?
+        info.bitmap_ppem_sizes = ppem_sizes.uniq.sort
+        info.bitmap_formats = formats.uniq
+      rescue StandardError => e
+        warn "Failed to populate bitmap info: #{e.message}"
+        info.has_bitmap_glyphs = false
+      end
+
       # Format OS/2 embedding permission flags into a human-readable string.
       #
       # @param flags [Integer] OS/2 fsType flags

data/lib/fontisan/config/conversion_matrix.yml

@@ -78,26 +78,34 @@ conversions:
       are architectural placeholders for future optimization.
 
   # Phase 2 conversions (Milestone 2.3) - WOFF
-  # NOTE: Temporarily disabled until WOFF writer bugs are fixed
-  # - from: ttf
-  #   to: woff
-  #   strategy: woff_writer
-  #   description: "Compress TrueType to WOFF format with zlib"
-  #   status: implemented
-  #   notes: >
-  #     WOFF 1.0 encoding with zlib compression. Supports optional metadata
-  #     and private data blocks. Individual table compression for optimal
-  #     file size reduction.
-
-  # - from: otf
-  #   to: woff
-  #   strategy: woff_writer
-  #   description: "Compress OpenType/CFF to WOFF format with zlib"
-  #   status: implemented
-  #   notes: >
-  #     WOFF 1.0 encoding with zlib compression. Supports optional metadata
-  #     and private data blocks. Individual table compression for optimal
-  #     file size reduction.
+  - from: ttf
+    to: woff
+    strategy: woff_writer
+    description: "Compress TrueType to WOFF format with zlib"
+    status: implemented
+    notes: >
+      WOFF 1.0 encoding with zlib compression. Supports optional metadata
+      and private data blocks. Individual table compression for optimal
+      file size reduction.
+
+  - from: otf
+    to: woff
+    strategy: woff_writer
+    description: "Compress OpenType/CFF to WOFF format with zlib"
+    status: implemented
+    notes: >
+      WOFF 1.0 encoding with zlib compression. Supports optional metadata
+      and private data blocks. Individual table compression for optimal
+      file size reduction.
+
+  - from: woff
+    to: woff
+    strategy: woff_recompress
+    description: "Copy WOFF font with re-compression"
+    status: implemented
+    notes: >
+      Same-format copy operation. Decompresses and re-compresses WOFF data,
+      useful for normalizing compression or updating metadata.
 
   # Reverse WOFF conversions (WOFF → TTF/OTF)
   - from: woff
@@ -139,6 +147,36 @@ conversions:
       transformation. Note: SVG fonts are deprecated in favor of WOFF2, but
       useful for fallback, conversion, and inspection purposes.
 
+  # WOFF2 decompression (reverse conversions)
+  - from: woff2
+    to: ttf
+    strategy: woff2_decoder
+    description: "Decompress WOFF2 to TrueType format"
+    status: implemented
+    notes: >
+      WOFF2 decompression with Brotli. Reverses table transformations
+      (glyf/loca, hmtx) if present. Preserves all font data and metadata.
+      Automatically detects font flavor from WOFF2 header.
+
+  - from: woff2
+    to: otf
+    strategy: woff2_decoder
+    description: "Decompress WOFF2 to OpenType/CFF format"
+    status: implemented
+    notes: >
+      WOFF2 decompression with Brotli. Reverses table transformations
+      if present. Preserves all font data and metadata. Automatically
+      detects font flavor from WOFF2 header.
+
+  - from: woff2
+    to: woff2
+    strategy: woff2_recompress
+    description: "Copy WOFF2 font with re-compression"
+    status: implemented
+    notes: >
+      Same-format copy operation. Decompresses and re-compresses WOFF2 data
+      with Brotli, useful for normalizing compression or updating metadata.
+
 # Conversion compatibility matrix
 #
 # This section documents which source features are preserved in conversions.

data/lib/fontisan/converters/outline_converter.rb

@@ -415,11 +415,14 @@ module Fontisan
           # If we have local subroutines, add Subrs offset
           # Subrs offset is relative to Private DICT start
           if local_subrs.any?
-            # Calculate size of Private DICT itself to know where Subrs starts
+            # Add a placeholder Subrs offset first to get accurate size
+            private_dict_hash[:subrs] = 0
+
+            # Calculate size of Private DICT with Subrs entry
             temp_private_dict_data = Tables::Cff::DictBuilder.build(private_dict_hash)
             subrs_offset = temp_private_dict_data.bytesize
 
-            # Add Subrs offset to DICT
+            # Update with actual Subrs offset
             private_dict_hash[:subrs] = subrs_offset
           end
 
@@ -729,7 +732,7 @@ module Fontisan
           if glyph_patterns.empty?
             charstring
           else
-            rewriter.rewrite(charstring, glyph_patterns)
+            rewriter.rewrite(charstring, glyph_patterns, glyph_id)
           end
         end
 

data/lib/fontisan/converters/svg_generator.rb

@@ -99,6 +99,51 @@ module Fontisan
 
       private
 
+      # Generate SVG for a color glyph from COLR/CPAL tables
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param colr_table [Tables::Colr] COLR table
+      # @param cpal_table [Tables::Cpal] CPAL table
+      # @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)
+        # Get layers for this glyph
+        layers = colr_table.layers_for_glyph(glyph_id)
+        return nil if layers.empty?
+
+        # Get palette colors
+        palette = cpal_table.palette(palette_index)
+        return nil unless palette
+
+        # Generate SVG for each layer
+        svg_paths = []
+        layers.each do |layer|
+          # Get outline for layer glyph
+          outline = extractor.extract(layer.glyph_id)
+          next unless outline
+
+          # Get color for this layer
+          color = if layer.uses_foreground_color?
+                    "currentColor" # Use CSS currentColor for foreground
+                  else
+                    palette[layer.palette_index] || "#000000FF"
+                  end
+
+          # Convert outline to SVG path
+          path_data = outline.to_svg_path
+          next if path_data.empty?
+
+          # Create colored path element
+          svg_paths << %(<path d="#{path_data}" fill="#{color}" />)
+        end
+
+        svg_paths.empty? ? nil : svg_paths.join("\n")
+      rescue StandardError => e
+        warn "Failed to generate color glyph #{glyph_id}: #{e.message}"
+        nil
+      end
+
       # Extract glyph data from font
       #
       # @param font [TrueTypeFont, OpenTypeFont] Source font

data/lib/fontisan/converters/woff2_encoder.rb

@@ -6,7 +6,9 @@ require_relative "../woff2/directory"
 require_relative "../woff2/table_transformer"
 require_relative "../utilities/brotli_wrapper"
 require_relative "../utilities/checksum_calculator"
+require_relative "../validation/woff2_validator"
 require "yaml"
+require "stringio"
 
 module Fontisan
   module Converters
@@ -24,6 +26,7 @@ module Fontisan
     # 5. Compress all tables with single Brotli stream
     # 6. Build WOFF2 header and table directory
     # 7. Assemble complete WOFF2 binary
+    # 8. (Optional) Validate encoded WOFF2
     #
     # For Phase 2 Milestone 2.1:
     # - Basic WOFF2 structure generation
@@ -33,8 +36,13 @@ module Fontisan
     #
     # @example Convert TTF to WOFF2
     #   encoder = Woff2Encoder.new
-    #   woff2_binary = encoder.convert(font)
-    #   File.binwrite('font.woff2', woff2_binary)
+    #   result = encoder.convert(font)
+    #   File.binwrite('font.woff2', result[:woff2_binary])
+    #
+    # @example Convert with validation
+    #   encoder = Woff2Encoder.new
+    #   result = encoder.convert(font, validate: true)
+    #   puts result[:validation_report].text_summary if result[:validation_report]
     class Woff2Encoder
       include ConversionStrategy
 
@@ -57,7 +65,9 @@ module Fontisan
       # @param options [Hash] Conversion options
       # @option options [Integer] :quality Brotli quality (0-11)
       # @option options [Boolean] :transform_tables Apply table transformations
-      # @return [Hash] Hash with :woff2_binary key containing WOFF2 binary
+      # @option options [Boolean] :validate Run validation after encoding
+      # @option options [Symbol] :validation_level Validation level (:strict, :standard, :lenient)
+      # @return [Hash] Hash with :woff2_binary and optional :validation_report keys
       # @raise [Error] If encoding fails
       def convert(font, options = {})
         validate(font, :woff2)
@@ -97,8 +107,16 @@ module Fontisan
         # Assemble WOFF2 binary
         woff2_binary = assemble_woff2(header, entries, compressed_data)
 
-        # Return in special format for ConvertCommand to handle
-        { woff2_binary: woff2_binary }
+        # Prepare result
+        result = { woff2_binary: woff2_binary }
+
+        # Optional validation
+        if options[:validate]
+          validation_report = validate_encoding(woff2_binary, options)
+          result[:validation_report] = validation_report
+        end
+
+        result
       end
 
       # Get list of supported conversions
@@ -144,6 +162,67 @@ module Fontisan
 
       private
 
+      # Validate encoded WOFF2 binary
+      #
+      # @param woff2_binary [String] Encoded WOFF2 data
+      # @param options [Hash] Validation options
+      # @return [Models::ValidationReport] Validation report
+      def validate_encoding(woff2_binary, options)
+        # Load the encoded WOFF2 from memory
+        io = StringIO.new(woff2_binary)
+        woff2_font = Woff2Font.from_file_io(io, "encoded.woff2")
+
+        # Run validation
+        validation_level = options[:validation_level] || :standard
+        validator = Validation::Woff2Validator.new(level: validation_level)
+        validator.validate(woff2_font, "encoded.woff2")
+      rescue StandardError => e
+        # If validation fails, create a report with the error
+        report = Models::ValidationReport.new(
+          font_path: "encoded.woff2",
+          valid: false,
+        )
+        report.add_error("woff2_validation", "Validation failed: #{e.message}", nil)
+        report
+      end
+
+      # Helper method to load WOFF2 from StringIO
+      #
+      # This is added to Woff2Font to support in-memory validation
+      module Woff2FontMemoryLoader
+        def self.from_file_io(io, path_for_report)
+          io.rewind
+
+          woff2 = Woff2Font.new
+          woff2.io_source = Woff2Font::IOSource.new(path_for_report)
+
+          # Read header
+          woff2.header = Woff2::Woff2Header.read(io)
+
+          # Validate signature
+          unless woff2.header.signature == Woff2::Woff2Header::SIGNATURE
+            raise InvalidFontError,
+                  "Invalid WOFF2 signature: expected 0x#{Woff2::Woff2Header::SIGNATURE.to_s(16)}, " \
+                  "got 0x#{woff2.header.signature.to_i.to_s(16)}"
+          end
+
+          # Read table directory
+          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)
+
+          # Apply transformations
+          Woff2Font.apply_transformations!(woff2.table_entries, woff2.decompressed_tables)
+
+          woff2
+        end
+      end
+
+      # Extend Woff2Font with in-memory loading
+      Woff2Font.singleton_class.prepend(Woff2FontMemoryLoader)
+
       # Load configuration from YAML file
       #
       # @param path [String, nil] Path to config file
@@ -183,9 +262,9 @@ module Fontisan
             "mode" => "font",
           },
           "transformations" => {
-            "enabled" => false, # Disabled for Milestone 2.1
-            "glyf_loca" => false,
-            "hmtx" => false,
+            "enabled" => true, # Enable transformations for better compression
+            "glyf_loca" => true,
+            "hmtx" => true,
           },
           "metadata" => {
             "include" => false,
@@ -255,11 +334,17 @@ module Fontisan
       # @return [Array<Woff2::Directory::Entry>] Table entries
       def build_table_entries(table_data, transformer, transform_enabled)
         entries = []
+        transformed_data = {}
 
         # Sort tables by tag for consistent output
         sorted_tags = table_data.keys.sort
 
         sorted_tags.each do |tag|
+          # Skip loca if we're transforming glyf (loca is combined with glyf)
+          if tag == "loca" && transform_enabled && transformer.transformable?("glyf")
+            next
+          end
+
           entry = Woff2::Directory::Entry.new
           entry.tag = tag
 
@@ -270,8 +355,10 @@ module Fontisan
           # Apply transformation if enabled and supported
           if transform_enabled && transformer.transformable?(tag)
             transformed = transformer.transform_table(tag)
-            if transformed && transformed.bytesize < data.bytesize
+            if transformed&.bytesize&.positive? && transformed.bytesize < data.bytesize
+              # Transformation successful and reduces size
               entry.transform_length = transformed.bytesize
+              transformed_data[tag] = transformed
             end
           end
 
@@ -281,6 +368,9 @@ module Fontisan
           entries << entry
         end
 
+        # Store transformed data for compression
+        @transformed_data = transformed_data
+
         entries
       end
 
@@ -295,12 +385,15 @@ module Fontisan
         combined_data = String.new(encoding: Encoding::BINARY)
 
         entries.each do |entry|
-          # Get table data
-          data = table_data[entry.tag]
+          # Use transformed data if available, otherwise use original
+          data = if @transformed_data && @transformed_data[entry.tag]
+                   @transformed_data[entry.tag]
+                 else
+                   table_data[entry.tag]
+                 end
+
           next unless data
 
-          # For this milestone, we don't have transformed data yet
-          # Use original table data
           combined_data << data
         end
 

data/lib/fontisan/models/bitmap_glyph.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # Bitmap glyph representation model
+    #
+    # Represents a bitmap glyph from the CBDT/CBLC tables. Each glyph contains
+    # bitmap image data at a specific ppem size.
+    #
+    # This model uses lutaml-model for structured serialization to YAML/JSON/XML.
+    #
+    # @example Creating a bitmap glyph
+    #   glyph = BitmapGlyph.new
+    #   glyph.glyph_id = 42
+    #   glyph.ppem = 16
+    #   glyph.format = "PNG"
+    #   glyph.width = 16
+    #   glyph.height = 16
+    #   glyph.data_size = 256
+    #
+    # @example Serializing to JSON
+    #   json = glyph.to_json
+    #   # {
+    #   #   "glyph_id": 42,
+    #   #   "ppem": 16,
+    #   #   "format": "PNG",
+    #   #   "width": 16,
+    #   #   "height": 16,
+    #   #   "data_size": 256
+    #   # }
+    class BitmapGlyph < Lutaml::Model::Serializable
+      # @!attribute glyph_id
+      #   @return [Integer] Glyph ID
+      attribute :glyph_id, :integer
+
+      # @!attribute ppem
+      #   @return [Integer] Pixels per em for this bitmap
+      attribute :ppem, :integer
+
+      # @!attribute format
+      #   @return [String] Bitmap format (e.g., "PNG", "JPEG", "TIFF")
+      attribute :format, :string
+
+      # @!attribute width
+      #   @return [Integer] Bitmap width in pixels
+      attribute :width, :integer
+
+      # @!attribute height
+      #   @return [Integer] Bitmap height in pixels
+      attribute :height, :integer
+
+      # @!attribute bit_depth
+      #   @return [Integer] Bit depth (1, 2, 4, 8, 32)
+      attribute :bit_depth, :integer
+
+      # @!attribute data_size
+      #   @return [Integer] Size of bitmap data in bytes
+      attribute :data_size, :integer
+
+      # @!attribute data_offset
+      #   @return [Integer] Offset to bitmap data in CBDT table
+      attribute :data_offset, :integer
+
+      # Check if this is a PNG bitmap
+      #
+      # @return [Boolean] True if format is PNG
+      def png?
+        format&.upcase == "PNG"
+      end
+
+      # Check if this is a JPEG bitmap
+      #
+      # @return [Boolean] True if format is JPEG
+      def jpeg?
+        format&.upcase == "JPEG"
+      end
+
+      # Check if this is a TIFF bitmap
+      #
+      # @return [Boolean] True if format is TIFF
+      def tiff?
+        format&.upcase == "TIFF"
+      end
+
+      # Check if this is a color bitmap (32-bit)
+      #
+      # @return [Boolean] True if 32-bit color
+      def color?
+        bit_depth == 32
+      end
+
+      # Check if this is a monochrome bitmap (1-bit)
+      #
+      # @return [Boolean] True if 1-bit monochrome
+      def monochrome?
+        bit_depth == 1
+      end
+
+      # Get the color depth description
+      #
+      # @return [String] Human-readable color depth
+      def color_depth
+        case bit_depth
+        when 1 then "1-bit (monochrome)"
+        when 2 then "2-bit (4 colors)"
+        when 4 then "4-bit (16 colors)"
+        when 8 then "8-bit (256 colors)"
+        when 32 then "32-bit (full color with alpha)"
+        else "#{bit_depth}-bit"
+        end
+      end
+
+      # Get bitmap dimensions as string
+      #
+      # @return [String] Dimensions in "WxH" format
+      def dimensions
+        "#{width}x#{height}"
+      end
+    end
+  end
+end