fontist 1.7.0 → 1.8.2

data/lib/fontist/font_formula.rb

@@ -1,158 +0,0 @@
-module Fontist
-  class FontFormula
-    include Singleton
-    extend Fontist::Utils::Dsl
-    include Fontist::Utils::ZipExtractor
-    include Fontist::Utils::ExeExtractor
-    include Fontist::Utils::MsiExtractor
-    include Fontist::Utils::SevenZipExtractor
-
-    attr_accessor :license, :license_url, :license_required, :copyright
-    attr_accessor :key, :homepage, :description, :options, :temp_resource
-
-    def font_list
-      @font_list ||= []
-    end
-
-    def resources
-      @resources ||= {}
-    end
-
-    def fonts
-      @fonts ||= font_list.uniq
-    end
-
-    def extract_font_styles(options)
-      extract_from_file(options) ||
-        extract_from_collection(options) || default_font
-    end
-
-    def reinitialize
-      @downloaded = false
-      @matched_fonts = []
-    end
-
-    def self.fetch_font(name, confirmation:)
-      if instance.license_required && confirmation.downcase != "yes"
-        raise(Fontist::Errors::LicensingError)
-      end
-
-      instance.reinitialize
-      instance.install_font(name, confirmation)
-    end
-
-    def install_font(name, confirmation)
-      run_in_temp_dir { extract }
-      matched_fonts_uniq = matched_fonts.flatten.uniq
-      matched_fonts_uniq.empty? ? nil : matched_fonts_uniq
-    end
-
-    private
-
-    attr_reader :downloaded, :matched_fonts
-
-    def resource(name, &block)
-      source = resources[name]
-      block_given? ? yield(source) : source
-    end
-
-    def fonts_path
-      @fonts_path = Fontist.fonts_path
-    end
-
-    def default_font
-      [{ type: "Regular", font: temp_resource[:filename] }]
-    end
-
-    def run_in_temp_dir(&block)
-      Dir.mktmpdir(nil, Dir.tmpdir) do |dir|
-        @temp_dir = Pathname.new(dir)
-
-        yield
-        @temp_dir = nil
-      end
-    end
-
-    def extract_from_file(options)
-      styles = options.fetch(:match_styles_from_file, [])
-
-      unless styles.empty?
-        styles.map do |attributes|
-          Fontist::Utils::Dsl::Font.new(attributes).attributes
-        end
-      end
-    end
-
-    def match_fonts(fonts_dir, font_name)
-      fonts = map_names_to_fonts(font_name).join("|")
-      font = fonts_dir.grep(/#{fonts}/i)
-      @matched_fonts.push(font) if font
-
-      font
-    end
-
-    def extract_from_collection(options)
-      styles = options.fetch(:extract_styles_from_collection, [])
-
-      unless styles.empty?
-        styles.map do |attributes|
-          filenames = temp_resource.slice(:filename, :source_filename)
-          Fontist::Utils::Dsl::CollectionFont.new(attributes.merge(filenames))
-            .attributes
-        end
-      end
-    end
-
-    def map_names_to_fonts(font_name)
-      fonts = Fontist::Formula.find_fonts(font_name)
-      fonts = fonts.map { |font| font.styles.map(&:font) }.flatten if fonts
-
-      fonts || []
-    end
-
-    def download_file(source)
-      url = source[:urls].first
-      Fontist.ui.say(%(Downloading font "#{key}" from #{url}))
-
-      downloaded_file = Fontist::Utils::Downloader.download(
-        url,
-        sha: source[:sha256],
-        file_size: source[:file_size],
-        progress_bar: is_progress_bar_enabled
-      )
-
-      @downloaded = true
-      downloaded_file
-    end
-
-    def is_progress_bar_enabled
-      options.nil? ? true : options.fetch(:progress_bar, true)
-    end
-
-    def font_file?(filename)
-      source_files.include?(filename)
-    end
-
-    def source_files
-      @source_files ||= fonts.flat_map do |font|
-        font[:styles].map do |style|
-          style[:source_font] || style[:font]
-        end
-      end
-    end
-
-    def target_filename(source_filename)
-      target_filenames[source_filename]
-    end
-
-    def target_filenames
-      @target_filenames ||= fonts.flat_map do |font|
-        font[:styles].map do |style|
-          source = style[:source_font] || style[:font]
-          target = style[:font]
-          [source, target]
-        end
-      end.to_h
-    end
-  end
-end

data/lib/fontist/formula_template.rb

@@ -1,122 +0,0 @@
-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
-              source_filename collection.source_filename
-
-              collection.fonts.each do |font|
-                provides_font(
-                  font.name,
-                  extract_styles_from_collection: 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,
-                      copyright: style.copyright,
-                    }
-                  end
-                )
-              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,
-                  source_filename: style.source_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,56 +0,0 @@
-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}"
-          Fontist::Registry.register(Object.const_get(klass))
-        end
-      end
-    end
-
-    def self.name_to_classname(name)
-      cleanname = name.gsub(/ /, "").sub(/\S/, &:upcase)
-      "#{cleanname}Font"
-    end
-  end
-end

data/lib/fontist/registry.rb

@@ -1,43 +0,0 @@
-module Fontist
-  class Registry
-    include Singleton
-
-    def initialize
-      @formulas ||= {}
-    end
-
-    def formulas
-      parse_to_object(@formulas)
-    end
-
-    def self.formulas
-      instance.formulas
-    end
-
-    def self.register(formula, key = nil)
-      key ||= formula.instance.key || formula.to_s
-      instance.register(formula, key)
-    end
-
-    def register(formula, key)
-      @formulas[key] = build_formula_data(formula)
-    end
-
-    private
-
-    def build_formula_data(formula)
-      {
-        installer: formula,
-        fonts: formula.instance.fonts,
-        license: formula.instance.license,
-        homepage: formula.instance.homepage ,
-        description: formula.instance.description,
-        license_required: formula.instance.license_required,
-      }
-    end
-
-    def parse_to_object(data)
-      JSON.parse(data.to_json, object_class: OpenStruct)
-    end
-  end
-end