fontisan 0.4.10 → 0.4.12

data/lib/fontisan/svg/standalone_glyph.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Svg
+    # Renders a single UFO glyph as a standalone SVG document (a
+    # `<svg>` root with one `<path>` and a viewBox sized to the
+    # glyph's bounding box). Distinct from {FontGenerator}, which
+    # emits a `<svg><defs><font>` document covering every glyph.
+    #
+    # Used by the `fontisan ufo extract` CLI command and by
+    # downstream consumers that want per-glyph SVG exports without
+    # having to slice up a font-format SVG themselves.
+    #
+    # Path rendering supports quadratic and cubic Bezier curves
+    # (UFO's standard outline model). Curve logic is inlined here
+    # rather than reaching into GlyphGenerator's private path code
+    # — that logic is font-format-specific (Y-axis flip via
+    # ViewBoxCalculator) and doesn't cleanly factor out.
+    class StandaloneGlyph
+      # @param units_per_em [Integer] font units-per-em (default 1000)
+      # @param ascent [Integer] font ascender in font units (default 800)
+      # @param descent [Integer] font descender in font units (default -200)
+      def initialize(units_per_em: 1000, ascent: 800, descent: -200)
+        @units_per_em = units_per_em.to_i
+        @ascent = ascent.to_i
+        @descent = descent.to_i
+      end
+
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @return [String] standalone SVG XML
+      def generate(glyph)
+        path_data = path_data_for(glyph)
+        view_box = view_box_for(glyph)
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="#{view_box}">
+            <path d="#{path_data}"/>
+          </svg>
+        SVG
+      end
+
+      private
+
+      def path_data_for(glyph)
+        return "" if glyph.contours.empty?
+
+        glyph.contours.filter_map { |c| contour_path(c) }.join(" ")
+      end
+
+      # Emit an SVG path for one contour with Y-axis flip applied.
+      # Walks points left-to-right; collects off-curve runs and
+      # flushes them as a Bezier curve (Q for 1 control point, C
+      # for 2). Single on-curve points become line segments.
+      def contour_path(contour)
+        points = contour.points
+        return nil if points.empty?
+
+        parts = []
+        first = points.first
+        parts << "M #{first.x} #{flip_y(first.y)}"
+
+        i = 1
+        while i < points.length
+          if points[i].on_curve?
+            parts << "L #{points[i].x} #{flip_y(points[i].y)}"
+            i += 1
+          else
+            # Collect consecutive off-curve points (1 → quadratic,
+            # 2 → cubic, 3+ → rare; treat as multiple quadratics).
+            controls = []
+            while i < points.length && !points[i].on_curve?
+              controls << points[i]
+              i += 1
+            end
+            end_pt = i < points.length ? points[i] : first
+            i += 1 if i < points.length
+
+            parts << curve_segment(controls, end_pt)
+          end
+        end
+
+        parts << "Z"
+        parts.join(" ")
+      end
+
+      def curve_segment(controls, end_pt)
+        end_x = end_pt.x
+        end_y = flip_y(end_pt.y)
+
+        case controls.size
+        when 1
+          "Q #{controls[0].x} #{flip_y(controls[0].y)} #{end_x} #{end_y}"
+        when 2
+          "C #{controls[0].x} #{flip_y(controls[0].y)} " \
+            "#{controls[1].x} #{flip_y(controls[1].y)} " \
+            "#{end_x} #{end_y}"
+        else
+          # 3+ controls: emit a Q to the midpoint of the first two,
+          # then continue. Rare in practice; degrades to Q chain.
+          mid_x = (controls[0].x + controls[1].x) / 2.0
+          mid_y = flip_y((controls[0].y + controls[1].y) / 2.0)
+          "Q #{controls[0].x} #{flip_y(controls[0].y)} #{mid_x} #{mid_y}"
+        end
+      end
+
+      def flip_y(y)
+        @ascent - y.to_f
+      end
+
+      def view_box_for(glyph)
+        bbox = bounding_box(glyph)
+        format("%<xmin>s %<ymin>s %<w>s %<h>s",
+               xmin: bbox[:x_min], ymin: bbox[:y_min],
+               w: (bbox[:x_max] - bbox[:x_min]),
+               h: (bbox[:y_max] - bbox[:y_min]))
+      end
+
+      def bounding_box(glyph)
+        points = glyph.contours.flat_map(&:points)
+        return { x_min: 0, y_min: 0, x_max: @units_per_em, y_max: @units_per_em } if points.empty?
+
+        xs = points.map(&:x)
+        ys = points.map(&:y)
+        { x_min: xs.min, y_min: ys.min, x_max: xs.max, y_max: ys.max }
+      end
+    end
+  end
+end

data/lib/fontisan/svg.rb

@@ -7,6 +7,7 @@ module Fontisan
     autoload :FontFaceGenerator, "fontisan/svg/font_face_generator"
     autoload :FontGenerator, "fontisan/svg/font_generator"
     autoload :GlyphGenerator, "fontisan/svg/glyph_generator"
+    autoload :StandaloneGlyph, "fontisan/svg/standalone_glyph"
     autoload :ViewBoxCalculator, "fontisan/svg/view_box_calculator"
   end
 end

data/lib/fontisan/tasks/fixture_downloader.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "net/http"
+require "fileutils"
+
+module Fontisan
+  # Tasks supporting the developer workflow: fixture downloads, etc.
+  # Lives under its own namespace so Rakefiles and other tooling can
+  # load just the task plumbing without pulling in the full fontisan
+  # stack (BinData tables, UFO, etc.).
+  module Tasks
+    # Downloads a single fixture file with retry on transient network
+    # failures. Used by `rake fixtures:download` so a single CDN blip
+    # (5xx, connection reset, OpenTimeout) doesn't sink a fresh
+    # checkout. Permanent failures (404, malformed URL) surface
+    # immediately.
+    #
+    # The downloader is a focused class, not a procedural Rakefile
+    # patch, so the retry logic is unit-testable in isolation.
+    #
+    # @example
+    #   Fontisan::Tasks::FixtureDownloader.new(
+    #     url: "https://github.com/.../font.ttf",
+    #     destination: "spec/fixtures/font.ttf",
+    #   ).call
+    class FixtureDownloader
+      RETRIABLE_ERRORS = [
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        Errno::ECONNRESET,
+        Errno::ECONNREFUSED,
+        Errno::EHOSTUNREACH,
+        Errno::ETIMEDOUT,
+        EOFError,
+        IOError,
+      ].freeze
+
+      # 5xx HTTP responses are transient server errors worth retrying.
+      # 4xx are permanent (404, 403) and must fail fast.
+      RETRIABLE_HTTP_STATUSES = (500..599)
+
+      DEFAULT_MAX_RETRIES = 3
+      DEFAULT_BASE_BACKOFF = 0.5 # seconds; doubles per attempt
+
+      # Error raised after exhausting all retries. Carries the last
+      # underlying exception so callers can log the root cause.
+      class Error < StandardError
+        attr_reader :last_error
+
+        def initialize(url:, attempts:, last_error:)
+          @last_error = last_error
+          super("Failed to download #{url} after #{attempts} attempts: " \
+                "#{last_error.class}: #{last_error.message}")
+        end
+      end
+
+      attr_reader :url, :destination, :max_retries, :base_backoff, :sleep_method
+
+      # @param url [String] source URL.
+      # @param destination [String] path to write bytes to. Parent dir
+      #   is auto-created.
+      # @param max_retries [Integer] total attempts including the
+      #   first. 3 means: try, retry, retry.
+      # @param base_backoff [Float] seconds to sleep before the first
+      #   retry. Doubles per attempt.
+      # @param sleep_method [#call] injectable sleep (for tests).
+      #   Defaults to Kernel.sleep.
+      def initialize(url:, destination:, max_retries: DEFAULT_MAX_RETRIES,
+                     base_backoff: DEFAULT_BASE_BACKOFF, sleep_method: method(:sleep))
+        @url = url
+        @destination = destination
+        @max_retries = max_retries
+        @base_backoff = base_backoff
+        @sleep_method = sleep_method
+      end
+
+      # Performs the download. Returns the destination path on
+      # success. Raises {Error} after exhausting retries.
+      #
+      # @return [String] destination path
+      # @raise [Error]
+      def call
+        attempts = 0
+        nil
+
+        begin
+          attempts += 1
+          fetch_to_destination
+          destination
+        rescue StandardError => e
+          e
+          raise if permanent_failure?(e)
+          raise Error.new(url: url, attempts: attempts, last_error: e) if attempts >= max_retries
+
+          backoff = base_backoff * (2**(attempts - 1))
+          sleep_method.call(backoff)
+          retry
+        end
+      end
+
+      private
+
+      def fetch_to_destination
+        FileUtils.mkdir_p(File.dirname(destination))
+
+        # IO.copy_stream avoids loading the whole response into memory
+        # and is more Windows-compatible than remote.read + File.binwrite.
+        # URLs come from FixtureFonts config (version-controlled), not
+        # user input — same trust model as the previous inline URI.open
+        # call in the Rakefile.
+        #
+        # Parsing with URI.parse first satisfies CodeQL's "open with
+        # non-constant value" check: any string that isn't a valid URI
+        # raises URI::InvalidURIError before OpenURI can dispatch on
+        # it. The parsed URI's .open is OpenURI's standard entry.
+        # rubocop:disable Security/Open
+        URI.parse(url).open(open_uri_options) do |remote|
+          File.open(destination, "wb") do |file|
+            IO.copy_stream(remote, file)
+          end
+        end
+        # rubocop:enable Security/Open
+      end
+
+      # `open-uri` follows redirects by default and surfaces HTTP
+      # errors as `OpenURI::HTTPError` whose `io.status` is the `[code,
+      # message]` array. We re-raise non-retriable 4xx as
+      # `permanent-failure`-tagged exceptions so the retry loop exits.
+      def open_uri_options
+        {
+          "User-Agent" => "fontisan-fixtures/1.0",
+          redirect: true,
+          open_timeout: 30,
+          read_timeout: 120,
+        }
+      end
+
+      def permanent_failure?(error)
+        case error
+        when OpenURI::HTTPError
+          status = parse_http_status(error)
+          status && !RETRIABLE_HTTP_STATUSES.cover?(status)
+        else
+          RETRIABLE_ERRORS.none? { |klass| error.is_a?(klass) }
+        end
+      end
+
+      def parse_http_status(error)
+        io = error.io
+        return nil unless io
+
+        status = io.status
+        return nil unless status
+
+        status.first.to_i
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/fontisan/tasks.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Tasks supporting the developer workflow: fixture downloads, etc.
+  # Lives under its own namespace so Rakefiles and other tooling can
+  # load just the task plumbing without pulling in the full fontisan
+  # stack (BinData tables, UFO, etc.).
+  module Tasks
+    autoload :FixtureDownloader, "fontisan/tasks/fixture_downloader"
+  end
+end

data/lib/fontisan/ufo/cli.rb

@@ -14,20 +14,15 @@ module Fontisan
       method_option :output, type: :string, required: true,
                              desc: "Output file path"
       method_option :to, type: :string, default: "ttf",
-                         desc: "Output format (ttf or otf)"
+                         desc: "Output format (ttf, otf, or otf2)"
       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])
+        format = (options[:to] || "ttf").to_s.downcase.to_sym
+        Convert.convert(font, to: format, output_path: options[:output])
         puts "wrote #{options[:output]} (#{File.size(options[:output])} bytes)"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
       rescue Errno::ENOENT
         warn "UFO not found: #{ufo}"
         exit 1
@@ -35,20 +30,12 @@ module Fontisan
 
       desc "convert INPUT OUTPUT", "Convert between UFO and binary formats"
       method_option :to, type: :string,
-                         desc: "Override format detection (ttf, otf, ufo)"
+                         desc: "Override format detection (ttf, otf, otf2, 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)
+          Convert.convert(font, to: format.to_sym, output_path: output)
         else
           # Binary → UFO
           loaded = Fontisan::FontLoader.load(input)
@@ -56,6 +43,9 @@ module Fontisan
           Writer.new(ufo).write(output)
         end
         puts "wrote #{output}"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
       end
 
       desc "validate UFO", "Check a UFO source for structural issues"
@@ -75,6 +65,29 @@ module Fontisan
         end
       end
 
+      desc "extract UFO GLYPH_NAME OUTPUT.svg",
+           "Render a single glyph from a UFO as a standalone SVG"
+      def extract(ufo, glyph_name, output)
+        font = Font.open(ufo)
+        glyph = font.glyph(glyph_name)
+        raise ArgumentError, "glyph not found: #{glyph_name.inspect}" unless glyph
+
+        head = font.info
+        renderer = Fontisan::Svg::StandaloneGlyph.new(
+          units_per_em: head.units_per_em || 1000,
+          ascent: head.ascender || 800,
+          descent: head.descender || -200,
+        )
+        File.write(output, renderer.generate(glyph))
+        puts "wrote #{output} (#{File.size(output)} bytes)"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
+      rescue Errno::ENOENT
+        warn "UFO not found: #{ufo}"
+        exit 1
+      end
+
       private
 
       def ufo?(path)

data/lib/fontisan/ufo/compile/feature_writers/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # Value object returned by every feature writer's +#write+
+        # method. Carries the structured data the corresponding
+        # table builder needs to encode the binary subtable.
+        #
+        # Writers return +nil+ instead when the UFO has no data for
+        # the feature — the compiler skips +nil+ outputs.
+        FeatureOutput = Struct.new(
+          :table_tag, # "GPOS", "GSUB", "GDEF"
+          :feature_tag, # "kern", "mark", "curs", etc. (nil for GDEF)
+          :lookup_type, # Integer GSUB/GPOS lookup type
+          :data,        # Hash — writer-specific structure
+          keyword_init: true,
+        ) do
+          def table_tag
+            self[:table_tag]
+          end
+
+          def feature_tag
+            self[:feature_tag]
+          end
+
+          def lookup_type
+            self[:lookup_type]
+          end
+
+          def data
+            self[:data]
+          end
+        end
+
+        # Abstract base class for feature writers. Concrete writers
+        # (Kern, Gdef, Mark, etc.) extend this and implement +#write+.
+        class Base
+          attr_reader :font
+
+          # @param font [Fontisan::Ufo::Font] the UFO source
+          def initialize(font)
+            @font = font
+          end
+
+          # @return [FeatureOutput, nil] structured data for the
+          #   feature, or +nil+ if the UFO has nothing for it
+          def write
+            raise NotImplementedError, "#{self.class} must implement #write"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/curs.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS Cursive (lookup type 3) — cursive attachment.
+        #
+        # Pairs glyphs via their entry and exit anchors for cursive
+        # (joining) scripts. UFO convention: a glyph's +<name>entry+
+        # and +<name>exit+ anchors define where it connects to its
+        # neighbors.
+        #
+        # Pairs every glyph that has at least one +entry+ anchor with
+        # every glyph that has the corresponding +exit+ anchor.
+        # Multiple entry/exit class names are supported.
+        class Curs < Base
+          LOOKUP_TYPE = 3
+          FEATURE_TAG = "curs"
+          TABLE_TAG = "GPOS"
+
+          # @return [FeatureOutput, nil]
+          def write
+            attachments = {}
+
+            entry_glyphs = glyphs_with_anchor(/entry\z/)
+            exit_glyphs = glyphs_with_anchor(/exit\z/)
+
+            return nil if entry_glyphs.empty? && exit_glyphs.empty?
+
+            # Cursive attachment: each glyph can be both a "previous"
+            # (with exit anchor) and "next" (with entry anchor) in
+            # a cursive chain. The GPOS builder handles the
+            # cross-references; we emit every glyph with its entry
+            # and/or exit anchor positions.
+            font.glyphs.each_value do |glyph|
+              entry = find_anchor(glyph, /entry\z/)
+              exit = find_anchor(glyph, /exit\z/)
+              next unless entry || exit
+
+              attachments[glyph.name] = {
+                entry: entry && [entry.x, entry.y],
+                exit: exit && [exit.x, exit.y],
+              }
+            end
+
+            return nil if attachments.empty?
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: FEATURE_TAG,
+              lookup_type: LOOKUP_TYPE,
+              data: { attachments: attachments },
+            )
+          end
+
+          private
+
+          def glyphs_with_anchor(pattern)
+            font.glyphs.select do |_name, glyph|
+              glyph.anchors.any? { |a| pattern.match?(a.name.to_s) }
+            end
+          end
+
+          def find_anchor(glyph, pattern)
+            glyph.anchors.find { |a| pattern.match?(a.name.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/gdef.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GDEF GlyphClassDef — classifies every glyph into one of
+        # the four OpenType glyph classes:
+        #
+        #   1 — Base glyph
+        #   2 — Ligature glyph
+        #   3 — Combining mark
+        #   4 — Glyph spacing variant (e.g. alternate space)
+        #
+        # The classification drives how GSUB/GPOS lookups apply. UFO
+        # sources carry this in the glyph's +lib+ plist under the
+        # +public.openTypeCategory+ key; this writer translates that
+        # into the structured form the GDEF builder expects.
+        class Gdef < Base
+          TABLE_TAG = "GDEF"
+
+          # Map UFO public.openTypeCategory values → OpenType glyph
+          # class integers. Glyphs whose category isn't listed get
+          # class 0 (unclassified — the GDEF ClassDef omits them).
+          CATEGORY_TO_CLASS = {
+            "base" => 1,
+            "ligature" => 2,
+            "mark" => 3,
+            "component" => 3, # UFO treats component as mark for GDEF
+            "spacing" => 4,
+          }.freeze
+
+          # @return [FeatureOutput]
+          def write
+            classifications = {}
+
+            font.glyphs.each_value do |glyph|
+              cls = classify(glyph)
+              classifications[glyph.name] = cls if cls
+            end
+
+            # A GDEF without any classified glyphs is meaningless —
+            # return nil so the compiler skips the table.
+            return nil if classifications.empty?
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: nil,
+              lookup_type: nil,
+              data: { classes: classifications },
+            )
+          end
+
+          private
+
+          # Resolve a glyph's GDEF class. Prefer the explicit
+          # +public.openTypeCategory+ lib entry; fall back to a
+          # heuristic (glyphs with anchors named "top"/"bottom" are
+          # marks; glyphs with component references are ligatures
+          # only if their name has a +.liga+ suffix).
+          def classify(glyph)
+            category = glyph_lib_category(glyph)
+            return CATEGORY_TO_CLASS[category] if category && CATEGORY_TO_CLASS.key?(category)
+
+            heuristic_class(glyph)
+          end
+
+          def glyph_lib_category(glyph)
+            return nil unless glyph.lib
+
+            lib = glyph.lib
+            return lib["public.openTypeCategory"] if lib["public.openTypeCategory"]
+
+            categories = lib["public.openTypeCategories"]
+            categories[glyph.name] if categories.is_a?(Hash)
+          end
+
+          def heuristic_class(glyph)
+            anchor_names = glyph.anchors.map(&:name)
+            mark_anchor_pattern = /\A_[a-zA-Z]+\z/
+            return 3 if anchor_names.any? { |n| mark_anchor_pattern.match?(n.to_s) }
+            return 2 if glyph.name.to_s.end_with?(".liga")
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/kern.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS PairPos (lookup type 2) — kerning pairs.
+        #
+        # Reads +font.kerning+ (parsed from kerning.plist) and emits
+        # a {FeatureOutput} whose +data+ is a structured list of
+        # pairs ready for the GPOS PairPos builder. Returns +nil+
+        # when the UFO has no kerning data — the compiler then
+        # omits the GPOS table entirely.
+        #
+        # Group-based kerning keys (e.g. +"@MMK_L_A @MMK_R_B"+) are
+        # emitted verbatim with +group: true+; the GPOS builder is
+        # responsible for resolving group references via the UFO's
+        # groups.plist data (TODO: groups.plist support is partial).
+        class Kern < Base
+          # GPOS lookup type 2 — PairPos (pair-positioning).
+          LOOKUP_TYPE = 2
+          FEATURE_TAG = "kern"
+          TABLE_TAG = "GPOS"
+
+          # @return [FeatureOutput, nil]
+          def write
+            return nil if font.kerning.nil? || font.kerning.empty?
+
+            pairs = font.kerning.pairs.map do |key, value|
+              left, right = key.to_s.split(" ", 2)
+              {
+                left: left,
+                right: right,
+                value: value.to_f,
+                group_left: left.to_s.start_with?("@"),
+                group_right: right.to_s.start_with?("@"),
+              }
+            end
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: FEATURE_TAG,
+              lookup_type: LOOKUP_TYPE,
+              data: { pairs: pairs },
+            )
+          end
+        end
+      end
+    end
+  end
+end