fontisan 0.4.11 → 0.4.13

data/lib/fontisan/subset/table_subsetter.rb

@@ -56,6 +56,8 @@ module Fontisan
         @options = options
         @glyf_data = nil
         @loca_offsets = nil
+        @subset_bbox = nil      # [xMin, yMin, xMax, yMax] over actual subset glyphs
+        @subset_max_advance = 0 # largest advanceWidth in subset hmtx
       end
 
       # Subset a table by tag
@@ -110,10 +112,12 @@ module Fontisan
         data
       end
 
-      # Subset hhea table (update numberOfHMetrics)
+      # Subset hhea table (update numberOfHMetrics + advanceWidthMax)
       #
-      # Updates the numberOfHMetrics field to reflect the number of
-      # horizontal metrics in the subset font.
+      # Updates numberOfHMetrics to reflect the subset's glyph count and
+      # recomputes advanceWidthMax from the subset's actual hmtx. The
+      # source TTC's advanceWidthMax covers every donor font and is far
+      # larger than any per-block subset needs.
       #
       # @param table [Hhea] Parsed hhea table
       # @param hmtx [Hmtx, nil] Optional parsed hmtx table (for calculating metrics)
@@ -128,9 +132,18 @@ module Fontisan
                               calculate_number_of_h_metrics
                             end
 
-        # Update numberOfHMetrics field (at offset 34, uint16)
+        # numberOfHMetrics at offset 34 (uint16)
         data[34, 2] = [new_num_h_metrics].pack("n")
 
+        # advanceWidthMax at offset 10 (uint16). Recompute from subset
+        # hmtx so a per-block subset doesn't keep the source TTC's
+        # max (which can be 4x larger than any glyph in the subset).
+        # Tables are processed alphabetically (hhea before hmtx), so
+        # we read hmtx directly here rather than relying on a cached
+        # value from subset_hmtx.
+        new_max = compute_subset_max_advance
+        data[10, 2] = [new_max].pack("n") if new_max.positive?
+
         data
       end
 
@@ -152,14 +165,18 @@ module Fontisan
         # Build new hmtx data
         data = String.new(encoding: Encoding::BINARY)
 
+        max_advance = 0
         mapping.old_ids.each do |old_id|
           metric = table.metric_for(old_id)
           next unless metric
 
-          data << [metric[:advance_width]].pack("n")
+          advance = metric[:advance_width]
+          max_advance = advance if advance && advance > max_advance
+          data << [advance].pack("n")
           data << [metric[:lsb]].pack("n")
         end
 
+        @subset_max_advance = max_advance
         data
       end
 
@@ -264,8 +281,32 @@ module Fontisan
       #
       # @param table [Head] Parsed head table
       # @return [String] Binary data of subset head table
+      # Subset head table (recompute bbox from actual subset glyphs)
+      #
+      # The source TTC's head.xMin/yMin/xMax/yMax covers every donor
+      # font in the collection — far larger than any per-block subset.
+      # Browsers and layout engines use head bbox (plus hhea + OS/2)
+      # to compute line height and clip text; a too-large bbox makes
+      # glyphs render at the wrong visual size.
+      #
+      # @param _table [Head] Parsed head table (unused; we re-serialize
+      #   directly from font.table_data so we don't lose other fields)
+      # @return [String] Binary data of subset head table
       def subset_head(_table)
-        font.table_data["head"]
+        # Trigger glyf build (which populates @subset_bbox) if not done.
+        glyf = font.table("glyf")
+        build_glyf_and_loca(glyf) unless @glyf_data
+
+        data = font.table_data["head"].dup
+
+        if @subset_bbox
+          x_min, y_min, x_max, y_max = @subset_bbox
+          # head layout: xMin at offset 36, yMin 38, xMax 40, yMax 42
+          # (each int16, big-endian, signed)
+          data[36, 8] = [x_min, y_min, x_max, y_max].pack("n4")
+        end
+
+        data
       end
 
       # Subset OS/2 table (optionally prune Unicode ranges)
@@ -295,6 +336,32 @@ module Fontisan
         mapping.size
       end
 
+      # Compute the largest advanceWidth across all subset glyphs by
+      # reading the source hmtx directly. Called from subset_hhea
+      # because hhea is processed before hmtx (alphabetical order).
+      #
+      # @return [Integer] max advanceWidth, or 0 if no metrics found
+      def compute_subset_max_advance
+        hmtx = font.table("hmtx")
+        return 0 unless hmtx
+
+        unless hmtx.parsed?
+          hhea = font.table("hhea")
+          maxp = font.table("maxp")
+          hmtx.parse_with_context(hhea.number_of_h_metrics, maxp.num_glyphs)
+        end
+
+        max_advance = 0
+        mapping.old_ids.each do |old_id|
+          metric = hmtx.metric_for(old_id)
+          next unless metric
+
+          advance = metric[:advance_width]
+          max_advance = advance if advance && advance > max_advance
+        end
+        max_advance
+      end
+
       # Build glyf and loca tables together
       #
       # This method extracts glyph data for all glyphs in the mapping,
@@ -318,6 +385,17 @@ module Fontisan
         @loca_offsets = []
         current_offset = 0
 
+        # Track union bbox across all subset glyphs. Glyph binary layout:
+        #   int16 numberOfContours (offset 0)
+        #   int16 xMin (offset 2)
+        #   int16 yMin (offset 4)
+        #   int16 xMax (offset 6)
+        #   int16 yMax (offset 8)
+        bbox_x_min = 1 << 30
+        bbox_y_min = 1 << 30
+        bbox_x_max = -(1 << 30)
+        bbox_y_max = -(1 << 30)
+
         # Process glyphs in mapping order
         mapping.old_ids.each do |old_id|
           @loca_offsets << current_offset
@@ -334,6 +412,21 @@ module Fontisan
           # Extract glyph data
           glyph_data = glyf_table.raw_data[offset, size]
 
+          # Update bbox union. Each glyph has at least 10 bytes of
+          # header (numberOfContours + 4 int16 bbox fields).
+          if glyph_data.bytesize >= 10
+            _n, gx_min, gy_min, gx_max, gy_max = glyph_data[0, 10].unpack("n5")
+            # Treat as signed int16
+            gx_min = (gx_min ^ 0x8000) - 0x8000
+            gy_min = (gy_min ^ 0x8000) - 0x8000
+            gx_max = (gx_max ^ 0x8000) - 0x8000
+            gy_max = (gy_max ^ 0x8000) - 0x8000
+            bbox_x_min = gx_min if gx_min < bbox_x_min
+            bbox_y_min = gy_min if gy_min < bbox_y_min
+            bbox_x_max = gx_max if gx_max > bbox_x_max
+            bbox_y_max = gy_max if gy_max > bbox_y_max
+          end
+
           # Check if compound glyph and remap components
           if compound_glyph?(glyph_data)
             glyph_data = remap_compound_glyph(glyph_data)
@@ -346,6 +439,11 @@ module Fontisan
 
         # Add final offset
         @loca_offsets << current_offset
+
+        # Stash union bbox if we saw at least one non-empty glyph.
+        return if bbox_x_min > bbox_x_max
+
+        @subset_bbox = [bbox_x_min, bbox_y_min, bbox_x_max, bbox_y_max]
       end
 
       # Check if glyph data represents a compound glyph

data/lib/fontisan/svg/standalone_glyph.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Svg
+    # Renders a single UFO glyph as a standalone SVG document (a
+    # `<svg>` root with one `<path>` and a viewBox sized to the
+    # glyph's bounding box). Distinct from {FontGenerator}, which
+    # emits a `<svg><defs><font>` document covering every glyph.
+    #
+    # Used by the `fontisan ufo extract` CLI command and by
+    # downstream consumers that want per-glyph SVG exports without
+    # having to slice up a font-format SVG themselves.
+    #
+    # Path rendering supports quadratic and cubic Bezier curves
+    # (UFO's standard outline model). Curve logic is inlined here
+    # rather than reaching into GlyphGenerator's private path code
+    # — that logic is font-format-specific (Y-axis flip via
+    # ViewBoxCalculator) and doesn't cleanly factor out.
+    class StandaloneGlyph
+      # @param units_per_em [Integer] font units-per-em (default 1000)
+      # @param ascent [Integer] font ascender in font units (default 800)
+      # @param descent [Integer] font descender in font units (default -200)
+      def initialize(units_per_em: 1000, ascent: 800, descent: -200)
+        @units_per_em = units_per_em.to_i
+        @ascent = ascent.to_i
+        @descent = descent.to_i
+      end
+
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @return [String] standalone SVG XML
+      def generate(glyph)
+        path_data = path_data_for(glyph)
+        view_box = view_box_for(glyph)
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="#{view_box}">
+            <path d="#{path_data}"/>
+          </svg>
+        SVG
+      end
+
+      private
+
+      def path_data_for(glyph)
+        return "" if glyph.contours.empty?
+
+        glyph.contours.filter_map { |c| contour_path(c) }.join(" ")
+      end
+
+      # Emit an SVG path for one contour with Y-axis flip applied.
+      # Walks points left-to-right; collects off-curve runs and
+      # flushes them as a Bezier curve (Q for 1 control point, C
+      # for 2). Single on-curve points become line segments.
+      def contour_path(contour)
+        points = contour.points
+        return nil if points.empty?
+
+        parts = []
+        first = points.first
+        parts << "M #{first.x} #{flip_y(first.y)}"
+
+        i = 1
+        while i < points.length
+          if points[i].on_curve?
+            parts << "L #{points[i].x} #{flip_y(points[i].y)}"
+            i += 1
+          else
+            # Collect consecutive off-curve points (1 → quadratic,
+            # 2 → cubic, 3+ → rare; treat as multiple quadratics).
+            controls = []
+            while i < points.length && !points[i].on_curve?
+              controls << points[i]
+              i += 1
+            end
+            end_pt = i < points.length ? points[i] : first
+            i += 1 if i < points.length
+
+            parts << curve_segment(controls, end_pt)
+          end
+        end
+
+        parts << "Z"
+        parts.join(" ")
+      end
+
+      def curve_segment(controls, end_pt)
+        end_x = end_pt.x
+        end_y = flip_y(end_pt.y)
+
+        case controls.size
+        when 1
+          "Q #{controls[0].x} #{flip_y(controls[0].y)} #{end_x} #{end_y}"
+        when 2
+          "C #{controls[0].x} #{flip_y(controls[0].y)} " \
+            "#{controls[1].x} #{flip_y(controls[1].y)} " \
+            "#{end_x} #{end_y}"
+        else
+          # 3+ controls: emit a Q to the midpoint of the first two,
+          # then continue. Rare in practice; degrades to Q chain.
+          mid_x = (controls[0].x + controls[1].x) / 2.0
+          mid_y = flip_y((controls[0].y + controls[1].y) / 2.0)
+          "Q #{controls[0].x} #{flip_y(controls[0].y)} #{mid_x} #{mid_y}"
+        end
+      end
+
+      def flip_y(y)
+        @ascent - y.to_f
+      end
+
+      def view_box_for(glyph)
+        bbox = bounding_box(glyph)
+        format("%<xmin>s %<ymin>s %<w>s %<h>s",
+               xmin: bbox[:x_min], ymin: bbox[:y_min],
+               w: (bbox[:x_max] - bbox[:x_min]),
+               h: (bbox[:y_max] - bbox[:y_min]))
+      end
+
+      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?
+
+        xs = points.map(&:x)
+        ys = points.map(&:y)
+        { x_min: xs.min, y_min: ys.min, x_max: xs.max, y_max: ys.max }
+      end
+    end
+  end
+end

data/lib/fontisan/svg.rb

@@ -7,6 +7,7 @@ module Fontisan
     autoload :FontFaceGenerator, "fontisan/svg/font_face_generator"
     autoload :FontGenerator, "fontisan/svg/font_generator"
     autoload :GlyphGenerator, "fontisan/svg/glyph_generator"
+    autoload :StandaloneGlyph, "fontisan/svg/standalone_glyph"
     autoload :ViewBoxCalculator, "fontisan/svg/view_box_calculator"
   end
 end

data/lib/fontisan/tables/head.rb

@@ -18,6 +18,16 @@ module Fontisan
       # Magic number that must be present in the head table
       MAGIC_NUMBER = 0x5F0F3CF5
 
+      # Bit flags for the `flags` field (uint16), per OpenType spec.
+      # Only bits we currently reference are named here; see the OpenType
+      # `head` table specification for the full list.
+      #
+      # Bit 11 indicates the font data has been losslessly modified
+      # (e.g. by subsetting or WOFF2 encoding). Per WOFF2 spec section 5,
+      # encoders MUST set this bit. Chrome's OpenType Sanitizer (OTS)
+      # rejects WOFF2 files where it is not set.
+      FLAG_LOSSLESS_MODIFYING = 0x0800
+
       # Version as 16.16 fixed-point (stored as int32)
       int32 :version_raw
 

data/lib/fontisan/ufo/cli.rb

@@ -14,20 +14,15 @@ module Fontisan
       method_option :output, type: :string, required: true,
                              desc: "Output file path"
       method_option :to, type: :string, default: "ttf",
-                         desc: "Output format (ttf or otf)"
+                         desc: "Output format (ttf, otf, or otf2)"
       def build(ufo)
         font = Font.open(ufo)
-        format_sym = (options[:to] || "ttf").to_s.downcase.to_sym
-        compiler =
-          case format_sym
-          when :ttf then Compile::TtfCompiler
-          when :otf then Compile::OtfCompiler
-          else
-            warn "unknown format: #{options[:to].inspect}"
-            exit 1
-          end
-        compiler.new(font).compile(output_path: options[:output])
+        format = (options[:to] || "ttf").to_s.downcase.to_sym
+        Convert.convert(font, to: format, output_path: options[:output])
         puts "wrote #{options[:output]} (#{File.size(options[:output])} bytes)"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
       rescue Errno::ENOENT
         warn "UFO not found: #{ufo}"
         exit 1
@@ -35,20 +30,12 @@ module Fontisan
 
       desc "convert INPUT OUTPUT", "Convert between UFO and binary formats"
       method_option :to, type: :string,
-                         desc: "Override format detection (ttf, otf, ufo)"
+                         desc: "Override format detection (ttf, otf, otf2, ufo)"
       def convert(input, output)
         if ufo?(input)
           font = Font.open(input)
           format = options[:to] || File.extname(output).delete(".").downcase
-          compiler =
-            case format.to_sym
-            when :ttf then Compile::TtfCompiler
-            when :otf then Compile::OtfCompiler
-            else
-              warn "unsupported output format: #{format.inspect}"
-              exit 1
-            end
-          compiler.new(font).compile(output_path: output)
+          Convert.convert(font, to: format.to_sym, output_path: output)
         else
           # Binary → UFO
           loaded = Fontisan::FontLoader.load(input)
@@ -56,6 +43,9 @@ module Fontisan
           Writer.new(ufo).write(output)
         end
         puts "wrote #{output}"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
       end
 
       desc "validate UFO", "Check a UFO source for structural issues"
@@ -75,6 +65,29 @@ module Fontisan
         end
       end
 
+      desc "extract UFO GLYPH_NAME OUTPUT.svg",
+           "Render a single glyph from a UFO as a standalone SVG"
+      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
+
+        head = font.info
+        renderer = Fontisan::Svg::StandaloneGlyph.new(
+          units_per_em: head.units_per_em || 1000,
+          ascent: head.ascender || 800,
+          descent: head.descender || -200,
+        )
+        File.write(output, renderer.generate(glyph))
+        puts "wrote #{output} (#{File.size(output)} bytes)"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
+      rescue Errno::ENOENT
+        warn "UFO not found: #{ufo}"
+        exit 1
+      end
+
       private
 
       def ufo?(path)

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # Value object returned by every feature writer's +#write+
+        # method. Carries the structured data the corresponding
+        # table builder needs to encode the binary subtable.
+        #
+        # Writers return +nil+ instead when the UFO has no data for
+        # the feature — the compiler skips +nil+ outputs.
+        FeatureOutput = Struct.new(
+          :table_tag, # "GPOS", "GSUB", "GDEF"
+          :feature_tag, # "kern", "mark", "curs", etc. (nil for GDEF)
+          :lookup_type, # Integer GSUB/GPOS lookup type
+          :data,        # Hash — writer-specific structure
+          keyword_init: true,
+        ) do
+          def table_tag
+            self[:table_tag]
+          end
+
+          def feature_tag
+            self[:feature_tag]
+          end
+
+          def lookup_type
+            self[:lookup_type]
+          end
+
+          def data
+            self[:data]
+          end
+        end
+
+        # Abstract base class for feature writers. Concrete writers
+        # (Kern, Gdef, Mark, etc.) extend this and implement +#write+.
+        class Base
+          attr_reader :font
+
+          # @param font [Fontisan::Ufo::Font] the UFO source
+          def initialize(font)
+            @font = font
+          end
+
+          # @return [FeatureOutput, nil] structured data for the
+          #   feature, or +nil+ if the UFO has nothing for it
+          def write
+            raise NotImplementedError, "#{self.class} must implement #write"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS Cursive (lookup type 3) — cursive attachment.
+        #
+        # Pairs glyphs via their entry and exit anchors for cursive
+        # (joining) scripts. UFO convention: a glyph's +<name>entry+
+        # and +<name>exit+ anchors define where it connects to its
+        # neighbors.
+        #
+        # Pairs every glyph that has at least one +entry+ anchor with
+        # every glyph that has the corresponding +exit+ anchor.
+        # Multiple entry/exit class names are supported.
+        class Curs < Base
+          LOOKUP_TYPE = 3
+          FEATURE_TAG = "curs"
+          TABLE_TAG = "GPOS"
+
+          # @return [FeatureOutput, nil]
+          def write
+            attachments = {}
+
+            entry_glyphs = glyphs_with_anchor(/entry\z/)
+            exit_glyphs = glyphs_with_anchor(/exit\z/)
+
+            return nil if entry_glyphs.empty? && exit_glyphs.empty?
+
+            # Cursive attachment: each glyph can be both a "previous"
+            # (with exit anchor) and "next" (with entry anchor) in
+            # a cursive chain. The GPOS builder handles the
+            # cross-references; we emit every glyph with its entry
+            # and/or exit anchor positions.
+            font.glyphs.each_value do |glyph|
+              entry = find_anchor(glyph, /entry\z/)
+              exit = find_anchor(glyph, /exit\z/)
+              next unless entry || exit
+
+              attachments[glyph.name] = {
+                entry: entry && [entry.x, entry.y],
+                exit: exit && [exit.x, exit.y],
+              }
+            end
+
+            return nil if attachments.empty?
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: FEATURE_TAG,
+              lookup_type: LOOKUP_TYPE,
+              data: { attachments: attachments },
+            )
+          end
+
+          private
+
+          def glyphs_with_anchor(pattern)
+            font.glyphs.select do |_name, glyph|
+              glyph.anchors.any? { |a| pattern.match?(a.name.to_s) }
+            end
+          end
+
+          def find_anchor(glyph, pattern)
+            glyph.anchors.find { |a| pattern.match?(a.name.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GDEF GlyphClassDef — classifies every glyph into one of
+        # the four OpenType glyph classes:
+        #
+        #   1 — Base glyph
+        #   2 — Ligature glyph
+        #   3 — Combining mark
+        #   4 — Glyph spacing variant (e.g. alternate space)
+        #
+        # The classification drives how GSUB/GPOS lookups apply. UFO
+        # sources carry this in the glyph's +lib+ plist under the
+        # +public.openTypeCategory+ key; this writer translates that
+        # into the structured form the GDEF builder expects.
+        class Gdef < Base
+          TABLE_TAG = "GDEF"
+
+          # Map UFO public.openTypeCategory values → OpenType glyph
+          # class integers. Glyphs whose category isn't listed get
+          # class 0 (unclassified — the GDEF ClassDef omits them).
+          CATEGORY_TO_CLASS = {
+            "base" => 1,
+            "ligature" => 2,
+            "mark" => 3,
+            "component" => 3, # UFO treats component as mark for GDEF
+            "spacing" => 4,
+          }.freeze
+
+          # @return [FeatureOutput]
+          def write
+            classifications = {}
+
+            font.glyphs.each_value do |glyph|
+              cls = classify(glyph)
+              classifications[glyph.name] = cls if cls
+            end
+
+            # A GDEF without any classified glyphs is meaningless —
+            # return nil so the compiler skips the table.
+            return nil if classifications.empty?
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: nil,
+              lookup_type: nil,
+              data: { classes: classifications },
+            )
+          end
+
+          private
+
+          # Resolve a glyph's GDEF class. Prefer the explicit
+          # +public.openTypeCategory+ lib entry; fall back to a
+          # heuristic (glyphs with anchors named "top"/"bottom" are
+          # marks; glyphs with component references are ligatures
+          # only if their name has a +.liga+ suffix).
+          def classify(glyph)
+            category = glyph_lib_category(glyph)
+            return CATEGORY_TO_CLASS[category] if category && CATEGORY_TO_CLASS.key?(category)
+
+            heuristic_class(glyph)
+          end
+
+          def glyph_lib_category(glyph)
+            return nil unless glyph.lib
+
+            lib = glyph.lib
+            return lib["public.openTypeCategory"] if lib["public.openTypeCategory"]
+
+            categories = lib["public.openTypeCategories"]
+            categories[glyph.name] if categories.is_a?(Hash)
+          end
+
+          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 2 if glyph.name.to_s.end_with?(".liga")
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end