fontisan 0.4.23 → 0.4.24

data/docs/api/layer.md

@@ -0,0 +1,89 @@
+---
+title: Ufo::Layer
+---
+
+# `Ufo::Layer`
+
+A single layer in a UFO source. A `Layer` holds a set of glyphs keyed by name. The default layer is `public.default` per UFO 3.
+
+```ruby
+layer = Fontisan::Ufo::Layer.new                       # => "public.default"
+layer.add(Fontisan::Ufo::Glyph.new(name: "A"))
+layer["A"]                                             # => the glyph
+layer.size                                             # => 1
+```
+
+## Naming contract
+
+Glyph names are the layer's primary key. Two distinct glyphs with the same name cannot coexist — adding the second would silently destroy the first, a class of bug that has historically cost real data (e.g. the CJK Ext G cmap loss when CBDT placeholders collided with outline glyphs sharing `"gid{N}"` names).
+
+To make that contract unbreakable, the API exposes two methods with named semantics:
+
+| Method | Behavior on conflict |
+|--------|----------------------|
+| `Layer#add(glyph)` | **Raises** `Ufo::GlyphExistsError` (the safe default) |
+| `Layer#put(glyph)` | Overwrites the existing glyph (explicit replace) |
+
+Callers that need auto-renaming — insert without giving up on a collision — call `Stitcher::UniqueGlyphName.in(target, base)` first to allocate a free name, then `Layer#add` the glyph under that name.
+
+## API
+
+### `Layer.new(name = "public.default")`
+
+Initialize an empty layer.
+
+### `#add(glyph) -> Glyph`
+
+Insert `glyph`. Raises `Ufo::GlyphExistsError` if a glyph with the same name is already present.
+
+```ruby
+layer = Fontisan::Ufo::Layer.new
+layer.add(Fontisan::Ufo::Glyph.new(name: "A"))
+
+layer.add(Fontisan::Ufo::Glyph.new(name: "A"))
+# => raises Fontisan::Ufo::GlyphExistsError: a glyph named "A" already exists
+```
+
+The original glyph is preserved when the second `add` raises — the layer is never partially mutated.
+
+### `#put(glyph) -> Glyph`
+
+Insert `glyph`, replacing any existing glyph with the same name. Use this when the caller has positively decided the previous glyph (if any) should be discarded.
+
+```ruby
+layer.put(Fontisan::Ufo::Glyph.new(name: "A"))  # overwrites the prior "A"
+```
+
+### `#[](glyph_name) -> Glyph, nil`
+
+Look up a glyph by name.
+
+### `#each { |glyph| ... }`
+
+Iterate over glyphs (no ordering guarantee).
+
+### `#size -> Integer`
+
+Number of glyphs in the layer.
+
+## `Ufo::GlyphExistsError`
+
+Raised by `Layer#add` on a name conflict. Carries the colliding name so callers can branch programmatically:
+
+```ruby
+begin
+  layer.add(glyph)
+rescue Fontisan::Ufo::GlyphExistsError => e
+  puts "name #{e.name.inspect} already taken"
+  # Decide: layer.put(glyph) to overwrite, or
+  # unique = Fontisan::Stitcher::UniqueGlyphName.in(target, e.name)
+  # layer.add(glyph.dup_as(name: unique))
+end
+```
+
+The error class is a sibling of `Layer` (not nested inside it) so the namespace stays flat — both `Ufo::Layer` and `Ufo::GlyphExistsError` live directly under `Fontisan::Ufo`.
+
+## See also
+
+- `docs/STITCHER_GUIDE.adoc` — `UniqueGlyphName`, `GlyphCopier`, and `CbdtPropagator` all build on the Layer naming contract.
+- `docs/UFO_COMPILATION.adoc` — how layers feed the TTF/OTF/CFF2 compilers.

data/docs/cli/subset.md

@@ -18,8 +18,23 @@ fontisan subset <font> [options]
 |--------|-------------|
 | `--chars TEXT` | Characters to include |
 | `--file FILE` | File containing characters |
+| `--unicodes RANGE` | Unicode ranges (`"U+0000-007F"`) |
+| `--glyphs LIST` | Glyph names/IDs |
 | `--output FILE` | Output file path |
-| `--format FORMAT` | Output format |
+| `--format FORMAT` | Output format (`ttf`, `woff`, `woff2`, …) |
+| `--profile PROFILE` | Subsetting profile (default: `pdf`) |
+| `--retain-gids` | Preserve original glyph IDs |
+
+## Profiles
+
+| Profile | Tables included | Use case |
+|---------|-----------------|----------|
+| `pdf` | core + glyf/loca | PDF embedding (smallest) |
+| `web` | core + glyf/loca + GSUB/GPOS + **CBDT/CBLC** | Web fonts that retain color-emoji bitmaps |
+| `minimal` | core only | Smallest valid font |
+| `full` | every standard table | Lossless re-export |
+
+The `web` profile is the one to reach for when the subset must still render color emoji in a browser: it preserves the CBDT (bitmap data) and CBLC (bitmap location) tables, and the paired subsetter rewrites them to keep only the bitmaps for the retained glyphs.
 
 ## Examples
 
@@ -27,13 +42,17 @@ fontisan subset <font> [options]
 # Subset to specific characters
 fontisan subset font.ttf --chars "ABCDEF" --output subset.ttf
 
-# Subset from file
-fontisan subset font.ttf --file chars.txt --output subset.ttf
+# Web subset that retains color-emoji bitmaps
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀😁😂🤣😊" \
+  --profile web \
+  --format woff2 \
+  --output emoji.woff2
 
-# Subset and convert format
-fontisan subset font.ttf --chars "Hello" --format woff2
+# PDF embedding profile (drops CBDT/CBLC, smaller output)
+fontisan subset font.ttf --chars "ABC" --profile pdf --output pdf-subset.ttf
 ```
 
 ## Detailed Documentation
 
-For comprehensive documentation including unicode ranges and advanced subsetting, see the [subset command guide](/guide/cli/subset).
+For comprehensive documentation including unicode ranges, profile selection, and CBDT/CBLC behavior, see the [subset command guide](/guide/cli/subset).

data/docs/guide/cli/subset.md

@@ -28,6 +28,7 @@ fontisan subset FONT [options]
 | `--glyphs LIST` | Glyph names/IDs |
 | `--output PATH` | Output file |
 | `--output-format FORMAT` | Output format |
+| `--profile PROFILE` | Subsetting profile (`pdf`, `web`, `minimal`, `full`; default `pdf`) |
 | `--retain-gids` | Retain glyph IDs |
 
 ## Examples
@@ -86,6 +87,36 @@ fontisan subset font.ttf --chars "ABC" --output-format woff2 --output subset.wof
 
 ## Subsetting Strategies
 
+### Profile selection
+
+The `--profile` option controls which font tables the subset retains. The right choice depends on what the subset is for:
+
+| Profile | When to use | Notable tables dropped |
+|---------|-------------|------------------------|
+| `pdf` (default) | PDF embedding, smallest valid output | GSUB, GPOS, CBDT, CBLC |
+| `web` | Browser/web font, **retains color-emoji bitmaps** | nothing that browsers need |
+| `minimal` | Absolute smallest core that still renders | glyf/loca, CBDT/CBLC, GSUB/GPOS |
+| `full` | Lossless re-export | (none) |
+
+```bash
+# Web subset that keeps color-emoji bitmaps so 😀 renders in color
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀😁😂🤣😊" \
+  --profile web \
+  --output-format woff2 \
+  --output emoji.woff2
+
+# PDF embedding — drops color bitmaps for size
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀" \
+  --profile pdf \
+  --output emoji-pdf.ttf
+```
+
+#### Web profile and CBDT/CBLC
+
+The `web` profile is the only built-in profile that retains CBDT (Color Bitmap Data) and CBLC (Color Bitmap Location) tables. The subsetter walks CBLC to find each retained glyph's bitmap block, rewrites CBDT to keep only those blocks, and rebuilds CBLC's IndexSubTableArray to point at the new offsets. Glyph IDs are remapped through the subset's `GlyphMapping`, so the output CBLC references subset GIDs, not source GIDs.
+
 ### Web Font Optimization
 
 ```bash

data/docs/guide/color-fonts/bitmaps.md

@@ -144,6 +144,23 @@ fontisan convert bitmap-font.ttf --to ttf --output bitmap-font.ttf
 fontisan convert bitmap-font.ttf --to ttf --no-bitmaps --output outline-only.ttf
 ```
 
+### Subsetting color-emoji fonts
+
+The `web` subsetting profile retains CBDT and CBLC tables and rewrites them to keep only the bitmaps for retained glyphs. Use it when subsetting a color-emoji source for browser delivery:
+
+```bash
+# Keep only 😀 + 😁 bitmaps; output WOFF2 for web
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀😁" \
+  --profile web \
+  --output-format woff2 \
+  --output emoji-subset.woff2
+```
+
+Other profiles (`pdf`, `minimal`, `full`) drop CBDT/CBLC — pick them when the subset doesn't need color-emoji rendering (e.g. PDF embedding where the subsetter is just selecting glyphs for outlines).
+
+See the [subset CLI docs](/cli/subset) and `docs/STITCHER_GUIDE.adoc` (CBDT/CBLC passthrough section) for the full story, including the GID-stability caveat when CBDT and outline donors cover overlapping codepoint ranges in stitch mode.
+
 ## Comparison
 
 | Feature | sbix | CBDT/CBLC |

data/lib/fontisan/cli.rb

@@ -360,7 +360,8 @@ module Fontisan
 
       # Handle --show-options
       if options[:show_options]
-        show_recommended_options(source_format, options[:to].is_a?(Array) ? options[:to].first : options[:to])
+        show_recommended_options(source_format,
+                                 options[:to].is_a?(Array) ? options[:to].first : options[:to])
         return
       end
 

data/lib/fontisan/collection/writer.rb

@@ -95,7 +95,8 @@ module Fontisan
       #
       # @return [String] TTC header binary
       def write_ttc_header
-        [TTC_TAG, VERSION_1_0_MAJOR, VERSION_1_0_MINOR, @fonts.size].pack("a4nnN")
+        [TTC_TAG, VERSION_1_0_MAJOR, VERSION_1_0_MINOR,
+         @fonts.size].pack("a4nnN")
       end
 
       # Write offset table

data/lib/fontisan/commands/validate_collection_command.rb

@@ -81,7 +81,13 @@ module Fontisan
         Check.new(
           name: :glyph_cap,
           passed: over.empty?,
-          message: over.empty? ? nil : "faces over cap: #{over.map { |s| "##{s.index}=#{s.glyph_count}" }.join(', ')}",
+          message: if over.empty?
+                     nil
+                   else
+                     "faces over cap: #{over.map do |s|
+                       "##{s.index}=#{s.glyph_count}"
+                     end.join(', ')}"
+                   end,
         )
       end
 

data/lib/fontisan/commands.rb

@@ -21,7 +21,8 @@ module Fontisan
     autoload :TablesCommand, "fontisan/commands/tables_command"
     autoload :UnicodeCommand, "fontisan/commands/unicode_command"
     autoload :UnpackCommand, "fontisan/commands/unpack_command"
-    autoload :ValidateCollectionCommand, "fontisan/commands/validate_collection_command"
+    autoload :ValidateCollectionCommand,
+             "fontisan/commands/validate_collection_command"
     autoload :ValidateCommand, "fontisan/commands/validate_command"
     autoload :VariableCommand, "fontisan/commands/variable_command"
   end

data/lib/fontisan/converters/collection_converter.rb

@@ -173,7 +173,12 @@ module Fontisan
             io.read(8) # signature + flavor
             io.rewind
             flavor = File.binread(path, 4, 4)&.unpack1("N")
-            flavor == Woff2::CollectionDecoder::TTC_FLAVOR ? :woff2_collection : (raise Error, "Not a WOFF2 collection: #{path}")
+            if flavor == Woff2::CollectionDecoder::TTC_FLAVOR
+              :woff2_collection
+            else
+              (raise Error,
+                     "Not a WOFF2 collection: #{path}")
+            end
           elsif Parsers::DfontParser.dfont?(io)
             :dfont
           else

data/lib/fontisan/converters/svg_generator.rb

@@ -192,7 +192,9 @@ palette_index: 0)
       def build_glyph_to_codepoints(cmap)
         return {} unless cmap
 
-        cmap.unicode_mappings.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(cp, gid), h|
+        cmap.unicode_mappings.each_with_object(Hash.new do |h, k|
+          h[k] = []
+        end) do |(cp, gid), h|
           h[gid] << cp
         end
       rescue StandardError => e

data/lib/fontisan/stitcher/collection_result.rb

@@ -9,7 +9,8 @@ module Fontisan
 
     # Return value of {Stitcher#write_collection}. Carries the output path,
     # total bytes, and one {SubfontStats} per declared subfont.
-    CollectionResult = Struct.new(:path, :bytes, :subfonts, keyword_init: true) do
+    CollectionResult = Struct.new(:path, :bytes, :subfonts,
+                                  keyword_init: true) do
       def face_count
         subfonts.size
       end

data/lib/fontisan/stitcher/glyph_copier.rb

@@ -89,7 +89,8 @@ module Fontisan
         bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
       end
 
-      def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
+      def copy_glyph_into(target_font, name:, source:, donor_gid:,
+codepoint: nil)
         original = source.glyph_for_gid(donor_gid)
         return unless original
 

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

@@ -403,7 +403,9 @@ module Fontisan
         private
 
         def group_by_block(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|
             block_label = find_block_label(cp) || :other
             h[block_label] << [cp, label]
           end

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.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