fontist 3.0.28 → 3.0.29

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

@@ -218,6 +218,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/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

data/lib/fontist/import/google/variable_font_source.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Fontist
+  module Import
+    module Google
+      # The real variable font files of a family as published in the
+      # google/fonts repository (METADATA.pb `fonts` entries whose filename
+      # carries an axis list, e.g. "Roboto[wdth,wght].ttf").
+      #
+      # The Google Fonts API only serves static per-weight instances, so these
+      # files are the only genuine variable sources. Google publishes them as
+      # TTF only.
+      class VariableFontSource
+        RAW_BASE = "https://raw.githubusercontent.com/google/fonts"
+        AXIS_LIST = /\[([^\]]+)\]/
+
+        attr_reader :directory, :commit, :files, :axes
+
+        # @param directory [String] repo-relative family dir, e.g. "ofl/roboto"
+        # @param commit [String] google/fonts commit SHA the URLs are pinned to
+        # @param files [Array<Models::FontFileMetadata>] METADATA.pb fonts
+        # @param axes [Array<Models::AxisMetadata>] METADATA.pb axes
+        def self.from_metadata(metadata, directory:, commit:)
+          files = Array(metadata.fonts).select do |font|
+            font.filename.to_s.match?(AXIS_LIST)
+          end
+          return nil if files.empty? || commit.to_s.empty?
+
+          new(directory: directory, commit: commit, files: files,
+              axes: Array(metadata.axes))
+        end
+
+        def initialize(directory:, commit:, files:, axes:)
+          @directory = directory
+          @commit = commit
+          @files = files
+          @axes = axes
+        end
+
+        def urls
+          files.map { |file| url_for(file.filename) }
+        end
+
+        # Axis tags in METADATA.pb order, limited to those the files carry.
+        def axis_tags
+          present = files.flat_map { |file| tags_in(file.filename) }.uniq
+          declared = axes.map(&:tag)
+          (declared & present) + (present - declared)
+        end
+
+        # Resource entry for a v5 formula (TTF only).
+        def resource(family_name)
+          {
+            "source" => "google",
+            "family" => family_name,
+            "files" => urls,
+            "urls" => urls,
+            "format" => "ttf",
+            "variable_axes" => axis_tags,
+          }
+        end
+
+        # One style per variable file, described by METADATA.pb.
+        def styles
+          files.map { |file| style_for(file) }
+        end
+
+        private
+
+        def style_for(file)
+          names_of(file).merge(
+            "font" => file.filename,
+            "formats" => ["ttf"],
+            "variable_font" => true,
+            "variable_axes" => tags_in(file.filename),
+            "source_resource" => "ttf_variable",
+          ).compact
+        end
+
+        def names_of(file)
+          {
+            "family_name" => file.name,
+            "type" => file.style.to_s == "italic" ? "Italic" : "Regular",
+            "full_name" => file.full_name,
+            "post_script_name" => file.post_script_name,
+            "copyright" => file.copyright,
+          }
+        end
+
+        def tags_in(filename)
+          filename[AXIS_LIST, 1].to_s.split(",")
+        end
+
+        def url_for(filename)
+          # Brackets stay literal: the installer matches style files against
+          # the URL basename, which must equal the downloaded file name.
+          encoded = filename.gsub(/[^A-Za-z0-9._,\-\[\]]/) do |char|
+            char.bytes.map { |b| format("%%%02X", b) }.join
+          end
+          "#{RAW_BASE}/#{commit}/#{directory}/#{encoded}"
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/google.rb

@@ -7,6 +7,7 @@ module Fontist
       autoload :MetadataAdapter, "#{__dir__}/google/metadata_adapter"
       autoload :MetadataParser, "#{__dir__}/google/metadata_parser"
       autoload :Models, "#{__dir__}/google/models"
+      autoload :VariableFontSource, "#{__dir__}/google/variable_font_source"
 
       DEFAULT_MAX_COUNT = 100
 

data/lib/fontist/import/sil_importer.rb

@@ -5,6 +5,9 @@ module Fontist
   module Import
     class SilImporter
       ROOT = "https://software.sil.org/fonts/".freeze
+      CARD_LINK_SELECTOR = "a.inner-card".freeze
+      CARD_TITLE_SELECTOR = ".title-text".freeze
+      LEGACY_LINK_SELECTOR = "table.products div.title > a".freeze
 
       def initialize(options = {})
         @output_path = options[:output_path]
@@ -99,7 +102,7 @@ module Fontist
       end
 
       def process_single_font(link, current, total)
-        family_name = link.content
+        family_name = link_name(link)
 
         # Display progress
         ImportDisplay.progress(current, total, family_name) if @verbose
@@ -257,7 +260,8 @@ module Fontist
       end
 
       def empty_result
-        { successful: 0, failed: 0, errors: [], duration: 0 }
+        { successful: 0, failed: 0, errors: [], duration: 0,
+          no_fonts_found: true }
       end
 
       def build_results(duration)
@@ -274,12 +278,21 @@ module Fontist
       def font_links
         html = URI.parse(ROOT).open("User-Agent" => Fontist::Utils::UserAgent.random_user_agent).read
         document = Nokogiri::HTML.parse(html)
-        document.css("table.products div.title > a")
+        links = document.css(CARD_LINK_SELECTOR)
+        links = document.css(LEGACY_LINK_SELECTOR) if links.empty?
+        links
+      end
+
+      # Font name of a product link. Cards on the current site also carry a
+      # description, so the name is taken from the card title only.
+      def link_name(link)
+        title = link.at_css(CARD_TITLE_SELECTOR)
+        (title || link).text.strip
       end
 
       def filter_by_name(links)
         links.select do |link|
-          link.content.downcase.include?(@font_name.downcase)
+          link_name(link).downcase.include?(@font_name.downcase)
         end
       end
 
@@ -342,7 +355,7 @@ module Fontist
       end
 
       def find_archive_url_by_page_link(link)
-        family_name = link.content
+        family_name = link_name(link)
 
         # Skip known index pages that just link to other fonts
         if index_page?(family_name)

data/lib/fontist/import/windows.rb

@@ -53,7 +53,7 @@ module Fontist
       def base_attrs(description)
         {
           schema_version: 5,
-          name: description,
+          name: formula_name(description),
           description: "#{description} for Windows",
           homepage: HOMEPAGE,
           platforms: ["windows"],
@@ -119,7 +119,7 @@ module Fontist
       end
 
       def formula_path(description)
-        filename = "#{normalize_key(description)}.yml"
+        filename = "#{formula_key(description)}.yml"
         formula_dir.join(filename)
       end
 
@@ -135,6 +135,17 @@ module Fontist
                          end
       end
 
+      # Formula names keep to letters, digits and spaces, so the file key the
+      # formulas repository derives from them (lowercase, spaces as
+      # underscores) needs no shell escaping in its CI.
+      def formula_name(description)
+        description.tr("-", " ").delete("^A-Za-z0-9 ").squeeze(" ").strip
+      end
+
+      def formula_key(description)
+        formula_name(description).downcase.tr(" ", "_")
+      end
+
       def normalize_key(name)
         name.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
       end

data/lib/fontist/import_cli.rb

@@ -122,6 +122,24 @@ module Fontist
       CLI::STATUS_UNKNOWN_ERROR
     end
 
+    desc "windows", "Import Windows font extension packs (Features on Demand)"
+    option :output_path,
+           type: :string,
+           desc: "Output directory for generated formulas " \
+                 "(default: formulas/windows)"
+
+    def windows
+      handle_class_options(options)
+      require_relative "import/windows"
+
+      Import::Windows.new(formulas_dir: options[:output_path]).call
+
+      CLI::STATUS_SUCCESS
+    rescue StandardError => e
+      Fontist.ui.error("Import error: #{e.message}")
+      CLI::STATUS_UNKNOWN_ERROR
+    end
+
     desc "sil", "Import formulas from SIL International"
     option :output_path,
            type: :string,
@@ -158,6 +176,7 @@ module Fontist
       )
 
       result = importer.call
+      return CLI::STATUS_UNKNOWN_ERROR if result[:no_fonts_found]
 
       # Report results only in non-verbose mode (verbose mode already has rich summary)
       unless options[:verbose]