fontist 3.0.0 → 3.0.2

data/lib/fontist/import/windows.rb

@@ -0,0 +1,162 @@
+require "yaml"
+require "fileutils"
+
+module Fontist
+  module Import
+    class Windows
+      HOMEPAGE = "https://learn.microsoft.com/en-us/typography/fonts/windows_11_font_list".freeze
+
+      def initialize(formulas_dir: nil)
+        @custom_formulas_dir = formulas_dir
+      end
+
+      def call
+        capabilities = WindowsFodMetadata.all_capabilities
+
+        Fontist.ui.say(
+          "Generating #{capabilities.size} Windows FOD formula files...",
+        )
+
+        capabilities.each do |cap_name|
+          generate_formula(cap_name)
+        end
+
+        Fontist.ui.say("Done. #{capabilities.size} formulas generated.")
+      end
+
+      private
+
+      def generate_formula(cap_name)
+        description = WindowsFodMetadata.description_for_capability(cap_name)
+        fonts_data = WindowsFodMetadata.fonts_for_capability(cap_name)
+        formula = build_formula(cap_name, description, fonts_data)
+        write_formula(description, formula, fonts_data.size)
+      end
+
+      def write_formula(description, formula, font_count)
+        path = formula_path(description)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, YAML.dump(stringify_keys(formula)))
+        Fontist.ui.say(
+          "  Created: #{File.basename(path)} (#{font_count} fonts)",
+        )
+      end
+
+      def build_formula(cap_name, description, fonts_data)
+        base_attrs(description).merge(
+          resources: build_resources(cap_name, description, fonts_data),
+          fonts: build_fonts(fonts_data),
+          **import_source_attrs(cap_name),
+        )
+      end
+
+      def base_attrs(description)
+        {
+          schema_version: 5,
+          name: description,
+          description: "#{description} for Windows",
+          homepage: HOMEPAGE,
+          platforms: ["windows"],
+          open_license: license_text,
+        }
+      end
+
+      def import_source_attrs(cap_name)
+        {
+          import_source: {
+            type: "windows",
+            capability_name: cap_name,
+            min_windows_version: "10.0",
+          },
+        }
+      end
+
+      def build_resources(cap_name, description, fonts_data)
+        all_fonts = collect_font_filenames(fonts_data)
+        formats = all_fonts.map { |f| detect_format(f) }.uniq
+
+        resource = {
+          source: "windows_fod",
+          capability_name: cap_name,
+        }
+        resource[:format] = formats.first if formats.size == 1
+
+        { normalize_key(description) => resource }
+      end
+
+      def collect_font_filenames(fonts_data)
+        fonts_data.flat_map do |_, data|
+          data["styles"].map { |s| s["font"] }
+        end
+      end
+
+      def build_fonts(fonts_data)
+        fonts_data.map do |family_name, data|
+          {
+            name: family_name,
+            styles: build_styles(family_name, data["styles"]),
+          }
+        end
+      end
+
+      def build_styles(family_name, styles)
+        styles.map do |style|
+          fmt = detect_format(style["font"])
+          {
+            family_name: family_name,
+            type: style["type"],
+            font: style["font"],
+            formats: [fmt],
+            variable_font: false,
+          }
+        end
+      end
+
+      def detect_format(filename)
+        File.extname(filename).downcase.delete(".").then do |ext|
+          %w[ttf ttc otf otc].include?(ext) ? ext : "ttf"
+        end
+      end
+
+      def formula_path(description)
+        filename = "#{normalize_key(description)}.yml"
+        formula_dir.join(filename)
+      end
+
+      def formula_dir
+        @formula_dir ||= if @custom_formulas_dir
+                           Pathname.new(@custom_formulas_dir).tap do |path|
+                             FileUtils.mkdir_p(path)
+                           end
+                         else
+                           Fontist.formulas_path.join("windows").tap do |path|
+                             FileUtils.mkdir_p(path)
+                           end
+                         end
+      end
+
+      def normalize_key(name)
+        name.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/^_|_$/, "")
+      end
+
+      def license_text
+        @license_text ||= File.read(
+          File.expand_path("windows/windows_license.txt", __dir__),
+        )
+      end
+
+      def stringify_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(k, v), result|
+            result[k.to_s] = stringify_keys(v)
+          end
+        when Array
+          obj.map { |item| stringify_keys(item) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import.rb

@@ -4,7 +4,8 @@ module Fontist
     autoload :CreateFormula, "#{__dir__}/import/create_formula"
     autoload :Files, "#{__dir__}/import/files"
     autoload :FontMetadataExtractor, "#{__dir__}/import/font_metadata_extractor"
-    autoload :FontParsingErrorCollector, "#{__dir__}/import/font_parsing_error_collector"
+    autoload :FontParsingErrorCollector,
+             "#{__dir__}/import/font_parsing_error_collector"
     autoload :FontStyle, "#{__dir__}/import/font_style"
     autoload :FormulaBuilder, "#{__dir__}/import/formula_builder"
     autoload :FormulaSerializer, "#{__dir__}/import/formula_serializer"
@@ -22,6 +23,7 @@ module Fontist
     autoload :TemplateHelper, "#{__dir__}/import/template_helper"
     autoload :TextHelper, "#{__dir__}/import/text_helper"
     autoload :UpgradeFormulas, "#{__dir__}/import/upgrade_formulas"
+    autoload :Windows, "#{__dir__}/import/windows"
 
     class << self
       def name_to_filename(name)

data/lib/fontist/import_source.rb

@@ -16,6 +16,7 @@ module Fontist
         "macos" => "Fontist::MacosImportSource",
         "google" => "Fontist::GoogleImportSource",
         "sil" => "Fontist::SilImportSource",
+        "windows" => "Fontist::WindowsImportSource",
       }
     end
 

data/lib/fontist/indexes/directory_snapshot.rb

@@ -57,8 +57,8 @@ module Fontist
       def initialize(directory_path, files, scanned_at)
         @directory_path = directory_path
         @files = files.freeze # Immutable
-        @files_by_filename = files.each_with_object({}) do |f, h|
-          h[f[:filename]] = f
+        @files_by_filename = files.to_h do |f|
+          [f[:filename], f]
         end.freeze
         @scanned_at = scanned_at
       end

data/lib/fontist/indexes/incremental_scanner.rb

@@ -53,14 +53,14 @@ module Fontist
       # cache: Optional hash of path => cached_version
       # Returns: Array of font metadata hashes
       def self.scan_batch(paths, cache: {})
-        paths.map do |path|
+        paths.filter_map do |path|
           cached = cache[path]
           if cached
             scan_with_cache(path, cached)
           else
             scan_font_file(path)
           end
-        end.compact
+        end
       end
 
       # Compute SHA256 signature of first 1KB for quick change detection

data/lib/fontist/indexes.rb

@@ -1,17 +1,21 @@
 module Fontist
   module Indexes
-    autoload :BaseFontCollectionIndex, "#{__dir__}/indexes/base_font_collection_index"
-    autoload :DefaultFamilyFontIndex, "#{__dir__}/indexes/default_family_font_index"
+    autoload :BaseFontCollectionIndex,
+             "#{__dir__}/indexes/base_font_collection_index"
+    autoload :DefaultFamilyFontIndex,
+             "#{__dir__}/indexes/default_family_font_index"
     autoload :DirectoryChange, "#{__dir__}/indexes/directory_change"
     autoload :DirectorySnapshot, "#{__dir__}/indexes/directory_snapshot"
     autoload :FilenameIndex, "#{__dir__}/indexes/filename_index"
     autoload :FontIndex, "#{__dir__}/indexes/font_index"
     autoload :FontistIndex, "#{__dir__}/indexes/fontist_index"
     autoload :FormulaKeyToPath, "#{__dir__}/indexes/formula_key_to_path"
-    autoload :IncrementalIndexUpdater, "#{__dir__}/indexes/incremental_index_updater"
+    autoload :IncrementalIndexUpdater,
+             "#{__dir__}/indexes/incremental_index_updater"
     autoload :IncrementalScanner, "#{__dir__}/indexes/incremental_scanner"
     autoload :IndexMixin, "#{__dir__}/indexes/index_mixin"
-    autoload :PreferredFamilyFontIndex, "#{__dir__}/indexes/preferred_family_font_index"
+    autoload :PreferredFamilyFontIndex,
+             "#{__dir__}/indexes/preferred_family_font_index"
     autoload :SystemIndex, "#{__dir__}/indexes/system_index"
     autoload :UserIndex, "#{__dir__}/indexes/user_index"
   end

data/lib/fontist/macos/catalog/asset.rb

@@ -29,11 +29,11 @@ module Fontist
         end
 
         def postscript_names
-          fonts.map(&:postscript_name).compact
+          fonts.filter_map(&:postscript_name)
         end
 
         def font_families
-          fonts.map(&:font_family_name).compact.uniq
+          fonts.filter_map(&:font_family_name).uniq
         end
 
         def primary_family_name

data/lib/fontist/macos_import_source.rb

@@ -1,4 +1,3 @@
-
 module Fontist
   # Import source for macOS supplementary fonts
   #

data/lib/fontist/repo.rb

@@ -194,7 +194,7 @@ module Fontist
 
         # Normalize git@ style to https style for comparison
         # git@github.com:user/repo -> github.com/user/repo
-        normalized.sub(/:/, "/")
+        normalized.sub(":", "/")
       end
 
       def ensure_private_formulas_path_exists

data/lib/fontist/resource.rb

@@ -15,6 +15,9 @@ module Fontist
     attribute :format, :string # ttf, otf, woff2, ttc, otc
     attribute :variable_axes, :string, collection: true # [wght], [ital,wght], etc.
 
+    # Windows FOD support
+    attribute :capability_name, :string
+
     key_value do
       map "name", to: :name
       map "source", to: :source
@@ -25,10 +28,11 @@ module Fontist
       map "files", to: :files
       map "format", to: :format
       map "variable_axes", to: :variable_axes
+      map "capability_name", to: :capability_name
     end
 
     def empty?
-      Array(urls).empty? && Array(files).empty?
+      Array(urls).empty? && Array(files).empty? && capability_name.nil?
     end
 
     def variable_font?

data/lib/fontist/resources/windows_fod_resource.rb

@@ -0,0 +1,51 @@
+module Fontist
+  module Resources
+    class WindowsFodResource
+      def initialize(resource, options = {})
+        @resource = resource
+        @options = options
+      end
+
+      def files(source_names, &block)
+        install_capability!
+
+        source_names.each do |filename|
+          path = File.join(system_fonts_dir, filename)
+          yield path if File.exist?(path)
+        end
+      end
+
+      private
+
+      def install_capability!
+        cap_name = @resource.capability_name
+        return if capability_installed?(cap_name)
+
+        Fontist.ui.say("Installing Windows font capability: #{cap_name}")
+        result = Utils::System.run_powershell(
+          "Add-WindowsCapability -Online -Name '#{ps_escape(cap_name)}'",
+        )
+        unless result.success?
+          raise Errors::WindowsFodInstallError.new(cap_name, result.stderr)
+        end
+      end
+
+      def capability_installed?(name)
+        result = Utils::System.run_powershell(
+          "(Get-WindowsCapability -Online -Name '#{ps_escape(name)}').State",
+        )
+        result.stdout.strip == "Installed"
+      end
+
+      # Escape single quotes for PowerShell single-quoted strings
+      def ps_escape(str)
+        str.gsub("'", "''")
+      end
+
+      def system_fonts_dir
+        windir = ENV["windir"] || ENV["SystemRoot"] || "C:/Windows"
+        File.join(windir, "Fonts")
+      end
+    end
+  end
+end

data/lib/fontist/resources.rb

@@ -3,5 +3,6 @@ module Fontist
     autoload :AppleCDNResource, "#{__dir__}/resources/apple_cdn_resource"
     autoload :ArchiveResource, "#{__dir__}/resources/archive_resource"
     autoload :GoogleResource, "#{__dir__}/resources/google_resource"
+    autoload :WindowsFodResource, "#{__dir__}/resources/windows_fod_resource"
   end
 end

data/lib/fontist/system_index.rb

@@ -426,7 +426,7 @@ module Fontist
 
     def scan_directory_mtimes
       dirs = extract_font_directories
-      dirs.map { |dir| [dir, directory_mtime(dir)] }.to_h
+      dirs.to_h { |dir| [dir, directory_mtime(dir)] }
     end
 
     def directory_mtime(dir)
@@ -444,10 +444,10 @@ module Fontist
       templates = SystemFont.system_config["system"][os]["paths"]
 
       # Extract directory part before wildcards
-      base_dirs = templates.map do |pattern|
+      base_dirs = templates.filter_map do |pattern|
         # Remove glob patterns to get base directory
         pattern.split("/*").first
-      end.compact.uniq
+      end.uniq
 
       # Add fontist fonts directory
       base_dirs << Fontist.fonts_path.to_s
@@ -458,10 +458,10 @@ module Fontist
     def parse_directory_mtimes
       return {} unless directory_mtimes
 
-      Hash[directory_mtimes.map do |entry|
+      directory_mtimes.to_h do |entry|
         dir, mtime = entry.split(":", 2)
         [dir, mtime.to_i]
-      end]
+      end
     end
 
     def save_metadata

data/lib/fontist/utils/downloader.rb

@@ -1,6 +1,10 @@
 module Fontist
   module Utils
     class Downloader
+      DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " \
+                           "AppleWebKit/537.36 (KHTML, like Gecko) " \
+                           "Chrome/131.0.0.0 Safari/537.36".freeze
+
       class << self
         def download(*args)
           new(*args).download
@@ -135,10 +139,11 @@ module Fontist
 
       def headers
         obj = Helpers.url_object(@file)
-        obj.respond_to?(:headers) &&
+        formula_headers = (obj.respond_to?(:headers) &&
           obj.headers &&
-          obj.headers.to_h.map { |k, v| [k.to_s, v] }.to_h || # rubocop:disable Style/HashTransformKeys, Metrics/LineLength
-          {}
+          obj.headers.to_h.to_h { |k, v| [k.to_s, v] }) || {} # rubocop:disable Style/HashTransformKeys, Metrics/LineLength
+
+        { "User-Agent" => DEFAULT_USER_AGENT }.merge(formula_headers)
       end
 
       def extract_raw_url

data/lib/fontist/utils/system.rb

@@ -3,7 +3,7 @@ module Fontist
     module System
       # Platform override from environment (ONLY platform tags supported)
       def self.platform_override
-        ENV["FONTIST_PLATFORM_OVERRIDE"]
+        ENV.fetch("FONTIST_PLATFORM_OVERRIDE", nil)
       end
 
       def self.platform_override?
@@ -154,7 +154,7 @@ module Fontist
 
         # Convert to comparable integer: major * 10000 + minor * 100 + patch
         # This allows: 10.11.6 = 101106, 26.0.0 = 260000
-        major * 10000 + minor * 100 + patch
+        (major * 10000) + (minor * 100) + patch
       end
 
       def self.version_in_range?(min_version, max_version)
@@ -179,6 +179,23 @@ module Fontist
         true
       end
 
+      PowerShellResult = Struct.new(:stdout, :stderr, :success,
+                                    keyword_init: true) do
+        alias_method :success?, :success
+      end
+
+      def self.run_powershell(command)
+        require "open3"
+        stdout, stderr, status = Open3.capture3(
+          "powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command
+        )
+        PowerShellResult.new(stdout: stdout, stderr: stderr,
+                             success: status.success?)
+      rescue Errno::ENOENT
+        PowerShellResult.new(stdout: "", stderr: "powershell.exe not found",
+                             success: false)
+      end
+
       def self.catalog_version_for_macos
         # Check for platform override first
         if platform_override?

data/lib/fontist/validation.rb

@@ -58,7 +58,7 @@ module Fontist
       self.valid_fonts = results.count(&:valid)
       self.invalid_fonts = total_fonts - valid_fonts
 
-      times = results.map(&:time_taken).compact
+      times = results.filter_map(&:time_taken)
       self.total_time = times.sum
       self.avg_time_per_font = times.empty? ? 0.0 : (total_time / times.size)
       self.min_time = times.min || 0.0

data/lib/fontist/validator.rb

@@ -172,9 +172,9 @@ module Fontist
 
     # Validate fonts sequentially with cache lookup.
     def validate_sequential(font_paths, cache_lookup:, verbose:)
-      font_paths.map do |path|
+      font_paths.filter_map do |path|
         validate_with_cache_lookup(path, cache_lookup)
-      end.compact
+      end
     end
 
     # Validate single font, using cache if available and file unchanged.

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.0".freeze
+  VERSION = "3.0.2".freeze
 end

data/lib/fontist/windows_fod_metadata.rb

@@ -0,0 +1,83 @@
+require "yaml"
+
+module Fontist
+  # Metadata for Windows Features on Demand (FOD) font capabilities
+  #
+  # Provides lookup methods to map between FOD capability names and
+  # their associated font families/filenames.
+  class WindowsFodMetadata
+    DATA_PATH = File.expand_path("import/windows/fod_capabilities.yml", __dir__)
+
+    class << self
+      # Reverse lookup: font family name -> capability name
+      #
+      # @param font_name [String] The font family name (e.g., "Meiryo")
+      # @return [String, nil] The capability name or nil if not found
+      def capability_for_font(font_name)
+        reverse_map[font_name.downcase]
+      end
+
+      # Get all font families for a capability
+      #
+      # @param cap_name [String] The capability name
+      # @return [Hash, nil] Hash of font family names to their metadata
+      def fonts_for_capability(cap_name)
+        cap = metadata.dig("capabilities", cap_name)
+        cap&.fetch("fonts", nil)
+      end
+
+      # Get the description for a capability
+      #
+      # @param cap_name [String] The capability name
+      # @return [String, nil] The description
+      def description_for_capability(cap_name)
+        metadata.dig("capabilities", cap_name, "description")
+      end
+
+      # Flat list of all FOD font family names
+      #
+      # @return [Array<String>] All font family names
+      def all_font_names
+        metadata["capabilities"].flat_map do |_cap, data|
+          data["fonts"].keys
+        end
+      end
+
+      # List of all capability names
+      #
+      # @return [Array<String>] All capability names
+      def all_capabilities
+        metadata["capabilities"].keys
+      end
+
+      # Raw parsed YAML metadata
+      #
+      # @return [Hash] The parsed YAML data
+      def metadata
+        @metadata ||= YAML.safe_load(File.read(DATA_PATH))
+      end
+
+      # Reset cached metadata (for testing)
+      # @api private
+      def reset_cache
+        @metadata = nil
+        @reverse_map = nil
+      end
+
+      private
+
+      # Build reverse lookup map: lowercase font name -> capability name
+      def reverse_map
+        @reverse_map ||= begin
+          map = {}
+          metadata["capabilities"].each do |cap_name, data|
+            data["fonts"].each_key do |font_name|
+              map[font_name.downcase] = cap_name
+            end
+          end
+          map
+        end
+      end
+    end
+  end
+end

data/lib/fontist/windows_import_source.rb

@@ -0,0 +1,54 @@
+module Fontist
+  # Import source for Windows Features on Demand (FOD) supplementary fonts
+  #
+  # Tracks the capability name and minimum Windows version for fonts
+  # installed via Add-WindowsCapability.
+  class WindowsImportSource < ImportSource
+    attribute :capability_name, :string
+    attribute :min_windows_version, :string
+
+    key_value do
+      map "capability_name", to: :capability_name
+      map "min_windows_version", to: :min_windows_version
+    end
+
+    # Returns the capability name for differentiation
+    #
+    # @return [String, nil] Capability name or nil
+    def differentiation_key
+      capability_name
+    end
+
+    # Checks if this import source is older than the provided new source
+    #
+    # @param new_source [WindowsImportSource] The new source to compare against
+    # @return [Boolean] true if this source is outdated
+    def outdated?(new_source)
+      return false unless new_source.is_a?(WindowsImportSource)
+
+      # Windows FOD capabilities don't have versioned updates in the same way;
+      # they are either present or not. Always return false.
+      false
+    end
+
+    # Returns a human-readable string representation
+    #
+    # @return [String] String representation for debugging/logging
+    def to_s
+      "Windows FOD (capability: #{capability_name}, " \
+        "min_version: #{min_windows_version})"
+    end
+
+    # Equality check based on capability name
+    #
+    # @param other [Object] The object to compare
+    # @return [Boolean] true if objects are equal
+    def ==(other)
+      return false unless other.is_a?(WindowsImportSource)
+
+      capability_name == other.capability_name
+    end
+
+    alias eql? ==
+  end
+end

data/lib/fontist.rb

@@ -52,7 +52,10 @@ module Fontist
   autoload :GoogleImportSource, "#{__dir__}/fontist/google_import_source"
   autoload :MacosImportSource, "#{__dir__}/fontist/macos_import_source"
   autoload :SilImportSource, "#{__dir__}/fontist/sil_import_source"
-  autoload :MacosFrameworkMetadata, "#{__dir__}/fontist/macos_framework_metadata"
+  autoload :MacosFrameworkMetadata,
+           "#{__dir__}/fontist/macos_framework_metadata"
+  autoload :WindowsImportSource, "#{__dir__}/fontist/windows_import_source"
+  autoload :WindowsFodMetadata, "#{__dir__}/fontist/windows_fod_metadata"
 
   # Manifest classes
   autoload :Manifest, "#{__dir__}/fontist/manifest"

data/script/generate_windows_formulas.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Generate Windows FOD (Features on Demand) formula files
+#
+# Usage:
+#   bundle exec ruby script/generate_windows_formulas.rb [output_dir]
+#
+# Generates formula YAML files for all 25 Windows FOD font capabilities.
+# Output goes to Formulas/windows/ by default, or to the specified directory.
+
+require "bundler/setup"
+require "fontist"
+require_relative "../lib/fontist/import/windows"
+
+output_dir = ARGV[0]
+
+importer = if output_dir
+             Fontist::Import::Windows.new(formulas_dir: output_dir)
+           else
+             Fontist::Import::Windows.new
+           end
+
+importer.call