fontisan 0.2.13 → 0.2.14

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.13"
+  VERSION = "0.2.14"
 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.14
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-21 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64