fontisan 0.2.23 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f84b59fae400f9db9dd05b2ddebce11bedb865138026f7a3a6d1b7ce0b3d8f2a
-  data.tar.gz: 563b27ed9dc91412fb83d7769a72a0d618109e3a6394236c7648524a60ad4fb6
+  metadata.gz: 0fe760da43bddcfad046aef63c311613ea3767569245b21a2bda6a6d5f100a5f
+  data.tar.gz: 7571202d9bc900928ee4c3859e4081af6d561f53740587f0f94f7a159dbbbec3
 SHA512:
-  metadata.gz: 7f2d94e40b9444414113ebf842a4a84e2188199829b4caf8b9e707bea6bca89c07b5e11fa04ba2f4aff1ce7ea658004385a5e2ae2ae4b4d4094d5bb90c4d5345
-  data.tar.gz: becf5ccba115f938caeb23d29e3cc0685edc9e0cb8452f8b1ed8b7e76cc8e742adcf3f9d1f5c8b1f01c1631fcb28a4ff2305068ce6b9677ef339d8f5fb4765b9
+  metadata.gz: 66e94f6047f20385c27583a191d5c78ded6589ee8d2004386613062adb2071aba41644736c632be4087e24998ae29a7066fc17e42773a3627832c32f67d3c670
+  data.tar.gz: b9180051a16410731a112602c4ff5d18b679b6c6e521d31f092b5be2c550aceaae8992729c6bc71d7dd919b71b669217866febd26ce014528cd91eb392af1c96

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

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