fontist 1.21.4 → 2.0.1

data/lib/fontist/indexes/formula_key_to_path.rb

@@ -0,0 +1,35 @@
+
+module Fontist
+  module Indexes
+    class FormulaKeyToPath < Lutaml::Model::Serializable
+      attribute :key, :string
+      attribute :formula_path, :string, collection: true
+
+      key_value do
+        map "key", to: :key
+        map "formula_path", to: :formula_path
+      end
+
+      def to_full
+        formula_path.map { |p| Formula.from_file(full_path(p)) }
+      end
+
+      def name
+        formula_path.map { |p| normalized(p) }
+      end
+
+      def normalized(path)
+        return "" unless path
+
+        escaped = Regexp.escape("#{Fontist.formulas_path}/")
+        path.sub(Regexp.new("^#{escaped}"), "").sub(/\.yml$/, "").to_s
+      end
+
+      private
+
+      def full_path(path)
+        Fontist.formulas_path.join(path).to_s
+      end
+    end
+  end
+end

data/lib/fontist/indexes/index_mixin.rb

@@ -0,0 +1,109 @@
+module Fontist
+  module Indexes
+    module IndexMixin
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def from_file(file_path = self.path)
+          Fontist.ui.debug("Index: #{file_path}")
+
+          Fontist.formulas_repo_path_exists!
+
+          rebuild unless File.exist?(file_path)
+
+          file_content = File.read(file_path).strip
+
+          if file_content.empty?
+            raise Fontist::Errors::FontIndexCorrupted, "Index file is empty: #{file_path}"
+          end
+
+          from_yaml(file_content)
+        end
+
+        def rebuild
+          # puts "Rebuilding index..."
+          new.build
+        end
+      end
+
+      def build
+        Formula.all.each do |formula|
+          add_formula(formula)
+        end
+
+        to_file
+
+        self
+      end
+
+      def add_formula(formula)
+        raise unless formula.is_a?(Formula)
+
+        formula.all_fonts.each do |font|
+          font.styles.each do |style|
+            add_index_formula(style, formula.path)
+          end
+        end
+
+        entries
+      end
+
+      def index_key_for_style(_style)
+        raise NotImplementedError, "index_key_for_style(style) must be implemented in including class"
+      end
+
+      def add_index_formula(style, formula_path)
+        key = index_key_for_style(style)
+        raise if key.nil? || key.empty?
+
+        key = normalize_key(key)
+        formula_path = Array(formula_path)
+        paths = formula_path.map { |p| relative_formula_path(p) }
+
+        if index_formula(key)
+          index_formula(key).formula_path.concat(paths).uniq!
+          return
+        end
+
+        entries << FormulaKeyToPath.new(
+          key: key,
+          formula_path: paths,
+        )
+      end
+
+      def load_formulas(key)
+        index_formulas(key).flat_map(&:to_full)
+      end
+
+      def load_index_formulas(key)
+        index_formulas(key)
+      end
+
+      def to_file(file_path = self.class.path)
+        # Use default path if file_path is nil
+        file_path = self.class.path if file_path.nil?
+        # puts "Writing index to #{file_path}"
+
+        FileUtils.mkdir_p(File.dirname(file_path))
+        File.write(file_path, to_yaml)
+      end
+
+      private
+
+      def index_formula(key)
+        Array(entries).detect { |f| normalize_key(f.key) == normalize_key(key) }
+      end
+
+      def index_formulas(key)
+        Array(entries).select { |f| normalize_key(f.key) == normalize_key(key) }
+      end
+
+      def relative_formula_path(path)
+        escaped = Regexp.escape("#{Fontist.formulas_path}/")
+        path.sub(Regexp.new("^#{escaped}"), "")
+      end
+    end
+  end
+end

data/lib/fontist/indexes/preferred_family_font_index.rb

@@ -1,19 +1,38 @@
-require_relative "base_index"
+require "lutaml/model"
+require_relative "index_mixin"
+require_relative "formula_key_to_path"
 
 module Fontist
   module Indexes
-    class PreferredFamilyFontIndex < BaseIndex
+    # YAML file structure:
+    # ---
+    # adobe arabic:
+    # - adobe_reader_19.yml
+    # myriad pro:
+    # - adobe_reader_20.yml
+    # akabara-cinderella:
+    # - akabara-cinderella.yml
+    # andale mono:
+    # - andale.yml
+    # - macos/andale_mono.yml
+    # - opensuse_webcore_fonts.yml
+    # - pclinuxos_webcore_fonts.yml
+    class PreferredFamilyFontIndex < Lutaml::Model::Collection
+      include IndexMixin
+      instances :entries, FormulaKeyToPath
+
+      key_value do
+        map_key to_instance: :key
+        map_value as_attribute: :formula_path
+        map_instances to: :entries
+      end
+
       def self.path
         Fontist.formula_preferred_family_index_path
       end
 
-      def add_formula(formula)
-        formula.fonts.each do |font|
-          font.styles.each do |style|
-            font_name = style.preferred_family_name || font.name
-            add_index_formula(font_name, formula.to_index_formula)
-          end
-        end
+      def index_key_for_style(style)
+        style.preferred_family_name || style.family_name
       end
 
       def normalize_key(key)

data/lib/fontist/manifest.rb

@@ -1,2 +1,144 @@
-require_relative "manifest/locations"
-require_relative "manifest/install"
+require "lutaml/model"
+
+module Fontist
+  class ManifestFont < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :styles, :string, collection: true
+
+    def style_paths(locations: false)
+      ary = Array(styles)
+      (ary.empty? ? [nil] : ary).flat_map do |style|
+        find_font_with_name(name, style).tap do |x|
+          raise Errors::MissingFontError.new(name, style) if x.nil? && locations
+        end
+      end.compact
+    end
+
+    def group_paths(locations: false)
+      style_paths(locations: locations).group_by(&:type)
+        .transform_values { |group| style(group) }
+    end
+
+    def style(styles_ary)
+      { "full_name" => styles_ary.first.full_name,
+        "paths" => styles_ary.filter_map(&:path) }
+    end
+
+    def find_font_with_name(font, style)
+      Fontist::SystemFont.find_styles(font, style)
+    end
+
+    def install(confirmation: "no", hide_licenses: false, no_progress: false)
+      Fontist::Font.install(
+        name,
+        force: true,
+        confirmation: confirmation,
+        hide_licenses: hide_licenses,
+        no_progress: no_progress,
+      )
+    end
+
+    def to_response(locations: false)
+      groups = group_paths(locations: locations)
+
+      return self if groups.empty?
+
+      ManifestResponseFont.new(
+        name: name,
+        styles: groups.map do |type, details|
+          ManifestResponseFontStyle.new(
+            type: type,
+            full_name: details["full_name"],
+            paths: details["paths"],
+          )
+        end,
+      )
+    end
+
+    def group_paths_empty?
+      group_paths.compact.empty?
+    end
+  end
+
+  # Manifest class for managing font manifests.
+  class Manifest < Lutaml::Model::Collection
+    instances :fonts, ManifestFont
+
+    # TODO: Re-enable these when
+    key_value do
+      map to: :fonts, root_mappings: {
+        name: :key,
+        styles: :value,
+      }
+    end
+
+    def self.from_file(path, locations: false)
+      Fontist.ui.debug("Manifest: #{path}")
+
+      unless File.exist?(path)
+        raise Fontist::Errors::ManifestCouldNotBeFoundError,
+              "Manifest file not found: #{path}"
+      end
+
+      file_content = File.read(path).strip
+
+      if file_content.empty?
+        raise Fontist::Errors::ManifestCouldNotBeReadError,
+              "Manifest file is empty: #{path}"
+      end
+
+      manifest_model = begin
+        from_yaml(file_content)
+      rescue StandardError => e
+        raise Fontist::Errors::ManifestCouldNotBeReadError,
+              "Manifest file could not be read: #{e.message}"
+      end
+
+      manifest_model.to_response(locations: locations)
+    end
+
+    def self.from_hash(data, options = {})
+      locations = options.delete(:locations) || false
+
+      model = super(data, options)
+
+      model.to_response(locations: locations)
+    end
+
+    def self.font_class
+      ManifestFont
+    end
+
+    def fonts_casted
+      Array(fonts).map do |font|
+        self.class.font_class === font ? font : self.class.font_class.new(font.to_h)
+      end
+    end
+
+    def install(confirmation: "no", hide_licenses: false, no_progress: false)
+      fonts_casted.each do |font|
+        paths = font.group_paths
+        if paths.length < fonts_casted.length
+          font.install(confirmation: confirmation,
+                       hide_licenses: hide_licenses, no_progress: no_progress)
+        end
+      end
+      to_response
+    end
+
+    def to_response(locations: false)
+      return self if fonts_casted.any?(&:group_paths_empty?) && !locations
+
+      ManifestResponse.new.tap do |response|
+        response.fonts = fonts_casted.map do |font|
+          font.to_response(locations: locations)
+        end
+      end
+    end
+
+    def to_file(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, to_yaml)
+    end
+  end
+end

data/lib/fontist/manifest_request.rb

@@ -0,0 +1,64 @@
+require "lutaml/model"
+require_relative "manifest"
+
+module Fontist
+  class ManifestRequestFont < ManifestFont
+    def to_response
+      font_styles = locate_styles.map do |style, detailed_styles|
+        # puts "Detailed styles for #{name}: #{detailed_styles.inspect}"
+
+        if detailed_styles.nil? || detailed_styles.empty?
+          Fontist.ui.error("Font #{name} with style #{style} not found, skipping")
+          ManifestResponseFontStyle.new(
+            type: style,
+          )
+        else
+          ManifestResponseFontStyle.new(
+            full_name: detailed_styles.first.full_name,
+            type: detailed_styles.first.type,
+            paths: detailed_styles.map(&:path),
+          )
+        end
+      end
+
+      ManifestResponseFont.new(
+        name: name,
+        styles: font_styles,
+      )
+    end
+
+    private
+
+    # Returns an array of paths for the font and all its styles
+    # A SystemIndexFont array is returned, which has the following structure:
+    # [{:path=>"/Library/Fonts/Arial Unicode.ttf",
+    # :full_name=>"Arial Unicode MS",
+    # :family_name=>"Arial Unicode MS",
+    # :type=>"Regular"}, ...],
+    def locate_styles
+      Array(styles).map do |style|
+        [
+          style,
+          Fontist::SystemFont.find_styles(name, style),
+        ]
+      end
+    end
+  end
+
+  # ---
+  # Andale Mono:
+  # - Regular
+  # Arial Black:
+  # - Regular
+  # Arial:
+  # - Bold
+  # - Italic
+  # - Bold Italic
+  class ManifestRequest < Manifest
+    instances :fonts, ManifestRequestFont
+
+    def self.font_class
+      ManifestRequestFont
+    end
+  end
+end

data/lib/fontist/manifest_response.rb

@@ -0,0 +1,66 @@
+require "lutaml/model"
+require_relative "manifest"
+
+module Fontist
+  class ManifestResponseFontStyle < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :full_name, :string
+    attribute :paths, :string, collection: true
+  end
+
+  class ManifestResponseFont < ManifestFont
+    attribute :name, :string
+    attribute :styles, ManifestResponseFontStyle, collection: true
+
+    key_value do
+      map "name", to: :name
+      map "styles", to: :styles, child_mappings: {
+        type: :key,
+        full_name: :full_name,
+        paths: :paths,
+      }
+    end
+
+    def install(confirmation: "no", hide_licenses: false, no_progress: false)
+      styles.each do |style|
+        if style.paths.nil?
+          # If no paths are found, notify the user but continue with the
+          # installation
+          Fontist.ui.error("Font #{name} with style #{style} not found, skipping installation.")
+        end
+      end
+
+      Fontist::Font.install(
+        name,
+        force: false,
+        confirmation: confirmation,
+        hide_licenses: hide_licenses,
+        no_progress: no_progress,
+      )
+    end
+  end
+
+  # Yu Gothic:
+  #   Bold:
+  #     full_name: Yu Gothic Bold
+  #     paths:
+  #     - "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothB.ttc"
+  #     - "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothB.ttc"
+  #   Regular:
+  #     full_name: Yu Gothic Regular
+  #     paths:
+  #     - "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothR.ttc"
+  #     - "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothR.ttc"
+  # Noto Sans Condensed:
+  #   Regular:
+  #     full_name: Noto Sans Condensed
+  #     paths:
+  #     - "/Users/foo/.fontist/fonts/NotoSans-Condensed.ttf"
+  class ManifestResponse < Manifest
+    instances :fonts, ManifestResponseFont
+
+    def self.font_class
+      ManifestResponseFont
+    end
+  end
+end

data/lib/fontist/repo.rb

@@ -35,7 +35,7 @@ module Fontist
 
     def build_formulas(path)
       path.glob("*.yml").map do |formula_path|
-        formula = Formula.new_from_file(formula_path)
+        formula = Formula.from_file(formula_path)
         Struct.new(:name, :description).new(formula.key, formula.description)
       end
     end

data/lib/fontist/system_font.rb

@@ -1,12 +1,8 @@
 require_relative "system_index"
 
 module Fontist
-  class SystemFont
-    def initialize(font:, style: nil)
-      @font = font
-      @style = style
-    end
-
+  # TODO: This is actually a SystemIndex font entry
+  class SystemFont < Lutaml::Model::Serializable
     def self.font_paths
       system_font_paths + fontist_font_paths
     end
@@ -15,6 +11,7 @@ module Fontist
       @system_font_paths ||= load_system_font_paths
     end
 
+    # This detects all fonts on the system from the configuration file.
     def self.load_system_font_paths
       os = Fontist::Utils::System.user_os.to_s
       templates = system_config["system"][os]["paths"]
@@ -48,29 +45,14 @@ module Fontist
     end
 
     def self.find(font)
-      new(font: font).find
-    end
-
-    def self.find_styles(font, style)
-      new(font: font, style: style).find_styles
-    end
-
-    def find
-      styles = find_styles
+      styles = find_styles(font)
       return unless styles
 
-      styles.map { |x| x[:path] }
-    end
-
-    def find_styles
-      find_by_index
+      styles.map(&:path)
     end
 
-    private
-
-    attr_reader :font, :style
-
-    def find_by_index
+    # This returns a SystemIndexEntry
+    def self.find_styles(font, style = nil)
       SystemIndex.system_index.find(font, style)
     end
   end