fontist 2.1.5 → 2.2.0

data/lib/fontist/import/{macos.rb → macos_importer.rb}

@@ -4,17 +4,18 @@ require "paint"
 
 module Fontist
   module Import
-    class Macos
+    class MacosImporter
       HOMEPAGE = "https://support.apple.com/en-om/HT211240#document".freeze
 
       def initialize(catalog_path, formulas_dir: nil, font_name: nil,
-force: false, verbose: false, import_cache: nil)
+force: false, verbose: false, import_cache: nil, schema_version: 4)
         @catalog_path = catalog_path
         @custom_formulas_dir = formulas_dir
         @font_name_filter = font_name
         @force = force
         @verbose = verbose
         @import_cache = import_cache
+        @schema_version = schema_version
         @success_count = 0
         @failure_count = 0
         @skipped_count = 0
@@ -129,6 +130,7 @@ force: false, verbose: false, import_cache: nil)
           verbose: @verbose,
           import_cache: @import_cache,
           name: family_name,
+          schema_version: @schema_version,
         ).call
 
         elapsed = Time.now - start_time

data/lib/fontist/import/recursive_extraction.rb

@@ -1,3 +1,5 @@
+require "excavate"
+
 module Fontist
   module Import
     class RecursiveExtraction

data/lib/fontist/import/{sil_import.rb → sil_importer.rb}

@@ -3,7 +3,7 @@ require "paint"
 
 module Fontist
   module Import
-    class SilImport
+    class SilImporter
       ROOT = "https://software.sil.org/fonts/".freeze
 
       def initialize(options = {})
@@ -12,6 +12,7 @@ module Fontist
         @verbose = options[:verbose]
         @import_cache = options[:import_cache]
         @force = options[:force]
+        @schema_version = options[:schema_version] || 4
         @success_count = 0
         @failure_count = 0
         @skipped_count = 0
@@ -301,6 +302,7 @@ module Fontist
         options[:import_source] = import_source if import_source
         options[:import_cache] = @import_cache if @import_cache
         options[:keep_existing] = !@force
+        options[:schema_version] = @schema_version
         # All SIL fonts use the SIL Open Font License
         options[:open_license] = "OFL-1.1"
 

data/lib/fontist/import/upgrade_formulas.rb

@@ -19,7 +19,7 @@ module Fontist
     # - Detects variable font axes from filenames
     class UpgradeFormulas
       ARCHIVE_EXTENSIONS = %w[zip tar gz tgz bz2 7z rar].freeze
-      FONT_EXTENSIONS = %w[ttf otf woff2 ttc otc].freeze
+      FONT_EXTENSIONS = %w[ttf otf woff woff2 ttc otc].freeze
 
       def initialize(formulas_path, options = {})
         @formulas_path = formulas_path

data/lib/fontist/import/v4_to_v5_migrator.rb

@@ -0,0 +1,263 @@
+require "date"
+require "fileutils"
+require "json"
+require "yaml"
+
+module Fontist
+  module Import
+    # Migrate v4 formulas to v5 schema
+    #
+    # This script converts existing v4 formula files to v5 format by:
+    # 1. Adding schema_version: 5
+    # 2. Detecting format from file extensions in resources
+    # 3. Detecting variable fonts from filename patterns
+    #
+    # Usage:
+    #   Fontist::Import::V4ToV5Migrator.new(input_path, output_path).migrate_all
+    #
+    class V4ToV5Migrator
+      FONT_EXTENSIONS = %w[ttf otf woff woff2 ttc otc dfont].freeze
+      ARCHIVE_EXTENSIONS = %w[zip tar gz tgz bz2 7z rar exe cab].freeze
+
+      def initialize(input_path, output_path = nil, options = {})
+        @input_path = input_path
+        @output_path = output_path || input_path
+        @verbose = options[:verbose]
+        @dry_run = options[:dry_run]
+      end
+
+      # Migrate all formulas in the input path
+      #
+      # @return [Hash] results with counts of migrated, skipped, failed
+      def migrate_all
+        results = { migrated: 0, skipped: 0, failed: 0, errors: [] }
+
+        files = formula_files
+        log "Found #{files.size} formula file(s) to process"
+
+        files.each do |path|
+          result = migrate_file(path)
+          case result
+          when :migrated
+            results[:migrated] += 1
+          when :skipped
+            results[:skipped] += 1
+          end
+        rescue StandardError => e
+          results[:failed] += 1
+          results[:errors] << { formula: path, error: e.message }
+          log "✗ Failed #{File.basename(path)}: #{e.message}"
+        end
+
+        log_summary(results)
+        results
+      end
+
+      # Migrate a single formula file
+      #
+      # @param path [String] path to formula file
+      # @return [Symbol] :migrated or :skipped
+      def migrate_file(path)
+        formula_data = load_yaml_without_aliases(path)
+        already_v5 = formula_data["schema_version"] == 5
+
+        # Add schema_version: 5
+        formula_data = add_schema_version(formula_data) unless already_v5
+
+        # Check if the raw file contains YAML aliases that need resolving
+        changed = file_has_yaml_aliases?(path)
+
+        changed |= upgrade_resources(formula_data) if formula_data["resources"]
+
+        # Nothing to do if already v5 and no fixes needed
+        if already_v5 && !changed
+          log "  Already v5: #{File.basename(path)}"
+          return :skipped
+        end
+
+        # Calculate output path
+        output_file = output_path_for(path)
+
+        # Save if not dry run
+        if @dry_run
+          log "  Would save: #{output_file}"
+        else
+          FileUtils.mkdir_p(File.dirname(output_file))
+          File.write(output_file, YAML.dump(formula_data))
+          log "  Saved: #{output_file}"
+        end
+
+        :migrated
+      end
+
+      private
+
+      def load_yaml_without_aliases(path)
+        data = YAML.safe_load(File.read(path), aliases: true, permitted_classes: [Date])
+        JSON.parse(JSON.generate(data))
+      end
+
+      def file_has_yaml_aliases?(path)
+        File.read(path).match?(/^\s*- \*\d+/)
+      end
+
+      def formula_files
+        if File.file?(@input_path)
+          [@input_path]
+        elsif File.directory?(@input_path)
+          Dir.glob(File.join(@input_path, "**/*.yml")).sort
+        else
+          []
+        end
+      end
+
+      def output_path_for(input_file)
+        return input_file if @output_path.nil? || @input_path == @output_path
+
+        # If input is a file and output is a directory, use the same filename
+        if File.file?(@input_path) && File.directory?(@output_path)
+          return File.join(@output_path, File.basename(input_file))
+        end
+
+        # Calculate relative path and map to output
+        relative = input_file.sub(@input_path, "")
+        File.join(@output_path, relative).sub(%r{/+}, "/")
+      end
+
+      def add_schema_version(formula_data)
+        # Insert schema_version at the beginning for clean YAML output
+        { "schema_version" => 5 }.merge(formula_data)
+      end
+
+      def upgrade_resources(formula_data)
+        changed = false
+
+        formula_data["resources"].each do |resource_name, resource_data|
+          next unless resource_data.is_a?(Hash)
+
+          # Skip archives - they don't have format
+          next if archive_resource?(resource_name, resource_data)
+
+          # Add format if missing
+          unless resource_data["format"]
+            format = detect_format(resource_name, resource_data)
+            if format
+              resource_data["format"] = format
+              changed = true
+            end
+          end
+
+          # Add variable_axes if missing and detected
+          unless resource_data["variable_axes"]
+            axes = detect_variable_axes(resource_name, resource_data)
+            if axes&.any?
+              resource_data["variable_axes"] = axes
+              changed = true
+            end
+          end
+        end
+
+        changed
+      end
+
+      def archive_resource?(resource_name, resource_data)
+        return true if archive_extension?(resource_name)
+
+        urls = Array(resource_data["urls"] || resource_data["files"])
+        urls.any? { |url| archive_extension?(url) }
+      end
+
+      def archive_extension?(path)
+        path =~ /\.(#{ARCHIVE_EXTENSIONS.join('|')})(?:\?|$)/i
+      end
+
+      def detect_format(resource_name, resource_data)
+        # Try from resource name
+        format = format_from_name(resource_name)
+        return format if format
+
+        # Try from URLs
+        urls = Array(resource_data["urls"] || resource_data["files"])
+        urls.each do |url|
+          format = format_from_url(url)
+          return format if format
+        end
+
+        # Try from files array
+        files = Array(resource_data["files"])
+        files.each do |file|
+          format = format_from_name(file)
+          return format if format
+        end
+
+        nil
+      end
+
+      def format_from_name(name)
+        if name =~ /\.(\w+)(?:\?|$)/
+          ext = Regexp.last_match(1).downcase
+          return ext if FONT_EXTENSIONS.include?(ext)
+        end
+        nil
+      end
+
+      def format_from_url(url)
+        filename = url.split("/").last.split("?").first
+        format_from_name(filename)
+      end
+
+      def detect_variable_axes(resource_name, resource_data)
+        # Try from resource name
+        axes = axes_from_name(resource_name)
+        return axes if axes.any?
+
+        # Try from URLs
+        urls = Array(resource_data["urls"] || resource_data["files"])
+        urls.each do |url|
+          axes = axes_from_name(url)
+          return axes if axes.any?
+        end
+
+        # Try from files array
+        files = Array(resource_data["files"])
+        files.each do |file|
+          axes = axes_from_name(file)
+          return axes if axes.any?
+        end
+
+        []
+      end
+
+      def axes_from_name(name)
+        if name =~ /\[([^\]]+)\]/
+          Regexp.last_match(1).split(",").map(&:strip)
+        else
+          []
+        end
+      end
+
+      def log(message)
+        puts message if @verbose
+      end
+
+      def log_summary(results)
+        return unless @verbose
+
+        puts "\n#{'=' * 60}"
+        puts "Migration Summary"
+        puts "=" * 60
+        puts "  Migrated: #{results[:migrated]}"
+        puts "  Skipped:  #{results[:skipped]}"
+        puts "  Failed:   #{results[:failed]}"
+
+        if results[:errors].any?
+          puts "\nErrors:"
+          results[:errors].each do |error|
+            puts "  - #{error[:formula]}: #{error[:error]}"
+          end
+        end
+        puts "=" * 60
+      end
+    end
+  end
+end

data/lib/fontist/import_cli.rb

@@ -21,6 +21,10 @@ module Fontist
     option :import_cache,
            type: :string,
            desc: "Directory for import cache (default: ~/.fontist/import_cache)"
+    option :schema_version,
+           type: :numeric,
+           default: 4,
+           desc: "Formula schema version (4 or 5). v5 supports multi-format fonts."
 
     def google
       handle_class_options(options)
@@ -35,6 +39,7 @@ module Fontist
         force: options[:force],
         verbose: options[:verbose],
         import_cache: options[:import_cache],
+        schema_version: options[:schema_version],
       )
 
       result = importer.import
@@ -78,9 +83,14 @@ module Fontist
     option :import_cache,
            type: :string,
            desc: "Directory for import cache (default: ~/.fontist/import_cache)"
+    option :schema_version,
+           type: :numeric,
+           default: 4,
+           desc: "Formula schema version (4 or 5). v5 supports multi-format fonts."
 
     def macos
       handle_class_options(options)
+      require_relative "import/macos_importer"
 
       # Handle deprecated formulas_dir option
       output_dir = if options[:formulas_dir] && !options[:output_path]
@@ -95,13 +105,14 @@ module Fontist
       verbose = options[:verbose]
       font_name = options[:font_name]
 
-      Import::Macos.new(
+      Import::MacosImporter.new(
         plist_path,
         formulas_dir: output_dir,
         font_name: font_name,
         force: force,
         verbose: verbose,
         import_cache: options[:import_cache],
+        schema_version: options[:schema_version],
       ).call
 
       CLI::STATUS_SUCCESS
@@ -127,16 +138,23 @@ module Fontist
     option :import_cache,
            type: :string,
            desc: "Directory for import cache (default: ~/.fontist/import_cache)"
+    option :schema_version,
+           type: :numeric,
+           default: 4,
+           desc: "Formula schema version (4 or 5). v5 supports multi-format fonts."
 
     def sil
       handle_class_options(options)
 
-      importer = Fontist::Import::SilImport.new(
+      require "fontist/import/sil_importer"
+
+      importer = Fontist::Import::SilImporter.new(
         output_path: options[:output_path],
         font_name: options[:font_name],
         force: options[:force],
         verbose: options[:verbose],
         import_cache: options[:import_cache],
+        schema_version: options[:schema_version],
       )
 
       result = importer.call

data/lib/fontist/indexes/index_mixin.rb

@@ -49,9 +49,9 @@ module Fontist
 
           file_content = File.read(file_path).strip
 
-          if file_content.empty?
-            raise Fontist::Errors::FontIndexCorrupted,
-                  "Index file is empty: #{file_path}"
+          if file_content.empty? || file_content == "---"
+            # Return empty collection for empty index files
+            return new
           end
 
           from_yaml(file_content)
@@ -105,7 +105,11 @@ module Fontist
       end
 
       def add_formula(formula)
-        raise unless formula.is_a?(Formula)
+        # Accept FormulaV4, FormulaV5, or any object that responds to all_fonts
+        unless formula.respond_to?(:all_fonts) && formula.respond_to?(:path)
+          raise ArgumentError,
+                "Expected formula-like object, got #{formula.class}"
+        end
 
         formula.all_fonts.each do |font|
           font.styles.each do |style|

data/lib/fontist/manifest.rb

@@ -1,10 +1,35 @@
 require "lutaml/model"
+require_relative "format_spec"
 
 module Fontist
   class ManifestFont < Lutaml::Model::Serializable
     attribute :name, :string
     attribute :styles, :string, collection: true
 
+    # Format specification (if not available, will transcode using Fontisan)
+    attribute :format, :string
+    attribute :variable_axes, :string, collection: true
+    attribute :prefer_variable, :boolean, default: false
+
+    # Transcoding options
+    attribute :transcode_path, :string
+    attribute :keep_original, :boolean, default: true
+
+    # Collection options
+    attribute :collection_index, :integer
+
+    # Build FormatSpec from attributes
+    def format_spec
+      FormatSpec.new(
+        format: format,
+        variable_axes: variable_axes,
+        prefer_variable: prefer_variable,
+        transcode_path: transcode_path,
+        keep_original: keep_original,
+        collection_index: collection_index,
+      )
+    end
+
     def style_paths(locations: false)
       ary = Array(styles)
       (ary.empty? ? [nil] : ary).flat_map do |style|
@@ -29,7 +54,7 @@ module Fontist
     end
 
     def install(confirmation: "no", hide_licenses: false, no_progress: false,
-location: nil)
+               location: nil)
       validate_location_parameter!(location)
       validate_platform_compatibility!
 
@@ -40,6 +65,7 @@ location: nil)
         hide_licenses: hide_licenses,
         no_progress: no_progress,
         location: location,
+        format_spec: format_spec,
       )
     rescue Fontist::Errors::PlatformMismatchError => e
       # Re-raise with clear context for manifest users

data/lib/fontist/path_scanning.rb

@@ -4,7 +4,7 @@ module Fontist
   module PathScanning
     FONT_EXTENSIONS = [
       ".ttf", ".TTF", ".ttc", ".TTC",
-      ".otf", ".OTF",
+      ".otf", ".OTF", ".otc", ".OTC",
       ".woff", ".woff2", ".WOFF", ".WOFF2"
     ].freeze
 

data/lib/fontist/resource.rb

@@ -0,0 +1,54 @@
+require "lutaml/model"
+
+module Fontist
+  # Resource - v5 resource with format metadata for multi-format support
+  class Resource < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :source, :string
+    attribute :urls, :string, collection: true
+    attribute :sha256, :string, collection: true
+    attribute :file_size, :integer
+    attribute :family, :string
+    attribute :files, :string, collection: true
+
+    # v5 format metadata
+    attribute :format, :string # ttf, otf, woff2, ttc, otc
+    attribute :variable_axes, :string, collection: true # [wght], [ital,wght], etc.
+
+    key_value do
+      map "name", to: :name
+      map "source", to: :source
+      map "urls", to: :urls
+      map "sha256", to: :sha256
+      map "file_size", to: :file_size
+      map "family", to: :family
+      map "files", to: :files
+      map "format", to: :format
+      map "variable_axes", to: :variable_axes
+    end
+
+    def empty?
+      Array(urls).empty? && Array(files).empty?
+    end
+
+    def variable_font?
+      variable_axes && !variable_axes.empty?
+    end
+
+    def static_font?
+      !variable_font?
+    end
+
+    def axes_tags
+      Array(variable_axes).map(&:to_s)
+    end
+
+    def has_axis?(tag)
+      axes_tags.include?(tag.to_s)
+    end
+
+    def collection_file?
+      %w[ttc otc].include?(format&.to_s)
+    end
+  end
+end

data/lib/fontist/resource_collection.rb

@@ -0,0 +1,18 @@
+require "lutaml/model"
+require_relative "resource"
+
+module Fontist
+  # Resource Collection
+  class ResourceCollection < Lutaml::Model::Collection
+    instances :resources, Resource
+
+    key_value do
+      map_key to_instance: :name
+      map_instances to: :resources
+    end
+
+    def empty?
+      resources.nil? || Array(resources).all?(&:empty?)
+    end
+  end
+end

data/lib/fontist/system_index.rb

@@ -117,6 +117,11 @@ module Fontist
     attribute :file_size, :integer
     attribute :file_mtime, :integer
 
+    # Format tracking (v5 schema support)
+    attribute :format, :string
+    attribute :variable_font, :boolean, default: false
+    attribute :variable_axes, :string, collection: true
+
     alias :type :subfamily
 
     key_value do
@@ -128,6 +133,9 @@ module Fontist
       map "preferred_subfamily_name", to: :preferred_subfamily_name
       map "file_size", to: :file_size
       map "file_mtime", to: :file_mtime
+      map "format", to: :format
+      map "variable_font", to: :variable_font
+      map "variable_axes", to: :variable_axes
     end
   end
 
@@ -195,7 +203,7 @@ module Fontist
       File.write(path, to_yaml)
     end
 
-    def find(font, style)
+    def find(font, style, format_spec: nil)
       current_fonts = index
 
       return nil if current_fonts.nil? || current_fonts.empty?
@@ -210,6 +218,13 @@ module Fontist
         end
       end
 
+      # Apply format filtering if specified
+      if format_spec&.has_constraints? && found_fonts
+        require_relative "format_matcher"
+        matcher = FormatMatcher.new(format_spec)
+        found_fonts = matcher.filter_indexed_fonts(found_fonts)
+      end
+
       found_fonts.empty? ? nil : found_fonts
     end
 
@@ -295,12 +310,6 @@ module Fontist
       self
     end
 
-    def update
-      tap do |col|
-        col.fonts = detect_paths(@paths_loader&.call || [])
-      end
-    end
-
     def update(verbose: false, stats: nil)
       tap do |col|
         col.fonts = detect_paths(@paths_loader&.call || [], verbose: verbose,
@@ -637,9 +646,9 @@ spinner_index = nil)
 
     def gather_fonts(path)
       case File.extname(path).gsub(/^\./, "").downcase
-      when "ttf", "otf"
+      when "ttf", "otf", "woff", "woff2"
         detect_file_font(path)
-      when "ttc"
+      when "ttc", "otc"
         detect_collection_fonts(path)
       else
         print_recognition_error(Errors::UnknownFontTypeError.new(path), path)

data/lib/fontist/utils/downloader.rb

@@ -141,8 +141,6 @@ module Fontist
           {}
       end
 
-      private
-
       def extract_raw_url
         obj = Helpers.url_object(@file)
         obj.respond_to?(:url) ? obj.url : obj

data/lib/fontist/utils/github_client.rb

@@ -31,11 +31,14 @@ module Fontist
         end
 
         def fetch_release(client, parsed_url)
-          client.release_for_tag("#{parsed_url.owner}/#{parsed_url.repo}", parsed_url.tag)
+          client.release_for_tag("#{parsed_url.owner}/#{parsed_url.repo}",
+                                 parsed_url.tag)
         end
 
         def find_asset_url(release, asset_name)
-          release.assets.find { |asset| asset.name == asset_name }&.browser_download_url
+          release.assets.find do |asset|
+            asset.name == asset_name
+          end&.browser_download_url
         end
       end
     end

data/lib/fontist/utils/github_url.rb

@@ -2,7 +2,7 @@ module Fontist
   module Utils
     class GitHubUrl
       GITHUB_RELEASE_PATTERN =
-        %r{^https?://github\.com/(?<owner>[^/]+)/(?<repo>[^/]+)/releases/download/(?<tag>[^/]+)/(?<asset>.+)$}
+        %r{^https?://github\.com/(?<owner>[^/]+)/(?<repo>[^/]+)/releases/download/(?<tag>[^/]+)/(?<asset>.+)$}.freeze
 
       class << self
         def match?(url)
@@ -19,7 +19,7 @@ module Fontist
               repo: match[:repo],
               tag: match[:tag],
               asset: match[:asset],
-              original_url: url_string
+              original_url: url_string,
             )
           else
             ParsedUrl.from_non_github_url(url_string)
@@ -39,7 +39,8 @@ module Fontist
         end
 
         def self.from_non_github_url(original_url)
-          new(owner: nil, repo: nil, tag: nil, asset: nil, original_url: original_url)
+          new(owner: nil, repo: nil, tag: nil, asset: nil,
+              original_url: original_url)
         end
 
         def matched?