fontist 3.0.37 → 3.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85b1409d941968bcf69c2058ab3e3ffac4138279bf6c262d670206590dd8e557
-  data.tar.gz: f025af9d9214504168b1612f7f42f3142afdadb9112e9283022fe92378665000
+  metadata.gz: 3ec4754ec2eb25b7e106ecd9254296d72900bf8df94b59d1707099f1585333c6
+  data.tar.gz: f41467d946e5513fb8f297d52984c792ffceb6ee20f4400b238ac786c844960f
 SHA512:
-  metadata.gz: 6c13e6cca540bd6f5e2ed3bd203bad3b4dad7db56824d34e36b511331b6a9bd5b5178ecf7fc6717318d54981950c33536ae3dfc6eafc82e4ceaf771f3b08fbdb
-  data.tar.gz: f1a3542fcda412f62e763cb38d9484028ddc65585eba3d6c9cb982eea8ef80656672769fc898a5b4266ef7419adadcf7e592200f4d7c8c9845505ddf13ec4f58
+  metadata.gz: 4a89a610ffd86cf8c4eaef413cb58e4837496b3eb637cb218ba9ba043f61c9f72e4b6e637c34d03c50acc539006fbefd02db5be870a35627758e789b3b583977
+  data.tar.gz: 1070a5850da3b68d883b9c578718d072ccad5c249df5f580e1510a9a2019313f76f645f063f6b39186a45deb9391d4c9a6cd501135ac54698da579ffbf5f68cb

data/.github/workflows/tebako-pack.yml

@@ -55,8 +55,11 @@ jobs:
       - id: tag
         env:
           GH_TOKEN: ${{ github.token }}
-          CALLED: ${{ github.event_name != 'workflow_dispatch' && github.event_name != 'pull_request' && inputs.publish }}
-          INPUT_TAG: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || '' }}
+          # A called workflow sees the caller's event (release.yml runs on
+          # workflow_dispatch), so tell the triggers apart by their inputs:
+          # only workflow_call has `publish`, only workflow_dispatch has `tag`.
+          CALLED: ${{ inputs.publish == true }}
+          INPUT_TAG: ${{ inputs.tag || '' }}
         run: |
           if [ "$CALLED" = true ]; then
             tag="v$(sed -n 's/.*VERSION = "\(.*\)".*/\1/p' lib/fontist/version.rb)"
@@ -183,7 +186,10 @@ jobs:
       matrix:
         # Distros whose git meets the git gem's >= 2.43; older ones refuse
         # the package on its git dependency.
-        image: [ 'ubuntu:24.04', 'debian:13', 'fedora:latest', 'rockylinux:9' ]
+        # ubuntu:22.04 ships an older git and first gets a newer one the
+        # documented way (git-prep.sh, see README.adoc). debian:12 has no leg:
+        # bookworm-backports carries no git package, so no >= 2.43 exists there.
+        image: [ 'ubuntu:24.04', 'debian:13', 'fedora:latest', 'rockylinux:9', 'ubuntu:22.04' ]
         arch: [ amd64 ]
         runner: [ ubuntu-24.04 ]
         include:
@@ -207,13 +213,46 @@ jobs:
           fi
           ls -l pkg
 
+      - name: Get git 2.43 or newer
+        if: matrix.image == 'ubuntu:22.04'
+        run: script/tebako/git-prep.sh
+
       - name: Install, use, remove
         run: script/tebako/package-smoke.sh pkg
 
+  # Test-only: the packed executables again, on runners other than the ones
+  # that packed them. No macOS leg: macos-14 is not offered to this repo
+  # (run 42989415969: "The configuration 'macos-14-arm64-us-default' is not
+  # supported") and macos-13 is a label GitHub has retired; the macOS
+  # binaries are smoke-tested on their packing runners in `pack`.
+  binary-smoke:
+    name: run ${{ matrix.name }} on ${{ matrix.os }}
+    needs: pack
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-24.04, name: linux-x86_64 }
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: fontist-${{ matrix.name }}
+          path: out
+
+      - name: Smoke test
+        run: |
+          chmod +x "out/fontist-${{ matrix.name }}"
+          git_dir="$(dirname "$(command -v git)")"
+          env -i HOME="$HOME" PATH="$git_dir:/usr/bin:/bin:/usr/sbin:/sbin" \
+            script/tebako/smoke.sh "out/fontist-${{ matrix.name }}"
+
   publish:
     name: attach to release
     if: needs.resolve.outputs.tag != ''
-    needs: [ resolve, pack, package-smoke ]
+    needs: [ resolve, pack, package-smoke, binary-smoke ]
     runs-on: ubuntu-24.04
     permissions:
       contents: write

data/Gemfile

@@ -18,11 +18,10 @@ gem "simplecov"
 gem "vcr"
 gem "webmock"
 
-# Optional YAML engine (consumer-side dependency; needs Ruby >= 3.0,
-# which is above fontist's gemspec floor, so it stays out of the
-# gemspec). Activated with FONTIST_YAML=yeptris; off by default
-# pending leptris/yeptris#863 (linux scalar-parity fix).
-gem "yeptris", require: false
+# yeptris is a runtime dependency (see the gemspec): the JSON backend in
+# lib/fontist/json.rb loads it unconditionally. The optional YAML engine
+# activated with FONTIST_YAML=yeptris stays off by default pending
+# leptris/yeptris#863 (linux scalar-parity fix).
 
 # Profiling tools (development only)
 # gem "ruby-prof", "~> 1.7"

data/README.adoc

@@ -78,8 +78,16 @@ macOS is older, so install a current one first (for example
 `brew install git`).
 
 On Debian and Ubuntu, install the `.deb` package. On Fedora and RHEL, install
-the `.rpm` package. Both put `fontist` in `/usr/bin` and depend on git 2.43 or
-newer, which Ubuntu 24.04, Debian 13, Fedora and RHEL 9 provide.
+the `.rpm` package. Both install the executable to `/usr/lib/fontist/fontist` and link it from
+`/usr/local/bin/fontist` (the link is removed with the package). They depend on
+git 2.43 or newer, which Ubuntu 24.04, Debian 13, Fedora and RHEL 9 provide.
+
+Ubuntu 22.04 ships an older git, so get a newer one once before installing the
+`.deb`: `sudo add-apt-repository ppa:git-core/ppa && sudo apt-get update && sudo apt-get install git`.
+Debian 12 has no git 2.43 or newer in its archive or in bookworm-backports, so
+the package cannot be installed there.
+
+`script/tebako/git-prep.sh` does exactly this and is what CI runs.
 
 [source,sh]
 ----

data/fontist.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "down", "~> 5.0"
   spec.add_dependency "excavate", "~> 1.0", ">= 1.0.3"
-  spec.add_dependency "fontisan", "~> 0.4", ">= 0.4.47"
+  spec.add_dependency "fontisan", "~> 0.4", ">= 0.4.48"
   spec.add_dependency "fuzzy_match", "~> 2.1"
   spec.add_dependency "git", "~> 6.0"
   spec.add_dependency "lutaml-model", "~> 0.8.164"
@@ -46,4 +46,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "socksify", "~> 1.7"
   spec.add_dependency "thor", "~> 1.4"
   spec.add_dependency "unibuf", "~> 0.1"
+  spec.add_dependency "yeptris", "~> 0.6.55"
 end

data/lib/fontist/font_operations/convert.rb

@@ -39,9 +39,7 @@ module Fontist
 
       def run(source, target, output)
         FileUtils.mkdir_p(File.dirname(output))
-        Fontisan::Commands::ConvertCommand.new(
-          source, to: target, output: output, quiet: true
-        ).run
+        Fontisan::Reference.convert(source, to: target, output: output)
       end
 
       def verify!(path, target)

data/lib/fontist/font_operations/extract.rb

@@ -18,9 +18,9 @@ module Fontist
       end
 
       def unpack(collection_path, index, output_dir)
-        Fontisan::Commands::UnpackCommand.new(
-          collection_path, output_dir: output_dir, font_index: index
-        ).run[:extracted_files].first
+        Fontisan::Reference.extract(
+          collection_path, index: index, output_dir: output_dir
+        )
       end
 
       def check_index!(path, index)

data/lib/fontist/font_operations/instance.rb

@@ -59,13 +59,17 @@ module Fontist
                 "#{File.basename(source)} is not a variable font"
         end
 
-        instancer = Fontisan::Variable::Instancer.new(font)
-        validate!(instancer, coords, File.basename(source))
+        validate!(Fontisan::Variable::Instancer.new(font), coords,
+                  File.basename(source))
         FileUtils.mkdir_p(File.dirname(output))
-        File.binwrite(output, instancer.instance(coords))
+        File.binwrite(output, instance_bytes(source, coords))
         output
       end
 
+      def instance_bytes(source, coords)
+        Fontisan::Reference.instance(source, coords: coords)
+      end
+
       def validate!(instancer, coords, name)
         axes = instancer.axes.to_h { |axis| [axis.tag, axis] }
         coords.each do |tag, value|

data/lib/fontist/font_operations/subset.rb

@@ -4,6 +4,7 @@ module Fontist
   module FontOperations
     # Keeps only the glyphs for the given characters.
     module Subset
+      NO_GLYPHS = "None of the requested characters exist in".freeze
       UNICODE_PART = /\A(u\+)?\h+(-(u\+)?\h+)?\z/i
 
       module_function
@@ -28,21 +29,16 @@ module Fontist
       end
 
       def write(source, output, codepoints)
-        font = Fontisan::FontLoader.load(source)
-        gids = glyph_ids(font, codepoints, File.basename(source))
-        options = Fontisan::Subset::Options.new(profile: "web")
-        binary = Fontisan::Subset::Builder.new(font, gids, options).build
+        binary = Fontisan::Reference.subset(
+          source, unicodes: codepoints, profile: "web"
+        )
         FileUtils.mkdir_p(File.dirname(output))
         File.binwrite(output, binary)
         output
-      end
-
-      def glyph_ids(font, codepoints, name)
-        mappings = font.table("cmap").unicode_mappings
-        gids = codepoints.uniq.filter_map { |cp| mappings[cp] }.uniq.sort
-        return gids if gids.any?
+      rescue Fontisan::Error => e
+        raise unless e.message.start_with?(NO_GLYPHS)
 
-        raise Error, "None of the requested characters exist in #{name}"
+        raise Error, e.message
       end
 
       # "U+0020-007E,U+00E9" => [32..126, 233].flatten

data/lib/fontist/scan_row_fonts.rb

@@ -0,0 +1,82 @@
+require "fontisan"
+
+module Fontist
+  # Turns `Fontisan.scan` rows into the font objects the indexes already
+  # consume (`FontFile` for single fonts, a `FontFile` over the english-only
+  # names for collection faces), so one batch scan can replace the per-path
+  # `FontFile.from_path` / `CollectionFile.from_path` loads.
+  #
+  # Only rows that carry no error are usable; anything else is left to the
+  # per-file path so its message stays byte-identical.
+  module ScanRowFonts
+    SINGLE_FORMATS = %w[ttf otf woff woff2].freeze
+    COLLECTION_FORMATS = %w[ttc otc].freeze
+
+    class << self
+      def usable?(rows)
+        return false if rows.nil? || rows.empty?
+
+        if rows.first["is_collection"]
+          collection_usable?(rows)
+        else
+          single_usable?(rows)
+        end
+      end
+
+      def file_font(row)
+        report_validation(row)
+        info = symbolize(row["names"] || {})
+        if row["has_fvar"] && info[:family_name]
+          info[:variable_instances] =
+            row["variable_instances"].map { |i| symbolize(i) }
+        end
+        FontFile.new(info)
+      end
+
+      def collection_face(row)
+        FontFile.new(symbolize(row["english_names"] || {}))
+      end
+
+      def warn_file_extension(path, row)
+        FontFile.check_extension_warning(path, row["is_collection"])
+      end
+
+      def warn_collection_extension(path)
+        CollectionFile.send(:check_extension_warning, path)
+      end
+
+      private
+
+      def collection_usable?(rows)
+        COLLECTION_FORMATS.include?(rows.first["format"]) &&
+          rows.all? { |row| collection_row_ok?(row) }
+      end
+
+      def single_usable?(rows)
+        row = rows.first
+        rows.size == 1 && SINGLE_FORMATS.include?(row["format"]) &&
+          row["errors"]["font_file"].nil? && !row["names"].nil?
+      end
+
+      def symbolize(hash)
+        hash.transform_keys(&:to_sym)
+      end
+
+      def collection_row_ok?(row)
+        row["is_collection"] && row["num_faces"].to_i.positive? &&
+          row["errors"]["collection_file"].nil? &&
+          row["errors"]["collection_member"].nil?
+      end
+
+      def report_validation(row)
+        validation = row["validation"]
+        return if validation.nil? || validation["valid"]
+
+        name = File.basename(row["path"])
+        Fontist.ui.debug(
+          "Font validation issues for #{name}: #{validation['error_summary']}",
+        )
+      end
+    end
+  end
+end

data/lib/fontist/system_index.rb

@@ -667,7 +667,8 @@ verbose:, stats:)
       show_minimal_progress = !verbose && sorted_paths.size > 100
       progress_interval = sorted_paths.size > 1000 ? 100 : 50
 
-      results = sorted_paths.flat_map.with_index do |path, index|
+      misses = []
+      slots = sorted_paths.each_with_index.map do |path, index|
         if verbose && stats
           display_progress(index + 1, sorted_paths.size, path, spinner_chars,
                            spinner_index)
@@ -678,25 +679,66 @@ verbose:, stats:)
         spinner_index += 1
 
         cached = existing_fonts_by_path[path]
-        detect_font_with_cache(path, cached, stats: stats)
+        if reusable_cache?(path, cached, stats: stats)
+          cached
+        else
+          misses << path unless excluded?(path)
+          path
+        end
+      end
+
+      rows = scan_rows_by_path(misses)
+      results = slots.flat_map do |slot|
+        slot.is_a?(String) ? entries_for_miss(slot, rows[slot], stats) : slot
       end.compact
 
       clear_progress_line if verbose
       results
     end
 
-    def detect_font_with_cache(path, cached, stats:)
+    def reusable_cache?(path, cached, stats:)
       # Fast path: reuse cached metadata if file unchanged
       if cached&.any? && file_unchanged?(path, cached.first)
         stats&.record_cache_hit
-        cached
+        true
       else
-        # Slow path: parse font file
         stats&.record_cache_miss
+        false
+      end
+    end
+
+    # One batch scan for every cache miss. The digest and name decoding run
+    # inside Fontisan.scan; no forks, no threads here.
+    def scan_rows_by_path(paths)
+      return {} if paths.empty?
+
+      Fontisan.scan(paths).group_by { |row| row["path"] }
+    end
+
+    def entries_for_miss(path, rows, stats)
+      return if excluded?(path)
+
+      if ScanRowFonts.usable?(rows)
+        build_entries_from_rows(path, rows)
+      else
+        # A failing or unusual file keeps the per-file path, so its error
+        # text and stats are exactly what they were before batching.
         detect_fonts(path, stats: stats)
       end
     end
 
+    def build_entries_from_rows(path, rows)
+      if rows.first["is_collection"]
+        ScanRowFonts.warn_collection_extension(path)
+        rows.map { |row| parse_font(ScanRowFonts.collection_face(row), path) }
+      else
+        ScanRowFonts.warn_file_extension(path, rows.first)
+        font_file = ScanRowFonts.file_font(rows.first)
+        entries = variable_font_entries(font_file, path)
+        entries.empty? ? parse_font(font_file, path) : entries
+      end
+    end
+
     def display_progress(current, total, path, spinner_chars,
 spinner_index = nil)
       spinner_index ||= (current / 10) % spinner_chars.length

data/lib/fontist/validator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "fontisan"
 require "parallel"
 
 module Fontist
@@ -43,14 +44,11 @@ module Fontist
       # Build read-only lookup from cache (non-shared state)
       cache_lookup = cache&.to_lookup || {}
 
-      # Validate in parallel or sequential
-      results = if use_parallel && font_paths.size > 10
-                  validate_parallel(font_paths, cache_lookup: cache_lookup,
-                                                verbose: verbose)
-                else
-                  validate_sequential(font_paths, cache_lookup: cache_lookup,
-                                                  verbose: verbose)
-                end
+      # Cache hits are reused; every miss goes through one batch scan.
+      parallel = use_parallel && font_paths.size > 10
+      results = validate_batched(font_paths, cache_lookup: cache_lookup,
+                                             parallel: parallel,
+                                             verbose: verbose)
 
       @report.results = results
       @report.calculate_summary!
@@ -153,41 +151,74 @@ module Fontist
 
     private
 
-    # Validate fonts in parallel using non-shared state.
-    # Each thread gets read-only cache_lookup (no shared writes)
-    def validate_parallel(font_paths, cache_lookup:, verbose:)
-      num_cores = [Parallel.processor_count, 8].min
+    # Reuse unchanged cache entries, then validate the misses with a single
+    # Fontisan.scan. Results keep the order of +font_paths+.
+    def validate_batched(font_paths, cache_lookup:, parallel:, verbose:)
+      hits, misses = font_paths.partition do |path|
+        cached = cache_lookup[path]
+        cached && file_unchanged?(path, cached)
+      end
 
-      if verbose
-        Fontist.ui.say("Using parallel processing with #{num_cores} cores")
+      fresh = validate_misses(misses, parallel: parallel, verbose: verbose)
+      hit_set = hits.to_set
+      font_paths.filter_map do |path|
+        hit_set.include?(path) ? cache_lookup[path] : fresh[path]
       end
+    end
 
-      # Map: Each thread validates independently (non-shared state)
-      # cache_lookup is read-only, no mutex needed
-      Parallel.map(font_paths, in_threads: num_cores) do |path|
-        validate_with_cache_lookup(path, cache_lookup)
-      end.compact
+    # @return [Hash{String => FontValidationResult}]
+    def validate_misses(paths, parallel:, verbose:)
+      return {} if paths.empty?
+
+      fresh = scan_results(paths)
+      # Failing files keep the per-file path so their messages are unchanged.
+      leftovers = fresh.select { |_, result| result.nil? }.keys
+      validate_leftovers(leftovers, parallel: parallel, verbose: verbose)
+        .each { |result| fresh[result.path] = result }
+      fresh
     end
 
-    # Validate fonts sequentially with cache lookup.
-    def validate_sequential(font_paths, cache_lookup:, verbose:)
-      font_paths.filter_map do |path|
-        validate_with_cache_lookup(path, cache_lookup)
+    # One scan for all paths; nil marks a file the scan could not read.
+    def scan_results(paths)
+      started = Time.now
+      rows = Fontisan.scan(paths).group_by { |row| row["path"] }
+      share = ((Time.now - started) / paths.size).round(4)
+
+      paths.to_h do |path|
+        [path, result_from_rows(path, rows[path], share)]
       end
     end
 
-    # Validate single font, using cache if available and file unchanged.
-    def validate_with_cache_lookup(path, cache_lookup)
-      cached = cache_lookup[path]
-
-      # Check if cached result is still valid (file unchanged)
-      if cached && file_unchanged?(path, cached)
-        # Return cached result without re-validating
-        return cached
+    def validate_leftovers(paths, parallel:, verbose:)
+      if parallel && paths.size > 1
+        num_cores = [Parallel.processor_count, 8].min
+        if verbose
+          Fontist.ui.say("Using parallel processing with #{num_cores} cores")
+        end
+        Parallel.map(paths, in_threads: num_cores) { |p| validate_single(p) }
+      else
+        paths.map { |path| validate_single(path) }
       end
+    end
+
+    # A passing result when the scan row for +path+ read cleanly, else nil.
+    def result_from_rows(path, rows, time_taken)
+      row = rows&.first
+      return unless row && row["names"] && row["errors"]["font_file"].nil?
+
+      names = row["names"]
+      FontValidationResult.new(
+        path: path, valid: true, time_taken: time_taken,
+        family_name: names["family_name"], full_name: names["full_name"],
+        file_size: safe_stat { File.size(path) },
+        file_mtime: safe_stat { File.mtime(path).to_i }
+      )
+    end
 
-      # No cache or file changed - validate
-      validate_single(path)
+    def safe_stat
+      yield
+    rescue StandardError
+      0
     end
 
     # Check if file has unchanged metadata compared to cached result.

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.37".freeze
+  VERSION = "3.0.38".freeze
 end

data/lib/fontist.rb

@@ -50,6 +50,7 @@ module Fontist
 
   # Data models
   autoload :CollectionFile, "#{__dir__}/fontist/collection_file"
+  autoload :ScanRowFonts, "#{__dir__}/fontist/scan_row_fonts"
   autoload :Extract, "#{__dir__}/fontist/extract"
   autoload :ExtractOptions, "#{__dir__}/fontist/extract"
   autoload :Resource, "#{__dir__}/fontist/resource"

data/packaging/nfpm.yaml

@@ -27,7 +27,12 @@ overrides:
 
 contents:
   - src: ${BINARY}
-    dst: /usr/bin/fontist
+    dst: /usr/lib/fontist/fontist
     expand: true  # nfpm leaves ${BINARY} in src alone without this
     file_info:
       mode: 0755
+
+# The postinstall script links the binary into /usr/local/bin.
+scripts:
+  postinstall: packaging/scripts/postinstall.sh
+  preremove: packaging/scripts/preremove.sh

data/packaging/scripts/postinstall.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+# The binary lives in /usr/lib/fontist; make it reachable from /usr/local/bin.
+set -e
+mkdir -p /usr/local/bin
+ln -sf /usr/lib/fontist/fontist /usr/local/bin/fontist

data/packaging/scripts/preremove.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+# Remove the /usr/local/bin symlink on removal, not on upgrade. dpkg passes
+# "remove" or "purge"; rpm passes the number of copies left (0 on removal).
+set -e
+case "$1" in
+  remove|purge|0)
+    if [ "$(readlink /usr/local/bin/fontist 2>/dev/null)" = /usr/lib/fontist/fontist ]; then
+      rm -f /usr/local/bin/fontist
+    fi
+    ;;
+esac
+exit 0

data/script/tebako/git-prep.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Get git >= 2.43 on Ubuntu 22.04, the documented one-time step
+# before installing the fontist .deb (see README.adoc). Run as root.
+#
+#   script/tebako/git-prep.sh
+set -euo pipefail
+
+export DEBIAN_FRONTEND=noninteractive
+# shellcheck disable=SC1091
+. /etc/os-release
+
+apt-get update -qq
+case "$ID:$VERSION_ID" in
+  ubuntu:22.04)
+    apt-get install -y -qq ca-certificates software-properties-common
+    add-apt-repository -y ppa:git-core/ppa
+    apt-get update -qq
+    apt-get install -y -qq git
+    ;;
+  *)
+    echo "git-prep: nothing to do on $ID $VERSION_ID" >&2
+    exit 1
+    ;;
+esac
+git --version

data/script/tebako/package-smoke.sh

@@ -24,10 +24,15 @@ if command -v ruby >/dev/null; then
   echo "package-smoke: this image has no business carrying ruby" >&2
   exit 1
 fi
+link="$(readlink /usr/local/bin/fontist || true)"
+if [ "$link" != /usr/lib/fontist/fontist ]; then
+  echo "package-smoke: /usr/local/bin/fontist links to '$link'" >&2
+  exit 1
+fi
 "$here/smoke.sh" "$(command -v fontist)"
 remove
-if command -v fontist >/dev/null; then
-  echo "package-smoke: fontist still on PATH after removal" >&2
+if [ -e /usr/local/bin/fontist ] || [ -L /usr/local/bin/fontist ] || command -v fontist >/dev/null; then
+  echo "package-smoke: fontist still present after removal" >&2
   exit 1
 fi
 echo "package-smoke: ok"

data/script/tebako/package.sh

@@ -14,6 +14,9 @@ version="$(sed -n 's/.*VERSION = "\(.*\)".*/\1/p' "$root/lib/fontist/version.rb"
 
 mkdir -p "$out"
 BINARY="$(cd "$(dirname "$binary")" && pwd)/$(basename "$binary")"
+out="$(cd "$out" && pwd)"
+# nfpm resolves the script paths in nfpm.yaml against the working directory.
+cd "$root"
 export ARCH="$arch" VERSION="$version" BINARY
 
 for packager in deb rpm; do

data/script/tebako/smoke.sh

@@ -3,7 +3,8 @@
 #
 #   script/tebako/smoke.sh <fontist-executable>
 #
-# Uses a throwaway FONTIST_PATH so it never touches a real ~/.fontist.
+# Uses a throwaway FONTIST_PATH, then a throwaway HOME, so it never touches a
+# real ~/.fontist.
 set -euo pipefail
 
 fontist="${1:?usage: smoke.sh <fontist-executable>}"
@@ -13,6 +14,7 @@ home="$(mktemp -d)"
 trap 'rm -rf "$home"' EXIT
 export FONTIST_PATH="$home"
 
+"$fontist" --version
 "$fontist" version
 "$fontist" install --accept-all-licenses "$font"
 
@@ -22,4 +24,13 @@ if ! find "$home/fonts" -type f | grep -q .; then
 fi
 "$fontist" list "$font" | tee "$home/list.txt"
 grep -qi "installed" "$home/list.txt"
+
+# Without FONTIST_PATH, fonts land in ~/.fontist.
+user_home="$(mktemp -d)"
+trap 'rm -rf "$home" "$user_home"' EXIT
+env -u FONTIST_PATH HOME="$user_home" "$fontist" install --accept-all-licenses "$font"
+if ! find "$user_home/.fontist/fonts" -type f | grep -q .; then
+  echo "smoke: no font file landed under $user_home/.fontist/fonts" >&2
+  exit 1
+fi
 echo "smoke: ok"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontist
 version: !ruby/object:Gem::Version
-  version: 3.0.37
+  version: 3.0.38
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-07 00:00:00.000000000 Z
+date: 2026-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -53,7 +53,7 @@ dependencies:
         version: '0.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.47
+        version: 0.4.48
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -63,7 +63,7 @@ dependencies:
         version: '0.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.47
+        version: 0.4.48
 - !ruby/object:Gem::Dependency
   name: fuzzy_match
   requirement: !ruby/object:Gem::Requirement
@@ -232,6 +232,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: yeptris
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.55
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.55
 description: Install openly-licensed fonts on Windows, Linux and Mac!
 email:
 - open.source@ribose.com
@@ -490,6 +504,7 @@ files:
 - lib/fontist/resources/archive_resource.rb
 - lib/fontist/resources/google_resource.rb
 - lib/fontist/resources/windows_fod_resource.rb
+- lib/fontist/scan_row_fonts.rb
 - lib/fontist/sil_import_source.rb
 - lib/fontist/style_version.rb
 - lib/fontist/system.yml
@@ -518,10 +533,13 @@ files:
 - lib/fontist/yaml_backend.rb
 - lib/tasks/system_fonts.rake
 - packaging/nfpm.yaml
+- packaging/scripts/postinstall.sh
+- packaging/scripts/preremove.sh
 - script/capture_system_fonts
 - script/download_system_indexes
 - script/generate_windows_formulas.rb
 - script/tebako/entry.rb
+- script/tebako/git-prep.sh
 - script/tebako/package-smoke.sh
 - script/tebako/package.sh
 - script/tebako/press.sh