fontist 3.0.25 → 3.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e161f1ace760cebffefd73f61835fef3abb2875972836c3ad7e82324a465d11
-  data.tar.gz: 85f425e3a050b0e9674e32b413d750bde0d40e4e34f3c261c6138dadc571e0a5
+  metadata.gz: 4bca0e4898879c116eb90bccf581f82177caafe4b981ac97d2ed974dbb9c19d2
+  data.tar.gz: 409088146ecdb388d8efd008f0b7d1d908863fb8d27b6d58aa5371812f5b93bb
 SHA512:
-  metadata.gz: 282670c9e6c9ebc53dedbaa927e80259a489f44bc33392d388c977ad909209b721b354b7922a2190f0e7554221a63ca3c15a234a55b100e27bdce92cca1e496e
-  data.tar.gz: 46ca6895943eefe3a7dce37a6e4cf08241530b6dfacc9fef5233f259ea091ab9d94aac2d4bdd903cc468948d3783a6ceff66219fd04f3514576f88a4a62048ef
+  metadata.gz: 49bbea30d8a19d69ad796f7dd7fe49c7c6bf940d38a9aeef07aae568f7700cb1b4a9d39e1427f1002dca02837ed41768975fdc6e9baa37d8a4921235a6a6071d
+  data.tar.gz: adc3b7fe62335de562352d1c516d0c9c71298bf0b5c5764ab2ae8bd64fc921dc55814602e78e40440c6c916e15a3b0ca6649af8ba5f9b88f1ff672ed31f95be3

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/system_index.rb

@@ -140,6 +140,33 @@ module Fontist
     end
   end
 
+  # Scan metadata for a system index collection, persisted in a
+  # companion file beside the index (an index file is a flat entry
+  # list and cannot carry scalars). Restoring it across processes is
+  # what makes the 30-minute scan threshold and the directory-mtime
+  # change check work at all.
+  class SystemIndexMetadata < Lutaml::Model::Serializable
+    attribute :last_scan_time, :integer, default: -> { 0 }
+    attribute :directory_mtimes, :string, collection: true, default: -> { [] }
+
+    key_value do
+      map "last_scan_time", to: :last_scan_time
+      map "directory_mtimes", to: :directory_mtimes
+    end
+
+    def self.load(path)
+      return new unless File.exist?(path)
+
+      from_yaml(File.read(path))
+    rescue Lutaml::Model::Error, Psych::SyntaxError, TypeError
+      new
+    end
+
+    def save(path)
+      File.write(path, to_yaml)
+    end
+  end
+
   class SystemIndexFontCollection < Lutaml::Model::Collection
     include Utils::Locking
 
@@ -151,14 +178,40 @@ module Fontist
     attribute :directory_mtimes, :string, collection: true, default: -> { [] }
 
     key_value do
+      # A bare entry list: the scan metadata lives in a companion
+      # metadata file (see SystemIndexMetadata), because a flat list
+      # cannot carry scalars and lutaml ignores scalar maps declared
+      # alongside map_instances
       map_instances to: :fonts
-      map "last_scan_time", to: :last_scan_time
-      map "directory_mtimes", to: :directory_mtimes
     end
 
     # Don't rebuild index more frequently than this (in seconds)
     INDEX_REBUILD_THRESHOLD = 30 * 60 # 30 minutes
 
+    def metadata_path
+      "#{@path}.metadata.yml"
+    end
+
+    def persist_metadata
+      return unless @path
+
+      SystemIndexMetadata
+        .new(last_scan_time: last_scan_time,
+             directory_mtimes: directory_mtimes)
+        .save(metadata_path)
+    end
+
+    def restore_metadata
+      return unless @path
+      return unless last_scan_time.to_i.zero?
+
+      meta = SystemIndexMetadata.load(metadata_path)
+      return unless meta.last_scan_time.to_i.positive?
+
+      self.last_scan_time = meta.last_scan_time
+      self.directory_mtimes = meta.directory_mtimes
+    end
+
     def set_path(path)
       @path = path
     end
@@ -172,12 +225,17 @@ module Fontist
       return new.set_content(path, paths_loader) unless File.exist?(path)
 
       from_yaml(File.read(path)).set_content(path, paths_loader)
+    rescue Lutaml::Model::Error, Psych::SyntaxError, TypeError
+      # Corrupt or unreadable index files degrade to an empty
+      # collection; the next rebuild rewrites them
+      new.set_content(path, paths_loader)
     end
 
     def set_content(path, paths_loader)
       tap do |content|
         content.set_path(path)
         content.set_path_loader(paths_loader)
+        content.restore_metadata
       end
     end
 
@@ -351,7 +409,8 @@ module Fontist
 
     def build(forced: false, verbose: false, stats: nil)
       if forced
-        return rebuild_with_lock(verbose: verbose, stats: stats)
+        return rebuild_with_lock(verbose: verbose, stats: stats,
+                                 honor_recent: false)
       end
 
       previous_index = load_index
@@ -372,14 +431,18 @@ module Fontist
 
     private
 
-    def rebuild_with_lock(verbose: false, stats: nil)
+    def rebuild_with_lock(verbose: false, stats: nil, honor_recent: true)
       # Use file locking to prevent concurrent rebuilds across processes
       lock_path = index_lock_path
       start_time = Time.now
 
       lock(lock_path) do
-        # Re-check if another process already rebuilt while we waited for lock
-        if File.exist?(@path)
+        # Re-check if another process already rebuilt while we waited
+        # for lock. Forced rebuilds (add_font, explicit rebuild) carry
+        # write intent and must always rescan: honoring the recent
+        # rebuild here served the pre-write index and silently dropped
+        # the font that triggered the rebuild
+        if honor_recent && File.exist?(@path)
           existing = self.class.from_file(path: @path,
                                           paths_loader: @paths_loader)
 
@@ -407,6 +470,7 @@ module Fontist
         self.last_scan_time = Time.now.to_i
         self.directory_mtimes = scan_directory_mtimes.map { |k, v| "#{k}:#{v}" }
         to_file(@path)
+        persist_metadata
 
         # Show completion message for large collections
         elapsed = Time.now - start_time
@@ -505,6 +569,7 @@ module Fontist
 
       # Save to file
       to_file(@path)
+      persist_metadata
     end
 
     def detect_paths(paths, verbose: false, stats: nil)

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.25".freeze
+  VERSION = "3.0.27".freeze
 end

data/lib/fontist.rb

@@ -25,6 +25,7 @@ module Fontist
   autoload :FontPath, "#{__dir__}/fontist/font_path"
   autoload :FontStyle, "#{__dir__}/fontist/font_style"
   autoload :Fontconfig, "#{__dir__}/fontist/fontconfig"
+  autoload :FormatSpec, "#{__dir__}/fontist/format_spec"
   autoload :Formula, "#{__dir__}/fontist/formula"
   autoload :FormulaCollection, "#{__dir__}/fontist/formula"
   autoload :FormulaPicker, "#{__dir__}/fontist/formula_picker"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontist
 version: !ruby/object:Gem::Version
-  version: 3.0.25
+  version: 3.0.27
 platform: ruby
 authors:
 - Ribose Inc.