fontist 3.0.29 → 3.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e972a1c6d0f3be11f50cbb811780bdd52ed08be5ac1fb0e51c437872421fe539
-  data.tar.gz: 04db98584e91f4edbba08f9934703f2e5f6dd9c361ae6dc3214cd5f0b9e4450f
+  metadata.gz: 2e9016d35c6100b87e2a7585f7193a8fbac76a1a32ab01e178a2d95bef017fa5
+  data.tar.gz: 6f02798721c34a5402bf413c9e1c003c3e968d1e01de44ae3562b726cf65bdb4
 SHA512:
-  metadata.gz: c3f3895e3e9293463b26957ac2be169cee7b6899c3c19e196ad1aaecf708322e419a1d560d6ec64c6dcac25adf4729cab339f0a17a709b25b80e020a3e2b8e88
-  data.tar.gz: 7caab4cc37bc85e0a4b8ae7ff65e14f71083979acdf6078c59c0034b5e5fb51c22072a467a082cf5c6dbd2419556c6d346d080b26199b77bb50677f81c0b21f0
+  metadata.gz: 7b2a062de85a9d66e0ec4e6e6d726c1d6716f8653c4ee96313eea8ba379941476064121d014851ce15bc6e7cf59ee4dcf3b77d68cd43fef7863238b9bbb55a68
+  data.tar.gz: 4d92357d6f58a7a1588bf4e6fb7793c94bbd8e47ecd1106cf9bbab87ef4321a4dd7fd172cbafab873f10c27c2563224fb7634fc0ad652baeda59e2ec433597b7

data/fontist.gemspec

@@ -8,8 +8,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ribose Inc."]
   spec.email         = ["open.source@ribose.com"]
 
+  # rubocop:disable Layout/LineLength
   spec.summary       = "Install openly-licensed fonts on Windows, Linux and Mac!"
   spec.description   = "Install openly-licensed fonts on Windows, Linux and Mac!"
+  # rubocop:enable Layout/LineLength
   spec.homepage      = "https://github.com/fontist/fontist"
   spec.license       = "BSD-2-Clause"
 
@@ -34,11 +36,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency "fontisan", "~> 0.4", ">= 0.4.47"
   spec.add_dependency "fuzzy_match", "~> 2.1"
   spec.add_dependency "git", "~> 6.0"
-  spec.add_dependency "json", "~> 2.0"
   spec.add_dependency "lutaml-model", "~> 0.8.0"
   spec.add_dependency "marcel", "~> 1.0"
   spec.add_dependency "nokogiri", "~> 1.0"
-  spec.add_dependency "octokit", "~> 4.0"
+  spec.add_dependency "octokit", "~> 10.0"
   spec.add_dependency "paint", "~> 2.3"
   spec.add_dependency "parallel", "~> 1.24"
   spec.add_dependency "plist", "~> 3.0"

data/lib/fontist/cache/store.rb

@@ -40,7 +40,7 @@ module Fontist
         ensure_cache_dir
         entry = CacheEntry.new(value, ttl)
         write_entry(key, entry)
-      rescue TypeError, JSON::GeneratorError
+      rescue TypeError, Fontist::JSON::DumpError
         # Values outside the JSON type system (Time, Date, arbitrary
         # objects) skip the write and read back as a miss
         false
@@ -113,9 +113,9 @@ module Fontist
       def read_entry(key)
         return nil unless File.exist?(cache_path(key))
 
-        payload = JSON.parse(File.read(cache_path(key)))
+        payload = Fontist::JSON.parse(File.read(cache_path(key)))
         CacheEntry.new(payload["value"], expires_at: payload["expires_at"])
-      rescue JSON::ParserError, TypeError, EOFError
+      rescue Fontist::JSON::ParseError, 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
@@ -137,9 +137,16 @@ module Fontist
       end
 
       def entry_payload(entry)
-        JSON.dump("version" => FORMAT_VERSION,
-                  "expires_at" => entry.expires_at,
-                  "value" => entry.value)
+        Fontist::JSON.dump("version" => FORMAT_VERSION,
+                           "expires_at" => entry.expires_at,
+                           "value" => entry.value)
+      rescue Fontist::JSON::DumpError
+        # Values outside the JSON type system (Time, Date, arbitrary
+        # objects) degrade to their string form, keeping the cache a
+        # best-effort store instead of a source of crashes
+        Fontist::JSON.dump("version" => FORMAT_VERSION,
+                           "expires_at" => entry.expires_at,
+                           "value" => entry.value.to_s)
       end
     end
   end

data/lib/fontist/cli.rb

@@ -312,7 +312,7 @@ module Fontist
                 end
 
       if options[:json]
-        Fontist.ui.say(JSON.pretty_generate(results.map(&:to_h)))
+        Fontist.ui.say(Fontist::JSON.pretty(results.map(&:to_h)))
       else
         print_find_results(results)
       end

data/lib/fontist/font_file.rb

@@ -63,14 +63,30 @@ module Fontist
           font = validate_and_load_single_font(path)
         end
         names = extract_names_from_font(font)
-        # WOFF and WOFF2 fonts from Fontisan hold no open file to close.
+        # `has_table?` consults the table directory, which survives the
+        # metadata-mode load, so the fvar check is cheap; only an actual
+        # variable font pays for the follow-up full read. WOFF and WOFF2
+        # fonts from Fontisan hold no open file to close.
+        variable = font.has_table?("fvar")
         font.close if font.respond_to?(:close)
+        names[:variable_instances] = extract_variable_instances_from_path(path) if
+          variable && names[:family_name]
         names
       rescue StandardError => e
         raise_font_file_error(e)
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
+      def extract_variable_instances_from_path(path)
+        # Full mode: the metadata-mode loader gates fvar data out, so the
+        # instance pass needs the real table read; this runs only for
+        # fonts already identified as variable by the cheap directory check.
+        font = Fontisan::FontLoader.load(path, mode: :full, lazy: true)
+        extract_variable_instances(font)
+      ensure
+        font.close if font.respond_to?(:close)
+      end
+
       # rubocop:disable Metrics/MethodLength
       def validate_and_load_single_font(path)
         # Load font first (we need to validate it, not the file path)
@@ -183,6 +199,62 @@ module Fontist
       end
       # rubocop:enable Metrics/MethodLength
 
+      # Named instances of a variable font, as `{family:, style:, full_name:}`
+      # triples. A variable file carries every named instance in one fvar
+      # table, but its name table exposes only the default instance's
+      # family, so an index built from the name table alone registers the
+      # file under a single family ("Fira Code Light") and every lookup of
+      # the other families/styles misses it. The RIBBI mapping follows the
+      # convention static families use: Regular/Bold live on the base
+      # family, every other weight becomes its own "Base Weight" family.
+      #
+      # @return [Array<Hash>] empty for a static font
+      # rubocop:disable Metrics/MethodLength
+      def extract_variable_instances(font)
+        return [] unless font.has_table?("fvar")
+
+        fvar = font.table("fvar")
+        name_table = font.table(Fontisan::Constants::NAME_TAG)
+        return [] unless name_table
+
+        base = name_table.english_name(Fontisan::Tables::Name::PREFERRED_FAMILY) ||
+          extract_any_name(name_table, Fontisan::Tables::Name::PREFERRED_FAMILY) ||
+          name_table.english_name(Fontisan::Tables::Name::FAMILY)
+        return [] unless base
+
+        ribbi = ["regular", "bold", "italic", "bold italic"]
+
+        fvar.instances.filter_map do |instance|
+          # fvar yields plain hashes ({name_id:, flags:, coordinates:,
+          # postscript_name_id:}), not message objects.
+          style = name_table.english_name(instance[:name_id]) ||
+            extract_any_name(name_table, instance[:name_id])
+          next unless style
+
+          if ribbi.include?(style.downcase)
+            family = base
+            type = style
+            full_name = "#{family} #{style}"
+          else
+            family = "#{base} #{style}"
+            type = "Regular"
+            full_name = family
+          end
+
+          {
+            family: family,
+            style: type,
+            full_name: full_name,
+          }
+        end
+      rescue StandardError => e
+        Fontist.ui.debug(
+          "Could not read variable instances: #{e.message}",
+        )
+        []
+      end
+      # rubocop:enable Metrics/MethodLength
+
       # Extract any available name for a given name ID by manually decoding the name record
       def extract_any_name(name_table, name_id)
         # Find any name record with the matching name_id
@@ -256,5 +328,11 @@ module Fontist
     def preferred_subfamily_name
       @info[:preferred_subfamily]
     end
+
+    # Named instances of a variable font (`{family:, style:, full_name:}`
+    # triples); empty for a static font.
+    def variable_instances
+      @info[:variable_instances] || []
+    end
   end
 end

data/lib/fontist/formula.rb

@@ -106,10 +106,16 @@ module Fontist
         # Parsing thousands of formula files dominates index rebuilds;
         # worker threads overlap the libyaml C parse, which releases
         # the GVL. The pool is capped like every other fontist pool, so
-        # worker counts never scale with host core counts
+        # worker counts never scale with host core counts.
+        #
+        # The parses bypass the shared parse cache: a corpus sweep never
+        # hits it (the LRU holds 64 entries against thousands of files),
+        # so caching would only evict entries that lookups re-use and
+        # pin dozens of parsed formulas in long-lived host processes
+        # after the sweep ends
         workers = [Parallel.processor_count, 8].min
         formulas = Parallel.map(paths, in_threads: workers) do |path|
-          Formula.from_file(path)
+          Formula.from_file(path, cache: false)
         end.compact
 
         FormulaCollection.new(formulas)
@@ -181,7 +187,7 @@ module Fontist
         find_by_key(key)
       end
 
-      def from_file(path)
+      def from_file(path, cache: true)
         unless File.exist?(path)
           raise Fontist::Errors::FormulaNotFoundError,
                 "Formula file not found: #{path}"
@@ -192,8 +198,13 @@ module Fontist
         # Parsing a formula costs ~10-20ms and the same formula is
         # re-read on every lookup, so the parsed instance is memoized
         # (mtime-validated) and shared between callers; treat as
-        # read-only
-        formula = Fontist::FromFileCache.memoize(path) { from_yaml(content) }
+        # read-only. Callers that sweep the whole corpus pass
+        # cache: false, since their parses would only thrash the cache
+        formula = if cache
+                    Fontist::FromFileCache.memoize(path) { from_yaml(content) }
+                  else
+                    from_yaml(content)
+                  end
 
         formula.tap do |f|
           f.path = path

data/lib/fontist/from_file_cache.rb

@@ -41,6 +41,10 @@ module Fontist
         mutex.synchronize { cache.clear }
       end
 
+      def size
+        mutex.synchronize { cache.size }
+      end
+
       private
 
       attr_reader :mutex

data/lib/fontist/helpers.rb

@@ -3,7 +3,7 @@ module Fontist
     def self.url_object(request)
       return request unless request.include?("\"url\"")
 
-      obj = JSON.parse(request.gsub("=>", ":"))
+      obj = Fontist::JSON.parse(request.gsub("=>", ":"))
       Struct.new(:url, :headers).new(obj["url"], obj["headers"])
     end
 

data/lib/fontist/import/convert_formulas.rb

@@ -56,7 +56,7 @@ module Fontist
       end
 
       def stringify_keys(hash)
-        JSON.parse(hash.to_json)
+        Fontist::JSON.parse(Fontist::JSON.dump(hash))
       end
     end
   end

data/lib/fontist/import/google/data_sources/base.rb

@@ -58,8 +58,8 @@ module Fontist
               raise "API request failed: #{response.code} #{response.message}"
             end
 
-            JSON.parse(response.body)
-          rescue JSON::ParserError => e
+            Fontist::JSON.parse(response.body)
+          rescue Fontist::JSON::ParseError => e
             raise "Failed to parse API response: #{e.message}"
           rescue StandardError => e
             raise "Failed to fetch from API: #{e.message}"
@@ -90,7 +90,7 @@ module Fontist
           # @param item [Hash] the raw item data
           # @return [FontFamily] the parsed font family
           def parse_item(item)
-            Models::FontFamily.from_json(item.to_json)
+            Models::FontFamily.from_json(Fontist::JSON.dump(item))
           end
         end
       end

data/lib/fontist/import/google/models/font_family.rb

@@ -59,15 +59,15 @@ module Fontist
 
             # Try to parse as JSON first
             begin
-              JSON.parse(files_data)
-            rescue JSON::ParserError, TypeError
+              Fontist::JSON.parse(files_data)
+            rescue Fontist::JSON::ParseError, TypeError
               # If it fails, convert Ruby hash syntax to JSON and parse
               if files_data.is_a?(String)
                 # Convert Ruby hash syntax (=>) to JSON syntax (:)
                 json_str = files_data.gsub("=>", ":")
                 begin
-                  return JSON.parse(json_str)
-                rescue JSON::ParserError
+                  return Fontist::JSON.parse(json_str)
+                rescue Fontist::JSON::ParseError
                   {}
                 end
               end

data/lib/fontist/import/helpers/hash_helper.rb

@@ -4,7 +4,7 @@ module Fontist
       module HashHelper
         class << self
           def stringify_keys(hash)
-            JSON.parse(hash.to_json)
+            Fontist::JSON.parse(Fontist::JSON.dump(hash))
           end
         end
       end

data/lib/fontist/import/v4_to_v5_migrator.rb

@@ -95,7 +95,7 @@ module Fontist
       def load_yaml_without_aliases(path)
         data = YAML.safe_load(File.read(path), aliases: true,
                                                permitted_classes: [Date])
-        JSON.parse(JSON.generate(data))
+        Fontist::JSON.parse(Fontist::JSON.dump(data))
       end
 
       def file_has_yaml_aliases?(path)

data/lib/fontist/index_cli.rb

@@ -205,7 +205,7 @@ module Fontist
       case options[:format].downcase
       when "json"
         require "json"
-        puts JSON.pretty_generate(fonts_data)
+        puts Fontist::JSON.pretty(fonts_data)
       when "yaml"
         require "yaml"
         puts YAML.dump(fonts_data)

data/lib/fontist/indexes/index_mixin.rb

@@ -103,13 +103,13 @@ module Fontist
           return entries if entries
 
           parse_sidecar_entries(sidecar_path)
-        rescue JSON::ParserError, TypeError
+        rescue Fontist::JSON::ParseError, TypeError
           nil
         end
 
         def rebuild_sidecar_entries
           entries_hash = from_file(path).entries_hash
-          File.write("#{path}.json", JSON.dump("entries" => entries_hash))
+          File.write("#{path}.json", Fontist::JSON.dump("entries" => entries_hash))
           entries_hash
         end
 
@@ -135,7 +135,7 @@ module Fontist
         # as read-only
         def parse_sidecar_entries(sidecar_path)
           mtime = File.mtime(sidecar_path)
-          entries = JSON.parse(File.read(sidecar_path))["entries"]
+          entries = Fontist::JSON.parse(File.read(sidecar_path))["entries"]
 
           sidecar_cache_mutex.synchronize do
             sidecar_cache[sidecar_path] = { mtime: mtime, entries: entries }
@@ -244,7 +244,7 @@ module Fontist
 
       def write_lookup_sidecar(file_path)
         File.write("#{file_path}.json",
-                   JSON.dump("entries" => entries_hash))
+                   Fontist::JSON.dump("entries" => entries_hash))
       end
 
       # key -> formula paths, in the sidecar's JSON-friendly shape

data/lib/fontist/json.rb

@@ -0,0 +1,76 @@
+require "yeptris"
+require "yeptris/json"
+
+module Fontist
+  # JSON encoding and decoding through yeptris's native engine, replacing
+  # the json gem as fontist's JSON backend. The yeptris parser and
+  # generator produce and accept the same plain Ruby structures as the
+  # json gem (string keys, arrays, scalars), so this module is a
+  # drop-in surface; call sites rescue the module's error classes
+  # instead of JSON::ParserError and JSON::GeneratorError.
+  module JSON
+    class Error < StandardError; end
+    class ParseError < Error; end
+    class DumpError < Error; end
+
+    class << self
+      def parse(source)
+        unless source.is_a?(String)
+          raise ParseError,
+                "cannot parse #{source.class}"
+        end
+
+        Yeptris::JSON.load(source)
+      rescue Yeptris::Error, TypeError => e
+        raise ParseError, e.message
+      end
+
+      def dump(object)
+        Yeptris::JSON.dump(object)
+      rescue Yeptris::Error, TypeError => e
+        raise DumpError, e.message
+      end
+
+      # Two-space-indented JSON for human-facing CLI output; yeptris's
+      # generator is compact-only, so the indentation is applied here
+      def pretty(object)
+        pretty_value(object, 0)
+      end
+
+      private
+
+      def pretty_value(value, depth)
+        case value
+        when Hash then pretty_object(value, depth)
+        when Array then pretty_array(value, depth)
+        else dump(value)
+        end
+      end
+
+      def pretty_object(hash, depth)
+        return "{}" if hash.empty?
+
+        inner = hash.map do |key, value|
+          "#{indent(depth + 1)}#{dump(key.to_s)}: #{pretty_value(value,
+                                                                 depth + 1)}"
+        end
+
+        "{\n#{inner.join(",\n")}\n#{indent(depth)}}"
+      end
+
+      def pretty_array(array, depth)
+        return "[]" if array.empty?
+
+        inner = array.map do |value|
+          "#{indent(depth + 1)}#{pretty_value(value, depth + 1)}"
+        end
+
+        "[\n#{inner.join(",\n")}\n#{indent(depth)}]"
+      end
+
+      def indent(depth)
+        "  " * depth
+      end
+    end
+  end
+end

data/lib/fontist/resource.rb

@@ -6,7 +6,12 @@ module Fontist
     attribute :name, :string
     attribute :source, :string
     attribute :urls, :string, collection: true
-    attribute :sha256, :string, collection: true
+    # Declared scalar: the corpus writes one digest per resource almost
+    # everywhere, and consumers render it verbatim. A handful of
+    # resources pair one digest with each mirror URL and write a list;
+    # a scalar-typed attribute keeps both forms as written instead of
+    # normalizing every single digest into a one-element Array.
+    attribute :sha256, :string
     attribute :file_size, :integer
     attribute :family, :string
     attribute :files, :string, collection: true

data/lib/fontist/system_index.rb

@@ -729,9 +729,48 @@ spinner_index = nil)
     def detect_file_font(path)
       font_file = FontFile.from_path(path)
 
+      entries = variable_font_entries(font_file, path)
+      return entries unless entries.empty?
+
       parse_font(font_file, path)
     end
 
+    # One index entry per named instance of a variable font: a variable
+    # file answers every lookup only if each family/style pair it carries
+    # is indexed separately — the name table alone registers just the
+    # default instance ("Fira Code Light"), leaving find_styles blind to
+    # the rest of the set.
+    def variable_font_entries(font_file, path)
+      instances = font_file.variable_instances
+      return [] if instances.empty?
+
+      file_size = begin
+        File.size(path)
+      rescue StandardError
+        0
+      end
+      file_mtime = begin
+        File.mtime(path).to_i
+      rescue StandardError
+        0
+      end
+
+      base = font_file.preferred_family_name || font_file.family
+      instances.map do |instance|
+        family = instance[:family]
+        SystemIndexFont.new(
+          path: path,
+          full_name: instance[:full_name],
+          family_name: family,
+          subfamily: instance[:style],
+          preferred_family_name: base,
+          preferred_subfamily_name: instance[:style],
+          file_size: file_size,
+          file_mtime: file_mtime,
+        )
+      end
+    end
+
     def detect_collection_fonts(path)
       CollectionFile.from_path(path) do |collection|
         collection.map do |font_file|

data/lib/fontist/validate_cli.rb

@@ -189,7 +189,7 @@ module Fontist
 
     def output_json_report(report, output_file)
       require "json"
-      json_content = JSON.pretty_generate(report.to_hash)
+      json_content = Fontist::JSON.pretty(report.to_hash)
 
       if output_file
         File.write(output_file, json_content)

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.29".freeze
+  VERSION = "3.0.31".freeze
 end

data/lib/fontist/yaml_backend.rb

@@ -14,13 +14,26 @@ module Fontist
     ENABLED_VALUE = "yeptris"
 
     class << self
-      # Returns the activated adapter class, or nil when the standard
-      # engine stays in place (flag unset, or yeptris unavailable)
+      # Pins the YAML adapter explicitly: lutaml-model auto-selects
+      # yeptris for a format whenever the yeptris gem is in the bundle,
+      # which would silently switch YAML parsing and dumping (and its
+      # line-wrap behavior) for every model in the process. The yeptris
+      # YAML engine activates only when explicitly enabled with
+      # FONTIST_YAML=yeptris; otherwise the standard Psych engine is
+      # pinned, because the yeptris x86_64-linux and Windows builds
+      # currently mis-parse some plain scalars as single-element Arrays
+      # (leptris/yeptris#863). Flip the default once that parity fix
+      # lands.
+      #
+      # Returns the activated adapter class.
       def activate!
-        return nil unless enabled?
-        return nil unless yeptris_available?
+        adapter =
+          if enabled? && yeptris_available?
+            Yaml::YeptrisAdapter
+          else
+            Lutaml::Yaml::Adapter::StandardAdapter
+          end
 
-        adapter = Yaml::YeptrisAdapter
         Lutaml::Model::AdapterResolver.set_adapter_class(:yaml, adapter)
 
         adapter

data/lib/fontist.rb

@@ -18,6 +18,7 @@ module Fontist
   # Core classes
   autoload :Config, "#{__dir__}/fontist/config"
   autoload :Css, "#{__dir__}/fontist/css"
+  autoload :JSON, "#{__dir__}/fontist/json"
   autoload :Font, "#{__dir__}/fontist/font"
   autoload :FontCollection, "#{__dir__}/fontist/font_collection"
   autoload :FontFile, "#{__dir__}/fontist/font_file"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontist
 version: !ruby/object:Gem::Version
-  version: 3.0.29
+  version: 3.0.31
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-03 00:00:00.000000000 Z
+date: 2026-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -92,20 +92,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
@@ -154,14 +140,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '10.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement
@@ -473,6 +459,7 @@ files:
 - lib/fontist/install_locations/fontist_location.rb
 - lib/fontist/install_locations/system_location.rb
 - lib/fontist/install_locations/user_location.rb
+- lib/fontist/json.rb
 - lib/fontist/macos.rb
 - lib/fontist/macos/catalog.rb
 - lib/fontist/macos/catalog/asset.rb