fontist 3.0.28 → 3.0.30

data/lib/fontist/font_operations/pack.rb

@@ -0,0 +1,49 @@
+require "fileutils"
+
+module Fontist
+  module FontOperations
+    # Bundles several font files into one TTC/OTC (or dfont) collection.
+    module Pack
+      FORMATS = %w[ttc otc dfont].freeze
+
+      module_function
+
+      # @param output [String] collection path; extension picks the format
+      #   unless +format+ is given
+      # @param files [Array<String>] two or more font files
+      # @return [String] the written collection path
+      def call(output, files, format: nil)
+        FontOperations.guard("Packing collection") do
+          format = (format || File.extname(output).delete(".")).to_s.downcase
+          validate!(files, format)
+          write(output, files, format)
+        end
+      end
+
+      def validate!(files, format)
+        unless FORMATS.include?(format)
+          raise Error, "Unsupported collection format '#{format}'. " \
+                       "Use one of: #{FORMATS.join(', ')}"
+        end
+        if files.size < 2
+          raise Error, "A collection needs at least two font files"
+        end
+
+        missing = files.reject { |f| File.exist?(f) }
+        raise Errors::SourceNotFoundError, missing.first if missing.any?
+      end
+
+      def write(output, files, format)
+        FileUtils.mkdir_p(File.dirname(output))
+        Fontisan::Commands::PackCommand.new(
+          files, output: output, format: format
+        ).run
+        unless File.size?(output)
+          raise Error, "No collection was written to #{output}"
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/fontist/font_operations/subset.rb

@@ -0,0 +1,68 @@
+require "fileutils"
+
+module Fontist
+  module FontOperations
+    # Keeps only the glyphs for the given characters.
+    module Subset
+      UNICODE_PART = /\A(u\+)?\h+(-(u\+)?\h+)?\z/i
+
+      module_function
+
+      # @param source [String] font file
+      # @param output [String] where to write the subset font
+      # @param unicodes [String, Array<Integer>, nil] "U+0020-007E,U+00E9"
+      #   or codepoints
+      # @param text [String, nil] characters to keep
+      # @return [String] output path
+      def call(source, output, unicodes: nil, text: nil)
+        FontOperations.guard("Subsetting") do
+          raise Errors::SourceNotFoundError, source unless File.exist?(source)
+
+          codepoints = parse_unicodes(unicodes) + text.to_s.codepoints
+          if codepoints.empty?
+            raise Error, "No characters to keep: give unicodes or text"
+          end
+
+          write(source, output, codepoints)
+        end
+      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
+        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?
+
+        raise Error, "None of the requested characters exist in #{name}"
+      end
+
+      # "U+0020-007E,U+00E9" => [32..126, 233].flatten
+      def parse_unicodes(value)
+        return Array(value).map(&:to_i) unless value.nil? || value.is_a?(String)
+
+        value.to_s.split(/[,\s]+/).reject(&:empty?).flat_map do |part|
+          parse_part(part)
+        end
+      end
+
+      def parse_part(part)
+        unless part.match?(UNICODE_PART)
+          raise Error, "Invalid unicode '#{part}'. Use e.g. U+0020-007E,U+00E9"
+        end
+
+        first, last = part.split("-", 2)
+          .map { |h| h.sub(/\Au\+/i, "").to_i(16) }
+        last ? (first..last).to_a : [first]
+      end
+    end
+  end
+end

data/lib/fontist/font_operations.rb

@@ -0,0 +1,25 @@
+module Fontist
+  # Font file operations backed by the Fontisan gem: collection member
+  # extraction, collection bundling, format conversion, subsetting and
+  # variable-font instancing.
+  module FontOperations
+    class Error < Errors::GeneralError; end
+
+    autoload :Convert, "#{__dir__}/font_operations/convert"
+    autoload :Extract, "#{__dir__}/font_operations/extract"
+    autoload :Instance, "#{__dir__}/font_operations/instance"
+    autoload :Pack, "#{__dir__}/font_operations/pack"
+    autoload :Subset, "#{__dir__}/font_operations/subset"
+
+    # Runs the block, turning any Fontisan failure into FontOperations::Error
+    # that names the operation.
+    def self.guard(operation)
+      require "fontisan"
+      yield
+    rescue Error, Errors::GeneralError
+      raise
+    rescue StandardError => e
+      raise Error, "#{operation} failed: #{e.message}"
+    end
+  end
+end

data/lib/fontist/format_spec.rb

@@ -30,6 +30,16 @@ module Fontist
     # Collection handling
     attribute :collection_index, :integer
 
+    # Subsetting: keep only these characters (U+0020-007E,U+00E9 / literal text)
+    attribute :subset_unicodes, :string
+    attribute :subset_text, :string
+
+    # Static instance of a variable font: "wght=300,wdth=90"
+    attribute :instance, :string
+
+    # Explicit opt-in: install the original format when conversion fails
+    attribute :fallback_to_original, :boolean, default: false
+
     # Convenience constructor for CLI
     def self.from_options(options = {})
       new(
@@ -40,9 +50,19 @@ module Fontist
         transcode_path: options[:transcode_path],
         keep_original: options.fetch(:keep_original, true),
         collection_index: options[:collection_index],
+        **operation_options(options),
       )
     end
 
+    def self.operation_options(options)
+      {
+        subset_unicodes: options[:subset_unicodes],
+        subset_text: options[:subset_text],
+        instance: options[:instance],
+        fallback_to_original: options[:fallback_to_original] || false,
+      }
+    end
+
     def self.parse_variable_axes(value)
       return nil if value.nil?
       return value if value.is_a?(Array)
@@ -72,6 +92,21 @@ module Fontist
       !available_formats.include?(format)
     end
 
+    # Check if a subset of characters was requested
+    def subset_requested?
+      !(subset_unicodes.to_s.strip.empty? && subset_text.to_s.empty?)
+    end
+
+    # Check if a static instance of a variable font was requested
+    def instance_requested?
+      !instance.to_s.strip.empty?
+    end
+
+    # Axis coordinates of the requested instance: {"wght" => 300.0}
+    def instance_coordinates
+      FontOperations::Instance.parse(instance)
+    end
+
     # Check if we need a specific collection index
     def specific_collection_index?
       !collection_index.nil?

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
@@ -218,6 +229,23 @@ module Fontist
       schema_version == 5
     end
 
+    # Formats of the style files, as recorded or read from file extensions.
+    # Archive resources often carry no format of their own.
+    def style_formats
+      fonts.flat_map(&:styles).flat_map do |style|
+        extension = File.extname(style.font.to_s).delete(".").downcase
+        Array(style.formats) + [extension]
+      end.reject(&:empty?).uniq
+    end
+
+    # Whether a resource offers a format, falling back to the style files
+    # when the resource records none.
+    def resource_offers_format?(resource, format)
+      return resource.format == format if resource.format
+
+      style_formats.include?(format)
+    end
+
     # Get the effective schema version (default to 4 if not set)
     def effective_schema_version
       schema_version || 4

data/lib/fontist/formula_picker.rb

@@ -21,10 +21,9 @@ module Fontist
       list = filter(formulas)
       return [] if list.empty?
 
-      # Use FormatMatcher for format filtering
       if @format_spec&.has_constraints?
         filtered = filter_by_format_spec(list)
-        raise_format_not_available_error(list) if filtered.empty? && !list.empty?
+        raise_format_not_available_error(list) if filtered.empty?
 
         list = filtered
       end
@@ -45,17 +44,37 @@ module Fontist
       ensure_fontist_version(list)
     end
 
+    # Formulas offering the requested format come first. When none does, a
+    # plain format request falls back to every formula so the installer can
+    # convert; a variable-font request cannot be met by conversion.
     def filter_by_format_spec(formulas)
       matcher = FormatMatcher.new(@format_spec)
+      offering = formulas.filter_map do |formula|
+        narrow_to_offered_format(formula, matcher)
+      end
+      return offering if offering.any?
+      return formulas if convertible_request?
 
-      formulas.filter_map do |formula|
-        next formula unless formula.v5?
+      []
+    end
 
-        matching = matcher.filter_resources(formula.resources)
-        if matching.any?
-          formula.dup.tap { |f| f.resources = matching }
-        end
+    def narrow_to_offered_format(formula, matcher)
+      return formula unless formula.v5?
+
+      matching = formula.resources.select do |resource|
+        offers_format?(formula, resource) && matcher.matches_resource?(resource)
       end
+      formula.dup.tap { |f| f.resources = matching } if matching.any?
+    end
+
+    def offers_format?(formula, resource)
+      return true unless @format_spec.format
+
+      formula.resource_offers_format?(resource, @format_spec.format)
+    end
+
+    def convertible_request?
+      !@format_spec.format.nil? && !@format_spec.variable_requested?
     end
 
     def ensure_fontist_version(formulas)

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/data_sources/github.rb

@@ -51,6 +51,23 @@ module Fontist
 
           private
 
+          # HEAD commit of the google/fonts clone, used to pin raw file URLs
+          def repository_commit
+            return @repository_commit if defined?(@repository_commit)
+
+            @repository_commit = git_head_commit
+          end
+
+          # No shell involved, so this also works on Windows, where
+          # `2>/dev/null` is not a valid redirect.
+          def git_head_commit
+            sha = IO.popen(%w[git rev-parse HEAD], chdir: @source_path.to_s,
+                                                   err: File::NULL, &:read)
+            sha.strip[/\A\h{40}\z/]
+          rescue SystemCallError
+            nil
+          end
+
           # Validate that the source path exists and contains fonts
           def validate_source_path!
             unless @source_path.exist?
@@ -155,6 +172,17 @@ module Fontist
               description: description,
               homepage: license_info[:homepage],
               font_file_data: font_files_data,
+            ).tap do |family|
+              family.variable_source = variable_source_for(metadata, family_dir)
+            end
+          end
+
+          # Real variable font files of the family, pinned to the clone's commit
+          def variable_source_for(metadata, family_dir)
+            VariableFontSource.from_metadata(
+              metadata,
+              directory: "#{family_dir.parent.basename}/#{family_dir.basename}",
+              commit: repository_commit,
             )
           end
 

data/lib/fontist/import/google/formula_builders/formula_builder_v5.rb

@@ -50,48 +50,32 @@ module Fontist
           def build_resources
             resources = {}
 
-            # Check if this is a variable font (has axes)
-            is_variable = family.variable_font?
-
-            if is_variable
-              # Variable fonts: the single file IS the variable font
-              # Google Fonts variable fonts are WOFF2 only
-              if woff2_files[family.family]&.any?
-                resources["woff2_variable"] = build_resource_entry(
-                  woff2_files[family.family],
-                  format: "woff2",
-                  variable: true,
-                  axes: family.axes,
-                )
-              end
+            # The only genuine variable files are the ones in google/fonts.
+            # The API serves static per-weight instances for every family,
+            # including variable ones, so those always go to *_static.
+            if variable_source
+              resources["ttf_variable"] =
+                variable_source.resource(family.family)
+            end
 
-              # Also include TTF if available (for desktop use)
-              if ttf_files[family.family]&.any?
-                resources["ttf_variable"] = build_resource_entry(
-                  ttf_files[family.family],
-                  format: "ttf",
-                  variable: true,
-                  axes: family.axes,
-                )
-              end
-            else
-              # Static fonts: separate TTF and WOFF2
-              static_ttf = filter_static_files(ttf_files[family.family])
-              if static_ttf.any?
-                resources["ttf_static"] = build_resource_entry(
-                  static_ttf, format: "ttf", variable: false
-                )
-              end
+            resources.merge(static_resources)
+          end
 
-              static_woff2 = filter_static_files(woff2_files[family.family])
-              if static_woff2.any?
-                resources["woff2_static"] = build_resource_entry(
-                  static_woff2, format: "woff2", variable: false
-                )
-              end
-            end
+          def static_resources
+            static_resource("ttf_static", "ttf", ttf_files)
+              .merge(static_resource("woff2_static", "woff2", woff2_files))
+          end
 
-            resources
+          def static_resource(key, format, files_by_family)
+            files = filter_static_files(files_by_family[family.family])
+            return {} if files.empty?
+
+            { key => build_resource_entry(files, format: format,
+                                                 variable: false) }
+          end
+
+          def variable_source
+            github_family&.variable_source
           end
 
           def build_resource_entry(files, format:, variable:, axes: nil)
@@ -132,17 +116,13 @@ module Fontist
 
           def is_variable_variant?(variant)
             # Variable fonts often have axes in the filename like "VariableFont_wght"
-            return true if variant.include?("Variable")
-
-            return false unless family.variable_font?
-
-            family.axes.any? { |axis| variant.include?(axis.tag) }
+            variant.include?("Variable")
           end
 
           def build_fonts
             parsed_fonts = []
 
-            # V5: Download and parse ALL TTF files (including variable fonts)
+            # V5: Download and parse the API's static TTF files
             ttf_files[family.family]&.each do |variant, url|
               sleep(0.05) # Throttle API requests
 
@@ -150,7 +130,6 @@ module Fontist
                 downloaded = Fontist::Utils::Downloader.download(url)
                 metadata = Fontist::Import::FontMetadataExtractor.new(downloaded.path).extract
 
-                # V5: Include both static and variable fonts
                 filename = url.split("/").last
 
                 style_data = build_style_data(metadata, filename)
@@ -164,6 +143,7 @@ module Fontist
               end
             end
 
+            parsed_fonts.concat(variable_source.styles) if variable_source
             return [] if parsed_fonts.empty?
 
             group_fonts_by_subfamily(parsed_fonts)
@@ -173,17 +153,10 @@ module Fontist
             # Add formats available for this style
             style["formats"] = determine_formats_for_style(variant)
 
-            # Add variable font info
-            # For variable fonts, ALL styles should be marked as variable
-            if family.variable_font?
-              style["variable_font"] = true
-              if family.axes&.any?
-                style["variable_axes"] =
-                  family.axes.map(&:tag)
-              end
-            else
-              style["variable_font"] = false
-            end
+            # Styles built from API files are static instances; the real
+            # variable styles come from variable_source.
+            style["variable_font"] = false
+            style["source_resource"] = "ttf_static" if variable_source
           end
 
           def determine_formats_for_style(variant)

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

@@ -24,6 +24,9 @@ module Fontist
           attribute :homepage, :string
           attribute :font_file_data, :string
 
+          # Real variable font files from google/fonts (VariableFontSource)
+          attr_accessor :variable_source
+
           json do
             map "family", to: :family
             map "variants", to: :variants
@@ -56,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