fontist 1.2.1 → 1.6.0

data/lib/fontist/fontist_font.rb

@@ -0,0 +1,70 @@
+module Fontist
+  class FontistFont
+    def initialize(font_name:)
+      @font_name = font_name
+
+      check_and_register_font_formulas
+    end
+
+    def self.find(name)
+      new(font_name: name).find
+    end
+
+    def find
+      return unless @font_name
+
+      filenames = fonts_filenames
+      return if filenames.empty?
+
+      paths = font_paths.select do |path|
+        filenames.any? { |f| File.basename(path).casecmp?(f) }
+      end
+
+      paths.empty? ? nil : paths
+    end
+
+    private
+
+    def fonts_filenames
+      fonts.map { |font| font.styles.map(&:font) }.flatten
+    end
+
+    def fonts
+      by_key || by_name || []
+    end
+
+    def by_key
+      _key, formula = formulas.detect do |key, _value|
+        key.to_s.casecmp?(@font_name)
+      end
+
+      return unless formula
+
+      formula.fonts
+    end
+
+    def by_name
+      _key, formula = formulas.detect do |_key, value|
+        value.fonts.map(&:name).map(&:downcase).include?(@font_name.downcase)
+      end
+
+      return unless formula
+
+      formula.fonts.select do |font|
+        font.name.casecmp?(@font_name)
+      end
+    end
+
+    def formulas
+      @formulas ||= Fontist::Registry.instance.formulas.to_h
+    end
+
+    def font_paths
+      Dir.glob(Fontist.fonts_path.join("**"))
+    end
+
+    def check_and_register_font_formulas
+      $check_and_register_font_formulas ||= Fontist::Formulas.register_formulas
+    end
+  end
+end

data/lib/fontist/formula.rb

@@ -2,6 +2,7 @@ module Fontist
   class Formula
     def initialize(options = {})
       @font_name = options.fetch(:font_name, nil)
+      @style_name = options.fetch(:style_name, nil)
 
       check_and_register_font_formulas
     end
@@ -18,6 +19,10 @@ module Fontist
       new(font_name: name).find_fonts
     end
 
+    def self.find_styles(font, style)
+      new(font_name: font, style_name: style).find_styles
+    end
+
     def all
       @all ||= Fontist::Registry.instance.formulas
     end
@@ -28,29 +33,42 @@ module Fontist
 
     def find_fonts
       formulas = [find_formula].flatten
-      match_fonts_by_name(formulas) unless formulas.empty?
+      fonts = take_fonts(formulas)
+      fonts.empty? ? nil : fonts
+    end
+
+    def find_styles
+      formulas.values.flat_map do |formula|
+        formula.fonts.flat_map do |f|
+          f.styles.select do |s|
+            f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
+          end
+        end
+      end
     end
 
     private
 
-    attr_reader :font_name
+    attr_reader :font_name, :style_name
 
     def find_formula
-      find_by_font_name || find_by_font || []
+      find_by_key || find_by_font_name || find_by_font || []
     end
 
     def formulas
       @formulas ||= all.to_h
     end
 
-    def match_fonts_by_name(formulas)
-      matched_fonts = formulas.map do |formula|
-        formula.fonts.select do |font|
-          font.name.downcase == font_name.downcase
-        end
+    def take_fonts(formulas)
+      formulas.map(&:fonts).flatten
+    end
+
+    def find_by_key
+      matched_formulas = formulas.select do |key, _value|
+        key.to_s.casecmp?(font_name)
       end
 
-      matched_fonts.empty? ? nil : matched_fonts.flatten
+      matched_formulas.empty? ? nil : matched_formulas.values
     end
 
     def find_by_font_name

data/lib/fontist/formula_template.rb

@@ -0,0 +1,108 @@
+module Fontist
+  class FormulaTemplate
+    def self.create_formula_class(formula)
+      Class.new(FontFormula) do |klass|
+        first_font = (formula.fonts || formula.font_collections.first.fonts).first
+        cleanname = first_font.name.gsub(/ /, "")
+        resource_name = formula.resources.to_h.keys.first
+        font_filename = first_font.styles.first.font
+
+        key formula.key&.to_sym || formula.name.gsub(/ /, "_").downcase.to_sym
+        display_progress_bar formula.display_progress_bar if formula.display_progress_bar
+        desc formula.description
+        homepage formula.homepage
+
+        formula.resources.to_h.each do |filename, options|
+          resource filename do
+            urls options.urls
+            sha256 options.sha256
+          end
+        end
+
+        if formula.font_collections
+          formula.font_collections.each do |collection|
+            provides_font_collection do
+              filename collection.filename
+
+              collection.fonts.each do |font|
+                styles = font.styles.map { |s| [s.type, s.full_name] }.to_h
+                provides_font font.name, extract_styles_from_collection: styles
+              end
+            end
+          end
+        end
+
+        if formula.fonts
+          formula.fonts.each do |font|
+            provides_font(
+              font.name,
+              match_styles_from_file: font.styles.map do |style|
+                {
+                  family_name: style.family_name,
+                  style: style.type,
+                  full_name: style.full_name,
+                  post_script_name: style.post_script_name,
+                  version: style.version,
+                  description: style.description,
+                  filename: style.font,
+                  copyright: style.copyright,
+                }
+              end
+            )
+          end
+        end
+
+        klass.define_method :extract do
+          resource = resource(resource_name)
+
+          [formula.extract].flatten.each do |operation|
+            method = "#{operation.format}_extract"
+            resource = if operation.options
+                         send(method, resource, **operation.options.to_h)
+                       else
+                         send(method, resource)
+                       end
+          end
+
+          if formula.fonts
+            formula.fonts.each do |font|
+              match_fonts(resource, font.name)
+            end
+          end
+
+          if formula.font_collections
+            formula.font_collections.each do |collection|
+              collection.fonts.each do |font|
+                match_fonts(resource, font.name)
+              end
+            end
+          end
+        end
+
+        klass.define_method :install do
+          case platform
+          when :macos
+            install_matched_fonts "$HOME/Library/Fonts/#{cleanname}"
+          when :linux
+            install_matched_fonts "/usr/share/fonts/truetype/#{cleanname.downcase}"
+          end
+        end
+
+        test do
+          case platform
+          when :macos
+            assert_predicate "$HOME/Library/Fonts/#{cleanname}/#{font_filename}", :exist?
+          when :linux
+            assert_predicate "/usr/share/fonts/truetype/#{cleanname.downcase}/#{font_filename}", :exist?
+          end
+        end
+
+        copyright formula.copyright
+        license_url formula.license_url
+
+        open_license formula.open_license if formula.open_license
+        requires_license_agreement formula.requires_license_agreement if formula.requires_license_agreement
+      end
+    end
+  end
+end

data/lib/fontist/formulas.rb

@@ -1,9 +1,45 @@
+require "git"
 require "fontist/utils"
 require "fontist/font_formula"
+require "fontist/formula_template"
 
 module Fontist
   module Formulas
     def self.register_formulas
+      load_formulas
+      update_registry
+    end
+
+    def self.fetch_formulas
+      if Dir.exist?(Fontist.formulas_repo_path)
+        Git.open(Fontist.formulas_repo_path).pull
+      else
+        Git.clone(Fontist.formulas_repo_url,
+                  Fontist.formulas_repo_path,
+                  depth: 1)
+      end
+    end
+
+    def self.load_formulas
+      Dir[Fontist.formulas_path.join("**/*.yml").to_s].sort.each do |file|
+        create_formula_class(file)
+      end
+    end
+
+    def self.create_formula_class(file)
+      formula = parse_to_object(YAML.load_file(file))
+      class_name = name_to_classname(formula.name)
+      return if Formulas.const_defined?(class_name)
+
+      klass = FormulaTemplate.create_formula_class(formula)
+      Formulas.const_set(class_name, klass)
+    end
+
+    def self.parse_to_object(hash)
+      JSON.parse(hash.to_json, object_class: OpenStruct)
+    end
+
+    def self.update_registry
       Formulas.constants.select do |constant|
         if Formulas.const_get(constant).is_a?(Class)
           klass = "Fontist::Formulas::#{constant}"
@@ -11,5 +47,10 @@ module Fontist
         end
       end
     end
+
+    def self.name_to_classname(name)
+      cleanname = name.gsub(/ /, "").sub(/\S/, &:upcase)
+      "#{cleanname}Font"
+    end
   end
 end

data/lib/fontist/import.rb

@@ -0,0 +1,9 @@
+module Fontist
+  module Import
+    class << self
+      def name_to_filename(name)
+        name.downcase.gsub(" ", "_") + ".yml"
+      end
+    end
+  end
+end

data/lib/fontist/import/convert_formulas.rb

@@ -0,0 +1,65 @@
+require_relative "formula_serializer"
+
+module Fontist
+  module Import
+    class ConvertFormulas
+      def call
+        find_formulas.each do |formula|
+          convert_to_yaml(formula)
+        end
+      end
+
+      private
+
+      def find_formulas
+        require_formulas_files
+        formulas_instances
+      end
+
+      def require_formulas_files
+        path = Fontist.lib_path.join("fontist", "converted_formulas")
+        Dir[path.join("**/*.rb").to_s].sort.each do |file|
+          require file
+        end
+      end
+
+      def formulas_instances
+        classes = Formulas.constants.select do |constant|
+          Formulas.const_get(constant).is_a?(Class)
+        end
+
+        classes.map do |constant|
+          Object.const_get("Fontist::Formulas::#{constant}").instance
+        end
+      end
+
+      def convert_to_yaml(formula)
+        hash = formula_hash(formula)
+        write_yaml(formula, hash)
+      end
+
+      def formula_hash(formula)
+        code = File.read(formula_path(formula))
+        FormulaSerializer.new(formula, code).call
+      end
+
+      def formula_path(formula)
+        formula.method(:extract).source_location.first
+      end
+
+      def write_yaml(formula, hash)
+        File.write(yaml_formula_path(formula), YAML.dump(stringify_keys(hash)))
+      end
+
+      def yaml_formula_path(formula)
+        name = formula_path(formula).match(/formulas\/(.*)_fonts?.rb/)[1]
+
+        Fontist.formulas_path.join(name + ".yml")
+      end
+
+      def stringify_keys(hash)
+        JSON.parse(hash.to_json)
+      end
+    end
+  end
+end

data/lib/fontist/import/create_formula.rb

@@ -0,0 +1,74 @@
+require "fontist/import"
+require_relative "recursive_extraction"
+require_relative "otf/font_file"
+require_relative "files/collection_file"
+require_relative "helpers/hash_helper"
+require_relative "formula_builder"
+
+module Fontist
+  module Import
+    class CreateFormula
+      FONT_PATTERN = /(\.ttf|\.otf)/i.freeze
+      FONT_COLLECTION_PATTERN = /\.ttc/i.freeze
+      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt|COPYING)$/i.freeze
+
+      def initialize(url, options = {})
+        @url = url
+        @options = options
+      end
+
+      def call
+        save(formula)
+      end
+
+      private
+
+      def formula
+        builder = FormulaBuilder.new
+        builder.url = @url
+        builder.archive = download(@url)
+        builder.extractor = extractor(builder.archive)
+        builder.options = @options
+        builder.font_files = font_files(builder.extractor)
+        builder.font_collection_files = font_collection_files(builder.extractor)
+        builder.license_text = license_texts(builder.extractor).first
+        builder.formula
+      end
+
+      def download(url)
+        return url if File.exist?(url)
+
+        Fontist::Utils::Downloader.download(url, progress_bar: true).path
+      end
+
+      def extractor(archive)
+        RecursiveExtraction.new(archive, subarchive: @options[:subarchive])
+      end
+
+      def font_files(extractor)
+        extractor.extract(FONT_PATTERN) do |path|
+          Otf::FontFile.new(path)
+        end
+      end
+
+      def font_collection_files(extractor)
+        extractor.extract(FONT_COLLECTION_PATTERN) do |path|
+          Files::CollectionFile.new(path)
+        end
+      end
+
+      def license_texts(extractor)
+        extractor.extract(LICENSE_PATTERN) do |path|
+          File.read(path)
+        end
+      end
+
+      def save(hash)
+        filename = Import.name_to_filename(hash[:name])
+        yaml = YAML.dump(Helpers::HashHelper.stringify_keys(hash))
+        File.write(filename, yaml)
+        filename
+      end
+    end
+  end
+end