fontisan 0.2.22 → 0.3.0

data/lib/fontisan/stitcher.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Multi-source font stitcher. Combines glyphs from one or more
+  # source fonts (UFO or loaded TTF/OTF) into a single new font.
+  #
+  # The Stitcher builds a Fontisan::Ufo::Font from selected glyphs,
+  # then delegates compilation to the existing TtfCompiler or
+  # OtfCompiler. Single source of truth: one compiler pipeline,
+  # whether the input is one UFO or many sources.
+  #
+  # @example Stitch ASCII from one UFO, Hiragana from another
+  #   stitcher = Fontisan::Stitcher.new
+  #   stitcher.add_source(:latin, Fontisan::Ufo::Font.open("latin.ufo"))
+  #   stitcher.add_source(:jp, Fontisan::Ufo::Font.open("jp.ufo"))
+  #   stitcher.include_range(0x41..0x5A, from: :latin)
+  #   stitcher.include_range(0x3040..0x309F, from: :jp)
+  #   stitcher.write_to("stitched.ttf", format: :ttf)
+  class Stitcher
+    autoload :Source,   "fontisan/stitcher/source"
+    autoload :Selector, "fontisan/stitcher/selector"
+
+    attr_reader :sources, :bindings
+
+    def initialize
+      @sources = {}
+      @bindings = []
+      @target = Ufo::Font.new
+    end
+
+    # Register a named source font.
+    # @param label [Symbol, String] name to reference this source by
+    # @param font [Fontisan::Ufo::Font, Fontisan::SfntFont] the source
+    def add_source(label, font)
+      @sources[label.to_sym] = Source.new(font)
+    end
+
+    # Include all codepoints in a range from a named source.
+    # @param range [Range<Integer>] codepoint range
+    # @param from [Symbol, String] source label
+    def include_range(range, from:)
+      Selector::Range.new(range).apply(source(from), @bindings)
+    end
+
+    # Include an explicit list of codepoints.
+    # @param codepoints [Array<Integer>]
+    # @param from [Symbol, String] source label
+    def include_codepoints(codepoints, from:)
+      Selector::Codepoints.new(codepoints).apply(source(from), @bindings)
+    end
+
+    # Include a single glyph by donor gid (rare; for unencoded glyphs
+    # like .notdef).
+    # @param donor_gid [Integer]
+    # @param from [Symbol, String] source label
+    def include_gid(donor_gid, from:)
+      Selector::Gid.new(donor_gid).apply(source(from), @bindings)
+    end
+
+    # Always include .notdef from a named source.
+    # @param from [Symbol, String] source label
+    def include_notdef(from:)
+      include_gid(0, from: from)
+    end
+
+    # Set font-wide metadata on the stitched font.
+    # @param info_hash [Hash] any subset of Fontisan::Ufo::Info fields
+    def set_info(info_hash)
+      @target.info = Ufo::Info.new(info_hash)
+    end
+
+    # Write the stitched font to disk.
+    # @param path [String] output file path
+    # @param format [Symbol] :ttf or :otf
+    def write_to(path, format: :ttf)
+      build_target_font
+      compiler = compiler_for(format)
+      compiler.new(@target).compile(output_path: path)
+      path
+    end
+
+    # Build the internal UFO::Font from the current bindings. Useful
+    # for testing or for further manipulation before writing.
+    # @return [Fontisan::Ufo::Font]
+    def build_target_font
+      @target = Ufo::Font.new
+      assign_gids_and_copy_glyphs
+      @target
+    end
+
+    private
+
+    def source(label)
+      @sources.fetch(label.to_sym) do
+        raise ArgumentError, "unknown source: #{label.inspect}"
+      end
+    end
+
+    def compiler_for(format)
+      case format.to_sym
+      when :ttf then Ufo::Compile::TtfCompiler
+      when :otf then Ufo::Compile::OtfCompiler
+      else
+        raise ArgumentError, "unknown format: #{format.inspect}"
+      end
+    end
+
+    # Walk bindings in codepoint order, assign sequential new gids,
+    # copy each glyph into the target font's default layer.
+    def assign_gids_and_copy_glyphs
+      # Always put .notdef at gid 0 first.
+      notdef_binding = @bindings.find { |b| b[:donor_gid].zero? }
+      if notdef_binding
+        copy_glyph_into(@target, name: ".notdef",
+                                 source: notdef_binding[:source],
+                                 donor_gid: 0)
+      else
+        # Synthesize an empty .notdef
+        @target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
+      end
+
+      sorted_bindings.each do |binding|
+        next if binding[:donor_gid].zero? # already handled
+
+        glyph = binding[:source].glyph_for_gid(binding[:donor_gid])
+        next unless glyph
+
+        # If multiple codepoints map to the same glyph, only the first
+        # binding creates the glyph; subsequent ones add unicode entries.
+        if @target.glyphs.key?(glyph.name)
+          add_extra_unicode(glyph.name, binding[:codepoint])
+        else
+          copy_glyph_into(@target, name: glyph.name,
+                                   source: binding[:source],
+                                   donor_gid: binding[:donor_gid],
+                                   codepoint: binding[:codepoint])
+        end
+      end
+    end
+
+    # Bindings sorted by codepoint (nil codepoints come last).
+    def sorted_bindings
+      @bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
+    end
+
+    def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
+      original = source.glyph_for_gid(donor_gid)
+      return unless original
+
+      copy = clone_glyph(original, name: name)
+      copy.add_unicode(codepoint) if codepoint
+      target_font.layers.default_layer.add(copy)
+    end
+
+    def add_extra_unicode(glyph_name, codepoint)
+      return unless codepoint
+
+      glyph = @target.glyph(glyph_name)
+      glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
+    end
+
+    # Deep-copy a glyph with a new name. Used so multiple target
+    # glyphs can share the same source outline without aliasing.
+    def clone_glyph(original, name:)
+      copy = Ufo::Glyph.new(name: name)
+      copy.width = original.width
+      copy.height = original.height
+      original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+      original.components.each { |c| copy.add_component(c) }
+      original.anchors.each { |a| copy.add_anchor(a) }
+      original.guidelines.each { |g| copy.add_guideline(g) }
+      copy
+    end
+
+    def clone_contour(original)
+      points = original.points.map do |p|
+        Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+      end
+      Ufo::Contour.new(points)
+    end
+  end
+end

data/lib/fontisan/stitcher_cli.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Fontisan
+  # CLI subcommand for multi-source font stitching.
+  #
+  #   fontisan stitch --source latin=PATH --source jp=PATH \
+  #     --output out.ttf \
+  #     --include-range latin=0x41-0x5A \
+  #     --include-range jp=0x3040-0x309F
+  class StitcherCli < Thor
+    desc "stitch", "Stitch glyphs from multiple sources into one font"
+    method_option :source, type: :array, required: true,
+                           desc: "Named source (name=path); repeatable"
+    method_option :include_range, type: :array, default: [],
+                                  desc: "Range to include (name=hex-hex); repeatable"
+    method_option :include_codepoints, type: :array, default: [],
+                                       desc: "Codepoint list (name=hex,hex,...); repeatable"
+    method_option :notdef_from, type: :string,
+                                desc: "Source label to take .notdef from"
+    method_option :output, type: :string, required: true,
+                           desc: "Output file path"
+    method_option :to, type: :string, default: "ttf",
+                       desc: "Output format (ttf or otf)"
+
+    def stitch
+      stitcher = Stitcher.new
+
+      options[:source].each do |spec|
+        label, path = spec.split("=", 2)
+        font = load_source(path)
+        stitcher.add_source(label, font)
+      end
+
+      options[:include_range]&.each do |spec|
+        label, range_str = spec.split("=", 2)
+        lo, hi = parse_range(range_str)
+        stitcher.include_range(lo..hi, from: label)
+      end
+
+      options[:include_codepoints]&.each do |spec|
+        label, cps_str = spec.split("=", 2)
+        cps = cps_str.split(",").map { |h| Integer(h) }
+        stitcher.include_codepoints(cps, from: label)
+      end
+
+      stitcher.include_notdef(from: options[:notdef_from]) if options[:notdef_from]
+
+      stitcher.write_to(options[:output], format: options[:to].to_sym)
+      puts "wrote #{options[:output]} (#{File.size(options[:output])} bytes)"
+    end
+
+    private
+
+    def load_source(path)
+      if File.directory?(path) && File.exist?(File.join(path, "fontinfo.plist"))
+        Ufo::Font.open(path)
+      else
+        FontLoader.load(path)
+      end
+    end
+
+    def parse_range(str)
+      lo, hi = str.split("-", 2)
+      [Integer(lo), Integer(hi)]
+    end
+  end
+end

data/lib/fontisan/tables/cff.rb

@@ -54,7 +54,8 @@ module Fontisan
       autoload :DictBuilder, "fontisan/tables/cff/dict_builder"
       autoload :Encoding, "fontisan/tables/cff/encoding"
       autoload :Header, "fontisan/tables/cff/header"
-      autoload :HintOperationInjector, "fontisan/tables/cff/hint_operation_injector"
+      autoload :HintOperationInjector,
+               "fontisan/tables/cff/hint_operation_injector"
       autoload :Index, "fontisan/tables/cff/index"
       autoload :IndexBuilder, "fontisan/tables/cff/index_builder"
       autoload :OffsetRecalculator, "fontisan/tables/cff/offset_recalculator"

data/lib/fontisan/tables.rb

@@ -12,7 +12,8 @@ module Fontisan
     autoload :CmapTable, "fontisan/tables/cmap_table"
     autoload :Colr, "fontisan/tables/colr"
     autoload :CompoundGlyph, "fontisan/tables/glyf/compound_glyph"
-    autoload :CompoundGlyphResolver, "fontisan/tables/glyf/compound_glyph_resolver"
+    autoload :CompoundGlyphResolver,
+             "fontisan/tables/glyf/compound_glyph_resolver"
     autoload :Cpal, "fontisan/tables/cpal"
     autoload :CurveConverter, "fontisan/tables/glyf/curve_converter"
     autoload :Cvar, "fontisan/tables/cvar"

data/lib/fontisan/ufo/anchor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # A mark-attachment anchor on a glyph (used in GSUB/GPOS).
+    class Anchor
+      attr_reader :x, :y, :name, :identifier
+
+      def initialize(x:, y:, name: nil, identifier: nil)
+        @x = x
+        @y = y
+        @name = name
+        @identifier = identifier
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/cli.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Fontisan
+  module Ufo
+    # CLI subcommand for UFO source operations.
+    #
+    #   fontisan ufo build font.ufo --output out.ttf [--format otf]
+    #   fontisan ufo convert font.ttf font.ufo
+    #   fontisan ufo validate font.ufo
+    class Cli < Thor
+      desc "build UFO", "Compile a UFO source to a binary font"
+      method_option :output, type: :string, required: true,
+                             desc: "Output file path"
+      method_option :to, type: :string, default: "ttf",
+                         desc: "Output format (ttf or otf)"
+      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])
+        puts "wrote #{options[:output]} (#{File.size(options[:output])} bytes)"
+      rescue Errno::ENOENT
+        warn "UFO not found: #{ufo}"
+        exit 1
+      end
+
+      desc "convert INPUT OUTPUT", "Convert between UFO and binary formats"
+      method_option :to, type: :string,
+                         desc: "Override format detection (ttf, otf, 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)
+        else
+          # Binary → UFO
+          loaded = Fontisan::FontLoader.load(input)
+          ufo = Convert::FromBinData.convert(loaded)
+          Writer.new(ufo).write(output)
+        end
+        puts "wrote #{output}"
+      end
+
+      desc "validate UFO", "Check a UFO source for structural issues"
+      def validate(ufo)
+        font = Font.open(ufo)
+        issues = []
+        issues << "no glyphs in default layer" if font.glyphs.empty?
+        issues << "no family name" unless font.info.family_name
+        issues << "unitsPerEm not set" unless font.info.units_per_em
+        issues << "missing .notdef glyph" unless font.glyph(".notdef")
+
+        if issues.empty?
+          puts "OK  #{ufo}"
+        else
+          issues.each { |i| warn "FAIL  #{i}" }
+          exit 1
+        end
+      end
+
+      private
+
+      def ufo?(path)
+        File.directory?(path) && File.exist?(File.join(path, "fontinfo.plist"))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Common orchestrator for TTF and OTF compilers.
+      # Subclasses implement `#build_outline_tables` (returning the
+      # format-specific table set: glyf+loca for TTF, CFF for OTF)
+      # and `sfnt_version` (0x00010000 for TTF, 0x4F54544F for OTF).
+      class BaseCompiler
+        SFNT_VERSION_TRUE_TYPE = 0x00010000
+        SFNT_VERSION_OPEN_TYPE = 0x4F54544F # "OTTO"
+
+        attr_reader :font
+
+        def initialize(font)
+          @font = font
+        end
+
+        # @param output_path [String] where to write the binary font
+        # @return [String] the path
+        def compile(output_path:)
+          tables = build_tables
+          write(tables, output_path)
+          output_path
+        end
+
+        # Format-specific extra tables. Override in subclasses.
+        # @return [Hash<String, #to_binary_s, String>]
+        def build_outline_tables
+          {}
+        end
+
+        # @return [Integer] 0x00010000 (TTF) or 0x4F54544F (OTF)
+        def sfnt_version
+          self.class::SFNT_VERSION
+        end
+
+        private
+
+        # All tables every OTF/TTF must have.
+        def build_tables
+          glyphs = font.glyphs.values
+          {
+            "head" => Head.build(font, glyphs: glyphs),
+            "hhea" => Hhea.build(font, glyphs: glyphs),
+            "maxp" => Maxp.build(font, glyphs: glyphs),
+            "OS/2" => Os2.build(font, glyphs: glyphs),
+            "name" => Name.build(font),
+            "post" => Post.build(font, glyphs: glyphs),
+            "hmtx" => Hmtx.build(font, glyphs: glyphs),
+            "cmap" => Cmap.build(font, glyphs: glyphs),
+          }.merge(build_outline_tables)
+        end
+
+        def write(tables_hash, output_path)
+          dir = File.dirname(output_path)
+          FileUtils.mkpath(dir) unless dir == "."
+
+          Fontisan::FontWriter.write_to_file(
+            tables_hash.transform_values { |t| serialize_table(t) },
+            output_path,
+            sfnt_version: sfnt_version,
+          )
+        end
+
+        # BinData records (Tables::*) respond to to_binary_s; raw
+        # String values pass through. We branch on class identity
+        # rather than `respond_to?` to keep the type system honest.
+        def serialize_table(table)
+          case table
+          when String then table
+          else table.to_binary_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `CFF ` table from UFO glyphs.
+      #
+      # Pipeline:
+      #   1. Convert each UFO glyph's contours to a Models::Outline
+      #      (cubic Bezier commands).
+      #   2. Encode each outline as a Type 2 charstring via the
+      #      existing `Tables::Cff::CharStringBuilder`.
+      #   3. Build the CFF structural INDEXes (Name, Top DICT, String,
+      #      Global Subr, CharStrings) with correct offsets.
+      #
+      # The Top DICT references absolute offsets to the charset,
+      # charstrings, and private dict. Those offsets depend on the
+      # size of everything that comes before them — including the Top
+      # DICT itself. We resolve the circular dependency with a
+      # fixed-point iteration: build the Top DICT, compute offsets,
+      # rebuild the Top DICT with the new offsets, repeat until it
+      # converges (typically 2 iterations).
+      module Cff
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String] CFF table bytes
+        def self.build(font, glyphs:)
+          name = font.info.postscript_font_name || font.info.family_name || "Untitled"
+          charstrings = glyphs.map { |g| charstring_for(g) }
+          private_dict = +""
+
+          layout = compute_layout(name: name, glyphs: glyphs,
+                                  charstrings: charstrings,
+                                  private_dict: private_dict)
+
+          assemble(layout: layout)
+        end
+
+        # ---------- charstring per-glyph ----------
+
+        def self.charstring_for(glyph)
+          return empty_charstring(glyph.width.to_i) if glyph.contours.empty?
+
+          builder = Fontisan::Tables::Cff::CharStringBuilder.new
+          builder.build(glyph.to_outline, width: glyph.width.to_i)
+        rescue StandardError
+          # Any failure (e.g., too-short contours, unsupported curve
+          # combination): fall back to an empty charstring so the
+          # INDEX stays valid.
+          empty_charstring(glyph.width.to_i)
+        end
+
+        def self.empty_charstring(width)
+          Fontisan::Tables::Cff::CharStringBuilder.build_empty(width: width.zero? ? nil : width)
+        end
+
+        # ---------- layout ----------
+
+        # Compute the byte offsets of every CFF structural section.
+        # Iterates until the Top DICT's encoded size stabilizes.
+        def self.compute_layout(name:, glyphs:, charstrings:, private_dict:)
+          name_index = index_bytes([name.b])
+          string_index = index_bytes([])
+          global_subr_index = index_bytes([])
+          charset = charset_bytes(glyphs)
+          charstrings_index = index_bytes(charstrings)
+
+          # First guess: Top DICT encoded with all-zero offsets.
+          top_dict = top_dict_bytes(0, 0, 0, 0)
+          top_dict_index = index_bytes([top_dict])
+
+          charset_offset = 0
+          charstrings_offset = 0
+          private_offset = 0
+
+          10.times do
+            header_size = 4
+            post_top_dict = header_size + name_index.bytesize +
+              top_dict_index.bytesize + string_index.bytesize +
+              global_subr_index.bytesize
+
+            charset_offset = post_top_dict
+            charstrings_offset = charset_offset + charset.bytesize
+            private_offset = charstrings_offset + charstrings_index.bytesize
+
+            new_top_dict = top_dict_bytes(
+              charset_offset,
+              charstrings_offset,
+              private_dict.bytesize,
+              private_offset,
+            )
+            new_top_dict_index = index_bytes([new_top_dict])
+
+            if new_top_dict_index.bytesize == top_dict_index.bytesize
+              # Converged. Use the freshly-encoded Top DICT so the
+              # layout hash is self-consistent with the offsets.
+              top_dict_index = new_top_dict_index
+              break
+            end
+
+            top_dict_index = new_top_dict_index
+          end
+
+          {
+            name_index: name_index,
+            top_dict_index: top_dict_index,
+            string_index: string_index,
+            global_subr_index: global_subr_index,
+            charset_offset: charset_offset,
+            charstrings_offset: charstrings_offset,
+            private_offset: private_offset,
+            charset: charset,
+            charstrings_index: charstrings_index,
+            private_dict: private_dict,
+          }
+        end
+
+        # ---------- byte emission ----------
+
+        def self.assemble(layout:)
+          io = StringIO.new("".b)
+
+          io.write([1, 0, 4, 1].pack("CCCC")) # CFF header (v1.0, hdrSize=4, offSize=1)
+
+          io.write(layout[:name_index])
+          io.write(layout[:top_dict_index])
+          io.write(layout[:string_index])
+          io.write(layout[:global_subr_index])
+
+          io.write(layout[:charset])
+          io.write(layout[:charstrings_index])
+          io.write(layout[:private_dict])
+
+          io.string
+        end
+
+        # Top DICT bytes with the three standard offset operators.
+        # Operators: charset(15), CharStrings(17), Private(18).
+        # Encoding (operator 16) is implicit for OpenType fonts.
+        def self.top_dict_bytes(charset_offset, charstrings_offset,
+                                private_size, private_offset)
+          bytes = +""
+          bytes << encode_int(charset_offset) << "\x0f"     # charset
+          bytes << encode_int(charstrings_offset) << "\x11" # CharStrings
+          bytes << encode_int(private_size) << encode_int(private_offset) << "\x12" # Private
+          bytes
+        end
+
+        # Format 0 charset: 1 format byte + (n-1) SIDs.
+        # Gid 0 is implicit .notdef.
+        def self.charset_bytes(glyphs)
+          return +"" if glyphs.size <= 1
+
+          bytes = +"\x00"
+          (1...glyphs.size).each { |_| bytes << [0].pack("n") } # SID 0 placeholder
+          bytes
+        end
+
+        # ---------- INDEX helpers ----------
+
+        def self.index_bytes(items)
+          io = StringIO.new("".b)
+          if items.empty?
+            io.write([0].pack("n"))
+            return io.string
+          end
+
+          count = items.size
+          offsets = [1]
+          items.each { |item| offsets << offsets.last + item.bytesize }
+          max_offset = offsets.last
+          off_size = byte_size_for(max_offset)
+
+          io.write([count, off_size].pack("nC"))
+          offsets.each { |o| io.write(pack_offset(o, off_size)) }
+          items.each { |item| io.write(item) }
+          io.string
+        end
+
+        def self.byte_size_for(max_value)
+          return 1 if max_value <= 0xFF
+          return 2 if max_value <= 0xFFFF
+          return 3 if max_value <= 0xFFFFFF
+
+          4
+        end
+
+        def self.pack_offset(value, size)
+          case size
+          when 1 then [value].pack("C")
+          when 2 then [value].pack("n")
+          when 3
+            [(value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF].pack("CCC")
+          when 4 then [value].pack("N")
+          end
+        end
+
+        # CFF DICT integer encoding (CFF spec section 3.1).
+        def self.encode_int(value)
+          if value.between?(-107, 107)
+            [value + 139].pack("C")
+          elsif value.between?(108, 1131)
+            v = value - 108
+            [(v / 256) + 247, v % 256].pack("CC")
+          elsif value.between?(-1131, -108)
+            v = -value - 108
+            [-(v / 256) - 247, v % 256].pack("CC")
+          elsif value.between?(-32_768, 32_767)
+            [28, value].pack("Cn")
+          else
+            [29, value].pack("CN")
+          end
+        end
+
+        private_class_method :charstring_for, :empty_charstring,
+                             :compute_layout, :assemble, :top_dict_bytes,
+                             :charset_bytes, :index_bytes, :byte_size_for,
+                             :pack_offset, :encode_int
+      end
+    end
+  end
+end