fontist 1.21.4 → 2.0.2

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/helpers.rb

@@ -1,9 +1,10 @@
-require "ostruct"
-
 module Fontist
   module Helpers
-    def self.parse_to_object(data)
-      JSON.parse(data.to_json, object_class: OpenStruct)
+    def self.url_object(request)
+      return request unless request.include?("\"url\"")
+
+      obj = JSON.parse(request.gsub("=>", ":"))
+      Struct.new(:url, :headers).new(obj["url"], obj["headers"])
     end
 
     def self.run(command)

data/lib/fontist/import/create_formula.rb

@@ -111,7 +111,8 @@ module Fontist
         @extractor ||=
           RecursiveExtraction.new(archive,
                                   subdir: @options[:subdir],
-                                  file_pattern: @options[:file_pattern])
+                                  file_pattern: @options[:file_pattern],
+                                  name_prefix: @options[:name_prefix])
       end
 
       def archive

data/lib/fontist/import/files/collection_file.rb

@@ -8,8 +8,9 @@ module Fontist
       class CollectionFile
         attr_reader :fonts
 
-        def initialize(path)
+        def initialize(path, name_prefix: nil)
           @path = path
+          @name_prefix = name_prefix
           @fonts = read
           @extension = detect_extension
         end
@@ -25,26 +26,15 @@ module Fontist
         private
 
         def read
-          switch_to_temp_dir do |tmp_dir|
+          Dir.mktmpdir do |tmp_dir|
             extract_ttfs(tmp_dir)
-              .map { |path| Otf::FontFile.new(path) }
+              .map { |path| Otf::FontFile.new(path, name_prefix: @name_prefix) }
               .reject { |font_file| hidden_or_pua_encoded?(font_file) }
           end
         end
 
-        def switch_to_temp_dir
-          Dir.mktmpdir do |tmp_dir|
-            Dir.chdir(tmp_dir) do
-              yield tmp_dir
-            end
-          end
-        end
-
         def extract_ttfs(tmp_dir)
-          filenames = ExtractTtc.extract(@path)
-          filenames.map do |filename|
-            File.join(tmp_dir, filename)
-          end
+          ExtractTtc.extract(@path, output_dir: tmp_dir)
         end
 
         def hidden_or_pua_encoded?(font_file)

data/lib/fontist/import/font_style.rb

@@ -0,0 +1,22 @@
+module Fontist
+  module Import
+    class FontStyle
+      attr_reader :family_name, :style, :full_name, :post_script_name,
+                  :version, :description, :filename, :copyright,
+                  :preferred_family_name, :preferred_style
+
+      def initialize(attributes = {})
+        @family_name = attributes[:family_name]
+        @style = attributes[:style]
+        @full_name = attributes[:full_name]
+        @post_script_name = attributes[:post_script_name]
+        @version = attributes[:version]
+        @description = attributes[:description]
+        @filename = attributes[:filename]
+        @copyright = attributes[:copyright]
+        @preferred_family_name = attributes[:preferred_family_name]
+        @preferred_style = attributes[:preferred_style]
+      end
+    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/import/otf/font_file.rb

@@ -21,8 +21,9 @@ module Fontist
 
         attr_reader :path
 
-        def initialize(path)
+        def initialize(path, name_prefix: nil)
           @path = path
+          @name_prefix = name_prefix
           @info = read
           @extension = detect_extension
         end
@@ -36,7 +37,8 @@ module Fontist
         end
 
         def family_name
-          info["Family"]
+          name = info["Family"]
+          @name_prefix ? "#{@name_prefix}#{name}" : name
         end
 
         def type
@@ -44,7 +46,10 @@ module Fontist
         end
 
         def preferred_family_name
-          info["Preferred family"]
+          name = info["Preferred family"]
+          return unless name
+
+          @name_prefix ? "#{@name_prefix}#{name}" : name
         end
 
         def preferred_type

data/lib/fontist/import/otf_style.rb

@@ -1,3 +1,5 @@
+require_relative "font_style"
+
 module Fontist
   module Import
     class OtfStyle
@@ -24,7 +26,7 @@ module Fontist
           style[:preferred_style] = @info["Preferred subfamily"]
         end
 
-        OpenStruct.new(style)
+        FontStyle.new(style)
       end
 
       private

data/lib/fontist/import/recursive_extraction.rb

@@ -8,10 +8,11 @@ module Fontist
       LICENSE_PATTERN =
         /(ofl\.txt|ufl\.txt|licenses?\.txt|license(\.md)?|copying)$/i.freeze
 
-      def initialize(archive, subdir: nil, file_pattern: nil)
+      def initialize(archive, subdir: nil, file_pattern: nil, name_prefix: nil)
         @archive = archive
         @subdir = subdir
         @file_pattern = file_pattern
+        @name_prefix = name_prefix
         @operations = {}
         @font_files = []
         @collection_files = []
@@ -80,10 +81,10 @@ module Fontist
       def match_font(path)
         case Files::FontDetector.detect(path)
         when :font
-          file = Otf::FontFile.new(path)
+          file = Otf::FontFile.new(path, name_prefix: @name_prefix)
           @font_files << file unless already_exist?(file)
         when :collection
-          @collection_files << Files::CollectionFile.new(path)
+          @collection_files << Files::CollectionFile.new(path, name_prefix: @name_prefix)
         end
       end
 
@@ -97,7 +98,11 @@ module Fontist
       end
 
       def font_candidate?(path)
-        font_directory?(path) && file_pattern?(path)
+        has_font_extension?(path) && font_directory?(path) && file_pattern?(path)
+      end
+
+      def has_font_extension?(path)
+        path.match?(/\.(ttf|otf|ttc|woff|woff2)$/i)
       end
 
       def font_directory?(path)