fontist 3.0.1 → 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

@@ -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/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

@@ -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.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
+
+        { "User-Agent" => DEFAULT_USER_AGENT }.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/version.rb

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

@@ -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

data/script/validate_windows_fod_ci.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Validate Windows FOD capabilities against live Windows system
+#
+# Usage:
+#   bundle exec ruby script/validate_windows_fod_ci.rb
+#
+# This script:
+# 1. Loads fod_capabilities.yml
+# 2. Queries Windows for real FOD capabilities via PowerShell
+# 3. Compares our YAML capability names against what Windows reports
+# 4. For installed capabilities, checks that expected font files exist
+# 5. Exits 0 on success, 1 on critical mismatches
+
+require "yaml"
+require "set"
+
+FONTS_DIR = 'C:\Windows\Fonts'
+YAML_PATH = File.expand_path(
+  "../lib/fontist/import/windows/fod_capabilities.yml",
+  __dir__,
+)
+
+def main
+  unless Gem.win_platform?
+    puts "SKIP: Not running on Windows"
+    exit 0
+  end
+
+  puts "=== Windows FOD Capability Validation ==="
+  puts ""
+
+  yaml_caps = load_yaml_capabilities
+  live_caps = query_live_capabilities
+
+  puts "YAML capabilities: #{yaml_caps.size}"
+  puts "Live capabilities: #{live_caps.size}"
+  puts ""
+
+  matched, missing_from_yaml, extra_in_yaml = compare(yaml_caps, live_caps)
+
+  print_results(matched, missing_from_yaml, extra_in_yaml)
+
+  errors = check_installed_fonts(yaml_caps, live_caps)
+
+  puts ""
+  summarize(matched, missing_from_yaml, extra_in_yaml, errors)
+end
+
+def load_yaml_capabilities
+  data = YAML.safe_load(File.read(YAML_PATH))
+  data.fetch("capabilities", {})
+rescue StandardError => e
+  puts "ERROR: Failed to load YAML: #{e.message}"
+  exit 1
+end
+
+def query_live_capabilities
+  output = `powershell -NoProfile -Command "Get-WindowsCapability -Online -Name 'Language.Fonts.*' | Select-Object Name, State | ConvertTo-Csv -NoTypeInformation"`
+
+  unless $?.success?
+    puts "ERROR: PowerShell command failed (exit #{$?.exitstatus})"
+    exit 1
+  end
+
+  caps = {}
+  output.each_line do |line|
+    line = line.strip.delete('"')
+    next if line.empty? || line.start_with?("Name")
+
+    name, state = line.split(",", 2)
+    caps[name] = state if name && state
+  end
+  caps
+end
+
+def compare(yaml_caps, live_caps)
+  yaml_names = yaml_caps.keys.to_set
+  live_names = live_caps.keys.to_set
+
+  matched = yaml_names & live_names
+  missing_from_yaml = live_names - yaml_names
+  extra_in_yaml = yaml_names - live_names
+
+  [matched, missing_from_yaml, extra_in_yaml]
+end
+
+def print_results(matched, missing_from_yaml, extra_in_yaml)
+  puts "=== Matched (#{matched.size}) ==="
+  matched.sort.each { |name| puts "  OK: #{name}" }
+
+  if missing_from_yaml.any?
+    puts ""
+    puts "=== Missing from our YAML (#{missing_from_yaml.size}) ==="
+    missing_from_yaml.sort.each { |name| puts "  MISSING: #{name}" }
+  end
+
+  if extra_in_yaml.any?
+    puts ""
+    puts "=== Extra in our YAML (#{extra_in_yaml.size}) ==="
+    extra_in_yaml.sort.each { |name| puts "  EXTRA: #{name}" }
+  end
+end
+
+def check_installed_fonts(yaml_caps, live_caps)
+  installed = live_caps.select { |_, state| state == "Installed" }
+  return [] if installed.empty?
+
+  puts ""
+  puts "=== Font File Checks for Installed Capabilities ==="
+
+  errors = []
+
+  installed.each_key do |cap_name|
+    cap_data = yaml_caps[cap_name]
+    next unless cap_data
+
+    fonts = cap_data.fetch("fonts", {})
+    fonts.each do |family_name, data|
+      files = data.fetch("files", [])
+      files.each do |filename|
+        path = File.join(FONTS_DIR, filename)
+        if File.exist?(path)
+          puts "  OK: #{filename} (#{family_name})"
+        else
+          puts "  MISSING: #{filename} (#{family_name}) — expected at #{path}"
+          errors << "#{cap_name}: #{filename} not found"
+        end
+      end
+    end
+  end
+
+  errors
+end
+
+def summarize(matched, missing_from_yaml, extra_in_yaml, font_errors)
+  puts "========================================="
+  puts "  Validation Summary"
+  puts "========================================="
+  puts "  Capability matches:      #{matched.size}"
+  puts "  Missing from our YAML:   #{missing_from_yaml.size}"
+  puts "  Extra in our YAML:       #{extra_in_yaml.size}"
+  puts "  Font file errors:        #{font_errors.size}"
+  puts ""
+
+  if missing_from_yaml.any?
+    puts "WARNING: #{missing_from_yaml.size} capabilities exist on Windows but not in our YAML."
+    puts "  Consider adding them to fod_capabilities.yml"
+    puts ""
+  end
+
+  if extra_in_yaml.any?
+    puts "WARNING: #{extra_in_yaml.size} capabilities in our YAML not found on this Windows version."
+    puts "  These may be version-specific or renamed."
+    puts ""
+  end
+
+  if font_errors.any?
+    puts "WARNING: #{font_errors.size} font files missing for installed capabilities."
+    font_errors.each { |e| puts "  - #{e}" }
+    puts ""
+  end
+
+  # Exit 1 only if we have zero matches (indicates a fundamental problem)
+  if matched.empty? && (missing_from_yaml.any? || extra_in_yaml.any?)
+    puts "CRITICAL: No capability names matched — our YAML may be completely wrong."
+    exit 1
+  end
+
+  puts "Validation passed."
+  exit 0
+end
+
+main