fontisan 0.2.13 → 0.2.16

data/lib/fontisan/true_type_collection.rb

@@ -32,7 +32,7 @@ module Fontisan
 
     # Get a single font from the collection
     #
-    # Overrides BaseCollection to use TrueType-specific from_ttc method.
+    # Uses the base class from_collection method.
     #
     # @param index [Integer] Index of the font (0-based)
     # @param io [IO] Open file handle
@@ -42,13 +42,13 @@ module Fontisan
       return nil if index >= num_fonts
 
       require_relative "true_type_font"
-      TrueTypeFont.from_ttc(io, font_offsets[index], mode: mode)
+      TrueTypeFont.from_collection(io, font_offsets[index], mode: mode)
     end
 
     # Extract fonts as TrueTypeFont objects
     #
     # Reads each font from the TTC file and returns them as TrueTypeFont objects.
-    # This method uses the TTC-specific from_ttc method.
+    # Uses the base class from_collection method.
     #
     # @param io [IO] Open file handle to read fonts from
     # @return [Array<TrueTypeFont>] Array of font objects
@@ -56,13 +56,13 @@ module Fontisan
       require_relative "true_type_font"
 
       font_offsets.map do |offset|
-        TrueTypeFont.from_ttc(io, offset)
+        TrueTypeFont.from_collection(io, offset)
       end
     end
 
     # List all fonts in the collection with basic metadata
     #
-    # Overrides BaseCollection to use TrueType-specific from_ttc method.
+    # Uses the base class from_collection method.
     #
     # @param io [IO] Open file handle to read fonts from
     # @return [CollectionListInfo] List of fonts with metadata
@@ -73,7 +73,7 @@ module Fontisan
       require_relative "tables/name"
 
       fonts = font_offsets.map.with_index do |offset, index|
-        font = TrueTypeFont.from_ttc(io, offset)
+        font = TrueTypeFont.from_collection(io, offset)
 
         # Extract basic font info
         name_table = font.table("name")
@@ -119,7 +119,7 @@ module Fontisan
 
     # Calculate table sharing statistics
     #
-    # Overrides BaseCollection to use TrueType-specific from_ttc method.
+    # Uses the base class from_collection method.
     #
     # @param io [IO] Open file handle
     # @return [TableSharingInfo] Sharing statistics
@@ -129,7 +129,7 @@ module Fontisan
 
       # Extract all fonts
       fonts = font_offsets.map do |offset|
-        TrueTypeFont.from_ttc(io, offset)
+        TrueTypeFont.from_collection(io, offset)
       end
 
       # Build table hash map (checksum -> size)

data/lib/fontisan/true_type_font.rb

@@ -23,66 +23,8 @@ module Fontisan
   #   ttf.to_file("output.ttf")
   #
   # @example Reading from TTC collection
-  #   ttf = TrueTypeFont.from_ttc(io, offset)
+  #   ttf = TrueTypeFont.from_collection(io, offset)
   class TrueTypeFont < SfntFont
-    # Read TrueType Font from a file
-    #
-    # @param path [String] Path to the TTF file
-    # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
-    # @param lazy [Boolean] If true, load tables on demand (default: false)
-    # @return [TrueTypeFont] A new instance
-    # @raise [ArgumentError] if path is nil or empty, or if mode is invalid
-    # @raise [Errno::ENOENT] if file does not exist
-    # @raise [RuntimeError] if file format is invalid
-    def self.from_file(path, mode: LoadingModes::FULL, lazy: false)
-      if path.nil? || path.to_s.empty?
-        raise ArgumentError,
-              "path cannot be nil or empty"
-      end
-      raise Errno::ENOENT, "File not found: #{path}" unless File.exist?(path)
-
-      # Validate mode
-      LoadingModes.validate_mode!(mode)
-
-      File.open(path, "rb") do |io|
-        font = read(io)
-        font.initialize_storage
-        font.loading_mode = mode
-        font.lazy_load_enabled = lazy
-
-        if lazy
-          # Reuse existing IO handle by duplicating it to prevent double file open
-          # The dup ensures the handle stays open after this block closes
-          font.io_source = io.dup
-          font.setup_finalizer
-        else
-          # Read tables upfront
-          font.read_table_data(io)
-        end
-
-        font
-      end
-    rescue BinData::ValidityError, EOFError => e
-      raise "Invalid TTF file: #{e.message}"
-    end
-
-    # Read TrueType Font from TTC at specific offset
-    #
-    # @param io [IO] Open file handle
-    # @param offset [Integer] Byte offset to the font
-    # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
-    # @return [TrueTypeFont] A new instance
-    def self.from_ttc(io, offset, mode: LoadingModes::FULL)
-      LoadingModes.validate_mode!(mode)
-
-      io.seek(offset)
-      font = read(io)
-      font.initialize_storage
-      font.loading_mode = mode
-      font.read_table_data(io)
-      font
-    end
-
     # Check if font is TrueType flavored
     #
     # @return [Boolean] true for TrueType fonts

data/lib/fontisan/type1/afm_parser.rb

@@ -153,7 +153,8 @@ module Fontisan
           elsif @copyright.nil? && (match = line.match(/^Notice\s+(\S.*)/i))
             @copyright = match[1].strip
           elsif @font_bbox.nil? && (match = line.match(/^FontBBox\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)$/i))
-            @font_bbox = [match[1].to_i, match[2].to_i, match[3].to_i, match[4].to_i]
+            @font_bbox = [match[1].to_i, match[2].to_i, match[3].to_i,
+                          match[4].to_i]
           end
 
           # Break early if all metrics found

data/lib/fontisan/type1/cff_to_type1_converter.rb

@@ -49,7 +49,7 @@ module Fontisan
         cntrmask: 20,     # CFF: 20, Type 1: Not supported (skip)
 
         # End char
-        endchar: 14,      # CFF: 14, Type 1: 14
+        endchar: 14, # CFF: 14, Type 1: 14
 
         # Miscellaneous
         callsubr: 10,     # CFF: 10, Type 1: 10
@@ -83,7 +83,7 @@ module Fontisan
       def convert(cff_charstring, private_dict: {})
         # Parse CFF CharString into operations
         parser = Tables::Cff::CharStringParser.new(cff_charstring,
-                                                       stem_count: private_dict[:stem_count]&.to_i || 0)
+                                                   stem_count: private_dict[:stem_count].to_i)
         operations = parser.parse
 
         # Extract width from operations (CFF spec: odd stack before first move = width)
@@ -106,13 +106,14 @@ module Fontisan
 
         # Find first move operator
         first_move_idx = operations.index do |op|
-          %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto hhcurveto].include?(op[:name])
+          %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto
+             hhcurveto].include?(op[:name])
         end
 
         return @default_width unless first_move_idx
 
         # Count operands before first move
-        operand_count = operations[0...first_move_idx].sum(0) do |op|
+        operand_count = operations[0...first_move_idx].sum do |op|
           op[:operands]&.length || 0
         end
 
@@ -140,10 +141,10 @@ module Fontisan
 
         # Add hsbw (horizontal sidebearing and width) at start
         # This is the standard width operator for horizontal fonts
-        result << encode_number(0)  # left sidebearing (usually 0 for CFF)
+        result << encode_number(0) # left sidebearing (usually 0 for CFF)
         result << encode_number(glyph_width)
         result << ESCAPE_BYTE
-        result << 34  # hsbw operator (two-byte: 12 34)
+        result << 34 # hsbw operator (two-byte: 12 34)
 
         x = 0
         y = 0
@@ -154,11 +155,12 @@ module Fontisan
         if width && operations.any?
           # Count operands before first move to determine if width was in stack
           first_move_idx = operations.index do |op|
-            %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto hhcurveto].include?(op[:name])
+            %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto
+               hhcurveto].include?(op[:name])
           end
 
           if first_move_idx
-            operand_count = operations[0...first_move_idx].sum(0) do |op|
+            operand_count = operations[0...first_move_idx].sum do |op|
               op[:operands]&.length || 0
             end
 
@@ -182,16 +184,17 @@ module Fontisan
             end
 
             if operands.length >= 2
-              dx, dy = operands[0], operands[1]
+              dx = operands[0]
+              dy = operands[1]
               x += dx
               y += dy
               result << encode_number(dx)
               result << encode_number(dy)
-              result << 21  # rmoveto
+              result << 21 # rmoveto
             elsif operands.length == 1
               # Only dy (hmoveto/vmoveto style)
               result << encode_number(operands.first)
-              result << 4  # vmoveto (closest approximation)
+              result << 4 # vmoveto (closest approximation)
             end
             first_move = false
           when :hmoveto
@@ -205,14 +208,14 @@ module Fontisan
             dx = operands.first
             x += dx if dx
             result << encode_number(dx)
-            result << 22  # hmoveto
+            result << 22 # hmoveto
             first_move = false
           when :vmoveto
             # vmoveto dy
             dy = op[:operands].first
             y += dy if dy
             result << encode_number(dy)
-            result << 4  # vmoveto
+            result << 4 # vmoveto
             first_move = false
           when :rlineto
             # rlineto dx dy
@@ -221,29 +224,31 @@ module Fontisan
             y += dy
             result << encode_number(dx)
             result << encode_number(dy)
-            result << 5  # rlineto
+            result << 5 # rlineto
             first_move = false
           when :hlineto
             # hlineto dx
             dx = op[:operands].first
             x += dx
             result << encode_number(dx)
-            result << 6  # hlineto
+            result << 6 # hlineto
             first_move = false
           when :vlineto
             # vlineto dy
             dy = op[:operands].first
             y += dy
             result << encode_number(dy)
-            result << 7  # vlineto
+            result << 7 # vlineto
             first_move = false
           when :rrcurveto
             # rrcurveto dx1 dy1 dx2 dy2 dx3 dy3
             dx1, dy1, dx2, dy2, dx3, dy3 = op[:operands]
             x += dx1 + dx2 + dx3
             y += dy1 + dy2 + dy3
-            [dx1, dy1, dx2, dy2, dx3, dy3].each { |val| result << encode_number(val) }
-            result << 8  # rrcurveto
+            [dx1, dy1, dx2, dy2, dx3, dy3].each do |val|
+              result << encode_number(val)
+            end
+            result << 8 # rrcurveto
             first_move = false
           when :hhcurveto, :hvcurveto, :vhcurveto
             # Flexible curve operators
@@ -293,7 +298,7 @@ module Fontisan
           [num + 139].pack("C")
         else
           # Use escape sequence (255) followed by 2-byte signed integer
-          num += 32768 if num < 0
+          num += 32768 if num.negative?
           [255, num % 256, num >> 8].pack("C*")
         end
       end

data/lib/fontisan/type1/private_dict.rb

@@ -176,18 +176,39 @@ module Fontisan
       #   puts priv.to_type1_format
       def to_type1_format
         result = []
-        result << array_to_type1(:BlueValues, @blue_values) unless @blue_values.empty?
-        result << array_to_type1(:OtherBlues, @other_blues) unless @other_blues.empty?
-        result << array_to_type1(:FamilyBlues, @family_blues) unless @family_blues.empty?
-        result << array_to_type1(:FamilyOtherBlues, @family_other_blues) unless @family_other_blues.empty?
+        unless @blue_values.empty?
+          result << array_to_type1(:BlueValues,
+                                   @blue_values)
+        end
+        unless @other_blues.empty?
+          result << array_to_type1(:OtherBlues,
+                                   @other_blues)
+        end
+        unless @family_blues.empty?
+          result << array_to_type1(:FamilyBlues,
+                                   @family_blues)
+        end
+        unless @family_other_blues.empty?
+          result << array_to_type1(:FamilyOtherBlues,
+                                   @family_other_blues)
+        end
         result << scalar_to_type1(:BlueScale, @blue_scale)
         result << scalar_to_type1(:BlueShift, @blue_shift)
         result << scalar_to_type1(:BlueFuzz, @blue_fuzz)
         result << array_to_type1(:StdHW, @std_hw) unless @std_hw.empty?
         result << array_to_type1(:StdVW, @std_vw) unless @std_vw.empty?
-        result << array_to_type1(:StemSnapH, @stem_snap_h) unless @stem_snap_h.empty?
-        result << array_to_type1(:StemSnapV, @stem_snap_v) unless @stem_snap_v.empty?
-        result << boolean_to_type1(:ForceBold, @force_bold) unless @force_bold == false
+        unless @stem_snap_h.empty?
+          result << array_to_type1(:StemSnapH,
+                                   @stem_snap_h)
+        end
+        unless @stem_snap_v.empty?
+          result << array_to_type1(:StemSnapV,
+                                   @stem_snap_v)
+        end
+        unless @force_bold == false
+          result << boolean_to_type1(:ForceBold,
+                                     @force_bold)
+        end
         result << scalar_to_type1(:lenIV, @len_iv)
 
         result.join("\n")

data/lib/fontisan/type1/seac_expander.rb

@@ -68,11 +68,13 @@ module Fontisan
         accent_glyph_name = @charstrings.encoding[components[:accent]]
 
         if base_glyph_name.nil?
-          raise Fontisan::Error, "Base glyph for char code #{components[:base]} not found"
+          raise Fontisan::Error,
+                "Base glyph for char code #{components[:base]} not found"
         end
 
         if accent_glyph_name.nil?
-          raise Fontisan::Error, "Accent glyph for char code #{components[:accent]} not found"
+          raise Fontisan::Error,
+                "Accent glyph for char code #{components[:accent]} not found"
         end
 
         # Get CharStrings for base and accent
@@ -80,11 +82,13 @@ module Fontisan
         accent_charstring = @charstrings[accent_glyph_name]
 
         if base_charstring.nil?
-          raise Fontisan::Error, "CharString not found for base glyph #{base_glyph_name}"
+          raise Fontisan::Error,
+                "CharString not found for base glyph #{base_glyph_name}"
         end
 
         if accent_charstring.nil?
-          raise Fontisan::Error, "CharString not found for accent glyph #{accent_glyph_name}"
+          raise Fontisan::Error,
+                "CharString not found for accent glyph #{accent_glyph_name}"
         end
 
         # Parse both CharStrings into command sequences
@@ -92,7 +96,8 @@ module Fontisan
         accent_commands = parse_charstring_to_commands(accent_charstring)
 
         # Transform accent by (adx, ady) offset
-        accent_commands = transform_commands(accent_commands, components[:adx], components[:ady])
+        accent_commands = transform_commands(accent_commands, components[:adx],
+                                             components[:ady])
 
         # Merge base and accent commands
         merged_commands = merge_outline_commands(base_commands, accent_commands)
@@ -278,8 +283,8 @@ module Fontisan
             dx1, dy1, dx2, dy2, dx3, dy3 = cmd[1..6]
             control_x = x + dx1
             control_y = y + dy1
-            anchor_x = x + dx1 + dx2
-            anchor_y = y + dy1 + dy2
+            x + dx1 + dx2
+            y + dy1 + dy2
             end_x = x + dx1 + dx2 + dx3
             end_y = y + dy1 + dy2 + dy3
 
@@ -288,7 +293,7 @@ module Fontisan
               cx: control_x,
               cy: control_y,
               x: end_x,
-              y: end_y
+              y: end_y,
             }
             x = end_x
             y = end_y
@@ -326,13 +331,13 @@ module Fontisan
         # vhcurveto: dy1 dx2 dy2 dx3
         # hvcurveto: dx1 dy2 dx3 dy3
         if cmd[0] == :vhcurveto
-          dy1, dx2, dy2, dx3 = cmd[1..4]
+          dy1, dx2, dy2, = cmd[1..4]
           control_x = x
           control_y = y + dy1
           end_x = x + dx2
           end_y = y + dy1 + dy2
         else
-          dx1, dy2, dx3, dy3 = cmd[1..4]
+          dx1, dy2, _, dy3 = cmd[1..4]
           control_x = x + dx1
           control_y = y
           end_x = x + dx1 + dx2
@@ -344,7 +349,7 @@ module Fontisan
           cx: control_x,
           cy: control_y,
           x: end_x,
-          y: end_y
+          y: end_y,
         }
       end
 
@@ -355,7 +360,7 @@ module Fontisan
       # @param dy [Integer] Y offset
       # @return [Array<Hash>] Transformed commands
       def transform_commands(commands, dx, dy)
-        return commands if dx == 0 && dy == 0
+        return commands if dx.zero? && dy.zero?
 
         commands.map do |cmd|
           case cmd[:type]
@@ -367,7 +372,7 @@ module Fontisan
               cx: cmd[:cx] + dx,
               cy: cmd[:cy] + dy,
               x: cmd[:x] + dx,
-              y: cmd[:y] + dy
+              y: cmd[:y] + dy,
             }
           when :curve_to
             {
@@ -377,7 +382,7 @@ module Fontisan
               cx2: cmd[:cx2] + dx,
               cy2: cmd[:cy2] + dy,
               x: cmd[:x] + dx,
-              y: cmd[:y] + dy
+              y: cmd[:y] + dy,
             }
           else
             cmd # close_path, etc. pass through
@@ -428,8 +433,8 @@ module Fontisan
             # Use hsbw to set initial position
             dx = cmd[:x] - x
             # hsbw is a two-byte operator: 12 34
-            charstring << encode_number(dx)  # sbw value
-            charstring << encode_number(0)    # width (always 0 for decomposed glyphs)
+            charstring << encode_number(dx) # sbw value
+            charstring << encode_number(0) # width (always 0 for decomposed glyphs)
             charstring << 12  # First byte of two-byte operator
             charstring << 34  # Second byte - hsbw
             x = cmd[:x]
@@ -492,7 +497,7 @@ module Fontisan
           [num + 139].pack("C*")
         else
           # Use escape sequence (255) followed by 2-byte signed integer
-          num += 32768 if num < 0
+          num += 32768 if num.negative?
           [255, num % 256, num >> 8].pack("C*")
         end
       end

data/lib/fontisan/variable/delta_applicator.rb

@@ -136,13 +136,13 @@ module Fontisan
         normalized_coords = @axis_normalizer.normalize(user_coords)
         region_scalars = @region_matcher.match(normalized_coords)
 
-        glyph_ids.each_with_object({}) do |glyph_id, results|
-          results[glyph_id] = {
+        glyph_ids.to_h do |glyph_id|
+          [glyph_id, {
             outline_deltas: @glyph_delta_processor&.apply_deltas(glyph_id,
                                                                  region_scalars),
             metric_deltas: @metric_delta_processor.apply_deltas(glyph_id,
                                                                 region_scalars),
-          }
+          }]
         end
       end
 

data/lib/fontisan/variation/optimizer.rb

@@ -352,7 +352,6 @@ module Fontisan
       #
       # @return [Set<Integer>] Set of used indices
       def collect_used_variation_indices
-        require "set"
         used = Set.new
 
         glyph_count = @cff2.glyph_count

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.13"
+  VERSION = "0.2.16"
 end

data/lib/fontisan/woff2_font.rb

@@ -373,11 +373,11 @@ module Fontisan
           raise InvalidFontError,
                 "Unknown WOFF2 flavor: 0x#{woff2.header.flavor.to_s(16)}"
         end
+      rescue BinData::ValidityError, EOFError => e
+        raise InvalidFontError, "Invalid WOFF2 file: #{e.message}"
       end
 
       woff2
-    rescue BinData::ValidityError, EOFError => e
-      raise InvalidFontError, "Invalid WOFF2 file: #{e.message}"
     end
 
     # Read table directory from IO

data/lib/fontisan/woff_font.rb

@@ -98,10 +98,10 @@ module Fontisan
         font.io_source = io
         font.read_compressed_table_data(io)
         font
+      rescue BinData::ValidityError, EOFError => e
+        Kernel.raise(::Fontisan::InvalidFontError,
+                     "Invalid WOFF file: #{e.message}")
       end
-    rescue BinData::ValidityError, EOFError => e
-      Kernel.raise(::Fontisan::InvalidFontError,
-                   "Invalid WOFF file: #{e.message}")
     end
 
     # Initialize storage hashes

data/lib/fontisan.rb

@@ -33,10 +33,11 @@ require "bindata"
 require "zlib"
 require "stringio"
 require "lutaml/model"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
 
 # Configure lutaml-model to use Nokogiri adapter for XML serialization
-Lutaml::Model::Config.xml_adapter = Lutaml::Model::Xml::NokogiriAdapter
+Lutaml::Model::Config.configure do |config|
+  config.xml_adapter_type = :nokogiri
+end
 
 # Core
 require_relative "fontisan/version"