fontisan 0.4.11 → 0.4.12

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.11"
+  VERSION = "0.4.12"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.4.12
 platform: ruby
 authors:
 - Ribose Inc.
@@ -144,15 +144,18 @@ files:
 - docs/.vitepress/theme/components/WithinHero.vue
 - docs/.vitepress/theme/index.ts
 - docs/.vitepress/theme/style.css
+- docs/AFDKO_MIGRATION.adoc
 - docs/APPLE_LEGACY_FONTS.adoc
 - docs/CFF2_SUPPORT.adoc
 - docs/COLLECTION_VALIDATION.adoc
 - docs/COLOR_FONTS.adoc
 - docs/CONVERSION_GUIDE.adoc
 - docs/EXTRACT_TTC_MIGRATION.md
+- docs/FEATURE_PARITY.adoc
 - docs/FONT_HINTING.adoc
 - docs/STITCHER_GUIDE.adoc
 - docs/SVG_TO_GLYF.adoc
+- docs/TTX.adoc
 - docs/TYPE1_FONTS.adoc
 - docs/UFO_COMPILATION.adoc
 - docs/VALIDATION.adoc
@@ -460,6 +463,7 @@ files:
 - lib/fontisan/svg/font_face_generator.rb
 - lib/fontisan/svg/font_generator.rb
 - lib/fontisan/svg/glyph_generator.rb
+- lib/fontisan/svg/standalone_glyph.rb
 - lib/fontisan/svg/view_box_calculator.rb
 - lib/fontisan/svg_to_glyf.rb
 - lib/fontisan/svg_to_glyf/assembler.rb
@@ -591,11 +595,24 @@ files:
 - lib/fontisan/ufo/compile/cmap.rb
 - lib/fontisan/ufo/compile/colr.rb
 - lib/fontisan/ufo/compile/cpal.rb
+- lib/fontisan/ufo/compile/feature_writers.rb
+- lib/fontisan/ufo/compile/feature_writers/base.rb
+- lib/fontisan/ufo/compile/feature_writers/curs.rb
+- lib/fontisan/ufo/compile/feature_writers/gdef.rb
+- lib/fontisan/ufo/compile/feature_writers/kern.rb
+- lib/fontisan/ufo/compile/feature_writers/kern2.rb
+- lib/fontisan/ufo/compile/feature_writers/mark.rb
+- lib/fontisan/ufo/compile/feature_writers/mark_family_base.rb
+- lib/fontisan/ufo/compile/feature_writers/mkmk.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/propagate_anchors.rb
+- lib/fontisan/ufo/compile/filters/remove_overlaps.rb
 - lib/fontisan/ufo/compile/filters/reverse_contour_direction.rb
+- lib/fontisan/ufo/compile/filters/sort_contours.rb
+- lib/fontisan/ufo/compile/filters/transformations.rb
 - lib/fontisan/ufo/compile/fvar.rb
 - lib/fontisan/ufo/compile/glyf_loca.rb
 - lib/fontisan/ufo/compile/gpos.rb
@@ -624,6 +641,15 @@ files:
 - lib/fontisan/ufo/contour.rb
 - lib/fontisan/ufo/convert.rb
 - lib/fontisan/ufo/convert/from_bin_data.rb
+- lib/fontisan/ufo/convert/to_dfont.rb
+- lib/fontisan/ufo/convert/to_otc.rb
+- lib/fontisan/ufo/convert/to_otf.rb
+- lib/fontisan/ufo/convert/to_otf2.rb
+- lib/fontisan/ufo/convert/to_postscript.rb
+- lib/fontisan/ufo/convert/to_ttc.rb
+- lib/fontisan/ufo/convert/to_ttf.rb
+- lib/fontisan/ufo/convert/to_woff.rb
+- lib/fontisan/ufo/convert/to_woff2.rb
 - lib/fontisan/ufo/data_set.rb
 - lib/fontisan/ufo/features.rb
 - lib/fontisan/ufo/font.rb