fontisan 0.2.2 → 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

@@ -50,62 +50,80 @@ module Fontisan
             # Brief mode: load each font and populate brief info
             brief_info = Models::CollectionBriefInfo.new
             brief_info.collection_path = @font_path
+            brief_info.collection_type = collection.class.collection_format
+            brief_info.collection_version = collection.version_string
             brief_info.num_fonts = collection.num_fonts
-            brief_info.fonts = []
-
-            collection.num_fonts.times do |index|
-              # Load individual font from collection
-              font = FontLoader.load(@font_path, font_index: index, mode: LoadingModes::METADATA)
-
-              # Populate brief info for this font
-              info = Models::FontInfo.new
-
-              # Font format and variable status
-              info.font_format = case font
-                                 when TrueTypeFont
-                                   "truetype"
-                                 when OpenTypeFont
-                                   "cff"
-                                 else
-                                   "unknown"
-                                 end
-              info.is_variable = font.has_table?(Constants::FVAR_TAG)
-
-              # Collection offset (only populated for fonts in collections)
-              info.collection_offset = collection.font_offsets[index]
-
-              # Essential names
-              if font.has_table?(Constants::NAME_TAG)
-                name_table = font.table(Constants::NAME_TAG)
-                info.family_name = name_table.english_name(Tables::Name::FAMILY)
-                info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
-                info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
-                info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
-                info.version = name_table.english_name(Tables::Name::VERSION)
-              end
-
-              # Essential metrics
-              if font.has_table?(Constants::HEAD_TAG)
-                head = font.table(Constants::HEAD_TAG)
-                info.font_revision = head.font_revision
-                info.units_per_em = head.units_per_em
-              end
-
-              # Vendor ID
-              if font.has_table?(Constants::OS2_TAG)
-                os2_table = font.table(Constants::OS2_TAG)
-                info.vendor_id = os2_table.vendor_id
-              end
-
-              brief_info.fonts << info
-            end
+            brief_info.fonts = load_collection_fonts(collection, @font_path)
 
             brief_info
           else
-            # Full mode: show detailed sharing statistics
-            collection.collection_info(io, @font_path)
+            # Full mode: show detailed sharing statistics AND font information
+            full_info = collection.collection_info(io, @font_path)
+
+            # Add font information to full mode
+            full_info.fonts = load_collection_fonts(collection, @font_path)
+
+            full_info
+          end
+        end
+      end
+
+      # Load font information for all fonts in a collection
+      #
+      # @param collection [TrueTypeCollection, OpenTypeCollection] The collection
+      # @param collection_path [String] Path to the collection file
+      # @return [Array<Models::FontInfo>] Array of font info objects
+      def load_collection_fonts(collection, collection_path)
+        fonts = []
+
+        collection.num_fonts.times do |index|
+          # Load individual font from collection
+          font = FontLoader.load(collection_path, font_index: index, mode: LoadingModes::METADATA)
+
+          # Populate font info
+          info = Models::FontInfo.new
+
+          # Font format and variable status
+          info.font_format = case font
+                             when TrueTypeFont
+                               "truetype"
+                             when OpenTypeFont
+                               "cff"
+                             else
+                               "unknown"
+                             end
+          info.is_variable = font.has_table?(Constants::FVAR_TAG)
+
+          # Collection offset (only populated for fonts in collections)
+          info.collection_offset = collection.font_offsets[index]
+
+          # Essential names
+          if font.has_table?(Constants::NAME_TAG)
+            name_table = font.table(Constants::NAME_TAG)
+            info.family_name = name_table.english_name(Tables::Name::FAMILY)
+            info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+            info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+            info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+            info.version = name_table.english_name(Tables::Name::VERSION)
+          end
+
+          # Essential metrics
+          if font.has_table?(Constants::HEAD_TAG)
+            head = font.table(Constants::HEAD_TAG)
+            info.font_revision = head.font_revision
+            info.units_per_em = head.units_per_em
           end
+
+          # Vendor ID
+          if font.has_table?(Constants::OS2_TAG)
+            os2_table = font.table(Constants::OS2_TAG)
+            info.vendor_id = os2_table.vendor_id
+          end
+
+          fonts << info
         end
+
+        fonts
       end
 
       # Get individual font information
@@ -184,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.
@@ -237,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