fontisan 0.2.2 → 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/collection_brief_info.rb

@@ -13,16 +13,22 @@ module Fontisan
     # @example Creating collection brief info
     #   info = CollectionBriefInfo.new(
     #     collection_path: "fonts.ttc",
+    #     collection_type: "TTC",
+    #     collection_version: "1.0",
     #     num_fonts: 3,
     #     fonts: [font_info1, font_info2, font_info3]
     #   )
     class CollectionBriefInfo < Lutaml::Model::Serializable
       attribute :collection_path, :string
+      attribute :collection_type, :string
+      attribute :collection_version, :string
       attribute :num_fonts, :integer
       attribute :fonts, FontInfo, collection: true
 
       key_value do
         map "collection_path", to: :collection_path
+        map "collection_type", to: :collection_type
+        map "collection_version", to: :collection_version
         map "num_fonts", to: :num_fonts
         map "fonts", to: :fonts
       end

data/lib/fontisan/models/collection_info.rb

@@ -2,6 +2,7 @@
 
 require "lutaml/model"
 require_relative "table_sharing_info"
+require_relative "font_info"
 
 module Fontisan
   module Models
@@ -20,7 +21,8 @@ module Fontisan
     #     num_fonts: 6,
     #     font_offsets: [48, 380, 712, 1044, 1376, 1676],
     #     file_size_bytes: 2240000,
-    #     table_sharing: table_sharing_obj
+    #     table_sharing: table_sharing_obj,
+    #     fonts: [font_info1, font_info2, ...]
     #   )
     class CollectionInfo < Lutaml::Model::Serializable
       attribute :collection_path, :string
@@ -32,6 +34,7 @@ module Fontisan
       attribute :font_offsets, :integer, collection: true
       attribute :file_size_bytes, :integer
       attribute :table_sharing, TableSharingInfo
+      attribute :fonts, FontInfo, collection: true
 
       yaml do
         map "collection_path", to: :collection_path
@@ -43,6 +46,7 @@ module Fontisan
         map "font_offsets", to: :font_offsets
         map "file_size_bytes", to: :file_size_bytes
         map "table_sharing", to: :table_sharing
+        map "fonts", to: :fonts
       end
 
       json do
@@ -55,6 +59,7 @@ module Fontisan
         map "font_offsets", to: :font_offsets
         map "file_size_bytes", to: :file_size_bytes
         map "table_sharing", to: :table_sharing
+        map "fonts", to: :fonts
       end
 
       # Get version as a formatted string

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