fontisan 0.4.23 → 0.4.25

data/lib/fontisan/stitcher/partition_strategy/by_script.rb

@@ -274,14 +274,18 @@ module Fontisan
         private
 
         def group_by_script(cp_map)
-          cp_map.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(cp, label), h|
+          cp_map.each_with_object(Hash.new do |h, k|
+            h[k] = []
+          end) do |(cp, label), h|
             script = script_of_codepoint(cp)
             h[script] << [cp, label]
           end
         end
 
         def script_of_codepoint(cp)
-          block_label = ByBlock::BLOCKS.find { |_label, range| range.cover?(cp) }&.first
+          block_label = ByBlock::BLOCKS.find do |_label, range|
+            range.cover?(cp)
+          end&.first
           return :other unless block_label
 
           SCRIPT_OF_BLOCK[block_label] || :other

data/lib/fontisan/stitcher/source.rb

@@ -321,7 +321,8 @@ module Fontisan
         compound.components.each do |component|
           next unless component.args_are_xy?
 
-          raw = cache[:glyf].glyph_for(component.glyph_index, cache[:loca], cache[:head])
+          raw = cache[:glyf].glyph_for(component.glyph_index, cache[:loca],
+                                       cache[:head])
           next unless raw
 
           matrix = component.transformation_matrix

data/lib/fontisan/stitcher.rb

@@ -150,7 +150,8 @@ module Fontisan
       Dir.mktmpdir do |dir|
         sub_path = File.join(dir, "sub#{subfont_name}#{metadata.extension}")
         metadata.compiler_class.new(target).compile(output_path: sub_path)
-        cbdt_propagator.propagate_tables_into(cbdt_propagator.cbdt_source, sub_path)
+        cbdt_propagator.propagate_tables_into(cbdt_propagator.cbdt_source,
+                                              sub_path)
 
         loaded = Fontisan::FontLoader.load(sub_path)
         stats = SubfontStats.new(

data/lib/fontisan/subset/table_strategy/glyf_loca_builder.rb

@@ -61,7 +61,8 @@ module Fontisan
             glyph_data = glyf.raw_data[offset, size]
 
             if glyph_data.bytesize >= 10
-              _n, gx_min, gy_min, gx_max, gy_max = glyph_data[0, 10].unpack("n5")
+              _n, gx_min, gy_min, gx_max, gy_max = glyph_data[0,
+                                                              10].unpack("n5")
               gx_min = to_signed_16(gx_min)
               gy_min = to_signed_16(gy_min)
               gx_max = to_signed_16(gx_max)

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/cff/cff2_charstring_builder.rb

@@ -40,8 +40,10 @@ module Fontisan
         # @param num_regions [Integer] number of variation regions
         # @param width [Integer, nil] advance width
         # @return [String] CFF2 charstring bytes with blend sequences
-        def self.build_variable(outline, master_outlines:, num_regions:, width: nil)
-          new.build_variable_outline(outline, master_outlines, num_regions, width)
+        def self.build_variable(outline, master_outlines:, num_regions:,
+width: nil)
+          new.build_variable_outline(outline, master_outlines, num_regions,
+                                     width)
         end
 
         # ---------- variable-font encoding ----------
@@ -65,7 +67,9 @@ module Fontisan
 
         # Process an outline with blend operators for each varying coordinate.
         def encode_variable_outline(outline, master_outlines, num_regions)
-          @master_states = master_outlines.map { MasterState.new(current_x: 0, current_y: 0) }
+          @master_states = master_outlines.map do
+            MasterState.new(current_x: 0, current_y: 0)
+          end
           @num_regions = num_regions
           @has_blend = false
 
@@ -90,7 +94,8 @@ module Fontisan
         # ---------- variable moveto ----------
 
         def encode_variable_moveto(cmd, master_cmds)
-          dx, dy, dx_deltas, dy_deltas = compute_variable_deltas(cmd, master_cmds)
+          dx, dy, dx_deltas, dy_deltas = compute_variable_deltas(cmd,
+                                                                 master_cmds)
 
           write_variable_number(dx, dx_deltas)
           write_variable_number(dy, dy_deltas)
@@ -102,7 +107,8 @@ module Fontisan
         # ---------- variable lineto ----------
 
         def encode_variable_lineto(cmd, master_cmds)
-          dx, dy, dx_deltas, dy_deltas = compute_variable_deltas(cmd, master_cmds)
+          dx, dy, dx_deltas, dy_deltas = compute_variable_deltas(cmd,
+                                                                 master_cmds)
 
           write_variable_number(dx, dx_deltas)
           write_variable_number(dy, dy_deltas)

data/lib/fontisan/tables/cff.rb

@@ -47,7 +47,8 @@ module Fontisan
       autoload :Charset, "fontisan/tables/cff/charset"
       autoload :CharString, "fontisan/tables/cff/charstring"
       autoload :CharStringBuilder, "fontisan/tables/cff/charstring_builder"
-      autoload :Cff2CharStringBuilder, "fontisan/tables/cff/cff2_charstring_builder"
+      autoload :Cff2CharStringBuilder,
+               "fontisan/tables/cff/cff2_charstring_builder"
       autoload :CharStringParser, "fontisan/tables/cff/charstring_parser"
       autoload :CharStringRebuilder, "fontisan/tables/cff/charstring_rebuilder"
       autoload :CharstringsIndex, "fontisan/tables/cff/charstrings_index"

data/lib/fontisan/tables/cff2/index_builder.rb

@@ -66,7 +66,8 @@ module Fontisan
           case off_size
           when 1 then [value].pack("C")
           when 2 then [value].pack("n")
-          when 3 then [(value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF].pack("CCC")
+          when 3 then [(value >> 16) & 0xFF, (value >> 8) & 0xFF,
+                       value & 0xFF].pack("CCC")
           when 4 then [value].pack("N")
           else raise ArgumentError, "invalid off_size: #{off_size}"
           end

data/lib/fontisan/tables/cpal.rb

@@ -27,7 +27,10 @@ module Fontisan
     # - numColorRecords (uint16): Total number of color records
     # - colorRecordsArrayOffset (uint32): Offset to color records array
     #
-    # Version 1 adds optional metadata for palette types and labels.
+    # Version 1 Header (24 bytes) adds:
+    # - paletteTypesArrayOffset (uint32): Offset to palette types array
+    # - paletteLabelsArrayOffset (uint32): Offset to palette labels array
+    # - paletteEntryLabelsArrayOffset (uint32): Offset to palette entry labels
     #
     # Color Record Structure (4 bytes, BGRA format):
     # - blue (uint8)
@@ -47,6 +50,13 @@ module Fontisan
       # OpenType table tag for CPAL
       TAG = "CPAL"
 
+      # Palette type bit flags (CPAL v1, paletteTypesArray entries).
+      PALETTE_TYPE_LIGHT_ON_DARK = 0x01
+      PALETTE_TYPE_DARK_ON_LIGHT = 0x02
+
+      # Offset that means "no table present" in CPAL v1.
+      NULL_OFFSET = 0
+
       # @return [Integer] CPAL version (0 or 1)
       attr_reader :version
 
@@ -71,6 +81,19 @@ module Fontisan
       # @return [Array<Hash>] Parsed color records (RGBA hashes)
       attr_reader :color_records
 
+      # @return [Array<Integer>, nil] Palette type bit flags, one per
+      #   palette. nil for CPAL v0 or when v1 has no palette types array.
+      attr_reader :palette_types
+
+      # @return [Array<Integer>, nil] Name-record IDs (name table) for
+      #   each palette. nil for CPAL v0 or when v1 has no labels array.
+      attr_reader :palette_labels
+
+      # @return [Array<Integer>, nil] Name-record IDs (name table) for
+      #   each palette entry index (shared across palettes). nil for
+      #   CPAL v0 or when v1 has no entry-labels array.
+      attr_reader :palette_entry_labels
+
       # Override read to parse CPAL structure
       #
       # @param io [IO, String] Binary data to read
@@ -102,8 +125,8 @@ module Fontisan
         # Parse color records
         parse_color_records(io)
 
-        # Version 1 features (palette types, labels) not implemented yet
-        # TODO: Add version 1 features in follow-up task
+        # Version 1: palette types + labels (lazily walked via offsets)
+        parse_v1_metadata if version == 1
       rescue StandardError => e
         raise CorruptedTableError, "Failed to parse CPAL table: #{e.message}"
       end
@@ -152,6 +175,44 @@ module Fontisan
         color_record ? color_to_hex(color_record) : nil
       end
 
+      # Get the name-record ID for a palette's human-readable label.
+      #
+      # @param palette_index [Integer]
+      # @return [Integer, nil] nameID for the palette, or nil if v0 / no labels
+      def palette_label(palette_index)
+        return nil unless palette_labels
+        return nil if palette_index.negative? || palette_index >= palette_labels.length
+
+        palette_labels[palette_index]
+      end
+
+      # Get the name-record ID for a palette entry's human-readable label.
+      #
+      # @param entry_index [Integer]
+      # @return [Integer, nil] nameID for the entry, or nil if v0 / no labels
+      def palette_entry_label(entry_index)
+        return nil unless palette_entry_labels
+        return nil if entry_index.negative? || entry_index >= palette_entry_labels.length
+
+        palette_entry_labels[entry_index]
+      end
+
+      # Whether a palette is intended for light-on-dark use (CPAL v1).
+      #
+      # @param palette_index [Integer]
+      # @return [Boolean] true if the palette type bit is set; false otherwise
+      def light_on_dark?(palette_index)
+        palette_type_set?(palette_index, PALETTE_TYPE_LIGHT_ON_DARK)
+      end
+
+      # Whether a palette is intended for dark-on-light use (CPAL v1).
+      #
+      # @param palette_index [Integer]
+      # @return [Boolean] true if the palette type bit is set; false otherwise
+      def dark_on_light?(palette_index)
+        palette_type_set?(palette_index, PALETTE_TYPE_DARK_ON_LIGHT)
+      end
+
       # Validate the CPAL table structure
       #
       # @return [Boolean] True if valid
@@ -169,7 +230,7 @@ module Fontisan
 
       private
 
-      # Parse CPAL header (12 bytes for version 0, 16 bytes for version 1)
+      # Parse CPAL header (12 bytes for v0, 24 bytes for v1)
       #
       # @param io [StringIO] Input stream
       def parse_header(io)
@@ -179,12 +240,14 @@ module Fontisan
         @num_color_records = io.read(2).unpack1("n")
         @color_records_array_offset = io.read(4).unpack1("N")
 
-        # Version 1 has additional header fields
-        if version == 1
-          # TODO: Parse version 1 header fields
-          # - paletteTypesArrayOffset (uint32)
-          # - paletteLabelsArrayOffset (uint32)
-          # - paletteEntryLabelsArrayOffset (uint32)
+        # Version 1 has three additional uint32 offset fields. Offsets
+        # are read here but the arrays themselves are walked lazily
+        # from parse_v1_metadata so the v0 path (most common) doesn't
+        # pay for the seeks.
+        if @version == 1
+          @palette_types_array_offset = io.read(4).unpack1("N")
+          @palette_labels_array_offset = io.read(4).unpack1("N")
+          @palette_entry_labels_array_offset = io.read(4).unpack1("N")
         end
       end
 
@@ -228,7 +291,7 @@ module Fontisan
         @palette_indices = []
         return if num_palettes.zero?
 
-        # Palette indices immediately follow header (at offset 12 for v0, 16 for v1)
+        # Palette indices immediately follow header (at offset 12 for v0, 24 for v1)
         # Each index is uint16 (2 bytes)
         num_palettes.times do
           index = io.read(2).unpack1("n")
@@ -262,6 +325,44 @@ module Fontisan
         end
       end
 
+      # CPAL v1 metadata: palette types + labels + entry labels.
+      # Walked lazily via the offsets parsed in parse_header. Any
+      # offset of 0 means "no table present" — leave the accessor nil
+      # rather than raise.
+      def parse_v1_metadata
+        @palette_types = walk_uint32_array(@palette_types_array_offset, num_palettes)
+        @palette_labels = walk_uint16_array(@palette_labels_array_offset, num_palettes)
+        @palette_entry_labels = walk_uint16_array(@palette_entry_labels_array_offset,
+                                                  num_palette_entries)
+      end
+
+      def walk_uint32_array(offset, count)
+        return nil if offset.nil? || offset == NULL_OFFSET
+        return [] if count.zero?
+
+        bytes = raw_data[offset, count * 4]
+        return nil unless bytes && bytes.bytesize == count * 4
+
+        bytes.unpack("N*")
+      end
+
+      def walk_uint16_array(offset, count)
+        return nil if offset.nil? || offset == NULL_OFFSET
+        return [] if count.zero?
+
+        bytes = raw_data[offset, count * 2]
+        return nil unless bytes && bytes.bytesize == count * 2
+
+        bytes.unpack("n*")
+      end
+
+      def palette_type_set?(palette_index, bit)
+        return false unless palette_types
+        return false if palette_index.negative? || palette_index >= palette_types.length
+
+        (palette_types[palette_index] & bit).nonzero? ? true : false
+      end
+
       # Convert color record to hex string
       #
       # @param color [Hash] Color hash with :red, :green, :blue, :alpha keys

data/lib/fontisan/tables.rb

@@ -6,7 +6,8 @@ module Fontisan
   module Tables
     autoload :CblcBigGlyphMetrics, "fontisan/tables/cblc_big_glyph_metrics"
     autoload :CblcBitmapSize, "fontisan/tables/cblc_bitmap_size"
-    autoload :CblcGlyphBitmapLocation, "fontisan/tables/cblc_glyph_bitmap_location"
+    autoload :CblcGlyphBitmapLocation,
+             "fontisan/tables/cblc_glyph_bitmap_location"
     autoload :CblcIndexSubTable, "fontisan/tables/cblc_index_subtable"
     autoload :CblcIndexSubTableArrayEntry,
              "fontisan/tables/cblc_index_subtable_array_entry"

data/lib/fontisan/ufo/cli.rb

@@ -74,7 +74,10 @@ module Fontisan
       def extract(ufo, glyph_name, output)
         font = Font.open(ufo)
         glyph = font.glyph(glyph_name)
-        raise ArgumentError, "glyph not found: #{glyph_name.inspect}" unless glyph
+        unless glyph
+          raise ArgumentError,
+                "glyph not found: #{glyph_name.inspect}"
+        end
 
         head = font.info
         renderer = Fontisan::Svg::StandaloneGlyph.new(

data/lib/fontisan/ufo/compile/cbdt_cblc.rb

@@ -65,7 +65,8 @@ module Fontisan
         # SbitLineMetrics (12 bytes): height, width, hori/vert bearings
         def self.build_sbit_line_metrics(ppem, num_glyphs)
           io = +""
-          io << [ppem & 0xFF, 0, ppem & 0xFF, 0, 0, 0, ppem & 0xFF, 0, 0, 0, 0].pack("C11")
+          io << [ppem & 0xFF, 0, ppem & 0xFF, 0, 0, 0, ppem & 0xFF, 0, 0, 0,
+                 0].pack("C11")
           io << [12 + num_glyphs * 8].pack("n")
           io
         end

data/lib/fontisan/ufo/compile/cff.rb

@@ -155,7 +155,10 @@ module Fontisan
           return +"" if glyphs.size <= 1
 
           bytes = +"\x00"
-          (1...glyphs.size).each { |_| bytes << [0].pack("n") } # SID 0 placeholder
+          # SID 0 placeholder
+          (1...glyphs.size).each do |_|
+            bytes << [0].pack("n")
+          end
           bytes
         end
 
@@ -193,7 +196,8 @@ module Fontisan
           when 1 then [value].pack("C")
           when 2 then [value].pack("n")
           when 3
-            [(value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF].pack("CCC")
+            [(value >> 16) & 0xFF, (value >> 8) & 0xFF,
+             value & 0xFF].pack("CCC")
           when 4 then [value].pack("N")
           end
         end

data/lib/fontisan/ufo/compile/cmap.rb

@@ -36,7 +36,9 @@ module Fontisan
             end
           end
 
-          subtable_bmp = format4_subtable(mappings.reject { |cp, _| cp > 0xFFFF })
+          subtable_bmp = format4_subtable(mappings.reject do |cp, _|
+            cp > 0xFFFF
+          end)
           subtable_full = format12_subtable(mappings)
 
           header_size = 4 + (2 * 8) # version + numTables + 2 records
@@ -44,8 +46,10 @@ module Fontisan
           offset_full = header_size + subtable_bmp.bytesize
 
           header = [0, 2].pack("nn")
-          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_BMP, offset_bmp)
-          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_FULL, offset_full)
+          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_BMP,
+                                    offset_bmp)
+          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_FULL,
+                                    offset_full)
           header + subtable_bmp + subtable_full
         end
 
@@ -82,7 +86,8 @@ module Fontisan
           segments = build_segments(mappings) + [0xFFFF..0xFFFF] # sentinel
           seg_count = segments.size
           search_range = largest_pow2_le(seg_count) * 2
-          entry_selector = (Math.log([1, search_range / 2].max) / Math.log(2)).to_i
+          entry_selector = (Math.log([1,
+                                      search_range / 2].max) / Math.log(2)).to_i
           range_shift = seg_count * 2 - search_range
 
           end_codes = segments.map(&:end)
@@ -98,7 +103,8 @@ module Fontisan
           end
 
           body = +""
-          body << [seg_count * 2, search_range, entry_selector, range_shift].pack("nnnn")
+          body << [seg_count * 2, search_range, entry_selector,
+                   range_shift].pack("nnnn")
           body << end_codes.pack("n*")
           body << [0].pack("n") # reservedPad
           body << start_codes.pack("n*")

data/lib/fontisan/ufo/compile/cpal.rb

@@ -38,7 +38,8 @@ module Fontisan
           offset = HEADER_SIZE + (num_palettes * 2) # header + indices
 
           io = +""
-          io << [VERSION, num_entries, num_palettes, num_records, offset].pack("nnnnN")
+          io << [VERSION, num_entries, num_palettes, num_records,
+                 offset].pack("nnnnN")
           indices.each { |idx| io << [idx].pack("n") }
           records.each { |c| io << color_bytes(c) }
           io

data/lib/fontisan/ufo/compile/feature_writers/gdef.rb

@@ -78,7 +78,9 @@ module Fontisan
           def heuristic_class(glyph)
             anchor_names = glyph.anchors.map(&:name)
             mark_anchor_pattern = /\A_[a-zA-Z]+\z/
-            return 3 if anchor_names.any? { |n| mark_anchor_pattern.match?(n.to_s) }
+            return 3 if anchor_names.any? do |n|
+              mark_anchor_pattern.match?(n.to_s)
+            end
             return 2 if glyph.name.to_s.end_with?(".liga")
 
             nil

data/lib/fontisan/ufo/compile/feature_writers/mark_family_base.rb

@@ -28,7 +28,9 @@ module Fontisan
 
                 attachments[class_name] ||= new_class_entry
                 attachments[class_name][:marks][mark_name] = mark_anchor
-                bases.each { |n, a| attachments[class_name][base_bucket_key][n] = a }
+                bases.each do |n, a|
+                  attachments[class_name][base_bucket_key][n] = a
+                end
               end
             end
 

data/lib/fontisan/ufo/compile/feature_writers.rb

@@ -16,7 +16,8 @@ module Fontisan
       # entry. No edits to the compiler.
       module FeatureWriters
         autoload :Base, "fontisan/ufo/compile/feature_writers/base"
-        autoload :MarkFamilyBase, "fontisan/ufo/compile/feature_writers/mark_family_base"
+        autoload :MarkFamilyBase,
+                 "fontisan/ufo/compile/feature_writers/mark_family_base"
         autoload :Kern, "fontisan/ufo/compile/feature_writers/kern"
         autoload :Kern2, "fontisan/ufo/compile/feature_writers/kern2"
         autoload :Gdef, "fontisan/ufo/compile/feature_writers/gdef"

data/lib/fontisan/ufo/compile/filters/cubic_to_quadratic.rb

@@ -134,8 +134,10 @@ module Fontisan
               right_c2 = Point.new(x: r2x, y: r2y, type: "offcurve")
               right_p3 = p3
 
-              left = subdivide_cubic(left_p0, left_c1, left_c2, left_p3, tolerance)
-              right = subdivide_cubic(right_p0, right_c1, right_c2, right_p3, tolerance)
+              left = subdivide_cubic(left_p0, left_c1, left_c2, left_p3,
+                                     tolerance)
+              right = subdivide_cubic(right_p0, right_c1, right_c2, right_p3,
+                                      tolerance)
 
               # Drop the duplicated midpoint point between halves
               left + right

data/lib/fontisan/ufo/compile/filters/remove_overlaps.rb

@@ -56,7 +56,8 @@ module Fontisan
                   next if i == j || drop.include?(j)
 
                   # Drop inner when its bbox is fully inside outer's.
-                  if contained_in?(bboxes[j], bboxes[i]) && (inner.points.size <= outer.points.size)
+                  if contained_in?(bboxes[j],
+                                   bboxes[i]) && (inner.points.size <= outer.points.size)
                     # Sanity: only drop if the point count is smaller —
                     # a fully-contained contour with MORE points is
                     # almost certainly the outer one in a malformed

data/lib/fontisan/ufo/compile/fvar.rb

@@ -28,7 +28,8 @@ module Fontisan
 
           axes_bytes = build_axes(axes)
           instances_bytes = build_instances(instances || [], axes.size)
-          header = build_header(axes.size, axes_bytes, instances_bytes, instances)
+          header = build_header(axes.size, axes_bytes, instances_bytes,
+                                instances)
           header + axes_bytes + instances_bytes
         end
 
@@ -38,7 +39,8 @@ module Fontisan
         #   majorVersion (2) + minorVersion (2) + axesArrayOffset (2)
         #   + reserved (2) + axisCount (2) + axisSize (2)
         #   + instanceCount (2) + instanceSize (2)
-        def self.build_header(axis_count, axes_bytes, _instances_bytes, instances)
+        def self.build_header(axis_count, axes_bytes, _instances_bytes,
+instances)
           axes_offset = 16
           axes_offset + axes_bytes.bytesize
 
@@ -86,7 +88,9 @@ module Fontisan
             name_id = inst[:name_id] || inst["name_id"] || 0
             flags = inst[:flags] || inst["flags"] || 0
             coords = inst[:coords] || inst["coords"] || []
-            padded = coords.first(axis_count) + Array.new([axis_count - coords.size, 0].max, 0)
+            padded = coords.first(axis_count) + Array.new(
+              [axis_count - coords.size, 0].max, 0
+            )
             padded = padded.first(axis_count).map { |c| fixed_value(c) }
 
             io << [name_id, flags].pack("nn")

data/lib/fontisan/ufo/compile/glyf_loca.rb

@@ -41,7 +41,8 @@ module Fontisan
               offsets.map { |o| o / 2 }.pack("n*")
             end
 
-          { "glyf" => glyf_bytes, "loca" => loca_bytes, :loca_format => use_long ? 1 : 0 }
+          { "glyf" => glyf_bytes, "loca" => loca_bytes,
+            :loca_format => use_long ? 1 : 0 }
         end
 
         # Encode a single glyph into glyf bytes. Empty glyphs (no
@@ -138,7 +139,8 @@ module Fontisan
           # nothing).
           ""
         end
-        private_class_method :encode_glyph, :encode_simple, :encode_points, :encode_composite
+        private_class_method :encode_glyph, :encode_simple, :encode_points,
+                             :encode_composite
       end
     end
   end

data/lib/fontisan/ufo/compile/gvar.rb

@@ -121,7 +121,9 @@ module Fontisan
           deltas = tuple[:deltas]
 
           # Encode delta data
-          all_fit_int8 = deltas.all? { |dx, dy| dx.between?(-127, 127) && dy.between?(-127, 127) }
+          all_fit_int8 = deltas.all? do |dx, dy|
+            dx.between?(-127, 127) && dy.between?(-127, 127)
+          end
 
           point_count = deltas.size
           flags = point_count & POINT_COUNT_MASK
@@ -195,7 +197,8 @@ module Fontisan
 
         def self.build_empty(glyph_count)
           # Minimal gvar with no variation data
-          header = [VERSION_MAJOR, VERSION_MINOR, 0, 0, 0, glyph_count, 1, glyph_count + 16].pack("nnnnnnNN")
+          header = [VERSION_MAJOR, VERSION_MINOR, 0, 0, 0, glyph_count, 1,
+                    glyph_count + 16].pack("nnnnnnNN")
           offsets = Array.new(glyph_count + 1, 0).pack("C*")
           header + offsets
         end

data/lib/fontisan/ufo/compile/head.rb

@@ -19,7 +19,8 @@ module Fontisan
         # @param glyphs [Array<Fontisan::Ufo::Glyph>] (unused here;
         #   bbox is computed by the caller for performance)
         # @return [Fontisan::Tables::Head]
-        def self.build(font, glyphs:, units_per_em: nil, loca_format: LOCA_FORMAT_LONG)
+        def self.build(font, glyphs:, units_per_em: nil,
+loca_format: LOCA_FORMAT_LONG)
           bbox = font_bbox(font, glyphs)
           Fontisan::Tables::Head.new(
             version_raw: 0x00010000,