fontisan 0.2.23 → 0.3.0

data/lib/fontisan/ufo/plist.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Fontisan
+  module Ufo
+    # Minimal XML plist parser/serializer for the files that UFO v3
+    # uses. UFO uses XML plists exclusively; binary plists are not
+    # used in the spec.
+    #
+    # The parser is typed at the value level: strings stay as String,
+    # integers stay as Integer, booleans become true/false, dicts
+    # become Hash<String, Object>, arrays become Array<Object>.
+    # Dates, data blobs, and nested structures are supported.
+    module Plist
+      class ParseError < StandardError; end
+
+      PLIST_DTD = "-//Apple//DTD PLIST 1.0//EN"
+      PLIST_NS  = "http://www.apple.com/DTDs/PropertyList-1.0.dtd"
+
+      # @param source [String, Nokogiri::XML::Document] the XML plist
+      # @return [Object] the deserialized value
+      def self.parse(source)
+        doc = source.is_a?(Nokogiri::XML::Document) ? source : Nokogiri::XML(source)
+        root = doc.root
+        raise ParseError, "no <plist> root element" unless root&.name == "plist"
+
+        parse_value(root.children.find { |c| c.element? || c.cdata? || c.text? && !c.text.strip.empty? })
+      end
+
+      # @param value [Object] the value to serialize
+      # @return [String] the XML plist text
+      def self.emit(value)
+        builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          create_doc_internal_subset(xml)
+          xml.plist(version: "1.0") do
+            emit_value(xml, value)
+          end
+        end
+        builder.to_xml(
+          save_with:
+            Nokogiri::XML::Node::SaveOptions::AS_XML |
+            Nokogiri::XML::Node::SaveOptions::NO_DECLARATION,
+        )
+      end
+
+      # @return [Nokogiri::XML::Document] the typed root
+      def self.parse_document(source)
+        source.is_a?(Nokogiri::XML::Document) ? source : Nokogiri::XML(source)
+      end
+
+      # ---------- private-ish (called via module_function) ----------
+
+      def self.parse_value(node)
+        return nil if node.nil?
+
+        case node.name
+        when "string" then node.text
+        when "integer" then node.text.to_i
+        when "real" then node.text.to_f
+        when "true" then true
+        when "false" then false
+        when "dict" then parse_dict(node)
+        when "array" then parse_array(node)
+        else
+          raise ParseError, "unsupported plist element: <#{node.name}>"
+        end
+      end
+
+      def self.parse_dict(node)
+        result = {}
+        children = node.element_children.to_a
+        # dict children are key/value pairs (key first, then value)
+        while children.any?
+          key_node = children.shift
+          raise ParseError, "dict key is not <key>" unless key_node.name == "key"
+
+          value_node = children.shift
+          result[key_node.text] = parse_value(value_node)
+        end
+        result
+      end
+
+      def self.parse_array(node)
+        node.element_children.map { |child| parse_value(child) }
+      end
+
+      def self.create_doc_internal_subset(xml)
+        xml.doc.create_internal_subset("plist", PLIST_DTD, PLIST_NS)
+      end
+
+      def self.emit_value(xml, value)
+        case value
+        when nil
+          # No <nil/> in Apple's plist DTD; use a sentinel string.
+          xml.string("")
+        when true then xml.__send__(true)
+        when false then xml.__send__(false)
+        when Integer then xml.integer(value)
+        when Float then xml.real(value)
+        when String then xml.string(value)
+        when Symbol then xml.string(value.to_s)
+        when Array then xml.array { value.each { |v| emit_value(xml, v) } }
+        when Hash  then xml.dict { emit_dict_body(xml, value) }
+        else
+          raise ArgumentError, "cannot plist-encode #{value.class}"
+        end
+      end
+
+      def self.emit_dict_body(xml, hash)
+        hash.each do |k, v|
+          xml.key(k.to_s)
+          emit_value(xml, v)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/point.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # A single outline point. UFO's `point` element has:
+    #   - x, y          (Float, font units)
+    #   - type          (one of "move", "line", "offcurve", "curve", "qcurve")
+    #   - smooth        (Bool, optional)
+    #
+    # "offcurve" is the UFO 1/2 name; UFO 3 uses "qcurve". Both are
+    # accepted on read.
+    class Point
+      attr_reader :x, :y, :type, :smooth
+
+      def initialize(x:, y:, type:, smooth: false)
+        @x = x
+        @y = y
+        @type = type.to_s
+        @smooth = smooth
+      end
+
+      def on_curve?
+        @type == "line" || @type == "move" || @type == "curve"
+      end
+
+      def off_curve?
+        @type == "offcurve" || @type == "qcurve"
+      end
+
+      # @return [Hash] suitable for `to_glif` output
+      def to_h
+        h = { x: @x, y: @y, type: @type }
+        h[:smooth] = true if @smooth
+        h
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/reader.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Reads a UFO source directory into a typed Fontisan::Ufo::Font.
+    #
+    # Reads, in order:
+    #   - `metainfo.plist`        (UFO version stamp; informational)
+    #   - `fontinfo.plist`         (Info)
+    #   - `layercontents.plist`    (layer ordering; optional in UFO 3)
+    #   - `glyphs/contents.plist`  (default-layer glyph order)
+    #   - `glyphs/<layer>/<name>.glif`  (per-glyph XML)
+    #   - `kerning.plist`          (Kerning)
+    #   - `features.fea`           (Features)
+    #   - `lib.plist`              (Lib)
+    #
+    # Phase 1 reads `fontinfo.plist` + `glyphs/contents.plist` +
+    # minimal `.glif` (name, advance, unicodes). Full `.glif`
+    # decoding (contours, components, anchors) lands when the
+    # compiler layer is built.
+    class Reader
+      attr_reader :font
+
+      def initialize(font)
+        @font = font
+      end
+
+      # @return [Fontisan::Ufo::Font]
+      def read
+        read_metainfo
+        read_fontinfo
+        read_layercontents
+        read_glyphs_contents
+        read_kerning
+        read_features
+        read_lib
+        @font
+      end
+
+      private
+
+      def read_metainfo
+        path = join(@font.path, "metainfo.plist")
+        return unless File.exist?(path)
+
+        data = Plist.parse(File.read(path))
+        @font.ufo_version = data["formatVersion"]
+      end
+
+      def read_fontinfo
+        path = join(@font.path, "fontinfo.plist")
+        return unless File.exist?(path)
+
+        data = Plist.parse(File.read(path))
+        @font.info = Info.new(data)
+      end
+
+      def read_layercontents
+        # layercontents.plist is optional in UFO 3; default layer is
+        # always present via LayerSet#initialize.
+        path = join(@font.path, "layercontents.plist")
+        return unless File.exist?(path)
+
+        order = Plist.parse(File.read(path))
+        order.each do |layer_name|
+          @font.layers.add(layer_name)
+        end
+      end
+
+      def read_glyphs_contents
+        # Each layer's glyphs may live under `glyphs/<layer_name>/` (UFO 3)
+        # or directly under `glyphs/` (UFO 2, single-layer case).
+        # The latter applies when `glyphs/<layer_name>/` does not exist
+        # but `glyphs/contents.plist` does.
+        @font.layers.each do |layer|
+          subdir = join(@font.path, "glyphs", layer.name)
+          contents_path = if Dir.exist?(subdir)
+                            join(subdir, "contents.plist")
+                          else
+                            join(@font.path, "glyphs", "contents.plist")
+                          end
+          next unless File.exist?(contents_path)
+
+          order = Plist.parse(File.read(contents_path))
+
+          # UFO 2 contents.plist is Hash<glyph_name, glif_filename>.
+          # UFO 3 contents.plist can be Array<glif_filename> or
+          # Array<Hash<glif_filename, glyph_name>>. Normalize to
+          # Hash<glyph_name, glif_filename>.
+          entries =
+            case order
+            when Hash then order
+            when Array
+              if order.first.is_a?(Hash)
+                order.reduce({}) { |h, pair| h.merge(pair) }
+              else
+                order.to_h { |filename| [File.basename(filename, ".glif"), filename] }
+              end
+            else
+              raise "unsupported contents.plist format: #{order.class}"
+            end
+
+          entries.each_value do |glif_filename|
+            glif_path = if Dir.exist?(subdir)
+                          join(subdir, glif_filename)
+                        else
+                          join(@font.path, "glyphs", glif_filename)
+                        end
+            next unless File.exist?(glif_path)
+
+            layer.add(Glyph.from_glif(File.read(glif_path)))
+          end
+        end
+      end
+
+      def read_kerning
+        path = join(@font.path, "kerning.plist")
+        return unless File.exist?(path)
+
+        data = Plist.parse(File.read(path))
+        @font.kerning = Kerning.new(data)
+      end
+
+      def read_features
+        path = join(@font.path, "features.fea")
+        return unless File.exist?(path)
+
+        @font.features = Features.new(text: File.read(path))
+      end
+
+      def read_lib
+        path = join(@font.path, "lib.plist")
+        return unless File.exist?(path)
+
+        data = Plist.parse(File.read(path))
+        @font.lib = Lib.new(data)
+      end
+
+      def join(*parts)
+        File.join(*parts)
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/transformation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # 2×3 transformation matrix, as used in UFO 3 for component and
+    # image placement. The matrix is laid out in the standard affine
+    # row-major order: `[a b c d e f]` represents
+    #
+    #     | a c e |
+    #     | b d f |
+    #     | 0 0 1 |
+    #
+    # (UFO and OpenType both use the row-major convention despite the
+    # geometrically column-major appearance — this is how the
+    # `transformation` element reads in .glif XML.)
+    class Transformation
+      IDENTITY_MATRIX = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0].freeze
+
+      attr_reader :a, :b, :c, :d, :e, :f
+
+      def initialize(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 0.0, f: 0.0)
+        @a = a.to_f
+        @b = b.to_f
+        @c = c.to_f
+        @d = d.to_f
+        @e = e.to_f
+        @f = f.to_f
+      end
+
+      def identity?
+        [a, b, c, d, e, f] == IDENTITY_MATRIX
+      end
+
+      def to_a
+        [a, b, c, d, e, f]
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/writer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Writes a UFO source directory from a typed Fontisan::Ufo::Font.
+    #
+    # Mirror of Reader. Writes, in order:
+    #   - `metainfo.plist`        (UFO version stamp)
+    #   - `fontinfo.plist`         (Info)
+    #   - `layercontents.plist`    (UFO 3 only; layer ordering)
+    #   - `glyphs/contents.plist`  (default-layer glyph order)
+    #   - `glyphs/<name>.glif`     (per-glyph XML)
+    #   - `glyphs/<layer>/...`     (additional layers)
+    #   - `kerning.plist`
+    #   - `features.fea`
+    #   - `lib.plist`
+    class Writer
+      UFO_VERSION_DEFAULT = 3
+
+      attr_reader :font
+
+      def initialize(font)
+        @font = font
+      end
+
+      # @param path [String] directory to write into; created if missing
+      # @param ufo_version [Integer] 2 or 3 (default 3)
+      def write(path, ufo_version: nil)
+        @ufo_version = ufo_version || @font.ufo_version || UFO_VERSION_DEFAULT
+
+        FileUtils.mkpath(path)
+        write_metainfo(path)
+        write_fontinfo(path)
+        write_layercontents(path)
+        write_glyphs(path)
+        write_kerning(path)
+        write_features(path)
+        write_lib(path)
+        path
+      end
+
+      private
+
+      def write_metainfo(path)
+        data = {
+          "creator" => "org.fontisan.ufo",
+          "formatVersion" => @ufo_version.to_i,
+        }
+        File.write(File.join(path, "metainfo.plist"), Plist.emit(data))
+      end
+
+      def write_fontinfo(path)
+        File.write(File.join(path, "fontinfo.plist"), Plist.emit(@font.info.to_plist))
+      end
+
+      def write_layercontents(path)
+        return unless @ufo_version >= 3
+        return if @font.layers.size <= 1
+
+        order = @font.layers.layers.keys
+        File.write(File.join(path, "layercontents.plist"), Plist.emit(order))
+      end
+
+      def write_glyphs(path)
+        # Default layer writes glyphs/contents.plist + glyphs/*.glif.
+        # Additional layers write glyphs/<layer>/contents.plist + .glif.
+        @font.layers.each do |layer|
+          layer_dir = if layer.name == Layer::DEFAULT_NAME && @ufo_version < 3
+                        File.join(path, "glyphs")
+                      elsif layer.name == Layer::DEFAULT_NAME
+                        File.join(path, "glyphs")
+                      else
+                        File.join(path, "glyphs", layer.name)
+                      end
+          FileUtils.mkpath(layer_dir)
+
+          contents =
+            layer.glyphs.transform_values { |g| "#{safe_filename(g.name)}.glif" }
+          File.write(File.join(layer_dir, "contents.plist"), Plist.emit(contents))
+
+          layer.glyphs.each_value do |glyph|
+            File.write(File.join(layer_dir, "#{safe_filename(glyph.name)}.glif"), glyph.to_glif)
+          end
+        end
+      end
+
+      # Map a glyph name to a filesystem-safe filename. UFO conventions
+      # use a base-prefixed name for names starting with non-letter.
+      def safe_filename(name)
+        return "_#{name}" if name.start_with?(".")
+        return "_#{name}" unless name.match?(/\A[A-Za-z_]/)
+
+        name
+      end
+
+      def write_kerning(path)
+        return if @font.kerning.empty?
+
+        File.write(File.join(path, "kerning.plist"), Plist.emit(@font.kerning.to_plist))
+      end
+
+      def write_features(path)
+        return if @font.features.text.nil? || @font.features.text.empty?
+
+        File.write(File.join(path, "features.fea"), @font.features.text)
+      end
+
+      def write_lib(path)
+        return if @font.lib.data.empty?
+
+        File.write(File.join(path, "lib.plist"), Plist.emit(@font.lib.data))
+      end
+    end
+  end
+end

data/lib/fontisan/ufo.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Unified Font Object (UFO) v3 model + compile + convert pipeline.
+  #
+  # A UFO is a directory-based font source format. Each UFO is a
+  # human-readable, human-editable collection of plists + GLIF XML
+  # files. fontisan can:
+  #
+  #   - Read any UFO source into a typed model (this namespace).
+  #   - Edit the model programmatically.
+  #   - Compile to a binary font (TTF, OTF, …) via
+  #     Fontisan::Ufo::Compile::*
+  #   - Convert any binary font fontisan can read INTO a UFO source.
+  #   - Stitch glyphs from multiple sources into a new font via
+  #     Fontisan::Stitcher.
+  #
+  # Reference: https://unifiedfontobject.org
+  module Ufo
+    autoload :Font,        "fontisan/ufo/font"
+    autoload :Info,        "fontisan/ufo/info"
+    autoload :Layer,       "fontisan/ufo/layer"
+    autoload :LayerSet,    "fontisan/ufo/layer_set"
+    autoload :Glyph,       "fontisan/ufo/glyph"
+    autoload :Contour,     "fontisan/ufo/contour"
+    autoload :Point,       "fontisan/ufo/point"
+    autoload :Component,   "fontisan/ufo/component"
+    autoload :Anchor,      "fontisan/ufo/anchor"
+    autoload :Guideline,   "fontisan/ufo/guideline"
+    autoload :Image,       "fontisan/ufo/image"
+    autoload :Transformation, "fontisan/ufo/transformation"
+    autoload :Kerning,     "fontisan/ufo/kerning"
+    autoload :Features,    "fontisan/ufo/features"
+    autoload :Lib,         "fontisan/ufo/lib"
+    autoload :DataSet,     "fontisan/ufo/data_set"
+    autoload :ImageSet,    "fontisan/ufo/image_set"
+    autoload :Plist,       "fontisan/ufo/plist"
+    autoload :Reader,      "fontisan/ufo/reader"
+    autoload :Writer,      "fontisan/ufo/writer"
+    autoload :Compile,     "fontisan/ufo/compile"
+    autoload :Convert,     "fontisan/ufo/convert"
+    autoload :Cli,         "fontisan/ufo/cli"
+  end
+end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.23"
+  VERSION = "0.3.0"
 end

data/lib/fontisan.rb

@@ -88,6 +88,7 @@ module Fontisan
   autoload :Svg, "fontisan/svg"
   autoload :Tables, "fontisan/tables"
   autoload :Type1, "fontisan/type1"
+  autoload :Ufo, "fontisan/ufo"
   autoload :Utilities, "fontisan/utilities"
   autoload :Utils, "fontisan/utils"
   autoload :Validation, "fontisan/validation"
@@ -110,6 +111,8 @@ module Fontisan
   autoload :OutlineExtractor, "fontisan/outline_extractor"
   autoload :SfntFont, "fontisan/sfnt_font"
   autoload :SfntTable, "fontisan/sfnt_table"
+  autoload :Stitcher, "fontisan/stitcher"
+  autoload :StitcherCli, "fontisan/stitcher_cli"
   autoload :TrueTypeCollection, "fontisan/true_type_collection"
   autoload :TrueTypeFont, "fontisan/true_type_font"
   autoload :TrueTypeFontExtensions, "fontisan/true_type_font_extensions"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -435,6 +435,13 @@ files:
 - lib/fontisan/pipeline/variation_resolver.rb
 - lib/fontisan/sfnt_font.rb
 - lib/fontisan/sfnt_table.rb
+- lib/fontisan/stitcher.rb
+- lib/fontisan/stitcher/selector.rb
+- lib/fontisan/stitcher/selector/codepoints.rb
+- lib/fontisan/stitcher/selector/gid.rb
+- lib/fontisan/stitcher/selector/range.rb
+- lib/fontisan/stitcher/source.rb
+- lib/fontisan/stitcher_cli.rb
 - lib/fontisan/subset.rb
 - lib/fontisan/subset/builder.rb
 - lib/fontisan/subset/glyph_mapping.rb
@@ -544,6 +551,49 @@ files:
 - lib/fontisan/type1/ttf_to_type1_converter.rb
 - lib/fontisan/type1/upm_scaler.rb
 - lib/fontisan/type1_font.rb
+- lib/fontisan/ufo.rb
+- lib/fontisan/ufo/anchor.rb
+- lib/fontisan/ufo/cli.rb
+- lib/fontisan/ufo/compile.rb
+- lib/fontisan/ufo/compile/base_compiler.rb
+- lib/fontisan/ufo/compile/cff.rb
+- lib/fontisan/ufo/compile/cmap.rb
+- lib/fontisan/ufo/compile/filters.rb
+- lib/fontisan/ufo/compile/filters/cubic_to_quadratic.rb
+- lib/fontisan/ufo/compile/filters/decompose_components.rb
+- lib/fontisan/ufo/compile/filters/flatten_components.rb
+- lib/fontisan/ufo/compile/filters/reverse_contour_direction.rb
+- lib/fontisan/ufo/compile/glyf_loca.rb
+- lib/fontisan/ufo/compile/head.rb
+- lib/fontisan/ufo/compile/hhea.rb
+- lib/fontisan/ufo/compile/hmtx.rb
+- lib/fontisan/ufo/compile/maxp.rb
+- lib/fontisan/ufo/compile/name.rb
+- lib/fontisan/ufo/compile/os2.rb
+- lib/fontisan/ufo/compile/otf_compiler.rb
+- lib/fontisan/ufo/compile/post.rb
+- lib/fontisan/ufo/compile/ttf_compiler.rb
+- lib/fontisan/ufo/component.rb
+- lib/fontisan/ufo/contour.rb
+- lib/fontisan/ufo/convert.rb
+- lib/fontisan/ufo/convert/from_bin_data.rb
+- lib/fontisan/ufo/data_set.rb
+- lib/fontisan/ufo/features.rb
+- lib/fontisan/ufo/font.rb
+- lib/fontisan/ufo/glyph.rb
+- lib/fontisan/ufo/guideline.rb
+- lib/fontisan/ufo/image.rb
+- lib/fontisan/ufo/image_set.rb
+- lib/fontisan/ufo/info.rb
+- lib/fontisan/ufo/kerning.rb
+- lib/fontisan/ufo/layer.rb
+- lib/fontisan/ufo/layer_set.rb
+- lib/fontisan/ufo/lib.rb
+- lib/fontisan/ufo/plist.rb
+- lib/fontisan/ufo/point.rb
+- lib/fontisan/ufo/reader.rb
+- lib/fontisan/ufo/transformation.rb
+- lib/fontisan/ufo/writer.rb
 - lib/fontisan/utilities.rb
 - lib/fontisan/utilities/brotli_wrapper.rb
 - lib/fontisan/utilities/checksum_calculator.rb