fontist 1.21.4 → 2.0.2

data/lib/fontist/index.rb

@@ -1,20 +1,59 @@
-require_relative "indexes/font_index"
+require "lutaml/model"
 require_relative "indexes/filename_index"
+require_relative "indexes/font_index"
+require_relative "indexes/default_family_font_index"
+require_relative "indexes/preferred_family_font_index"
 
 module Fontist
-  class Index
+  class IndexEntry < Lutaml::Model::Serializable
+    attribute :path, :string
+    attribute :full_name, :string
+    attribute :family_name, :string
+    attribute :style, :string
+    attribute :type, :string
+    attribute :source_font, :string
+
+    key_value do
+      map "path", to: :path
+      map "full_name", to: :full_name
+      map "family_name", to: :family_name
+      map "style", to: :style
+      map "type", to: :type
+      map "source_font", to: :source_font
+    end
+  end
+
+  class Index < Lutaml::Model::Collection
+    instances :entries, IndexEntry
+
+    key_value do
+      map_instances to: :entries
+    end
+
+    def self.from_file(path)
+      return new unless File.exist?(path)
+
+      content = File.read(path)
+      from_yaml(content)
+    end
+
+    def to_file(path)
+      File.write(path, to_yaml)
+    end
+
     def self.rebuild
-      Fontist::Indexes::DefaultFamilyFontIndex.rebuild
-      Fontist::Indexes::PreferredFamilyFontIndex.rebuild
-      Fontist::Indexes::FilenameIndex.rebuild
+      Fontist::Indexes::DefaultFamilyFontIndex.rebuild.to_file
+      Fontist::Indexes::PreferredFamilyFontIndex.rebuild.to_file
+      Fontist::Indexes::FilenameIndex.rebuild.to_file
 
       reset_cache
     end
 
+    # TODO: Uncomment all lines when each fixed
     def self.reset_cache
-      Fontist::Indexes::DefaultFamilyFontIndex.reset_cache
-      Fontist::Indexes::PreferredFamilyFontIndex.reset_cache
-      Fontist::Indexes::FilenameIndex.reset_cache
+      # Fontist::Indexes::DefaultFamilyFontIndex.reset_cache
+      # Fontist::Indexes::PreferredFamilyFontIndex.reset_cache
+      # Fontist::Indexes::FilenameIndex.reset_cache
     end
   end
 end

data/lib/fontist/indexes/default_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 DefaultFamilyFontIndex < 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 DefaultFamilyFontIndex < 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_index_path
       end
 
-      def add_formula(formula)
-        formula.fonts.each do |font|
-          font.styles.each do |style|
-            font_name = style.default_family_name || font.name
-            add_index_formula(font_name, formula.to_index_formula)
-          end
-        end
+      def index_key_for_style(style)
+        style.default_family_name || style.family_name
       end
 
       def normalize_key(key)

data/lib/fontist/indexes/filename_index.rb

@@ -1,18 +1,55 @@
-require_relative "base_index"
+require "lutaml/model"
+require_relative "index_mixin"
+require_relative "formula_key_to_path"
 
 module Fontist
   module Indexes
-    class FilenameIndex < BaseIndex
+    # YAML file structure:
+    # ---
+    # AdobeArabic_Bold.otf:
+    # - adobe_reader_19.yml
+    # AdobeArabic_BoldItalic.otf:
+    # - adobe_reader_19.yml
+    # AdobeArabic_Italic.otf:
+    # - adobe_reader_19.yml
+    # AdobeArabic_Regular.otf:
+    # - adobe_reader_19.yml
+    # adobedevanagari_bold.otf:
+    # - adobe_reader_19.yml
+    class FilenameIndex < 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_filename_index_path
       end
 
-      def add_formula(formula)
-        formula.fonts.each do |font|
-          font.styles.each do |style|
-            add_index_formula(style.font, formula.to_index_formula)
-          end
-        end
+      ## Fonts
+      # fonts:
+      # - name: Adobe Pi Std
+      #   styles:
+      #   - family_name: Adobe Pi Std
+      #     type: Regular
+
+      ## Font collections
+      # font_collections:
+      # - filename: AdelleSans.ttc
+      #   fonts:
+      #   - name: Adelle Sans Devanagari
+      #     styles:
+
+      def index_key_for_style(style)
+        style.font
+      end
+
+      def normalize_key(key)
+        key
       end
     end
   end

data/lib/fontist/indexes/font_index.rb

@@ -4,11 +4,11 @@ require_relative "preferred_family_font_index"
 module Fontist
   module Indexes
     class FontIndex
-      def self.from_yaml
+      def self.from_file
         if Fontist.preferred_family?
-          PreferredFamilyFontIndex.from_yaml
+          PreferredFamilyFontIndex.from_file
         else
-          DefaultFamilyFontIndex.from_yaml
+          DefaultFamilyFontIndex.from_file
         end
       end
     end

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/resources/archive_resource.rb

@@ -33,10 +33,11 @@ module Fontist
       end
 
       def try_download_file(request, source)
-        info_log(request)
+        url = Helpers.url_object(request)
+        info_log(url)
 
         Fontist::Utils::Downloader.download(
-          request,
+          url,
           sha: source.sha256,
           file_size: source.file_size,
           progress_bar: !@options[:no_progress],