fontist 1.21.4 → 2.0.1

data/lib/fontist/system_index.rb

@@ -2,157 +2,142 @@ require_relative "font_file"
 require_relative "collection_file"
 
 module Fontist
-  class SystemIndex
-    include Utils::Locking
-
-    class DefaultFamily
-      def family_name(name)
-        name.family
-      end
+  # {:path=>"/Library/Fonts/Arial Unicode.ttf",
+  # :full_name=>"Arial Unicode MS",
+  # :family_name=>"Arial Unicode MS",
+  # :preferred_family_name=>"Arial",
+  # :preferred_subfamily=>"Regular",
+  # :subfamily=>"Regular"},
+  class SystemIndexFont < Lutaml::Model::Serializable
+    attribute :path, :string
+    attribute :full_name, :string
+    attribute :family_name, :string
+    attribute :preferred_family_name, :string
+    attribute :preferred_subfamily, :string
+    attribute :subfamily, :string
+    alias :type :subfamily
+
+    key_value do
+      map "path", to: :path
+      map "full_name", to: :full_name
+      map "family_name", to: :family_name
+      map "type", to: :subfamily
+      map "preferred_family_name", to: :preferred_family_name
+      map "preferred_subfamily", to: :preferred_subfamily
+    end
+  end
 
-      def type(name)
-        name.subfamily
-      end
+  class SystemIndexFontCollection < Lutaml::Model::Collection
+    instances :fonts, SystemIndexFont
+    attr_accessor :path, :paths_loader
 
-      def transform_override_keys(dict)
-        dict
-      end
+    key_value do
+      map_instances to: :fonts
     end
 
-    class PreferredFamily
-      def family_name(name)
-        name.preferred_family || name.family
-      end
-
-      def type(name)
-        name.preferred_subfamily || name.subfamily
-      end
+    def set_path(path)
+      @path = path
+    end
 
-      def transform_override_keys(dict)
-        mapping = { preferred_family_name: :family_name, preferred_type: :type }
-        dict.transform_keys! { |k| mapping[k] }
-      end
+    def set_path_loader(paths_loader)
+      @paths_loader = paths_loader
     end
 
-    ALLOWED_KEYS = %i[path full_name family_name type].freeze
+    def self.from_file(path:, paths_loader:)
+      # If the file does not exist, return a new collection
+      return new.set_content(path, paths_loader) unless File.exist?(path)
 
-    def self.system_index
-      path = if Fontist.preferred_family?
-               Fontist.system_preferred_family_index_path
-             else
-               Fontist.system_index_path
-             end
+      from_yaml(File.read(path)).set_content(path, paths_loader)
+    end
 
-      @system_index ||= {}
-      @system_index[Fontist.preferred_family?] ||= {}
-      @system_index[Fontist.preferred_family?][path] ||=
-        new(path, -> { SystemFont.font_paths }, family)
+    def set_content(path, paths_loader)
+      tap do |content|
+        content.set_path(path)
+        content.set_path_loader(paths_loader)
+      end
     end
 
-    def self.fontist_index
-      path = if Fontist.preferred_family?
-               Fontist.fontist_preferred_family_index_path
-             else
-               Fontist.fontist_index_path
-             end
+    ALLOWED_KEYS = %i[path full_name family_name type].freeze
 
-      @fontist_index ||= {}
-      @fontist_index[Fontist.preferred_family?] ||= {}
-      @fontist_index[Fontist.preferred_family?][path] ||=
-        new(path, -> { SystemFont.fontist_font_paths }, family)
-    end
+    # Check if the content has all required keys
+    def check_index
+      Fontist.formulas_repo_path_exists!
 
-    def self.family
-      Fontist.preferred_family? ? PreferredFamily.new : DefaultFamily.new
-    end
+      Array(fonts).each do |font|
+        missing_keys = ALLOWED_KEYS.reject do |key|
+          font.send(key)
+        end
 
-    def excluded_fonts
-      @excluded_fonts ||= YAML.load_file(Fontist.excluded_fonts_path)
+        raise_font_index_corrupted(font, missing_keys) if missing_keys.any?
+      end
     end
 
-    def initialize(index_path, font_paths_fetcher, family)
-      @index_path = index_path
-      @font_paths_fetcher = font_paths_fetcher
-      @family = family
+    def to_file(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, to_yaml)
     end
 
     def find(font, style)
-      fonts = index.select do |file|
-        file[:family_name].casecmp?(font) &&
-          (style.nil? || file[:type].casecmp?(style))
+      found_fonts = index.select do |file|
+        file.family_name.casecmp?(font) &&
+          (style.nil? || file.type.casecmp?(style))
       end
 
-      fonts.empty? ? nil : fonts
+      found_fonts.empty? ? nil : found_fonts
     end
 
-    def rebuild
-      build_index
-    end
-
-    private
-
     def index
-      return @index unless index_changed?
+      return fonts unless index_changed?
 
-      @index = build_index
-    end
+      build
+      check_index
 
-    def index_changed?
-      @index.nil? ||
-        @index.map { |x| x[:path] }.uniq.sort != font_paths.sort
+      fonts
     end
 
-    def font_paths
-      @font_paths_fetcher.call
+    def index_changed?
+      fonts.nil? || fonts.empty? || font_paths != (@paths_loader&.call || []).sort.uniq
     end
 
-    def build_index
-      lock(lock_path) do
-        do_build_index
+    def update
+      tap do |col|
+        col.fonts = detect_paths(@paths_loader&.call || [])
       end
     end
 
-    def lock_path
-      Utils::Cache.lock_path(@index_path)
-    end
-
-    def do_build_index
+    def build(forced: false)
       previous_index = load_index
-      updated_index = detect_paths(font_paths, previous_index)
-      updated_index.tap do |index|
-        save_index(index) if changed?(updated_index, previous_index)
+      updated_fonts = update
+      if forced || changed?(updated_fonts, previous_index.fonts || [])
+        to_file(@path)
       end
+
+      self
     end
 
-    def changed?(this, that)
-      this.map { |x| x[:path] }.uniq.sort != that.map { |x| x[:path] }.uniq.sort
+    def rebuild
+      build(forced: true)
     end
 
+    private
+
     def load_index
-      index = File.exist?(@index_path) ? YAML.load_file(@index_path) : []
-      check_index(index)
+      index = self.class.from_file(path: @path, paths_loader: @paths_loader)
+      index.check_index
       index
     end
 
-    def check_index(index)
-      index.each do |item|
-        missing_keys = ALLOWED_KEYS - item.keys
-        unless missing_keys.empty?
-          raise(Errors::FontIndexCorrupted, <<~MSG.chomp)
-            Font index is corrupted.
-            Item #{item.inspect} misses required attributes: #{missing_keys.join(', ')}.
-            You can remove the index file (#{@index_path}) and try again.
-          MSG
-        end
-      end
+    def font_paths
+      fonts.map(&:path).uniq.sort
     end
 
-    def detect_paths(paths, index)
-      by_path = index.group_by { |x| x[:path] }
-
-      paths.flat_map do |path|
-        next by_path[path] if by_path[path]
+    def changed?(this_fonts, that_fonts)
+      this_fonts.map(&:path).uniq.sort != that_fonts.map(&:path).uniq.sort
+    end
 
+    def detect_paths(paths)
+      # paths are file paths to font files
+      paths.sort.uniq.flat_map do |path|
         detect_fonts(path)
       end.compact
     end
@@ -169,6 +154,10 @@ module Fontist
       excluded_fonts.include?(File.basename(path))
     end
 
+    def excluded_fonts
+      @excluded_fonts ||= YAML.load_file(Fontist.excluded_fonts_path)
+    end
+
     def gather_fonts(path)
       case File.extname(path).gsub(/^\./, "").downcase
       when "ttf", "otf"
@@ -189,42 +178,64 @@ module Fontist
     end
 
     def detect_file_font(path)
-      file = FontFile.from_path(path)
+      font_file = FontFile.from_path(path)
 
-      parse_font(file, path)
+      parse_font(font_file, path)
     end
 
     def detect_collection_fonts(path)
       CollectionFile.from_path(path) do |collection|
-        collection.map do |file|
-          parse_font(file, path)
+        collection.map do |font_file|
+          parse_font(font_file, path)
         end
       end
     end
 
-    def parse_font(file, path)
-      family_name = @family.family_name(file)
-
-      {
+    def parse_font(font_file, path)
+      SystemIndexFont.new(
         path: path,
-        full_name: file.full_name,
-        family_name: family_name,
-        type: @family.type(file),
-      }.merge(override_font_props(path, family_name))
+        full_name: font_file.full_name,
+        family_name: font_file.family,
+        subfamily: font_file.subfamily,
+        preferred_family_name: font_file.preferred_family,
+        preferred_subfamily_name: font_file.preferred_subfamily,
+      )
+    end
+
+    def raise_font_index_corrupted(font, missing_keys)
+      raise(Errors::FontIndexCorrupted, <<~MSG.chomp)
+        Font index is corrupted.
+        Item #{font.inspect} misses required attributes: #{missing_keys.join(', ')}.
+        You can remove the index file (#{@path}) and try again.
+      MSG
     end
+  end
 
-    def override_font_props(path, font_name)
-      override = Formula.find_by_font_file(path)
-        &.style_override(font_name)&.to_h || {}
+  class SystemIndex
+    include Utils::Locking
 
-      @family.transform_override_keys(override)
-        .slice(*ALLOWED_KEYS)
+    def self.system_index
+      @system_index = SystemIndexFontCollection.from_file(
+        path: Fontist.system_index_path,
+        paths_loader: -> { SystemFont.font_paths },
+      )
     end
 
-    def save_index(index)
-      dir = File.dirname(@index_path)
-      FileUtils.mkdir_p(dir)
-      File.write(@index_path, YAML.dump(index))
+    def self.fontist_index
+      @fontist_index = SystemIndexFontCollection.from_file(
+        path: Fontist.fontist_index_path,
+        paths_loader: -> { SystemFont.fontist_font_paths },
+      )
     end
+
+    # def build_index
+    #   lock(lock_path) do
+    #     do_build_index
+    #   end
+    # end
+
+    # def lock_path
+    #   Utils::Cache.lock_path(@index_path)
+    # end
   end
 end

data/lib/fontist/utils/cache.rb

@@ -1,5 +1,55 @@
+require "lutaml/model"
+
 module Fontist
   module Utils
+    class CacheIndexItem < Lutaml::Model::Serializable
+      attribute :url, :string
+      attribute :name, :string
+    end
+
+    class CacheIndex < Lutaml::Model::Serializable
+      attribute :items, CacheIndexItem, collection: true, default: []
+
+      key_value do
+        map to: :items, root_mappings: {
+          url: :key,
+          name: :value,
+        }
+      end
+
+      def self.from_file(path)
+        return new unless File.exist?(path)
+
+        content = File.read(path)
+
+        return new if content.strip.empty? || content.strip == "---"
+
+        from_yaml(content) || {}
+      end
+
+      def to_file(path)
+        File.write(path, to_yaml)
+      end
+
+      def [](key)
+        Array(items).find { |i| i.url == key }&.name
+      end
+
+      def []=(key, value)
+        item = Array(items).find { |i| i.url == key }
+        if item
+          item.name = value
+        else
+          items << CacheIndexItem.new(url: key, name: value)
+        end
+      end
+
+      def delete(key)
+        item = Array(items).find { |i| i.url == key }
+        items.delete(item) if item
+      end
+    end
+
     class Cache
       MAX_FILENAME_SIZE = 255
 
@@ -34,7 +84,7 @@ module Fontist
           return unless map[key]
 
           value = map.delete(key)
-          File.write(cache_map_path, YAML.dump(map))
+          map.to_file(cache_map_path)
           value
         end
       end
@@ -43,7 +93,7 @@ module Fontist
         lock(lock_path) do
           map = load_cache
           map[key] = value
-          File.write(cache_map_path, YAML.dump(map))
+          map.to_file(cache_map_path)
         end
       end
 
@@ -54,7 +104,7 @@ module Fontist
       end
 
       def load_cache
-        cache_map_path.exist? ? YAML.load_file(cache_map_path) : {}
+        CacheIndex.from_file(cache_map_path)
       end
 
       def downloaded_file(path)
@@ -83,7 +133,7 @@ module Fontist
         lock(lock_path) do
           map = load_cache
           map[key] = path
-          File.write(cache_map_path, YAML.dump(map))
+          map.to_file(cache_map_path)
         end
 
         path

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "1.21.4".freeze
+  VERSION = "2.0.1".freeze
 end

data/lib/fontist.rb

@@ -1,19 +1,9 @@
 require "down"
 require "digest"
-require "json"
-require "yaml"
 require "singleton"
 
-require "fontist/errors"
-require "fontist/version"
-
-require "fontist/repo"
-require "fontist/font"
-require "fontist/formula"
-require "fontist/system_font"
-require "fontist/manifest"
-require "fontist/helpers"
-require "fontist/config"
+require_relative "fontist/errors"
+require_relative "fontist/version"
 
 module Fontist
   def self.ui
@@ -141,7 +131,7 @@ module Fontist
   end
 
   def self.use_cache?
-    instance_variable_defined?("@use_cache") ? @use_cache : true
+    instance_variable_defined?(:@use_cache) ? @use_cache : true
   end
 
   def self.use_cache=(bool)
@@ -163,4 +153,34 @@ module Fontist
   def self.google_fonts_key
     ENV["GOOGLE_FONTS_API_KEY"] || config[:google_fonts_key]
   end
+
+  def self.formulas_repo_path_exists!
+    return true if Dir.exist?(Fontist.formulas_repo_path)
+
+    raise Errors::MainRepoNotFoundError.new(
+      "Please fetch formulas with `fontist update`.",
+    )
+  end
 end
+
+require_relative "fontist/repo"
+require_relative "fontist/font"
+require_relative "fontist/formula"
+require_relative "fontist/system_font"
+require_relative "fontist/manifest"
+require_relative "fontist/manifest_response"
+require_relative "fontist/manifest_request"
+require_relative "fontist/helpers"
+require_relative "fontist/config"
+require_relative "fontist/update"
+require_relative "fontist/index"
+require_relative "fontist/indexes/font_index"
+require_relative "fontist/indexes/filename_index"
+require_relative "fontist/cli"
+require_relative "fontist/font_installer"
+require_relative "fontist/fontconfig"
+require_relative "fontist/formula_picker"
+require_relative "fontist/formula_suggestion"
+require_relative "fontist/extract"
+require_relative "fontist/font_style"
+require_relative "fontist/font_collection"