fontisan 0.2.3 → 0.2.4

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

data/lib/fontisan/open_type_font.rb

@@ -512,6 +512,12 @@ module Fontisan
         Constants::GPOS_TAG => Tables::Gpos,
         Constants::GLYF_TAG => Tables::Glyf,
         Constants::LOCA_TAG => Tables::Loca,
+        "SVG " => Tables::Svg,
+        "COLR" => Tables::Colr,
+        "CPAL" => Tables::Cpal,
+        "CBDT" => Tables::Cbdt,
+        "CBLC" => Tables::Cblc,
+        "sbix" => Tables::Sbix,
       }[tag]
     end
 

data/lib/fontisan/optimizers/charstring_rewriter.rb

@@ -30,12 +30,13 @@ module Fontisan
       #
       # @param charstring [String] original CharString bytes
       # @param patterns [Array<Pattern>] patterns to replace in this CharString
+      # @param glyph_id [Integer, nil] glyph ID being rewritten (for position filtering)
       # @return [String] rewritten CharString with subroutine calls
-      def rewrite(charstring, patterns)
+      def rewrite(charstring, patterns, glyph_id = nil)
         return charstring if patterns.empty?
 
         # Build list of all replacements: [position, pattern]
-        replacements = build_replacement_list(charstring, patterns)
+        replacements = build_replacement_list(charstring, patterns, glyph_id)
 
         # Remove overlapping replacements
         replacements = remove_overlaps(replacements)
@@ -120,16 +121,26 @@ module Fontisan
       # Build list of all pattern replacements with their positions
       # @param charstring [String] CharString being rewritten
       # @param patterns [Array<Pattern>] patterns to find
+      # @param glyph_id [Integer, nil] glyph ID being rewritten (for position filtering)
       # @return [Array<Array>] array of [position, pattern] pairs
-      def build_replacement_list(charstring, patterns)
+      def build_replacement_list(charstring, patterns, glyph_id = nil)
         replacements = []
 
         patterns.each do |pattern|
-          # Find all positions where this pattern occurs
-          positions = find_pattern_positions(charstring, pattern)
+          if glyph_id && pattern.respond_to?(:positions) && pattern.positions.is_a?(Hash)
+            # Use exact positions from pattern analysis for this glyph
+            glyph_positions = pattern.positions[glyph_id] || []
 
-          positions.each do |position|
-            replacements << [position, pattern]
+            glyph_positions.each do |position|
+              replacements << [position, pattern]
+            end
+          else
+            # Fallback for backward compatibility (unit tests without glyph_id)
+            positions = find_pattern_positions(charstring, pattern)
+
+            positions.each do |position|
+              replacements << [position, pattern]
+            end
           end
         end
 
@@ -140,7 +151,7 @@ module Fontisan
       # @param charstring [String] CharString to search
       # @param pattern [Pattern] pattern to find
       # @return [Array<Integer>] array of start positions
-      def find_pattern_positions(charstring, pattern)
+      def find_pattern_positions(charstring, pattern, glyph_id = nil)
         positions = []
         offset = 0
 

data/lib/fontisan/optimizers/pattern_analyzer.rb

@@ -160,7 +160,9 @@ module Fontisan
                         charstrings.length
                       end
 
-        sampled_glyphs = charstrings.keys.sample(sample_size)
+        # Use deterministic selection instead of random sampling
+        # Sort keys first to ensure consistent ordering across platforms
+        sampled_glyphs = charstrings.keys.sort.take(sample_size)
 
         # NEW: Pre-compute boundaries for sampled glyphs
         # Check if boundaries are useful (more than just start position)
@@ -249,7 +251,7 @@ module Fontisan
           # Build positions hash
           positions = {}
           by_glyph.each do |glyph_id, glyph_occurrences|
-            positions[glyph_id] = glyph_occurrences.map(&:last)
+            positions[glyph_id] = glyph_occurrences.map(&:last).uniq
           end
 
           @patterns[bytes] = Pattern.new(

data/lib/fontisan/optimizers/subroutine_builder.rb

@@ -95,22 +95,23 @@ module Fontisan
       # @return [String] encoded bytes
       def encode_integer(num)
         # Range 1: -107 to 107 (single byte)
+        # CFF spec: byte value = 139 + number
         if num >= -107 && num <= 107
-          return [32 + num].pack("c")
+          return [139 + num].pack("C")
         end
 
         # Range 2: 108 to 1131 (two bytes)
         if num >= 108 && num <= 1131
           b0 = 247 + ((num - 108) >> 8)
           b1 = (num - 108) & 0xff
-          return [b0, b1].pack("c*")
+          return [b0, b1].pack("C*")
         end
 
         # Range 3: -1131 to -108 (two bytes)
         if num >= -1131 && num <= -108
           b0 = 251 - ((num + 108) >> 8)
           b1 = -(num + 108) & 0xff
-          return [b0, b1].pack("c*")
+          return [b0, b1].pack("C*")
         end
 
         # Range 4: -32768 to 32767 (three bytes)
@@ -118,7 +119,7 @@ module Fontisan
           b0 = 29
           b1 = (num >> 8) & 0xff
           b2 = num & 0xff
-          return [b0, b1, b2].pack("c*")
+          return [b0, b1, b2].pack("C*")
         end
 
         # Range 5: Larger numbers (five bytes)
@@ -127,7 +128,7 @@ module Fontisan
         b2 = (num >> 16) & 0xff
         b3 = (num >> 8) & 0xff
         b4 = num & 0xff
-        [b0, b1, b2, b3, b4].pack("c*")
+        [b0, b1, b2, b3, b4].pack("C*")
       end
     end
   end

data/lib/fontisan/optimizers/subroutine_optimizer.rb

@@ -30,7 +30,9 @@ module Fontisan
       # @return [Array<Pattern>] selected patterns
       def optimize_selection
         selected = []
-        remaining = @patterns.sort_by { |p| -p.savings }
+        # Sort by savings (descending), then by length (descending), then by min glyph ID,
+        # then by byte values for complete determinism across platforms
+        remaining = @patterns.sort_by { |p| [-p.savings, -p.length, p.glyphs.min, p.bytes.bytes] }
 
         remaining.each do |pattern|
           break if selected.length >= @max_subrs
@@ -50,7 +52,8 @@ module Fontisan
       # @return [Array<Pattern>] ordered subroutines
       def optimize_ordering(subroutines)
         # Higher frequency = lower ID (shorter encoding)
-        subroutines.sort_by { |subr| -subr.frequency }
+        # Use same comprehensive sort keys as optimize_selection for consistency
+        subroutines.sort_by { |subr| [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes] }
       end
 
       # Check if nesting would be beneficial

data/lib/fontisan/pipeline/output_writer.rb

@@ -96,9 +96,9 @@ module Fontisan
 
         writer = Converters::WoffWriter.new
         font = build_font_from_tables(tables)
-        result = writer.convert(font, @options)
+        woff_data = writer.convert(font, @options)
 
-        File.binwrite(@output_path, result[:woff_data])
+        File.binwrite(@output_path, woff_data)
       end
 
       # Write WOFF2 format