fontist 3.0.1 → 3.0.3

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

@@ -23,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/macos/catalog/catalog_manager.rb

@@ -55,7 +55,7 @@ module Fontist
             Fontist.ui.say("Downloading Font#{version} catalog from #{url}...") if Fontist.ui.respond_to?(:say)
 
             URI(url).open(
-              "User-Agent" => "Fontist/#{Fontist::VERSION}",
+              "User-Agent" => Fontist::Utils::UserAgent.random_user_agent,
             ) do |response|
               File.write(catalog_file, response.read)
             end

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/utils/downloader.rb

@@ -135,10 +135,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.to_h { |k, v| [k.to_s, v] }) || # rubocop:disable Style/HashTransformKeys, Metrics/LineLength
-          {}
+          obj.headers.to_h.to_h { |k, v| [k.to_s, v] }) || {} # rubocop:disable Style/HashTransformKeys, Metrics/LineLength
+
+        Utils::UserAgent.browser_headers.merge(formula_headers)
       end
 
       def extract_raw_url

data/lib/fontist/utils/system.rb

@@ -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/utils/user_agent.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Fontist
+  module Utils
+    module UserAgent
+      PROFILES = [
+        {
+          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",
+          platform: '"macOS"',
+          chrome_version: "131",
+        },
+        {
+          user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " \
+                      "AppleWebKit/537.36 (KHTML, like Gecko) " \
+                      "Chrome/130.0.0.0 Safari/537.36",
+          platform: '"Windows"',
+          chrome_version: "130",
+        },
+        {
+          user_agent: "Mozilla/5.0 (X11; Linux x86_64) " \
+                      "AppleWebKit/537.36 (KHTML, like Gecko) " \
+                      "Chrome/132.0.0.0 Safari/537.36",
+          platform: '"Linux"',
+          chrome_version: "132",
+        },
+        {
+          user_agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " \
+                      "AppleWebKit/537.36 (KHTML, like Gecko) " \
+                      "Chrome/130.0.0.0 Safari/537.36",
+          platform: '"macOS"',
+          chrome_version: "130",
+        },
+        {
+          user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " \
+                      "AppleWebKit/537.36 (KHTML, like Gecko) " \
+                      "Chrome/132.0.0.0 Safari/537.36",
+          platform: '"Windows"',
+          chrome_version: "132",
+        },
+      ].freeze
+
+      ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9," \
+               "image/avif,image/webp,image/apng,*/*;q=0.8," \
+               "application/signed-exchange;v=b3;q=0.7"
+
+      ACCEPT_LANGUAGE = "en-US,en;q=0.9"
+
+      STATIC_HEADERS = {
+        "Accept" => ACCEPT,
+        "Accept-Language" => ACCEPT_LANGUAGE,
+        "Cache-Control" => "no-cache",
+        "Pragma" => "no-cache",
+        "Sec-Ch-Ua-Mobile" => "?0",
+        "Sec-Fetch-Dest" => "document",
+        "Sec-Fetch-Mode" => "navigate",
+        "Sec-Fetch-Site" => "cross-site",
+        "Sec-Fetch-User" => "?1",
+        "Upgrade-Insecure-Requests" => "1",
+      }.freeze
+
+      class << self
+        def random_profile
+          PROFILES.sample
+        end
+
+        def browser_headers
+          profile = random_profile
+          build_headers(profile)
+        end
+
+        def random_user_agent
+          random_profile[:user_agent]
+        end
+
+        private
+
+        def build_headers(profile)
+          STATIC_HEADERS.merge(
+            "User-Agent" => profile[:user_agent],
+            "Sec-Ch-Ua" => build_sec_ch_ua(profile[:chrome_version]),
+            "Sec-Ch-Ua-Platform" => profile[:platform],
+          )
+        end
+
+        def build_sec_ch_ua(chrome_version)
+          "\"Google Chrome\";v=\"#{chrome_version}\", " \
+            "\"Chromium\";v=\"#{chrome_version}\", " \
+            "\"Not_A Brand\";v=\"24\""
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils.rb

@@ -9,6 +9,7 @@ module Fontist
     autoload :Locking, "#{__dir__}/utils/locking"
     autoload :System, "#{__dir__}/utils/system"
     autoload :UI, "#{__dir__}/utils/ui"
+    autoload :UserAgent, "#{__dir__}/utils/user_agent"
 
     # Converts a glob pattern to case-insensitive by replacing each
     # alphabetic character with a character class [aA]

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.1".freeze
+  VERSION = "3.0.3".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

@@ -54,6 +54,8 @@ module Fontist
   autoload :SilImportSource, "#{__dir__}/fontist/sil_import_source"
   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