fontisan 0.4.22 → 0.4.24

data/lib/fontisan/tables/cblc_index_subtable_format_parser.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Per-format CBLC IndexSubTable parser. Extracted as a sibling class so
+    # that CblcIndexSubTable remains a pure data model.
+    #
+    # The five OpenType formats differ in how the offset array encodes
+    # glyph lengths and CBDT offsets. This class hides that arithmetic
+    # behind a uniform [.locations] entry point that returns a flat list
+    # of CblcGlyphBitmapLocation objects (one per glyph in the range).
+    #
+    # Reference: OpenType CBLC spec, IndexSubTable formats 1–5.
+    class CblcIndexSubTableFormatParser
+      # Format 4 (bit-packed offsets) is rare and not currently parsed.
+      class UnsupportedFormat < Fontisan::Error; end
+
+      class << self
+        # Returns an Array of CblcGlyphBitmapLocation, one per glyph in
+        # the IndexSubTable's glyph range.
+        #
+        # @param header [CblcIndexSubTableHeader] the 8-byte IndexSubTable header
+        # @param bytes [String] the full CBLC table bytes
+        # @param base [Integer] absolute offset of this IndexSubTable within CBLC
+        # @param first [Integer] first glyph ID covered
+        # @param last [Integer] last glyph ID covered
+        # @return [Array<CblcGlyphBitmapLocation>]
+        def locations(header:, bytes:, base:, first:, last:)
+          case header.index_format
+          when 1 then format_1(header, bytes, base, first, last)
+          when 2 then format_2(header, bytes, base, first, last)
+          when 3 then format_3(header, bytes, base, first, last)
+          when 5 then format_5(header, bytes, base, first, last)
+          when 4
+            raise UnsupportedFormat,
+                  "CBLC IndexSubTable format 4 (bit-packed) is unsupported"
+          else
+            raise UnsupportedFormat,
+                  "Unknown CBLC IndexSubTable format: #{header.index_format}"
+          end
+        end
+
+        # Returns the raw bytes the IndexSubTable occupies in CBLC.
+        #
+        # @return [String]
+        def raw_bytes(header:, bytes:, base:, first:, last:)
+          count = last - first + 1
+          length = byte_length(header.index_format, count, bytes, base)
+          bytes[base, length]
+        end
+
+        private
+
+        # Format 1: variable metrics + variable size, uint32 offsetArray.
+        # offsets[0] is the first glyph's bitmap start (relative to
+        # imageDataOffset); offsets[i+1] - offsets[i] = glyph i's length.
+        def format_1(header, bytes, base, first, last)
+          count = last - first + 1
+          offsets = uint32_array(bytes, base + 8, count + 1)
+          build(first, count, offsets, header.image_format,
+                header.image_data_offset)
+        end
+
+        # Format 2: constant metrics + constant size. One imageSize field
+        # applies to every glyph; the i-th glyph's bitmap is at
+        # imageDataOffset + i * imageSize.
+        def format_2(header, bytes, base, first, last)
+          count = last - first + 1
+          image_size = bytes[base + 8, 4].unpack1("N")
+          Array.new(count) do |i|
+            CblcGlyphBitmapLocation.new(
+              glyph_id: first + i,
+              image_format: header.image_format,
+              cbdt_offset: header.image_data_offset + (i * image_size),
+              byte_length: image_size,
+            )
+          end
+        end
+
+        # Format 3: like format 1 but offsets are uint16 and stored as
+        # multiples of 4 (CBDT bitmap data is 4-byte aligned).
+        def format_3(header, bytes, base, first, last)
+          count = last - first + 1
+          raw = uint16_array(bytes, base + 8, count + 1)
+          offsets = raw.map { |v| v * 4 }
+          build(first, count, offsets, header.image_format,
+                header.image_data_offset)
+        end
+
+        # Format 5: constant metrics + constant size with an explicit
+        # uint32 offsetArray (count + 1 entries). Length per glyph is
+        # the constant imageSize; offset comes from the array.
+        def format_5(header, bytes, base, first, last)
+          count = last - first + 1
+          image_size = bytes[base + 8, 4].unpack1("N")
+          offset_array_start = base + 12 + 8 + 4
+          offsets = uint32_array(bytes, offset_array_start, count + 1)
+          Array.new(count) do |i|
+            start_off = offsets[i] || 0
+            CblcGlyphBitmapLocation.new(
+              glyph_id: first + i,
+              image_format: header.image_format,
+              cbdt_offset: header.image_data_offset + start_off,
+              byte_length: image_size,
+            )
+          end
+        end
+
+        def build(first, count, offsets, image_format, image_data_offset)
+          Array.new(count) do |i|
+            start_off = offsets[i] || 0
+            end_off = offsets[i + 1] || start_off
+            CblcGlyphBitmapLocation.new(
+              glyph_id: first + i,
+              image_format: image_format,
+              cbdt_offset: image_data_offset + start_off,
+              byte_length: end_off - start_off,
+            )
+          end
+        end
+
+        def byte_length(index_format, count, bytes, base)
+          case index_format
+          when 1, 3
+            entry_size = index_format == 1 ? 4 : 2
+            8 + (count + 1) * entry_size
+          when 2
+            8 + 4 + 8 # header + imageSize + bigGlyphMetrics
+          when 5
+            8 + 4 + 8 + 4 + (count + 1) * 4
+          else
+            bytes.bytesize - base
+          end
+        end
+
+        def uint32_array(bytes, offset, count)
+          return [] if count.zero?
+
+          bytes[offset, count * 4].unpack("N*")
+        end
+
+        def uint16_array(bytes, offset, count)
+          return [] if count.zero?
+
+          bytes[offset, count * 2].unpack("n*")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cblc_index_subtable_header.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # 8-byte header common to all CBLC IndexSubTable formats.
+    #
+    #   uint16 indexFormat
+    #   uint16 imageFormat
+    #   uint32 imageDataOffset (absolute, from start of CBDT)
+    #
+    # Format-specific data follows immediately after this header.
+    class CblcIndexSubTableHeader < Binary::BaseRecord
+      uint16 :index_format
+      uint16 :image_format
+      uint32 :image_data_offset
+    end
+  end
+end

data/lib/fontisan/tables/cblc_sbit_line_metrics.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # SbitLineMetrics record embedded in CBLC BitmapSize records.
+    #
+    # Two of these (horizontal + vertical) appear in every BitmapSize,
+    # totalling 24 bytes per strike. The fields are signed/unsigned 8-bit
+    # integers; OpenType specifies signed values for some, unsigned for
+    # others, mirroring the EBDT/BDF layout.
+    #
+    # Reference: OpenType CBLC spec, "SbitLineMetrics" sub-structure.
+    class CblcSbitLineMetrics < Binary::BaseRecord
+      int8 :ascender
+      int8 :descender
+      uint8 :width_max
+      int8 :caret_slope_numerator
+      int8 :caret_slope_denominator
+      int8 :caret_offset
+      int8 :min_origin_sb
+      int8 :min_advance_sb
+      int8 :max_before_bl
+      int8 :min_after_bl
+      int8 :pad1
+      int8 :pad2
+    end
+  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.rb

@@ -4,6 +4,18 @@
 
 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 :CblcIndexSubTable, "fontisan/tables/cblc_index_subtable"
+    autoload :CblcIndexSubTableArrayEntry,
+             "fontisan/tables/cblc_index_subtable_array_entry"
+    autoload :CblcIndexSubTableFormatParser,
+             "fontisan/tables/cblc_index_subtable_format_parser"
+    autoload :CblcIndexSubTableHeader,
+             "fontisan/tables/cblc_index_subtable_header"
+    autoload :CblcSbitLineMetrics, "fontisan/tables/cblc_sbit_line_metrics"
     autoload :Cbdt, "fontisan/tables/cbdt"
     autoload :Cblc, "fontisan/tables/cblc"
     autoload :Cff, "fontisan/tables/cff"

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,

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

@@ -62,7 +62,8 @@ module Fontisan
           io << [regions.size].pack("n") # regionCount
           regions.each do |region|
             region.each do |coords|
-              io << [f2dot14(coords[:start]), f2dot14(coords[:peak]), f2dot14(coords[:end])].pack("nnn")
+              io << [f2dot14(coords[:start]), f2dot14(coords[:peak]),
+                     f2dot14(coords[:end])].pack("nnn")
             end
           end
           io

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

@@ -51,7 +51,9 @@ module Fontisan
 
         def self.format0_bytes(records)
           # Strings are stored UTF-16BE on disk (Windows Unicode).
-          encoded = records.map { |r| r[:value].encode("UTF-16BE").force_encoding("BINARY") }
+          encoded = records.map do |r|
+            r[:value].encode("UTF-16BE").force_encoding("BINARY")
+          end
           storage = encoded.join
           storage_offset = 6 + (records.size * 12)
 

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

@@ -75,7 +75,8 @@ module Fontisan
             if glyph && glyph[:data]
               offsets << current_offset
               data = glyph[:data].b
-              glyph_data << [glyph[:origin_x] || 0, glyph[:origin_y] || 0].pack("nn")
+              glyph_data << [glyph[:origin_x] || 0,
+                             glyph[:origin_y] || 0].pack("nn")
               glyph_data << (glyph[:graphic_type] || PNG_TYPE).ljust(4)[0, 4]
               glyph_data << data
               current_offset += 8 + data.bytesize

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

@@ -26,7 +26,8 @@ module Fontisan
           axis_value_count = axis_value_list.size
 
           design_axes = serialize_design_axes(axes)
-          value_tables, value_offsets = serialize_axis_values(axis_value_list, design_axes.bytesize)
+          value_tables, value_offsets = serialize_axis_values(axis_value_list,
+                                                              design_axes.bytesize)
 
           header = serialize_header(
             design_axis_count: design_axis_count,
@@ -45,7 +46,8 @@ module Fontisan
           io
         end
 
-        def self.serialize_header(design_axis_count:, design_axes_size:, axis_value_count:, elided_name_id:)
+        def self.serialize_header(design_axis_count:, design_axes_size:,
+axis_value_count:, elided_name_id:)
           design_axes_offset = HEADER_SIZE
           offset_to_axis_value_offsets = design_axes_offset + design_axes_size
 
@@ -86,7 +88,8 @@ module Fontisan
             flags = av[:flags] || av["flags"] || 0
             name_id = av[:name_id] || av["name_id"] || 0
             value = f2dot14(av[:value] || av["value"] || 0)
-            value_tables << [format, axis_idx, flags, name_id, value].pack("nnnnn")
+            value_tables << [format, axis_idx, flags, name_id,
+                             value].pack("nnnnn")
           end
 
           [value_tables, value_offsets]

data/lib/fontisan/ufo/convert/from_bin_data.rb

@@ -82,7 +82,8 @@ module Fontisan
 
           if raw && raw.encoding == Encoding::UTF_16BE
             raw.encode("UTF-8")
-          elsif raw && raw.bytesize >= 2 && raw.getbyte(0).between?(0, 127) && raw.getbyte(1).zero?
+          elsif raw && raw.bytesize >= 2 && raw.getbyte(0).between?(0,
+                                                                    127) && raw.getbyte(1).zero?
             # Looks like UTF-16BE
             raw.force_encoding("UTF-16BE").encode("UTF-8")
           else
@@ -165,7 +166,10 @@ module Fontisan
           return unless glyf && loca && head
 
           # Tables need context-aware initialization before per-glyph access.
-          loca.parse_with_context(head.index_to_loc_format, num_glyphs) if loca.respond_to?(:parse_with_context)
+          if loca.respond_to?(:parse_with_context)
+            loca.parse_with_context(head.index_to_loc_format,
+                                    num_glyphs)
+          end
 
           num_glyphs.times do |gid|
             glyph_name = glyph_name_for(font, gid) || "glyph#{gid}"

data/lib/fontisan/ufo/convert/to_dfont.rb

@@ -17,10 +17,14 @@ module Fontisan
         # @return [String] the output_path
         def self.convert(ufo, output_path:, compiler: :ttf, **_opts)
           compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
-          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+          unless compiler_class
+            raise ArgumentError,
+                  "unknown intermediate compiler: #{compiler.inspect}"
+          end
 
           Dir.mktmpdir do |dir|
-            intermediate_path = File.join(dir, "intermediate#{ext_for(compiler)}")
+            intermediate_path = File.join(dir,
+                                          "intermediate#{ext_for(compiler)}")
             compiler_class.new(ufo).compile(output_path: intermediate_path)
 
             loaded = Fontisan::FontLoader.load(intermediate_path)

data/lib/fontisan/ufo/convert/to_otc.rb

@@ -18,7 +18,10 @@ module Fontisan
         # @return [String] the output_path
         def self.convert(ufo, output_path:, compiler: :otf, **_opts)
           compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
-          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+          unless compiler_class
+            raise ArgumentError,
+                  "unknown intermediate compiler: #{compiler.inspect}"
+          end
 
           Dir.mktmpdir do |dir|
             intermediate_path = File.join(dir, "intermediate.otf")