fontist 2.1.6 → 2.2.1

data/lib/fontist/font_installer.rb

@@ -1,14 +1,18 @@
 require "excavate"
+require_relative "format_matcher"
 
 module Fontist
   class FontInstaller
     attr_reader :location
 
-    def initialize(formula, font_name: nil, no_progress: false, location: nil)
+    def initialize(formula, font_name: nil, no_progress: false, location: nil,
+                   format_spec: nil, confirmation: "no")
       @formula = formula
       @font_name = font_name
       @no_progress = no_progress
       @location = InstallLocation.create(formula, location_type: location)
+      @format_spec = format_spec
+      @confirmation = confirmation
     end
 
     def install(confirmation:)
@@ -54,6 +58,7 @@ module Fontist
 
     def license_is_accepted?(confirmation)
       return true unless @formula.license_required?
+      return true if @formula.licensed_for_current_platform?
 
       "yes".casecmp?(confirmation)
     end
@@ -93,7 +98,20 @@ module Fontist
     end
 
     def resource_options
-      @formula.resources.first
+      @resource_options ||= begin
+        if @formula.resources.size == 1 || !@formula.v5?
+          @formula.resources.first
+        elsif @format_spec&.has_constraints?
+          matcher = FormatMatcher.new(@format_spec)
+          matcher.select_preferred_resource(@formula.resources)
+        else
+          find_desktop_resource || @formula.resources.first
+        end
+      end
+    end
+
+    def find_desktop_resource
+      @formula.resources.find { |r| r.format && FormatMatcher::DESKTOP_FORMATS.include?(r.format) }
     end
 
     def font_file?(path)
@@ -105,13 +123,32 @@ module Fontist
     end
 
     def source_files
-      @source_files ||= fonts.flat_map do |font|
-        font.styles.map do |style|
-          style.source_font || style.font
+      @source_files ||= begin
+        styles = filtered_styles
+
+        # Use FormatMatcher for filtering
+        if @format_spec&.has_constraints? && @formula.v5?
+          matcher = FormatMatcher.new(@format_spec)
+          styles = matcher.filter_styles(styles)
         end
+
+        file_names = styles.map { |s| s.source_font || s.font }
+
+        if @formula.v5? && resource_options&.source == "google" && file_names.any?
+          resource_basenames = Array(resource_options.files).map { |f| File.basename(f) }
+          unless file_names.any? { |f| resource_basenames.include?(f) }
+            return resource_basenames
+          end
+        end
+
+        file_names
       end
     end
 
+    def filtered_styles
+      fonts.flat_map(&:styles)
+    end
+
     def fonts
       @formula.all_fonts.select do |font|
         @font_name.nil? || font.name.casecmp?(@font_name)
@@ -129,23 +166,144 @@ module Fontist
     end
 
     def subdirectories
-      @subdirectories ||= [@formula.extract].flatten.compact.filter_map(&:options).filter_map(&:fonts_sub_dir)
+      @subdirectories ||= begin
+        extracts = [@formula.extract].flatten.compact
+        # options is a collection, so we need to flatten it too
+        options = extracts.flat_map { |e| e.options }.compact
+        options.filter_map(&:fonts_sub_dir)
+      end
     end
 
     def install_font_file(source)
       source_basename = File.basename(source)
       target_name = target_filename(source_basename) || source_basename
+      source_format = detect_font_format(source)
+
+      # Check if transcoding is needed (format requested but not available)
+      if @format_spec&.format && @format_spec.format != source_format
+        check_transcode_license_warning!
+        install_with_conversion(source, target_name, source_format)
+      else
+        @location.install_font(source, target_name)
+      end
+    end
+
+    def detect_font_format(path)
+      ext = File.extname(path).downcase.delete(".")
+      case ext
+      when "ttf", "otf", "woff", "woff2", "ttc", "otc", "dfont"
+        ext
+      else
+        "ttf" # Default
+      end
+    end
+
+    # Check and warn about license implications of transcoding
+    def check_transcode_license_warning!
+      return unless @formula.license_required?
+
+      if @confirmation != "yes"
+        raise Errors::TranscodeLicenseNotAcceptedError.new(
+          @formula.fonts.first&.name || @formula.name,
+        )
+      end
 
-      # Use location object to handle installation
-      # This handles all the logic for:
-      # - Checking if font exists
-      # - Managed vs non-managed location handling
-      # - Unique filename generation
-      # - Index updates
-      # - Warning messages
-      @location.install_font(source, target_name)
+      # User has accepted the license, but we still warn them
+      # that transcoding may not be permitted by all licenses
+      Fontist.ui.warn("\n#{'=' * 60}")
+      Fontist.ui.warn("LICENSE TRANSCODING NOTICE")
+      Fontist.ui.warn("=" * 60)
+      Fontist.ui.warn(
+        "You are transcoding a font that requires a license agreement.",
+      )
+      Fontist.ui.warn(
+        "Some font licenses do not permit conversion or modification,",
+      )
+      Fontist.ui.warn(
+        "of which transcoding is a type. Please ensure your use of",
+      )
+      Fontist.ui.warn("this font complies with the license terms.")
+      Fontist.ui.warn("#{'=' * 60}\n")
+    end
+
+    def install_with_conversion(source, target_name, source_format)
+      target_format = @format_spec.format
+
+      # Check if Fontisan can convert between formats
+      matcher = FormatMatcher.new(@format_spec)
+      unless matcher.can_convert?(source_format, target_format)
+        Fontist.ui.warn(
+          "Cannot convert from #{source_format} to #{target_format}",
+        )
+        Fontist.ui.warn("Installing original format instead")
+        return @location.install_font(source, target_name)
+      end
+
+      begin
+        converted_path = convert_with_fontisan(source, target_format)
+
+        # Determine where to save converted font
+        converted_name = target_name.sub(/\.[^.]+$/, ".#{target_format}")
+
+        Fontist.ui.success(
+          "Converted #{source_format} to #{target_format}: #{converted_name}",
+        )
+
+        # Install converted font
+        result = @location.install_font(converted_path, converted_name)
+
+        # Keep original if requested and transcode_path specified
+        if @format_spec.keep_original && @format_spec.transcode_path
+          @location.install_font(source, target_name)
+        end
+
+        # Clean up temp converted file if Fontisan created one
+        cleanup_temp_file(converted_path) if converted_path != source
+
+        result
+      rescue StandardError => e
+        Fontist.ui.warn("Could not convert to #{target_format}: #{e.message}")
+        Fontist.ui.warn("Installing original format instead")
+        @location.install_font(source, target_name)
+      end
+    end
+
+    # Convert font using Fontisan library
+    def convert_with_fontisan(source_path, target_format)
+      require "fontisan"
+
+      font = Fontisan::FontLoader.load(source_path)
+
+      case target_format
+      when "woff"
+        font.to_woff(path: temp_path_for(source_path, "woff"))
+      when "woff2"
+        font.to_woff2(path: temp_path_for(source_path, "woff2"))
+      else
+        raise Errors::UnsupportedTranscodeError.new(
+          File.extname(source_path),
+          target_format,
+        )
+      end
+    rescue LoadError
+      Fontist.ui.error(
+        "Fontisan gem not found. Transcoding requires the fontisan gem.",
+      )
+      Fontist.ui.error("Add it to your Gemfile or run: gem install fontisan")
+      raise
+    end
+
+    def temp_path_for(source_path, format)
+      base = File.basename(source_path, ".*")
+      dir = @format_spec&.transcode_path || Dir.mktmpdir
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      File.join(dir, "#{base}.#{format}")
+    end
 
-      # Return path if installed, nil if skipped
+    def cleanup_temp_file(path)
+      File.delete(path) if File.exist?(path)
+    rescue StandardError
+      # Ignore cleanup errors
     end
 
     def macos_asset_directory

data/lib/fontist/font_model.rb

@@ -1,6 +1,7 @@
 require "lutaml/model"
 
 module Fontist
+  # FontModel - uses FontStyle with v5 format metadata
   class FontModel < Lutaml::Model::Serializable
     attribute :name, :string
     attribute :styles, FontStyle, collection: true

data/lib/fontist/font_path.rb

@@ -37,10 +37,10 @@ module Fontist
 
       # On Windows, use case-insensitive comparison; on Unix, case-sensitive
       result = if Fontist::Utils::System.windows?
-        normalized_path.downcase.start_with?(normalized_fonts_path.downcase)
-      else
-        normalized_path.start_with?(normalized_fonts_path)
-      end
+                 normalized_path.downcase.start_with?(normalized_fonts_path.downcase)
+               else
+                 normalized_path.start_with?(normalized_fonts_path)
+               end
 
       puts "  result: #{result.inspect}" if ENV["DEBUG_FONT_PATH"]
       result

data/lib/fontist/font_style.rb

@@ -1,6 +1,7 @@
 require "lutaml/model"
 
 module Fontist
+  # FontStyle - v5 font style with format metadata for multi-format support
   class FontStyle < Lutaml::Model::Serializable
     attribute :family_name, :string
     attribute :type, :string
@@ -17,6 +18,12 @@ module Fontist
     attribute :default_type, :string
     attribute :override, :string
 
+    # v5 format metadata
+    attribute :formats, :string, collection: true # ["ttf", "woff2"]
+    attribute :variable_font, :boolean # true/false
+    attribute :variable_axes, :string, collection: true # ["wght", "wdth"]
+    attribute :source_resource, :string
+
     key_value do
       map "family_name", to: :family_name
       map "type", to: :type
@@ -32,6 +39,16 @@ module Fontist
       map "default_family_name", to: :default_family_name
       map "default_type", to: :default_type
       map "override", to: :override
+      map "formats", to: :formats
+      map "variable_font", to: :variable_font
+      map "variable_axes", to: :variable_axes
+      map "source_resource", to: :source_resource
+    end
+
+    # Helper to check if this is a variable font
+    # Returns false if not set, true only if explicitly set to true
+    def variable_font?
+      variable_font == true
     end
   end
 end

data/lib/fontist/format_matcher.rb

@@ -0,0 +1,176 @@
+module Fontist
+  # Centralized format matching service
+  #
+  # All format matching logic exists here. Other classes delegate to this.
+  # Supports matching across:
+  # - Resources (formula download sources)
+  # - Styles (font style entries)
+  # - Indexed fonts (system/user/fontist indexes)
+  # - Collections (TTC/OTC with multiple fonts)
+  #
+  # For transcoding, delegates to Fontisan library.
+  class FormatMatcher
+    # All supported formats
+    DESKTOP_FORMATS = %w[ttf otf ttc otc dfont].freeze
+    WEB_FORMATS = %w[woff woff2].freeze
+    ALL_FORMATS = (DESKTOP_FORMATS + WEB_FORMATS).freeze
+
+    def initialize(format_spec)
+      @spec = format_spec || FormatSpec.new
+    end
+
+    # Check if a resource matches the format spec
+    def matches_resource?(resource)
+      return true unless @spec.has_constraints?
+
+      if @spec.format && resource.format && resource.format != @spec.format
+        return false
+      end
+
+      if @spec.variable_requested?
+        return false unless resource.variable_font?
+        return axes_match?(resource.variable_axes) if @spec.axes.any?
+      end
+
+      true
+    end
+
+    # Check if a style matches the format spec
+    # @param style [FontStyle, SystemIndexFont] Style object to check
+    def matches_style?(style)
+      return true unless @spec.has_constraints?
+
+      # Check format constraint for FontStyle (v5 formulas have formats)
+      if @spec.format && style.is_a?(FontStyle) && style.formats && !Array(style.formats).include?(@spec.format)
+        return false
+      end
+
+      if @spec.variable_requested?
+        # Check if style is variable
+        is_variable = style.variable_font?
+        return false unless is_variable
+
+        return axes_match?(style.variable_axes) if @spec.axes.any?
+      end
+
+      true
+    end
+
+    # Check if an indexed font matches the format spec
+    def matches_indexed_font?(indexed_font)
+      return true unless @spec.has_constraints?
+      return false if @spec.format && indexed_font.format != @spec.format
+
+      if @spec.variable_requested?
+        return false unless indexed_font.variable_font
+
+        return axes_match?(indexed_font.variable_axes) if @spec.axes.any?
+      end
+
+      true
+    end
+
+    # Filter resources to only matching ones
+    def filter_resources(resources)
+      resources.select { |r| matches_resource?(r) }
+    end
+
+    # Filter styles to only matching ones
+    def filter_styles(styles)
+      styles.select { |s| matches_style?(s) }
+    end
+
+    # Filter indexed fonts to only matching ones
+    def filter_indexed_fonts(fonts)
+      fonts.select { |f| matches_indexed_font?(f) }
+    end
+
+    # Select best resource based on preferences
+    def select_preferred_resource(resources)
+      return resources.first if resources.empty?
+      return resources.first unless @spec.has_constraints?
+
+      # Match exact format first (e.g. format: "ttf" selects the ttf resource)
+      exact = find_exact_format(resources)
+      return exact if exact
+
+      preferred = find_preferred_format(resources)
+      return preferred if preferred
+
+      variable = find_variable_resource(resources)
+      return variable if variable
+
+      resources.first
+    end
+
+    # Check if requested format needs transcoding from available formats
+    def installation_strategy(available_formats)
+      requested = @spec.format
+
+      if !requested
+        return { strategy: :install, format: available_formats.first }
+      end
+
+      if available_formats.include?(requested)
+        return { strategy: :install, format: requested }
+      end
+
+      # Check if Fontisan can convert from any available format
+      convertible = available_formats.find { |f| self.class.can_convert?(f, requested) }
+      if convertible
+        return {
+          strategy: :convert,
+          from: convertible,
+          to: requested,
+        }
+      end
+
+      {
+        strategy: :unavailable,
+        requested: requested,
+        available: available_formats,
+      }
+    end
+
+    # Check if Fontisan can convert between formats (instance method for convenience)
+    def can_convert?(from_format, to_format)
+      self.class.can_convert?(from_format, to_format)
+    end
+
+    # Class method for checking Fontisan conversion capability
+    def self.can_convert?(from_format, to_format)
+      return false unless from_format && to_format
+
+      # Fontisan supports conversion from desktop to web formats
+      DESKTOP_FORMATS.include?(from_format.to_s) &&
+        WEB_FORMATS.include?(to_format.to_s)
+    end
+
+    private
+
+    def find_exact_format(resources)
+      return nil unless @spec.format
+
+      resources.find { |r| r.format == @spec.format }
+    end
+
+    def find_preferred_format(resources)
+      return nil unless @spec.prefer_format
+
+      resources.find { |r| r.format == @spec.prefer_format }
+    end
+
+    def find_variable_resource(resources)
+      return nil unless @spec.prefer_variable
+
+      resources.find { |r| r.variable_font? }
+    end
+
+    def axes_match?(available_axes)
+      return true if @spec.axes.empty?
+
+      available = Array(available_axes).map(&:to_s)
+      @spec.axes.all? { |axis| available.include?(axis) }
+    end
+  end
+end

data/lib/fontist/format_spec.rb

@@ -0,0 +1,80 @@
+require "lutaml/model"
+
+module Fontist
+  # Encapsulates format requirements for font installation/lookup
+  #
+  # Supports:
+  # - Format selection (install specific format)
+  # - Variable axes selection
+  # - Automatic transcoding (if format not available, transcode from available)
+  # - Transcode destination specification
+  #
+  # This model is passed through the entire pipeline:
+  # CLI -> Font -> FormulaPicker -> FontInstaller -> Index
+  class FormatSpec < Lutaml::Model::Serializable
+    # Format preference (what format to install)
+    # If format not available in formula, will transcode from available format
+    attribute :format, :string
+
+    # Variable font selection
+    attribute :variable_axes, :string, collection: true
+    attribute :prefer_variable, :boolean, default: false
+
+    # Format preferences
+    attribute :prefer_format, :string
+
+    # Transcoding options (used when format not available)
+    attribute :transcode_path, :string
+    attribute :keep_original, :boolean, default: true
+
+    # Collection handling
+    attribute :collection_index, :integer
+
+    # Convenience constructor for CLI
+    def self.from_options(options = {})
+      new(
+        format: options[:format],
+        variable_axes: parse_variable_axes(options[:variable_axes]),
+        prefer_variable: options[:prefer_variable] || false,
+        prefer_format: options[:prefer_format],
+        transcode_path: options[:transcode_path],
+        keep_original: options.fetch(:keep_original, true),
+        collection_index: options[:collection_index],
+      )
+    end
+
+    def self.parse_variable_axes(value)
+      return nil if value.nil?
+      return value if value.is_a?(Array)
+
+      value.to_s.split(",").map(&:strip).compact
+    end
+
+    # Check if any format constraints are specified
+    def has_constraints?
+      !!(format || variable_axes&.any? || prefer_variable || prefer_format)
+    end
+
+    # Check if variable font is requested
+    def variable_requested?
+      !!(variable_axes&.any? || prefer_variable)
+    end
+
+    # Get axes as array (never nil)
+    def axes
+      Array(variable_axes)
+    end
+
+    # Check if transcoding might be needed (format specified but not available)
+    def needs_transcode?(available_formats)
+      return false unless format
+
+      !available_formats.include?(format)
+    end
+
+    # Check if we need a specific collection index
+    def specific_collection_index?
+      !collection_index.nil?
+    end
+  end
+end