fontist 3.0.15 → 3.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e34cf04876b1c50b7ada12a6d8c23a1954baaecc499433d25844f2c0df899c97
-  data.tar.gz: 3728d8848dd1eb1d92ef0f7b28d251e1f9ef3a9d5d3ec7592f39607f05d9b3d0
+  metadata.gz: aa8aac3407b7b54563dc14319ade845a761256f0ce2d324ed9a7a1da7dfe9613
+  data.tar.gz: 2ec396abab12f551459a0e7455355243c46e0f4359bf2de4f018ebcde46a30e0
 SHA512:
-  metadata.gz: 415419b02587672d1e4676365a2658f0d126f1860a2b67f22aef5509dcb14268deab6db07847b655151612247b94d029bfb9cea65352b8d80a41b017f6c97b76
-  data.tar.gz: 6cab85a340fb53f66d2ba771de09aa6d13a882a98aeb60ffd806da24207a669b61e8d9e57f59821107f6231f5b1070f18a107fde561289d787a32fb2afd3ca09
+  metadata.gz: dd1a4460fc10c117bb6d7fc3dcbced001f83c918c64e70621778575e7edce78544a94fbbbbe5e64f22294e5c0525af723043055feae62f3a21fe299020cdda71
+  data.tar.gz: 33e5d409a00bd73c39e839a9a9acad2f31aa2dde95697f1ad08ebfc4f0d2aa980cfb8cac95524b8fdc310c1e880546dbf09bb15ebd3060d44a71948821f35db9

data/lib/fontist/formula.rb

@@ -1,4 +1,5 @@
 require "lutaml/model"
+require "parallel"
 require_relative "format_matcher"
 require "git"
 
@@ -100,9 +101,14 @@ module Fontist
       end
 
       def all
-        formulas = Dir[Fontist.formulas_path.join("**/*.yml").to_s].filter_map do |path|
+        paths = Dir[Fontist.formulas_path.join("**/*.yml").to_s]
+
+        # Parsing thousands of formula files dominates index rebuilds;
+        # worker threads overlap the libyaml C parse, which releases
+        # the GVL
+        formulas = Parallel.map(paths) do |path|
           Formula.from_file(path)
-        end
+        end.compact
 
         FormulaCollection.new(formulas)
       end

data/lib/fontist/from_file_cache.rb

@@ -8,21 +8,39 @@ module Fontist
   # changes (e.g. after `fontist update` rewrites the formulas repo).
   module FromFileCache
     def self.memoize(path)
-      mutex.synchronize do
-        mtime = File.mtime(path)
-        entry = cache[path]
-        if entry.nil? || entry[:mtime] != mtime
-          entry = { mtime: mtime, value: yield }
-          cache[path] = entry
-        end
-        entry[:value]
-      end
+      mtime = File.mtime(path)
+
+      hit = current_value(path, mtime)
+      return hit if hit
+
+      # Parse without holding the lock so parallel readers (e.g.
+      # Formula.all over worker threads) overlap; concurrent misses on
+      # the same path may duplicate work but write identical values
+      value = yield
+
+      store(path, mtime, value)
+
+      value
     end
 
     def self.clear
       mutex.synchronize { cache.clear }
     end
 
+    def self.current_value(path, mtime)
+      hit = mutex.synchronize { cache[path] }
+      hit&.fetch(:mtime, nil) == mtime ? hit[:value] : nil
+    end
+
+    def self.store(path, mtime, value)
+      mutex.synchronize do
+        existing = cache[path]
+        if existing.nil? || existing[:mtime] != mtime
+          cache[path] = { mtime: mtime, value: value }
+        end
+      end
+    end
+
     def self.mutex
       @mutex ||= Mutex.new
     end

data/lib/fontist/system_index.rb

@@ -100,6 +100,39 @@ module Fontist
     end
   end
 
+  # Thread-safe progress display for parallel index scans
+  class ScanProgress
+    SPINNER_CHARS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].freeze
+
+    def initialize(total, verbose:, &on_step)
+      @total = total
+      @verbose = verbose
+      @on_step = on_step
+      @mutex = Mutex.new
+      @processed = 0
+      # Show minimal progress for large collections even in non-verbose mode
+      @minimal = !verbose && total > 100
+      @interval = total > 1000 ? 100 : 50
+    end
+
+    def step(path)
+      @mutex.synchronize do
+        @processed += 1
+        if @verbose
+          @on_step&.call(@processed, path)
+        elsif @minimal && report?
+          Fontist.ui.say("Scanning fonts: #{@processed}/#{@total}...")
+        end
+      end
+    end
+
+    private
+
+    def report?
+      (@processed % @interval).zero? || @processed == @total
+    end
+  end
+
   # {:path=>"/Library/Fonts/Arial Unicode.ttf",
   # :full_name=>"Arial Unicode MS",
   # :family_name=>"Arial Unicode MS",
@@ -518,33 +551,38 @@ stats:)
       if verbose
         puts Paint["Using parallel processing with #{num_cores} cores",
                    :cyan]
-      end
-
-      # Thread-safe progress tracking
-      progress_mutex = Mutex.new
-      processed_count = 0
-      spinner_chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
 
-      # Show minimal progress for large collections even in non-verbose mode
-      show_minimal_progress = !verbose && sorted_paths.size > 100
-      progress_interval = sorted_paths.size > 1000 ? 100 : 50
+        # Verbose runs keep threads so live progress and per-font stats
+        # stay visible; fontisan parsing is GVL-bound, so this mode is
+        # slow, but it is the human-attended path
+        process_paths_in_threads(sorted_paths, existing_fonts_by_path,
+                                 verbose: verbose, stats: stats,
+                                 num_workers: num_cores)
+      else
+        # Measured on 600 system fonts: single thread 2.3s, 8 threads
+        # 3.3s (GVL-bound, mutex contention), 8 processes 0.6s. The
+        # silent build path therefore forks instead of threading
+        results = Parallel.map(sorted_paths, in_processes: num_cores) do |path|
+          detect_font_with_cache(path, existing_fonts_by_path[path],
+                                 stats: nil)
+        end.flatten.compact
+
+        stats&.total_fonts = results.size
+        results
+      end
+    end
 
-      results = Parallel.map(sorted_paths, in_threads: num_cores) do |path|
-        cached = existing_fonts_by_path[path]
-        result = detect_font_with_cache(path, cached, stats: stats)
-
-        # Update progress (thread-safe)
-        progress_mutex.synchronize do
-          processed_count += 1
-          if verbose && stats
-            display_progress(processed_count, sorted_paths.size, path,
-                             spinner_chars)
-          elsif show_minimal_progress && ((processed_count % progress_interval).zero? || processed_count == sorted_paths.size)
-            # Show minimal progress every N fonts or at the end
-            Fontist.ui.say("Scanning fonts: #{processed_count}/#{sorted_paths.size}...")
-          end
-        end
+    def process_paths_in_threads(sorted_paths, existing_fonts_by_path,
+verbose:, stats:, num_workers:)
+      progress = ScanProgress.new(sorted_paths.size, verbose: verbose) do |count, path|
+        display_progress(count, sorted_paths.size, path,
+                         ScanProgress::SPINNER_CHARS)
+      end
 
+      results = Parallel.map(sorted_paths, in_threads: num_workers) do |path|
+        result = detect_font_with_cache(path, existing_fonts_by_path[path],
+                                        stats: stats)
+        progress.step(path)
         result
       end.flatten.compact
 

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.15".freeze
+  VERSION = "3.0.17".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontist
 version: !ruby/object:Gem::Version
-  version: 3.0.15
+  version: 3.0.17
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-31 00:00:00.000000000 Z
+date: 2026-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down