fontisan 0.4.22 → 0.4.24

data/lib/fontisan/subset.rb

@@ -8,6 +8,9 @@ module Fontisan
     autoload :GlyphMapping, "fontisan/subset/glyph_mapping"
     autoload :Options, "fontisan/subset/options"
     autoload :Profile, "fontisan/subset/profile"
+    autoload :SharedState, "fontisan/subset/shared_state"
+    autoload :SubsetContext, "fontisan/subset/subset_context"
+    autoload :TableStrategy, "fontisan/subset/table_strategy"
     autoload :TableSubsetter, "fontisan/subset/table_subsetter"
   end
 end

data/lib/fontisan/svg/standalone_glyph.rb

@@ -118,7 +118,10 @@ module Fontisan
 
       def bounding_box(glyph)
         points = glyph.contours.flat_map(&:points)
-        return { x_min: 0, y_min: 0, x_max: @units_per_em, y_max: @units_per_em } if points.empty?
+        if points.empty?
+          return { x_min: 0, y_min: 0, x_max: @units_per_em,
+                   y_max: @units_per_em }
+        end
 
         xs = points.map(&:x)
         ys = points.map(&:y)

data/lib/fontisan/svg_to_glyf/assembler.rb

@@ -74,7 +74,8 @@ module Fontisan
       private
 
       def build_from_doc_path(data, group_transform, doc, codepoint)
-        final = normalizer_for(width: doc.viewbox_width, height: doc.viewbox_height)
+        final = normalizer_for(width: doc.viewbox_width,
+                               height: doc.viewbox_height)
           .final_transform(group_transform)
         contours = build_contours(data, final)
         assemble_glyph(glyph_name_for(codepoint), contours, codepoint)
@@ -89,13 +90,15 @@ module Fontisan
       def transform_contour(contour, transform)
         points = contour.points.map do |pt|
           x, y = transform.apply(pt.x, pt.y)
-          Fontisan::Ufo::Point.new(x: x.round, y: y.round, type: pt.type, smooth: pt.smooth)
+          Fontisan::Ufo::Point.new(x: x.round, y: y.round, type: pt.type,
+                                   smooth: pt.smooth)
         end
         Fontisan::Ufo::Contour.new(points)
       end
 
       def normalizer_for(width:, height:)
-        Geometry::Normalizer.new(viewbox_width: width, viewbox_height: height, upm: @upm)
+        Geometry::Normalizer.new(viewbox_width: width, viewbox_height: height,
+                                 upm: @upm)
       end
 
       def assemble_glyph(name, contours, codepoint)

data/lib/fontisan/svg_to_glyf/geometry/transform_parser.rb

@@ -22,7 +22,9 @@ module Fontisan
           transforms = transform_string.scan(FUNCTION_RE).map do |name, args|
             build_transform(name, args)
           end
-          transforms.reduce(AffineTransform.identity) { |acc, t| acc.compose(t) }
+          transforms.reduce(AffineTransform.identity) do |acc, t|
+            acc.compose(t)
+          end
         end
 
         def self.build_transform(name, args_string)
@@ -35,7 +37,8 @@ module Fontisan
           when "skewX" then AffineTransform.skew_x_radians(degrees_to_radians(args.fetch(0)))
           when "skewY" then AffineTransform.skew_y_radians(degrees_to_radians(args.fetch(0)))
           else
-            raise ArgumentError, "unknown SVG transform function: #{name.inspect}"
+            raise ArgumentError,
+                  "unknown SVG transform function: #{name.inspect}"
           end
         end
 
@@ -59,9 +62,13 @@ module Fontisan
         end
 
         def self.build_matrix(args)
-          raise ArgumentError, "matrix() requires 6 arguments, got #{args.size}" if args.size != 6
+          if args.size != 6
+            raise ArgumentError,
+                  "matrix() requires 6 arguments, got #{args.size}"
+          end
 
-          AffineTransform.new(args[0], args[1], args[2], args[3], args[4], args[5])
+          AffineTransform.new(args[0], args[1], args[2], args[3], args[4],
+                              args[5])
         end
 
         # Rotate around a specific point: translate to origin, rotate,

data/lib/fontisan/svg_to_glyf/geometry.rb

@@ -5,8 +5,10 @@ module Fontisan
     # Geometry primitives for SvgToGlyf: affine transforms, SVG
     # transform attribute parsing, and coordinate normalization.
     module Geometry
-      autoload :AffineTransform, "fontisan/svg_to_glyf/geometry/affine_transform"
-      autoload :TransformParser, "fontisan/svg_to_glyf/geometry/transform_parser"
+      autoload :AffineTransform,
+               "fontisan/svg_to_glyf/geometry/affine_transform"
+      autoload :TransformParser,
+               "fontisan/svg_to_glyf/geometry/transform_parser"
       autoload :Normalizer, "fontisan/svg_to_glyf/geometry/normalizer"
     end
   end

data/lib/fontisan/tables/cbdt.rb

@@ -1,167 +1,112 @@
 # frozen_string_literal: true
 
-require "stringio"
-
 module Fontisan
   module Tables
-    # CBDT (Color Bitmap Data) table parser
-    #
-    # The CBDT table contains the actual bitmap data for color glyphs. It works
-    # together with the CBLC table which provides the location information for
-    # finding bitmaps in this table.
-    #
-    # CBDT Table Structure:
-    # ```
-    # CBDT Table = Header (8 bytes)
-    #            + Bitmap Data (variable length)
-    # ```
-    #
-    # Header (8 bytes):
-    # - majorVersion (uint16): Major version (2 or 3)
-    # - minorVersion (uint16): Minor version (0)
-    # - reserved (uint32): Reserved, set to 0
+    # CBDT (Color Bitmap Data) table.
     #
-    # The bitmap data format depends on the index subtable format in CBLC.
-    # Common formats include:
-    # - Format 17: Small metrics, PNG data
-    # - Format 18: Big metrics, PNG data
-    # - Format 19: Metrics in CBLC, PNG data
+    # CBDT stores the raw bitmap data blocks for color glyphs. CBLC indexes
+    # into CBDT via `imageDataOffset` and per-glyph offset arrays. CBDT
+    # itself is essentially a blob: the 4-byte header (majorVersion +
+    # minorVersion) followed by an opaque sequence of bitmap blocks.
     #
-    # This parser provides low-level access to bitmap data. For proper bitmap
-    # extraction, use together with CBLC table which contains the index.
+    # This model exposes the header fields via BinData and preserves the
+    # original bytes for subsetting and direct slicing. A Cbdt constructed
+    # via `Cbdt.new` (no `read`) has no captured bytes — `raw_data` is nil
+    # and `data_size` returns 0.
     #
-    # Reference: OpenType CBDT specification
-    # https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt
+    # Reference: OpenType CBDT specification.
+    # https://learn.microsoft.com/en-us/typography/opentype/spec/cbdt
     #
-    # @example Reading a CBDT table
-    #   data = font.table_data['CBDT']
-    #   cbdt = Fontisan::Tables::Cbdt.read(data)
-    #   bitmap_data = cbdt.bitmap_data_at(offset, length)
+    # @example Reading CBDT and slicing a bitmap block
+    #   cbdt = Fontisan::Tables::Cbdt.read(font.table_data["CBDT"])
+    #   bytes = cbdt.bitmap_data_at(120, 4096)
     class Cbdt < Binary::BaseRecord
-      # OpenType table tag for CBDT
       TAG = "CBDT"
 
-      # Supported CBDT versions
-      VERSION_2_0 = 0x0002_0000
-      VERSION_3_0 = 0x0003_0000
+      # CBDT v2.0 — original release
+      VERSION_2_0 = 0x00020000
+      # CBDT v3.0 — adds PNG image format support
+      VERSION_3_0 = 0x00030000
 
-      # @return [Integer] Major version (2 or 3)
-      attr_reader :major_version
+      uint16 :major_version
+      uint16 :minor_version
 
-      # @return [Integer] Minor version (0)
-      attr_reader :minor_version
-
-      # @return [String] Raw binary data for the entire CBDT table
-      attr_reader :raw_data
-
-      # Override read to parse CBDT structure
+      # Whether this instance was populated from real table bytes.
       #
-      # @param io [IO, String] Binary data to read
-      # @return [Cbdt] Parsed CBDT table
-      def self.read(io)
-        cbdt = new
-        return cbdt if io.nil?
-
-        data = io.is_a?(String) ? io : io.read
-        cbdt.parse!(data)
-        cbdt
+      # @return [Boolean]
+      def has_raw_data?
+        defined?(@raw_data) && !@raw_data.nil? ? true : false
       end
 
-      # Parse the CBDT table structure
+      # Raw bytes captured at read time, or nil for a fresh instance.
       #
-      # @param data [String] Binary data for the CBDT table
-      # @raise [CorruptedTableError] If CBDT structure is invalid
-      def parse!(data)
-        @raw_data = data
-        io = StringIO.new(data)
-
-        # Parse CBDT header (8 bytes)
-        parse_header(io)
-        validate_header!
-      rescue StandardError => e
-        raise CorruptedTableError, "Failed to parse CBDT table: #{e.message}"
-      end
+      # @return [String, nil]
+      def raw_data
+        return @raw_data if defined?(@raw_data)
 
-      # Get bitmap data at specific offset and length
-      #
-      # Used together with CBLC index to extract bitmap data.
-      #
-      # @param offset [Integer] Offset from start of table
-      # @param length [Integer] Length of bitmap data
-      # @return [String, nil] Binary bitmap data or nil
-      def bitmap_data_at(offset, length)
-        return nil if offset.nil? || length.nil?
-        return nil if offset.negative? || length.negative?
-        return nil if offset + length > raw_data.length
-
-        raw_data[offset, length]
+        nil
       end
 
-      # Get combined version number
+      # Combined version number (e.g. 0x00030000 for v3.0).
       #
-      # @return [Integer] Combined version (e.g., 0x00020000 for v2.0)
+      # @return [Integer]
       def version
-        return nil if major_version.nil? || minor_version.nil?
-
         (major_version << 16) | minor_version
       end
 
-      # Get table data size
+      # Total byte size of the captured CBDT bytes, or 0 if none.
       #
-      # @return [Integer] Size of CBDT table in bytes
+      # @return [Integer]
       def data_size
-        raw_data&.length || 0
+        raw_data&.bytesize || 0
       end
 
-      # Check if offset is valid for this table
+      # Whether `offset` falls within the captured CBDT byte range.
       #
-      # @param offset [Integer] Offset to check
-      # @return [Boolean] True if offset is within table bounds
+      # @param offset [Integer, nil]
+      # @return [Boolean]
       def valid_offset?(offset)
         return false if offset.nil? || offset.negative?
-        return false if raw_data.nil?
 
-        offset < raw_data.length
+        offset < data_size
       end
 
-      # Validate the CBDT table structure
+      # Slice `length` bytes starting at `offset` from the CBDT blob.
+      # Returns nil for out-of-range offsets/lengths so callers can use a
+      # nil check instead of rescuing IndexError.
       #
-      # @return [Boolean] True if valid
-      def valid?
-        return false if major_version.nil? || minor_version.nil?
-        return false unless [2, 3].include?(major_version)
-        return false unless minor_version.zero?
-        return false unless raw_data
+      # @param offset [Integer, nil] start byte
+      # @param length [Integer, nil] number of bytes
+      # @return [String, nil]
+      def bitmap_data_at(offset, length)
+        return nil if offset.nil? || length.nil?
+        return nil if offset.negative? || length.negative?
+        return nil if offset + length > data_size
 
-        true
+        raw_data[offset, length]
       end
 
-      private
-
-      # Parse CBDT header (8 bytes)
+      # Serialize the captured bytes back to binary. Falls back to BinData's
+      # default serialization (4-byte header) if no bytes were captured,
+      # so consumers can construct a CBDT from scratch.
       #
-      # @param io [StringIO] Input stream
-      def parse_header(io)
-        @major_version = io.read(2).unpack1("n")
-        @minor_version = io.read(2).unpack1("n")
-        @reserved = io.read(4).unpack1("N")
+      # @return [String]
+      def to_binary_s
+        return raw_data if has_raw_data?
+
+        super
       end
 
-      # Validate header values
+      # Whether the header declares a CBDT version fontisan understands
+      # (v2.0 or v3.0) and any raw bytes were captured.
       #
-      # @raise [CorruptedTableError] If validation fails
-      def validate_header!
-        unless [2, 3].include?(major_version)
-          raise CorruptedTableError,
-                "Unsupported CBDT major version: #{major_version} " \
-                "(only versions 2 and 3 supported)"
-        end
-
-        unless minor_version.zero?
-          raise CorruptedTableError,
-                "Unsupported CBDT minor version: #{minor_version} " \
-                "(only version 0 supported)"
-        end
+      # @return [Boolean]
+      def valid?
+        return false unless [2, 3].include?(major_version)
+        return false unless minor_version.zero?
+        return false unless has_raw_data?
+
+        true
       end
     end
   end