fontist 1.6.0 → 1.8.1

data/lib/fontist/formula_template.rb

@@ -1,108 +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
-
-              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,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/manifest/common.rb

@@ -1,60 +0,0 @@
-module Fontist
-  module Manifest
-    class Common
-      def initialize(manifest)
-        @manifest = manifest
-      end
-
-      def self.call(manifest)
-        new(manifest).call
-      end
-
-      def call
-        font_names.zip(font_paths).to_h
-      end
-
-      private
-
-      def font_names
-        fonts.keys
-      end
-
-      def fonts
-        @fonts ||= begin
-          unless File.exist?(@manifest)
-            raise Fontist::Errors::ManifestCouldNotBeFoundError
-          end
-
-          fonts = YAML.load_file(@manifest)
-          unless fonts.is_a?(Hash)
-            raise Fontist::Errors::ManifestCouldNotBeReadError
-          end
-
-          fonts
-        end
-      end
-
-      def font_paths
-        fonts.map do |font, styles|
-          styles_to_ary = [styles].flatten
-          style_paths_map(font, styles_to_ary)
-        end
-      end
-
-      def style_paths_map(font, names)
-        paths = style_paths(font, names)
-        names.zip(paths).to_h
-      end
-
-      def style_paths(font, names)
-        names.map do |style|
-          file_paths(font, style)
-        end
-      end
-
-      def file_paths(_font, _style)
-        raise NotImplementedError.new("Implement #file_paths in child class")
-      end
-    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