fontisan 0.2.3 → 0.2.5

data/lib/fontisan/converters/woff2_encoder.rb

@@ -6,7 +6,10 @@ require_relative "../woff2/directory"
 require_relative "../woff2/table_transformer"
 require_relative "../utilities/brotli_wrapper"
 require_relative "../utilities/checksum_calculator"
+# Validation temporarily disabled - will be reimplemented with new DSL framework in Week 3+
+# require_relative "../validation/woff2_validator"
 require "yaml"
+require "stringio"
 
 module Fontisan
   module Converters
@@ -24,6 +27,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 +37,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 +66,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 +108,17 @@ 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
+        # Temporarily disabled - will be reimplemented with new DSL framework
+        # 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 +164,43 @@ module Fontisan
 
       private
 
+      # 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 +240,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 +312,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 +333,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 +346,9 @@ module Fontisan
           entries << entry
         end
 
+        # Store transformed data for compression
+        @transformed_data = transformed_data
+
         entries
       end
 
@@ -295,12 +363,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

data/lib/fontisan/models/bitmap_strike.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # Bitmap strike representation model
+    #
+    # Represents a bitmap strike (size) from the CBLC table. Each strike contains
+    # bitmap glyphs at a specific ppem (pixels per em) size.
+    #
+    # This model uses lutaml-model for structured serialization to YAML/JSON/XML.
+    #
+    # @example Creating a bitmap strike
+    #   strike = BitmapStrike.new
+    #   strike.ppem = 16
+    #   strike.start_glyph_id = 10
+    #   strike.end_glyph_id = 100
+    #   strike.bit_depth = 32
+    #
+    # @example Serializing to JSON
+    #   json = strike.to_json
+    #   # {
+    #   #   "ppem": 16,
+    #   #   "start_glyph_id": 10,
+    #   #   "end_glyph_id": 100,
+    #   #   "bit_depth": 32
+    #   # }
+    class BitmapStrike < Lutaml::Model::Serializable
+      # @!attribute ppem
+      #   @return [Integer] Pixels per em (square pixels)
+      attribute :ppem, :integer
+
+      # @!attribute start_glyph_id
+      #   @return [Integer] First glyph ID in this strike
+      attribute :start_glyph_id, :integer
+
+      # @!attribute end_glyph_id
+      #   @return [Integer] Last glyph ID in this strike
+      attribute :end_glyph_id, :integer
+
+      # @!attribute bit_depth
+      #   @return [Integer] Bit depth (1, 2, 4, 8, or 32)
+      attribute :bit_depth, :integer
+
+      # @!attribute num_glyphs
+      #   @return [Integer] Number of glyphs in this strike
+      attribute :num_glyphs, :integer
+
+      # Get glyph IDs covered by this strike
+      #
+      # @return [Range] Range of glyph IDs
+      def glyph_range
+        start_glyph_id..end_glyph_id
+      end
+
+      # Check if this strike covers a specific glyph ID
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] True if glyph is in range
+      def includes_glyph?(glyph_id)
+        glyph_range.include?(glyph_id)
+      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
+
+      # Check if this is a color strike (32-bit)
+      #
+      # @return [Boolean] True if 32-bit color
+      def color?
+        bit_depth == 32
+      end
+
+      # Check if this is a monochrome strike (1-bit)
+      #
+      # @return [Boolean] True if 1-bit monochrome
+      def monochrome?
+        bit_depth == 1
+      end
+    end
+  end
+end

data/lib/fontisan/models/color_glyph.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "color_layer"
+
+module Fontisan
+  module Models
+    # Color glyph information model
+    #
+    # Represents a complete color glyph from the COLR table, containing
+    # multiple layers that are rendered in order to create the final
+    # multi-colored glyph.
+    #
+    # This model uses lutaml-model for structured serialization to YAML/JSON/XML.
+    #
+    # @example Creating a color glyph
+    #   glyph = ColorGlyph.new
+    #   glyph.glyph_id = 100
+    #   glyph.num_layers = 3
+    #   glyph.layers = [layer1, layer2, layer3]
+    #
+    # @example Serializing to JSON
+    #   json = glyph.to_json
+    #   # {
+    #   #   "glyph_id": 100,
+    #   #   "num_layers": 3,
+    #   #   "layers": [...]
+    #   # }
+    class ColorGlyph < Lutaml::Model::Serializable
+      # @!attribute glyph_id
+      #   @return [Integer] Base glyph ID
+      attribute :glyph_id, :integer
+
+      # @!attribute num_layers
+      #   @return [Integer] Number of color layers
+      attribute :num_layers, :integer
+
+      # @!attribute layers
+      #   @return [Array<ColorLayer>] Array of color layers
+      attribute :layers, ColorLayer, collection: true
+
+      # Check if glyph has color layers
+      #
+      # @return [Boolean] True if glyph has layers
+      def has_layers?
+        num_layers&.positive? || false
+      end
+
+      # Check if glyph is empty
+      #
+      # @return [Boolean] True if no layers
+      def empty?
+        !has_layers?
+      end
+    end
+  end
+end

data/lib/fontisan/models/color_layer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # Color layer information model
+    #
+    # Represents a single color layer in a COLR glyph. Each layer specifies
+    # a glyph ID to render and the palette index for its color.
+    #
+    # This model uses lutaml-model for structured serialization to YAML/JSON/XML.
+    #
+    # @example Creating a color layer
+    #   layer = ColorLayer.new
+    #   layer.glyph_id = 42
+    #   layer.palette_index = 2
+    #   layer.color = "#FF0000FF"
+    #
+    # @example Serializing to YAML
+    #   yaml = layer.to_yaml
+    #   # glyph_id: 42
+    #   # palette_index: 2
+    #   # color: "#FF0000FF"
+    class ColorLayer < Lutaml::Model::Serializable
+      # @!attribute glyph_id
+      #   @return [Integer] Glyph ID of the layer
+      attribute :glyph_id, :integer
+
+      # @!attribute palette_index
+      #   @return [Integer] Index into CPAL palette (0xFFFF = foreground)
+      attribute :palette_index, :integer
+
+      # @!attribute color
+      #   @return [String, nil] Hex color from palette (#RRGGBBAA), nil if foreground
+      attribute :color, :string
+
+      # Check if this layer uses the foreground color
+      #
+      # @return [Boolean] True if using text foreground color
+      def uses_foreground_color?
+        palette_index == 0xFFFF
+      end
+
+      # Check if this layer uses a palette color
+      #
+      # @return [Boolean] True if using CPAL palette color
+      def uses_palette_color?
+        !uses_foreground_color?
+      end
+    end
+  end
+end

data/lib/fontisan/models/color_palette.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # Color palette information model
+    #
+    # Represents a color palette from the CPAL table. Each palette contains
+    # an array of RGBA colors in hex format that can be referenced by
+    # COLR layer palette indices.
+    #
+    # This model uses lutaml-model for structured serialization to YAML/JSON/XML.
+    #
+    # @example Creating a color palette
+    #   palette = ColorPalette.new
+    #   palette.index = 0
+    #   palette.num_colors = 3
+    #   palette.colors = ["#FF0000FF", "#00FF00FF", "#0000FFFF"]
+    #
+    # @example Serializing to YAML
+    #   yaml = palette.to_yaml
+    #   # index: 0
+    #   # num_colors: 3
+    #   # colors:
+    #   #   - "#FF0000FF"
+    #   #   - "#00FF00FF"
+    #   #   - "#0000FFFF"
+    class ColorPalette < Lutaml::Model::Serializable
+      # @!attribute index
+      #   @return [Integer] Palette index (0-based)
+      attribute :index, :integer
+
+      # @!attribute num_colors
+      #   @return [Integer] Number of colors in this palette
+      attribute :num_colors, :integer
+
+      # @!attribute colors
+      #   @return [Array<String>] Array of hex color strings (#RRGGBBAA)
+      attribute :colors, :string, collection: true
+
+      # Get a color by index
+      #
+      # @param color_index [Integer] Color index within palette
+      # @return [String, nil] Hex color string or nil if invalid index
+      def color_at(color_index)
+        return nil if color_index.negative? || color_index >= colors.length
+
+        colors[color_index]
+      end
+
+      # Check if palette is empty
+      #
+      # @return [Boolean] True if no colors
+      def empty?
+        colors.nil? || colors.empty?
+      end
+    end
+  end
+end

data/lib/fontisan/models/font_info.rb

@@ -38,6 +38,22 @@ module Fontisan
       attribute :units_per_em, :integer
       attribute :collection_offset, :integer
 
+      # Color font information (from COLR/CPAL tables)
+      attribute :is_color_font, Lutaml::Model::Type::Boolean
+      attribute :color_glyphs, :integer
+      attribute :color_palettes, :integer
+      attribute :colors_per_palette, :integer
+
+      # SVG table information
+      attribute :has_svg_table, Lutaml::Model::Type::Boolean
+      attribute :svg_glyph_count, :integer
+
+      # Bitmap table information (CBDT/CBLC, sbix)
+      attribute :has_bitmap_glyphs, Lutaml::Model::Type::Boolean
+      attribute :bitmap_strikes, Models::BitmapStrike, collection: true
+      attribute :bitmap_ppem_sizes, :integer, collection: true
+      attribute :bitmap_formats, :string, collection: true
+
       key_value do
         map "font_format", to: :font_format
         map "is_variable", to: :is_variable
@@ -66,6 +82,16 @@ module Fontisan
         map "permissions", to: :permissions
         map "units_per_em", to: :units_per_em
         map "collection_offset", to: :collection_offset
+        map "is_color_font", to: :is_color_font
+        map "color_glyphs", to: :color_glyphs
+        map "color_palettes", to: :color_palettes
+        map "colors_per_palette", to: :colors_per_palette
+        map "has_svg_table", to: :has_svg_table
+        map "svg_glyph_count", to: :svg_glyph_count
+        map "has_bitmap_glyphs", to: :has_bitmap_glyphs
+        map "bitmap_strikes", to: :bitmap_strikes
+        map "bitmap_ppem_sizes", to: :bitmap_ppem_sizes
+        map "bitmap_formats", to: :bitmap_formats
       end
     end
   end

data/lib/fontisan/models/svg_glyph.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # SVG glyph representation model
+    #
+    # Represents an SVG document for a glyph or range of glyphs from the SVG table.
+    # Each SVG document can cover multiple glyph IDs and may be compressed.
+    #
+    # This model uses lutaml-model for structured serialization to YAML/JSON/XML.
+    #
+    # @example Creating an SVG glyph
+    #   svg_glyph = SvgGlyph.new
+    #   svg_glyph.glyph_id = 100
+    #   svg_glyph.start_glyph_id = 100
+    #   svg_glyph.end_glyph_id = 105
+    #   svg_glyph.svg_content = '<svg>...</svg>'
+    #   svg_glyph.compressed = false
+    #
+    # @example Serializing to JSON
+    #   json = svg_glyph.to_json
+    #   # {
+    #   #   "glyph_id": 100,
+    #   #   "start_glyph_id": 100,
+    #   #   "end_glyph_id": 105,
+    #   #   "svg_content": "<svg>...</svg>",
+    #   #   "compressed": false
+    #   # }
+    class SvgGlyph < Lutaml::Model::Serializable
+      # @!attribute glyph_id
+      #   @return [Integer] Primary glyph ID (usually same as start_glyph_id)
+      attribute :glyph_id, :integer
+
+      # @!attribute start_glyph_id
+      #   @return [Integer] First glyph ID in range covered by this SVG
+      attribute :start_glyph_id, :integer
+
+      # @!attribute end_glyph_id
+      #   @return [Integer] Last glyph ID in range covered by this SVG
+      attribute :end_glyph_id, :integer
+
+      # @!attribute svg_content
+      #   @return [String] SVG XML content (decompressed)
+      attribute :svg_content, :string
+
+      # @!attribute compressed
+      #   @return [Boolean] Whether the original data was gzip compressed
+      attribute :compressed, :boolean, default: -> { false }
+
+      # Get glyph IDs covered by this SVG document
+      #
+      # @return [Range] Range of glyph IDs
+      def glyph_range
+        start_glyph_id..end_glyph_id
+      end
+
+      # Check if this SVG covers a specific glyph ID
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] True if glyph is in range
+      def includes_glyph?(glyph_id)
+        glyph_range.include?(glyph_id)
+      end
+
+      # Check if this SVG covers multiple glyphs
+      #
+      # @return [Boolean] True if range includes more than one glyph
+      def covers_multiple_glyphs?
+        start_glyph_id != end_glyph_id
+      end
+
+      # Get the number of glyphs covered by this SVG
+      #
+      # @return [Integer] Number of glyphs in range
+      def num_glyphs
+        end_glyph_id - start_glyph_id + 1
+      end
+
+      # Check if SVG content is present
+      #
+      # @return [Boolean] True if svg_content is not nil or empty
+      def has_content?
+        !svg_content.nil? && !svg_content.empty?
+      end
+    end
+  end
+end