fontisan 0.2.23 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f84b59fae400f9db9dd05b2ddebce11bedb865138026f7a3a6d1b7ce0b3d8f2a
-  data.tar.gz: 563b27ed9dc91412fb83d7769a72a0d618109e3a6394236c7648524a60ad4fb6
+  metadata.gz: '0979321b74749068da214fbb4880701c1f78905cce2db2aa7a8a2263da669af3'
+  data.tar.gz: 3ccbb49464b62e831475fe601fecc9b7085c6dda5a16ec66d9b9c56c14ff0742
 SHA512:
-  metadata.gz: 7f2d94e40b9444414113ebf842a4a84e2188199829b4caf8b9e707bea6bca89c07b5e11fa04ba2f4aff1ce7ea658004385a5e2ae2ae4b4d4094d5bb90c4d5345
-  data.tar.gz: becf5ccba115f938caeb23d29e3cc0685edc9e0cb8452f8b1ed8b7e76cc8e742adcf3f9d1f5c8b1f01c1631fcb28a4ff2305068ce6b9677ef339d8f5fb4765b9
+  metadata.gz: 87538383c69009f3610778a717ae6263accb950e07b8803914358927bfc1e7510c18c664d88267b17dcabbeaab4fa97d4ac72b3294ae492472d0659843dbe540
+  data.tar.gz: 459343281dd3b295141eed4c8091ccc3d9ce6228d49c293eb6a182d26676428eaf4cb571295b8f55ac4101ba88d879c7525b06f5ad1596a83ea544d2f88a8351

data/README.adoc

@@ -2376,6 +2376,106 @@ Fontisan can:
 * Importing and generation PNG block ruler layers
 
 
+== UFO source operations
+
+fontisan reads, writes, and compiles UFO (Unified Font Object) v2/v3
+font sources into binary font formats (TTF, OTF). No AFDKO or Python
+fonttools needed.
+
+=== Build a UFO to binary
+
+[source,bash]
+----
+# TTF (TrueType outlines)
+fontisan ufo build font.ufo --output out.ttf --to ttf
+
+# OTF (CFF outlines)
+fontisan ufo build font.ufo --output out.otf --to otf
+----
+
+The TTF compiler automatically applies:
+- `cubic_to_quadratic` filter (UFO cubic Beziers -> TTF quadratic)
+- `reverse_contour_direction` filter (TTF winding convention)
+
+=== Convert between UFO and binary
+
+[source,bash]
+----
+# UFO -> binary
+fontisan ufo convert font.ufo out.ttf --to ttf
+
+# Binary -> UFO (reverse direction)
+fontisan ufo convert font.ttf font.ufo/
+----
+
+=== Validate a UFO source
+
+[source,bash]
+----
+fontisan ufo validate font.ufo
+----
+
+Checks: glyphs present, family name set, unitsPerEm set, .notdef exists.
+
+=== Ruby API
+
+[source,ruby]
+----
+require "fontisan"
+
+# Read a UFO
+font = Fontisan::Ufo::Font.open("font.ufo")
+puts font.family_name
+puts font.glyphs.size
+
+# Compile to TTF
+Fontisan::Ufo::Compile::TtfCompiler.new(font).compile(output_path: "out.ttf")
+
+# Compile to OTF
+Fontisan::Ufo::Compile::OtfCompiler.new(font).compile(output_path: "out.otf")
+
+# Write back to UFO (round-trip)
+Fontisan::Ufo::Writer.new(font).write("out.ufo")
+
+# Convert a binary font to UFO
+ttf = Fontisan::FontLoader.load("font.ttf")
+ufo = Fontisan::Ufo::Convert::FromBinData.convert(ttf)
+----
+
+== Font stitching
+
+The Stitcher combines glyphs from multiple source fonts into one new
+font. Sources can be UFO directories or loaded TTF/OTF files.
+
+=== Ruby API
+
+[source,ruby]
+----
+stitcher = Fontisan::Stitcher.new
+stitcher.add_source(:latin, Fontisan::FontLoader.load("NotoSans.ttf"))
+stitcher.add_source(:cjk, Fontisan::FontLoader.load("FSung-m.ttf"))
+
+stitcher.include_range(0x41..0x5A, from: :latin)    # A-Z
+stitcher.include_range(0x4E00..0x9FFF, from: :cjk)  # CJK Unified
+stitcher.include_notdef(from: :latin)
+
+stitcher.write_to("stitched.ttf", format: :ttf)
+----
+
+=== CLI
+
+[source,bash]
+----
+fontisan stitch \
+  --source latin=NotoSans.ttf \
+  --source cjk=FSung-m.ttf \
+  --include-range latin=0x41-0x5A \
+  --include-range cjk=0x4E00-0x9FFF \
+  --notdef-from latin \
+  --output stitched.ttf
+----
+
+
 == Testing
 
 === General

data/lib/fontisan/cli.rb

@@ -28,6 +28,12 @@ module Fontisan
     desc "cldr", "Manage local CLDR cache (subcommands)", hide: true
     subcommand "cldr", CldrCli
 
+    desc "ufo", "UFO source operations (build, convert, validate)"
+    subcommand "ufo", Fontisan::Ufo::Cli
+
+    desc "stitch", "Stitch glyphs from multiple source fonts into one output"
+    subcommand "stitch", StitcherCli
+
     desc "info PATH", "Display font information"
     option :brief, type: :boolean, default: false,
                    desc: "Brief mode - only essential info (5x faster, uses metadata loading)",

data/lib/fontisan/stitcher/selector/codepoints.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module Selector
+      # Include an explicit list of codepoints.
+      class Codepoints
+        attr_reader :codepoints
+
+        def initialize(codepoints)
+          @codepoints = codepoints
+        end
+
+        def apply(source, bindings)
+          @codepoints.each do |cp|
+            gid = source.gid_for_codepoint(cp)
+            next unless gid
+
+            bindings << {
+              codepoint: cp,
+              source: source,
+              donor_gid: gid,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/selector/gid.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module Selector
+      # Include a single glyph by its donor gid. Used for unencoded
+      # glyphs (.notdef, spaces, format-specific specials).
+      class Gid
+        attr_reader :gid
+
+        def initialize(gid)
+          @gid = gid
+        end
+
+        def apply(source, bindings)
+          bindings << {
+            codepoint: nil,
+            source: source,
+            donor_gid: @gid,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/selector/range.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module Selector
+      # Include every codepoint in a Range (e.g. 0x41..0x5A = A-Z).
+      # Glyphs missing from the source are silently skipped.
+      class Range
+        attr_reader :range
+
+        def initialize(range)
+          @range = range
+        end
+
+        def apply(source, bindings)
+          @range.each do |cp|
+            gid = source.gid_for_codepoint(cp)
+            next unless gid
+
+            bindings << {
+              codepoint: cp,
+              source: source,
+              donor_gid: gid,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/selector.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Selectors decide which glyphs from a source to include in the
+    # stitched font. Each selector appends to the Stitcher's bindings
+    # list. OCP: adding a new way to select = adding a new Selector
+    # class + a registry entry.
+    module Selector
+      autoload :Range,      "fontisan/stitcher/selector/range"
+      autoload :Codepoints, "fontisan/stitcher/selector/codepoints"
+      autoload :Gid,        "fontisan/stitcher/selector/gid"
+
+      REGISTRY = {
+        range: Range,
+        codepoints: Codepoints,
+        gid: Gid,
+      }.freeze
+
+      def self.resolve(name)
+        REGISTRY[name.to_sym] or
+          raise ArgumentError, "unknown selector: #{name.inspect}"
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/source.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Wraps a source font (UFO or loaded TTF/OTF) behind a single
+    # extraction API used by the selectors.
+    #
+    # For UFO sources, glyphs are accessed by name directly. For TTF
+    # or OTF sources, the source is lazily converted to a UFO::Font
+    # via Ufo::Convert::FromBinData on first glyph access, then cached.
+    # This is O(n) in donor glyph count but amortized across all
+    # codepoint extractions from that donor.
+    class Source
+      attr_reader :font
+
+      def initialize(font)
+        @font = font
+        @ufo_cache = nil
+      end
+
+      # @return [Symbol] :ufo, :ttf, :otf
+      def format
+        case @font
+        when Fontisan::Ufo::Font then :ufo
+        when Fontisan::TrueTypeFont then :ttf
+        when Fontisan::OpenTypeFont then :otf
+        else :unknown
+        end
+      end
+
+      # Find the gid for a Unicode codepoint in this source.
+      # @param codepoint [Integer]
+      # @return [Integer, nil]
+      def gid_for_codepoint(codepoint)
+        case @font
+        when Fontisan::Ufo::Font then ufo_gid_for(codepoint)
+        else bin_data_gid_for(codepoint)
+        end
+      end
+
+      # Extract a glyph by gid.
+      # @param gid [Integer]
+      # @return [Fontisan::Ufo::Glyph, nil]
+      def glyph_for_gid(gid)
+        case @font
+        when Fontisan::Ufo::Font then ufo_glyph_at(gid)
+        else converted_ufo_glyph_at(gid)
+        end
+      end
+
+      private
+
+      # ---------- UFO source ----------
+
+      def ufo_gid_for(codepoint)
+        @font.glyphs.each_with_index do |(_name, glyph), index|
+          return index if glyph.unicodes.include?(codepoint)
+        end
+        nil
+      end
+
+      def ufo_glyph_at(gid)
+        names = @font.glyphs.keys
+        name = names[gid]
+        return nil unless name
+
+        @font.glyph(name)
+      end
+
+      # ---------- TTF/OTF source ----------
+
+      def bin_data_gid_for(codepoint)
+        cmap = @font.table("cmap")
+        return nil unless cmap
+
+        cmap.unicode_mappings[codepoint]
+      end
+
+      # Lazily convert the loaded TTF/OTF to a UFO::Font, then
+      # extract glyphs from the cached UFO model.
+      def converted_ufo
+        return @ufo_cache if @ufo_cache
+
+        @ufo_cache = Fontisan::Ufo::Convert::FromBinData.convert(@font)
+      end
+
+      def converted_ufo_glyph_at(gid)
+        ufo = converted_ufo
+        names = ufo.glyphs.keys
+        name = names[gid]
+        return nil unless name
+
+        ufo.glyph(name)
+      end
+    end
+  end
+end

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