fontist 1.21.4 → 2.0.1

data/lib/fontist/formula.rb

@@ -1,23 +1,104 @@
-require "fontist/index"
-require "fontist/helpers"
-require "fontist/update"
+require "lutaml/model"
+require_relative "font_model"
+require_relative "font_collection"
+require_relative "extract"
+require_relative "index"
+require_relative "helpers"
+require_relative "update"
 require "git"
 
 module Fontist
-  class Formula
+  require "lutaml/model"
+
+  class Resource < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :source, :string
+    attribute :urls, :string, collection: true
+    attribute :sha256, :string, collection: true
+    attribute :file_size, :integer
+    attribute :family, :string
+    attribute :files, :string, collection: true
+
+    def empty?
+      Array(urls).empty? && Array(files).empty?
+    end
+  end
+
+  class ResourceCollection < Lutaml::Model::Collection
+    instances :resources, Resource
+
+    key_value do
+      root "resources"
+      map to: :resources
+      map_key to_instance: :name
+    end
+
+    def empty?
+      resources.nil? || Array(resources).all?(&:empty?)
+    end
+  end
+
+  class Formula < Lutaml::Model::Serializable
     NAMESPACES = {
       "sil" => "SIL",
       "macos" => "macOS",
     }.freeze
 
+    attribute :name, :string
+    attribute :path, :string
+    attribute :description, :string
+    attribute :homepage, :string
+    attribute :display_progress_bar, :boolean
+    attribute :repository, :string
+    attribute :copyright, :string
+    attribute :license_url, :string
+    attribute :open_license, :string
+    attribute :requires_license_agreement, :string
+    attribute :platforms, :string, collection: true
+    attribute :min_fontist, :string
+    attribute :digest, :string
+    attribute :instructions, :string
+    attribute :resources, ResourceCollection, collection: true
+    attribute :font_collections, FontCollection, collection: true
+    attribute :fonts, FontModel, collection: true, default: []
+    attribute :extract, Extract, collection: true
+    attribute :command, :string
+
+    key_value do
+      map "name", to: :name
+      map "description", to: :description
+      map "homepage", to: :homepage
+      map "display_progress_bar", to: :display_progress_bar
+      map "repository", to: :repository
+      map "platforms", to: :platforms
+      map "resources", to: :resources, value_map: {
+        to: { empty: :empty, omitted: :omitted, nil: :nil },
+      }
+      map "digest", to: :digest
+      map "instructions", to: :instructions
+      map "font_collections", to: :font_collections
+      map "fonts", to: :fonts
+      map "extract", to: :extract, value_map: {
+        to: { empty: :empty, omitted: :omitted, nil: :nil },
+      }
+      map "min_fontist", to: :min_fontist
+      map "copyright", to: :copyright
+      map "requires_license_agreement", to: :requires_license_agreement
+      map "license_url", to: :license_url
+      map "open_license", to: :open_license
+      map "command", to: :command
+    end
+
     def self.update_formulas_repo
       Update.call
     end
 
     def self.all
-      Dir[Fontist.formulas_path.join("**/*.yml").to_s].map do |path|
-        Formula.new_from_file(path)
+      formulas = Dir[Fontist.formulas_path.join("**/*.yml").to_s].map do |path|
+        Formula.from_file(path)
       end
+
+      FormulaCollection.new(formulas)
     end
 
     def self.all_keys
@@ -27,28 +108,28 @@ module Fontist
     end
 
     def self.find(font_name)
-      Indexes::FontIndex.from_yaml.load_formulas(font_name).first
+      Indexes::FontIndex.from_file.load_formulas(font_name).first
     end
 
     def self.find_many(font_name)
-      Indexes::FontIndex.from_yaml.load_formulas(font_name)
+      Indexes::FontIndex.from_file.load_formulas(font_name)
     end
 
     def self.find_fonts(font_name)
-      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_file.load_formulas(font_name)
 
       formulas.map do |formula|
-        formula.fonts.select do |f|
+        formula.all_fonts.select do |f|
           f.name.casecmp?(font_name)
         end
       end.flatten
     end
 
     def self.find_styles(font_name, style_name)
-      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_file.load_formulas(font_name)
 
       formulas.map do |formula|
-        formula.fonts.map do |f|
+        formula.all_fonts.map do |f|
           f.styles.select do |s|
             f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
           end
@@ -64,7 +145,7 @@ module Fontist
       path = Fontist.formulas_path.join("#{key}.yml")
       return unless File.exist?(path)
 
-      new_from_file(path)
+      from_file(path)
     end
 
     def self.find_by_name(name)
@@ -78,30 +159,32 @@ module Fontist
     end
 
     def self.find_by_font_file(font_file)
-      key = Indexes::FilenameIndex
-        .from_yaml
+      key = Indexes::FilenameIndex.from_file
         .load_index_formulas(File.basename(font_file))
-        .map(&:name)
+        .flat_map(&:name)
         .first
 
       find_by_key(key)
     end
 
-    def self.new_from_file(path)
-      data = YAML.safe_load(
-        File.read(path),
-        permitted_classes: [Date, Symbol, Time]
-      )
-      new(data, path)
-    end
+    def self.from_file(path)
+      unless File.exist?(path)
+        raise Fontist::Errors::FormulaCouldNotBeFoundError,
+              "Formula file not found: #{path}"
+      end
+
+      content = File.read(path)
 
-    def initialize(data, path)
-      @data = data
-      @path = real_path(path)
+      from_yaml(content).tap do |formula|
+        formula.path = path
+        formula.name = titleize(formula.key_from_path) if formula.name.nil?
+      end
     end
 
-    def to_index_formula
-      Indexes::IndexFormula.new(path)
+    def self.titleize(str)
+      str.split("/").map do |part|
+        part.tr("_", " ").split.map(&:capitalize).join(" ")
+      end.join("/")
     end
 
     def manual?
@@ -109,118 +192,81 @@ module Fontist
     end
 
     def downloadable?
-      @data.key?("resources")
+      !resources.nil? && !resources.empty?
     end
 
     def source
-      return unless @data["resources"]
+      return nil if resources.empty?
 
-      @data["resources"].values.first["source"]
-    end
-
-    def path
-      @path
+      resources.first.source
     end
 
     def key
-      @key ||= {}
-      @key[@path] ||= key_from_path
-    end
-
-    def name
-      @name ||= {}
-      @name[key] ||= namespace.empty? ? base_name : "#{namespace}/#{base_name}"
-    end
-
-    def description
-      @data["description"]
-    end
-
-    def homepage
-      @data["homepage"]
+      @key ||= key_from_path
     end
 
-    def copyright
-      @data["copyright"]
-    end
+    def key_from_path
+      return "" unless @path
 
-    def license_url
-      @data["license_url"]
+      escaped = Regexp.escape("#{Fontist.formulas_path}/")
+      @path.sub(Regexp.new("^#{escaped}"), "").sub(/\.yml$/, "").to_s
     end
 
     def license
-      @data["open_license"] || @data["requires_license_agreement"]
-    end
-
-    def license_required
-      @data["requires_license_agreement"] ? true : false
+      open_license || requires_license_agreement
     end
 
-    def platforms
-      @data["platforms"]
-    end
-
-    def min_fontist
-      @data["min_fontist"]
-    end
-
-    def extract
-      Helpers.parse_to_object(@data["extract"])
+    def license_required?
+      requires_license_agreement ? true : false
     end
 
     def file_size
-      return unless @data["resources"]
+      return nil if resources.nil? || resources.empty?
 
-      @data["resources"].values.first["file_size"]&.to_i
-    end
-
-    def resources
-      Helpers.parse_to_object(@data["resources"]&.values)
-    end
-
-    def instructions
-      @data["instructions"]
+      resources.first.file_size
     end
 
     def font_by_name(name)
-      fonts.find do |font|
+      all_fonts.find do |font|
         font.name.casecmp?(name)
       end
     end
 
     def fonts_by_name(name)
-      fonts.select do |font|
+      all_fonts.select do |font|
         font.name.casecmp?(name)
       end
     end
 
-    def fonts
-      @fonts ||= Helpers.parse_to_object(fonts_by_family)
+    def all_fonts
+      Array(fonts) + collection_fonts
     end
 
-    def digest
-      @data["digest"]
+    def collection_fonts
+      Array(font_collections).flat_map do |c|
+        c.fonts.flat_map do |f|
+          f.styles.each do |s|
+            s.font = c.filename
+            s.source_font = c.source_filename
+          end
+          f
+        end
+      end
     end
 
     def style_override(font)
-      fonts
+      all_fonts
         .map(&:styles)
         .flatten
-        .detect { |s| s.family_name == font }
-        &.dig(:override) || {}
+        .detect { |s| s.family_name == font }&.override || {}
     end
 
     private
 
-    def real_path(path)
+    def real_path
       Dir.glob(path).first
     end
 
-    def key_from_path
-      escaped = Regexp.escape("#{Fontist.formulas_path}/")
-      @path.sub(Regexp.new("^#{escaped}"), "").sub(/\.yml$/, "").to_s
-    end
-
     def namespace
       namespace_from_mappings || namespace_from_key
     end
@@ -248,14 +294,14 @@ module Fontist
         .split.map(&:capitalize).join(" ")
     end
 
-    def fonts_by_family
-      return hash_all_fonts unless Fontist.preferred_family?
+    def fonts_by_family(data)
+      return hash_all_fonts(data) unless Fontist.preferred_family?
 
-      preferred_family_fonts
+      preferred_family_fonts(data)
     end
 
-    def preferred_family_fonts
-      groups = preferred_family_styles.group_by do |style|
+    def preferred_family_fonts(data)
+      groups = preferred_family_styles(data).group_by do |style|
         style["family_name"]
       end
 
@@ -264,8 +310,8 @@ module Fontist
       end
     end
 
-    def preferred_family_styles
-      hash_all_fonts.flat_map do |font|
+    def preferred_family_styles(data)
+      hash_all_fonts(data).flat_map do |font|
         font["styles"].map do |style|
           style.merge(preferred_style(style))
         end
@@ -273,20 +319,22 @@ module Fontist
     end
 
     def preferred_style(style)
-      { "family_name" => style["preferred_family_name"] || style["family_name"],
+      {
+        "family_name" => style["preferred_family_name"] || style["family_name"],
         "type" => style["preferred_type"] || style["type"],
         "default_family_name" => style["family_name"],
-        "default_type" => style["type"] }
+        "default_type" => style["type"],
+      }
     end
 
-    def hash_all_fonts
-      hash_collection_fonts + hash_fonts
+    def hash_all_fonts(data)
+      hash_collection_fonts(data) + hash_fonts(data)
     end
 
-    def hash_collection_fonts
-      return [] unless @data["font_collections"]
+    def hash_collection_fonts(data)
+      return [] unless data["font_collections"]
 
-      @data["font_collections"].flat_map do |coll|
+      data["font_collections"].flat_map do |coll|
         filenames = { "font" => coll["filename"],
                       "source_font" => coll["source_filename"] }
 
@@ -296,10 +344,19 @@ module Fontist
       end
     end
 
-    def hash_fonts
-      return [] unless @data["fonts"]
+    def hash_fonts(data)
+      return [] unless data["fonts"]
+
+      data["fonts"]
+    end
+  end
+
+  class FormulaCollection < Lutaml::Model::Collection
+    instances :formulas, Formula
 
-      @data["fonts"]
+    key_value do
+      map "name", to: :name
+      map "formula", to: :formula
     end
   end
 end

data/lib/fontist/import/formula_serializer.rb

@@ -26,8 +26,8 @@ module Fontist
       def fonts_attributes
         { display_progress_bar: formula_progress_bar(@formula),
           resources: @formula.resources,
-          font_collections: font_collections(@formula.fonts),
-          fonts: standalone_fonts(@formula.fonts),
+          font_collections: font_collections(@formula.all_fonts),
+          fonts: standalone_fonts(@formula.all_fonts),
           extract: extract_type(@code) }
       end
 
@@ -122,11 +122,11 @@ module Fontist
       # rubocop:enable Metrics/MethodLength, Metrics/LineLength
 
       def requires_license_agreement(formula)
-        formula.license if formula.license && formula.license_required
+        formula.license if formula.license && formula.license_required?
       end
 
       def open_license(formula)
-        formula.license if formula.license && !formula.license_required
+        formula.license if formula.license && !formula.license_required?
       end
     end
   end

data/lib/fontist/import/google_import.rb

@@ -69,7 +69,7 @@ module Fontist
 
       def formula(font_name)
         path = formula_path(font_name)
-        Formula.new_from_file(path) if File.exist?(path)
+        Formula.from_file(path) if File.exist?(path)
       end
 
       def formula_path(name)

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