fontisan 0.4.10 → 0.4.12

data/lib/fontisan/ufo/compile/filters/transformations.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Applies a 2×3 affine transformation to every glyph's
+        # contours + components. The general-purpose filter — other
+        # filters (decompose_components, propagate_anchors) are
+        # special cases of geometric transforms applied to specific
+        # glyph subsets.
+        #
+        # Used for:
+        #   - Symmetric mirroring (e.g. italic→upright flip).
+        #   - Slant adjustment.
+        #   - Custom per-font offsets that callers want baked in at
+        #     compile time rather than carried as variation axis deltas.
+        #
+        # Identity matrix is a no-op fast path.
+        module Transformations
+          DEFAULT_OFFSET_X = 0.0
+          DEFAULT_OFFSET_Y = 0.0
+
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @param matrix [Fontisan::Ufo::Transformation, Array<Numeric>, nil]
+          #   The affine matrix to apply. Accepts either a
+          #   +Transformation+ value object or the raw +[a, b, c, d, e, f]+
+          #   array. +nil+ (the default) is a no-op — leaves glyphs
+          #   unchanged.
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array (mutated)
+          def self.run(glyphs, matrix: nil, **_opts)
+            return glyphs if matrix.nil?
+
+            transform = coerce_transformation(matrix)
+            return glyphs if transform.identity?
+
+            glyphs.each { |g| apply_to_glyph(g, transform) }
+            glyphs
+          end
+
+          class << self
+            private
+
+            # Coerce the matrix argument into a Transformation.
+            # Centralizes the "array, object, or nil?" decision so
+            # callers can pass any form.
+            def coerce_transformation(matrix)
+              return Fontisan::Ufo::Transformation.new if matrix.nil?
+              return matrix if matrix.is_a?(Fontisan::Ufo::Transformation)
+
+              Fontisan::Ufo::Transformation.new(
+                a: matrix[0], b: matrix[1],
+                c: matrix[2], d: matrix[3],
+                e: matrix[4], f: matrix[5]
+              )
+            end
+
+            # Apply the transform in place: each contour's points are
+            # rewritten with transformed coordinates; each component's
+            # +transformation+ is composed with the new one (so nested
+            # component refs chain correctly).
+            def apply_to_glyph(glyph, transform)
+              glyph.contours.each do |contour|
+                contour.points = contour.points.map do |pt|
+                  tx, ty = transform.apply(pt.x, pt.y)
+                  Fontisan::Ufo::Point.new(
+                    x: tx, y: ty,
+                    type: pt.type, smooth: pt.smooth
+                  )
+                end
+              end
+
+              glyph.components.map! do |component|
+                Fontisan::Ufo::Component.new(
+                  base_glyph: component.base_glyph,
+                  # Composition order: outer transform ∘ existing.
+                  # For a base-glyph point P, the component places it
+                  # at T_existing(P) in this glyph; the outer transform
+                  # then maps that to T_outer(T_existing(P)). So the
+                  # new component transformation is T_outer ∘ T_existing.
+                  transformation: compose(transform, component.transformation),
+                  identifier: component.identifier,
+                )
+              end
+            end
+
+            # Compose two affine transformations: result = outer ∘ inner
+            #   | outer.a outer.c outer.e |   | inner.a inner.c inner.e |
+            #   | outer.b outer.d outer.f | × | inner.b inner.d inner.f |
+            #   |   0        0        1   |   |   0        0        1   |
+            #
+            # Each input can be a Transformation, a 6-array, or nil
+            # (treated as identity — the default Component state).
+            # The result is always a Transformation.
+            def compose(outer, inner)
+              outer_t = coerce_transformation(outer)
+              inner_t = coerce_transformation(inner)
+
+              Fontisan::Ufo::Transformation.new(
+                a: outer_t.a * inner_t.a + outer_t.c * inner_t.b,
+                b: outer_t.b * inner_t.a + outer_t.d * inner_t.b,
+                c: outer_t.a * inner_t.c + outer_t.c * inner_t.d,
+                d: outer_t.b * inner_t.c + outer_t.d * inner_t.d,
+                e: outer_t.a * inner_t.e + outer_t.c * inner_t.f + outer_t.e,
+                f: outer_t.b * inner_t.e + outer_t.d * inner_t.f + outer_t.f,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,6 +20,14 @@ module Fontisan
                  "fontisan/ufo/compile/filters/decompose_components"
         autoload :FlattenComponents,
                  "fontisan/ufo/compile/filters/flatten_components"
+        autoload :Transformations,
+                 "fontisan/ufo/compile/filters/transformations"
+        autoload :SortContours,
+                 "fontisan/ufo/compile/filters/sort_contours"
+        autoload :PropagateAnchors,
+                 "fontisan/ufo/compile/filters/propagate_anchors"
+        autoload :RemoveOverlaps,
+                 "fontisan/ufo/compile/filters/remove_overlaps"
 
         # Filters that MUST run for TTF output (TrueType only
         # supports quadratic curves + clockwise outer winding).
@@ -38,6 +46,10 @@ module Fontisan
           cubic_to_quadratic: CubicToQuadratic,
           decompose_components: DecomposeComponents,
           flatten_components: FlattenComponents,
+          transformations: Transformations,
+          sort_contours: SortContours,
+          propagate_anchors: PropagateAnchors,
+          remove_overlaps: RemoveOverlaps,
         }.freeze
 
         # @param names [Array<Symbol>] filter names from REGISTRY

data/lib/fontisan/ufo/compile.rb

@@ -33,6 +33,7 @@ module Fontisan
       autoload :TtfCompiler,  "fontisan/ufo/compile/ttf_compiler"
       autoload :OtfCompiler,  "fontisan/ufo/compile/otf_compiler"
       autoload :Filters,      "fontisan/ufo/compile/filters"
+      autoload :FeatureWriters, "fontisan/ufo/compile/feature_writers"
       autoload :Fvar,         "fontisan/ufo/compile/fvar"
       autoload :Gpos,         "fontisan/ufo/compile/gpos"
       autoload :Gvar,         "fontisan/ufo/compile/gvar"

data/lib/fontisan/ufo/convert/to_dfont.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # UFO → dfont (Mac OS resource-fork font container). Two-step:
+      #
+      #   1. Compile UFO → TTF/OTF in tmpdir.
+      #   2. Load + feed to Collection::DfontBuilder, which wraps the
+      #      SFNT binary in a Mac resource fork.
+      module ToDfont
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @param compiler [Symbol] :ttf (default) or :otf
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, compiler: :ttf, **_opts)
+          compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
+          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate#{ext_for(compiler)}")
+            compiler_class.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            result = Fontisan::Collection::DfontBuilder.new([loaded]).build
+            File.binwrite(output_path, result[:binary])
+          end
+
+          output_path
+        end
+
+        def self.ext_for(compiler)
+          %i[otf otf2].include?(compiler) ? ".otf" : ".ttf"
+        end
+        private_class_method :ext_for
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_otc.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # UFO → OpenType Collection (.otc). Two-step:
+      #
+      #   1. Compile UFO → OTF (CFF) in tmpdir.
+      #   2. Load + feed to Collection::Builder with format: :otc.
+      #
+      # A single UFO produces a single-face collection.
+      module ToOtc
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @param compiler [Symbol] :otf (default, CFF1) or :otf2 (CFF2)
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, compiler: :otf, **_opts)
+          compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
+          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate.otf")
+            compiler_class.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            Fontisan::Collection::Builder.new([loaded], format: :otc,
+                                                        optimize: true).build_to_file(output_path)
+          end
+
+          output_path
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_otf.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Convert
+      # Thin facade over Compile::OtfCompiler (CFF1 outlines).
+      module ToOtf
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:)
+          Compile::OtfCompiler.new(ufo).compile(output_path: output_path)
+          output_path
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_otf2.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Convert
+      # Thin facade over Compile::Otf2Compiler (CFF2 outlines, used
+      # for variable OTF). CFF2 still inherits the 65,535-glyph cap
+      # because maxp.numGlyphs is uint16 — see Stitcher::GlyphLimit.
+      module ToOtf2
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:)
+          Compile::Otf2Compiler.new(ufo).compile(output_path: output_path)
+          output_path
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_postscript.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # Shared logic for UFO → PostScript Type 1 (PFB or PFA).
+      # Used by ToPfb and ToPfa below; not registered in
+      # WRAPPER_FOR_FORMAT directly. Callers should use the
+      # format-specific modules.
+      module ToPostscript
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @param compiler [Symbol] :ttf (default) or :otf
+        # @param generator_class [Class] Type1::PFBGenerator or Type1::PFAGenerator
+        # @param ps_options [Hash] forwarded to the generator
+        #   (encoding, upm_scale, convert_curves)
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, generator_class:, compiler: :ttf, **ps_options)
+          compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
+          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate#{ext_for(compiler)}")
+            compiler_class.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            bytes = generator_class.generate(loaded, ps_options)
+            File.binwrite(output_path, bytes)
+          end
+
+          output_path
+        end
+
+        def self.ext_for(compiler)
+          %i[otf otf2].include?(compiler) ? ".otf" : ".ttf"
+        end
+        private_class_method :ext_for
+      end
+
+      # UFO → PostScript Type 1 Binary (.pfb).
+      module ToPfb
+        def self.convert(ufo, output_path:, **)
+          ToPostscript.convert(ufo, output_path: output_path,
+                                    generator_class: Fontisan::Type1::PFBGenerator, **)
+        end
+      end
+
+      # UFO → PostScript Type 1 ASCII (.pfa).
+      module ToPfa
+        def self.convert(ufo, output_path:, **)
+          ToPostscript.convert(ufo, output_path: output_path,
+                                    generator_class: Fontisan::Type1::PFAGenerator, **)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_ttc.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # UFO → TrueType Collection (.ttc). Two-step:
+      #
+      #   1. Compile UFO → TTF in tmpdir.
+      #   2. Load + feed to Collection::Builder with format: :ttc.
+      #
+      # A single UFO produces a single-face collection. Multi-face
+      # collections from multiple UFOs are a separate concern (the
+      # Stitcher pipeline handles that case).
+      module ToTtc
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, **_opts)
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate.ttf")
+            Compile::TtfCompiler.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            Fontisan::Collection::Builder.new([loaded], format: :ttc,
+                                                        optimize: true).build_to_file(output_path)
+          end
+
+          output_path
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_ttf.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Convert
+      # Thin facade over Compile::TtfCompiler. Exists so callers
+      # have a uniform +Ufo::Convert::To{Format}.convert+ API across
+      # all output formats, and so the CLI's format dispatch can be
+      # a hash lookup instead of a case statement.
+      module ToTtf
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:)
+          Compile::TtfCompiler.new(ufo).compile(output_path: output_path)
+          output_path
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_woff.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # UFO → WOFF. Two-step pipeline:
+      #
+      #   1. Compile the UFO to a TTF (or OTF) in a tmpdir via the
+      #      corresponding Compile::*Compiler.
+      #   2. Load the compiled binary back via FontLoader, then run
+      #      Converters::WoffWriter to wrap it in the WOFF container.
+      #
+      # The tmpfile is cleaned up automatically (Dir.mktmpdir block).
+      # The original UFO is never mutated.
+      #
+      # Why two steps instead of one in-memory pass: the WOFF
+      # encoders operate on a loaded font's table directory (they
+      # need checksums, offsets, alignment), not on a UFO model.
+      # Round-tripping through the compiled binary is the simplest
+      # path; an in-memory variant would duplicate the table-bytes
+      # extraction that FontLoader already does.
+      module ToWoff
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @param compiler [Symbol] which intermediate format to use:
+        #   :ttf (default) or :otf
+        # @param woff_options [Hash] forwarded to WoffWriter.convert
+        #   (zlib_level, uncompressed, compression_threshold,
+        #   metadata_xml, etc.)
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, compiler: :ttf, **woff_options)
+          compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
+          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate#{format_ext(compiler)}")
+            compiler_class.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            woff_bytes = Fontisan::Converters::WoffWriter.new.convert(loaded, woff_options)
+            File.binwrite(output_path, woff_bytes)
+          end
+
+          output_path
+        end
+
+        def self.format_ext(compiler)
+          %i[otf otf2].include?(compiler) ? ".otf" : ".ttf"
+        end
+        private_class_method :format_ext
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert/to_woff2.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # UFO → WOFF2. Same two-step pipeline as ToWoff, but with the
+      # WOFF2 encoder (Brotli compression, optional glyf/loca
+      # transforms) instead of WOFF (zlib).
+      #
+      # Returns the output_path; the WOFF2 binary itself lands at
+      # +output_path+.
+      module ToWoff2
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @param compiler [Symbol] which intermediate format to use:
+        #   :ttf (default) or :otf
+        # @param woff2_options [Hash] forwarded to Woff2Encoder.convert
+        #   (brotli_quality, transform_tables, quality legacy alias)
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, compiler: :ttf, **woff2_options)
+          compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
+          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate#{format_ext(compiler)}")
+            compiler_class.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            result = Fontisan::Converters::Woff2Encoder.new.convert(loaded, woff2_options)
+            File.binwrite(output_path, result[:woff2_binary])
+          end
+
+          output_path
+        end
+
+        def self.format_ext(compiler)
+          %i[otf otf2].include?(compiler) ? ".otf" : ".ttf"
+        end
+        private_class_method :format_ext
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/convert.rb

@@ -5,14 +5,77 @@ module Fontisan
     # Conversion layer between the UFO model and fontisan's BinData
     # table layer. Two directions:
     #
-    #   ToBinData.convert(ufo_font)   → Hash<tag, BinData record or bytes>
-    #   FromBinData.convert(loaded_font) → Fontisan::Ufo::Font
+    #   ToBinData / To{Format} .convert(ufo, output_path:) → writes file
+    #   FromBinData.convert(loaded_font)                   → Ufo::Font
     #
-    # The ToBinData path is already implemented as Compile::* modules
-    # (each table builder IS a UFO→BinData converter). This namespace
-    # owns the reverse direction.
+    # The To* paths are thin facades over the corresponding
+    # Compile::*Compiler classes. They exist to give callers a single
+    # uniform convert API and to keep the CLI's format dispatch in
+    # one data-driven place (COMPILER_FOR_FORMAT) instead of a switch
+    # statement per CLI command.
     module Convert
       autoload :FromBinData, "fontisan/ufo/convert/from_bin_data"
+      autoload :ToTtf, "fontisan/ufo/convert/to_ttf"
+      autoload :ToOtf, "fontisan/ufo/convert/to_otf"
+      autoload :ToOtf2, "fontisan/ufo/convert/to_otf2"
+      autoload :ToWoff, "fontisan/ufo/convert/to_woff"
+      autoload :ToWoff2, "fontisan/ufo/convert/to_woff2"
+      autoload :ToDfont, "fontisan/ufo/convert/to_dfont"
+      autoload :ToTtc, "fontisan/ufo/convert/to_ttc"
+      autoload :ToOtc, "fontisan/ufo/convert/to_otc"
+      autoload :ToPostscript, "fontisan/ufo/convert/to_postscript"
+      autoload :ToPfb, "fontisan/ufo/convert/to_postscript"
+      autoload :ToPfa, "fontisan/ufo/convert/to_postscript"
+
+      # Single source of truth for "which compiler handles this
+      # output format?". OCP: adding a format = adding one entry
+      # here + one wrapper file. The CLI reads from this hash
+      # instead of a case statement.
+      COMPILER_FOR_FORMAT = {
+        ttf: Compile::TtfCompiler,
+        otf: Compile::OtfCompiler,
+        otf2: Compile::Otf2Compiler,
+      }.freeze
+
+      # Wrapper modules for 2-step pipelines (UFO → compiler →
+      # tmpfile → encoder → output). These don't fit the 1-step
+      # COMPILER_FOR_FORMAT registry because they need a tmpdir +
+      # a second encoder pass. OCP: adding a 2-step format =
+      # adding one entry here + one wrapper file.
+      WRAPPER_FOR_FORMAT = {
+        woff: ToWoff,
+        woff2: ToWoff2,
+        dfont: ToDfont,
+        ttc: ToTtc,
+        otc: ToOtc,
+        pfb: ToPfb,
+        pfa: ToPfa,
+      }.freeze
+
+      # Convert a UFO to a binary format, writing to +output_path+.
+      # Routes through either COMPILER_FOR_FORMAT (1-step: ttf/otf/
+      # otf2) or WRAPPER_FOR_FORMAT (2-step: woff/woff2). Raises
+      # +ArgumentError+ for unknown formats.
+      #
+      # @param ufo [Fontisan::Ufo::Font]
+      # @param to [Symbol] format key
+      # @param output_path [String]
+      # @param opts [Hash] forwarded to the compiler or wrapper
+      #   (woff/woff2 wrappers take +compiler:+ + woff-specific opts)
+      # @return [String] the output_path
+      def self.convert(ufo, to:, output_path:, **)
+        format_key = to.to_sym
+
+        if (wrapper = WRAPPER_FOR_FORMAT[format_key])
+          return wrapper.convert(ufo, output_path: output_path, **)
+        end
+
+        compiler = COMPILER_FOR_FORMAT[format_key]
+        raise ArgumentError, "unknown UFO output format: #{to.inspect}" unless compiler
+
+        compiler.new(ufo).compile(output_path: output_path)
+        output_path
+      end
     end
   end
 end

data/lib/fontisan/ufo/transformation.rb

@@ -34,6 +34,17 @@ module Fontisan
       def to_a
         [a, b, c, d, e, f]
       end
+
+      # Apply this transformation to a single (x, y) coordinate.
+      #
+      # @param x [Numeric]
+      # @param y [Numeric]
+      # @return [Array(Float, Float)] the transformed [tx, ty]
+      def apply(x, y)
+        xf = x.to_f
+        yf = y.to_f
+        [a * xf + c * yf + e, b * xf + d * yf + f]
+      end
     end
   end
 end

data/lib/fontisan/version.rb

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

data/lib/fontisan.rb

@@ -118,6 +118,7 @@ module Fontisan
   autoload :SfntTable, "fontisan/sfnt_table"
   autoload :Stitcher, "fontisan/stitcher"
   autoload :StitcherCli, "fontisan/stitcher_cli"
+  autoload :Tasks, "fontisan/tasks"
   autoload :TrueTypeCollection, "fontisan/true_type_collection"
   autoload :TrueTypeFont, "fontisan/true_type_font"
   autoload :TrueTypeFontExtensions, "fontisan/true_type_font_extensions"