fontist 3.0.26 → 3.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 215b46de2d4feadfbd1d3644dd060cc5afdd54afd30ba1f6a50e428c5c2be4ef
-  data.tar.gz: 7eea12f0743488fbfbd4c5d924a2bfce06de918aaa9cf4bbc24b92fbe02d937f
+  metadata.gz: cdbd031efa6ca583a610246930ceddc3cc365f3b6047d49ccc9287efee8223ec
+  data.tar.gz: a5bc28594e55dc5e7a2050293338d9f19597edc44801dfe3bb5c98b9adb900ea
 SHA512:
-  metadata.gz: 93ddd5d5863d137e0ed95f9e8829b2bb84797b7887f8d9a122f8259f920bde832f3d810b1057539504b1f7b584ba7e4d245726943cdcdc1a874c9656c52b125c
-  data.tar.gz: 2af73abb7b5d07aa4a5699aa309fbeec7e8053b7944f902a26a7e70804e3ff71c511dda0e0bb68e4e1e7e5f2e841e265eb08c06095de5f8390dd82e312190b79
+  metadata.gz: 2d7ec1b13570f62ebe344a5b0e11d18b13e4160ed1e76f4ccbdf93fe3f5d40d376b4af457ee5e5e3f658afbe6c9df9a144a0f011f98cbc2eb39163c15f77f014
+  data.tar.gz: 8ebaacfb87497c01fbc41c9074e4febbca0f788f7d81ab6c1d409ae0b7123cdc9d78dbd24501fb03cfa824dcc4932cb10d64f203039185582456a0a466e00410

data/lib/fontist/cache/store.rb

@@ -1,10 +1,24 @@
 require "fileutils"
 require "digest"
+require "json"
 
 module Fontist
   module Cache
-    # Backend store using Marshal for serialization
+    # Backend store persisting entries as inert JSON.
+    #
+    # The previous Marshal backend was removed deliberately: Marshal
+    # load of a file from a user-writable path executes arbitrary
+    # object instantiation on tampered content, and fontist runs
+    # embedded in long-lived host processes where that escalation
+    # lands. Values must be
+    # JSON-native (hashes with string keys, arrays, strings, numbers,
+    # booleans, nil); anything else skips the write and reads back as
+    # a miss. Files written by the previous Marshal backend carry a
+    # different extension and are simply never read; #clear removes
+    # them.
     class Store
+      FORMAT_VERSION = 1
+
       def initialize(cache_dir)
         @cache_dir = cache_dir.to_s
         ensure_cache_dir
@@ -26,6 +40,10 @@ module Fontist
         ensure_cache_dir
         entry = CacheEntry.new(value, ttl)
         write_entry(key, entry)
+      rescue TypeError, JSON::GeneratorError
+        # Values outside the JSON type system (Time, Date, arbitrary
+        # objects) skip the write and read back as a miss
+        false
       end
 
       def delete(key)
@@ -35,20 +53,29 @@ module Fontist
       end
 
       def clear
-        Dir.glob(File.join(@cache_dir, "*.marshal")).each do |f|
-          File.delete(f)
-        rescue StandardError
-          nil
-        end
+        glob_delete("*.json")
+        # Sweep entries written by the pre-JSON Marshal backend
+        glob_delete("*.marshal")
       end
 
       def cleanup_temp_files
-        # Clean up orphaned .tmp files from interrupted writes
-        # This can happen if the process crashes between File.write and File.rename
-        Dir.glob(File.join(@cache_dir, "*.tmp")).each do |tmp|
-          File.delete(tmp)
-        rescue StandardError
-          nil
+        # Clean up orphaned .tmp files from interrupted writes: this
+        # happens when a process crashes between write and rename
+        glob_delete("*.tmp")
+      end
+
+      # Cache entry with TTL support
+      class CacheEntry
+        attr_reader :value, :expires_at
+
+        def initialize(value, ttl = nil, expires_at: nil)
+          @value = value
+          @expires_at = expires_at
+          @expires_at ||= (Time.now + ttl).to_i if ttl
+        end
+
+        def expired?
+          !!(@expires_at && Time.now.to_i > @expires_at)
         end
       end
 
@@ -61,7 +88,7 @@ module Fontist
       end
 
       def cache_path(key)
-        File.join(@cache_dir, "#{sanitize_key(key)}.marshal")
+        File.join(@cache_dir, "#{sanitize_key(key)}.json")
       end
 
       def sanitize_key(key)
@@ -75,57 +102,44 @@ module Fontist
         end
       end
 
+      def glob_delete(pattern)
+        Dir.glob(File.join(@cache_dir, pattern)).each do |f|
+          File.delete(f)
+        rescue StandardError
+          nil
+        end
+      end
+
       def read_entry(key)
         return nil unless File.exist?(cache_path(key))
 
-        begin
-          # Use binary read mode for Marshal data - critical on Windows
-          Marshal.load(File.binread(cache_path(key)))
-        rescue ArgumentError, TypeError, EOFError
-          # Cache file is corrupted - delete it and return nil
-          # This can happen on Windows when file is read while being written,
-          # or when cache files from previous runs are corrupted
-          begin
-            File.delete(cache_path(key))
-          rescue StandardError
-            nil
-          end
-          nil
-        end
+        payload = JSON.parse(File.read(cache_path(key)))
+        CacheEntry.new(payload["value"], expires_at: payload["expires_at"])
+      rescue JSON::ParserError, TypeError, EOFError
+        # Corrupted file - delete it and return nil. This can happen
+        # on Windows when a file is read while being written, or when
+        # cache files from previous runs are corrupted
+        delete(key)
+        nil
       end
 
       def write_entry(key, entry)
-        # Use temp file + atomic rename to prevent race conditions
-        # This ensures readers never see partial writes, even on Windows
-        temp_path = "#{cache_path(key)}.tmp"
+        payload = entry_payload(entry)
 
-        # Use binary write mode for Marshal data - critical on Windows
-        File.binwrite(temp_path, Marshal.dump(entry))
-        # Atomic rename (overwrites target atomically)
-        # File.rename is atomic on all platforms for same filesystem
+        # Temp file + atomic rename: readers never see partial writes
+        temp_path = "#{cache_path(key)}.tmp"
+        File.write(temp_path, payload)
         File.rename(temp_path, cache_path(key))
       rescue StandardError => e
-        # Clean up temp file if rename fails
-        begin
-          File.delete(temp_path)
-        rescue StandardError
-          nil
-        end
+        # Clean up temp file if the write or rename fails
+        delete(temp_path)
         raise e
       end
 
-      # Cache entry with TTL support
-      class CacheEntry
-        attr_reader :value, :expires_at
-
-        def initialize(value, ttl)
-          @value = value
-          @expires_at = ttl ? (Time.now + ttl).to_i : nil
-        end
-
-        def expired?
-          !!(@expires_at && Time.now.to_i > @expires_at)
-        end
+      def entry_payload(entry)
+        JSON.dump("version" => FORMAT_VERSION,
+                  "expires_at" => entry.expires_at,
+                  "value" => entry.value)
       end
     end
   end

data/lib/fontist/indexes/directory_snapshot.rb

@@ -13,11 +13,15 @@ module Fontist
         new(directory_path, files, Time.now.to_i)
       end
 
-      # Create from existing data (for cache restoration)
+      # Create from existing data (for cache restoration). The cache
+      # store serializes to JSON, so keys arrive as strings; normalize
+      # them back to the symbol-keyed shape used throughout this class
       def self.from_hash(hash)
+        hash = (hash || {}).transform_keys(&:to_sym)
+        files = Array(hash[:files]).map { |file| file.transform_keys(&:to_sym) }
         new(
           hash[:directory_path].to_s,
-          hash[:files],
+          files,
           hash[:scanned_at],
         )
       end

data/lib/fontist/indexes/index_mixin.rb

@@ -75,6 +75,7 @@ module Fontist
           # Drop the memoized parsed instance along with the index file,
           # to force a fresh parse on next access
           Fontist::FromFileCache.clear
+          reset_sidecar_cache
 
           # Delete the index file and its lookup sidecar to force a
           # rebuild on next access. This is important for tests to
@@ -96,10 +97,12 @@ module Fontist
         def sidecar_entries
           sidecar_path = "#{path}.json"
           return unless File.exist?(sidecar_path)
-          return if File.exist?(path) &&
-            File.mtime(sidecar_path) < File.mtime(path)
+          return if sidecar_stale?(sidecar_path)
 
-          JSON.parse(File.read(sidecar_path))["entries"]
+          entries = cached_sidecar_entries(sidecar_path)
+          return entries if entries
+
+          parse_sidecar_entries(sidecar_path)
         rescue JSON::ParserError, TypeError
           nil
         end
@@ -109,6 +112,51 @@ module Fontist
           File.write("#{path}.json", JSON.dump("entries" => entries_hash))
           entries_hash
         end
+
+        private
+
+        def sidecar_stale?(sidecar_path)
+          File.exist?(path) && File.mtime(sidecar_path) < File.mtime(path)
+        end
+
+        def cached_sidecar_entries(sidecar_path)
+          mtime = File.mtime(sidecar_path)
+          entry = nil
+          sidecar_cache_mutex.synchronize do
+            entry = sidecar_cache[sidecar_path]
+          end
+          entry[:entries] if entry&.fetch(:mtime, nil) == mtime
+        end
+
+        # Parsing the sidecar costs tens of milliseconds per call and
+        # lookups re-enter many times per operation (every printed font
+        # path consults the filename sidecar), so parsed entries are
+        # memoized per sidecar mtime and shared between callers; treat
+        # as read-only
+        def parse_sidecar_entries(sidecar_path)
+          mtime = File.mtime(sidecar_path)
+          entries = JSON.parse(File.read(sidecar_path))["entries"]
+
+          sidecar_cache_mutex.synchronize do
+            sidecar_cache[sidecar_path] = { mtime: mtime, entries: entries }
+          end
+
+          entries
+        end
+
+        # Class-level cache of parsed sidecar entries, invalidated by
+        # sidecar mtime so `fontist update` rewrites are picked up
+        def sidecar_cache
+          @sidecar_cache ||= {}
+        end
+
+        def sidecar_cache_mutex
+          @sidecar_cache_mutex ||= Mutex.new
+        end
+
+        def reset_sidecar_cache
+          sidecar_cache_mutex.synchronize { sidecar_cache.clear }
+        end
       end
 
       # Build index by loading all formulas from disk.

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.26".freeze
+  VERSION = "3.0.28".freeze
 end

metadata

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