fontist 1.7.3 → 1.8.5

data/lib/fontist/formula.rb

@@ -1,50 +1,43 @@
+require "fontist/index"
+require "fontist/helpers"
+require "git"
+
 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
+    def self.update_formulas_repo
+      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.all
-      new.all
+      Dir[Fontist.formulas_path.join("**/*.yml").to_s].map do |path|
+        Formula.new_from_file(path)
+      end
     end
 
     def self.find(font_name)
-      new(font_name: font_name).find
+      Indexes::FontIndex.from_yaml.load_formulas(font_name).first
     end
 
-    def self.find_fonts(name)
-      new(font_name: name).find_fonts
-    end
-
-    def self.find_styles(font, style)
-      new(font_name: font, style_name: style).find_styles
-    end
+    def self.find_fonts(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
-    def all
-      @all ||= Fontist::Registry.instance.formulas
-    end
-
-    def find
-      formulas.values.detect do |formula|
-        formula.fonts.any? do |f|
-          f.name.casecmp?(font_name)
-        end
-      end
-    end
-
-    def find_fonts
-      formulas.values.map do |formula|
+      formulas.map do |formula|
         formula.fonts.select do |f|
           f.name.casecmp?(font_name)
         end
       end.flatten
     end
 
-    def find_styles
-      formulas.values.map do |formula|
+    def self.find_styles(font_name, style_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
+
+      formulas.map do |formula|
         formula.fonts.map do |f|
           f.styles.select do |s|
             f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
@@ -53,16 +46,89 @@ module Fontist
       end.flatten
     end
 
+    def self.new_from_file(path)
+      data = YAML.load_file(path)
+      new(data, path)
+    end
+
+    def initialize(data, path)
+      @data = data
+      @path = path
+    end
+
+    def to_index_formula
+      Indexes::IndexFormula.new(path)
+    end
+
+    def path
+      @path
+    end
+
+    def key
+      @data["key"] || default_key
+    end
+
+    def description
+      @data["description"]
+    end
+
+    def homepage
+      @data["homepage"]
+    end
+
+    def copyright
+      @data["copyright"]
+    end
+
+    def license_url
+      @data["license_url"]
+    end
+
+    def license
+      @data["open_license"] || @data["requires_license_agreement"]
+    end
+
+    def license_required
+      @data["requires_license_agreement"] ? true : false
+    end
+
+    def extract
+      Helpers.parse_to_object(@data["extract"])
+    end
+
+    def resources
+      Helpers.parse_to_object(@data["resources"].values)
+    end
+
+    def fonts
+      @fonts ||= Helpers.parse_to_object(hash_collection_fonts + hash_fonts)
+    end
+
     private
 
-    attr_reader :font_name, :style_name
+    def default_key
+      escaped = Regexp.escape(Fontist.formulas_path.to_s + "/")
+      @path.sub(Regexp.new("^" + escaped), "").sub(/\.yml$/, "")
+    end
+
+    def hash_collection_fonts
+      return [] unless @data["font_collections"]
+
+      @data["font_collections"].flat_map do |coll|
+        filenames = { "font" => coll["filename"],
+                      "source_font" => coll["source_filename"] }
 
-    def formulas
-      @formulas ||= all.to_h
+        coll["fonts"].map do |font|
+          { "name" => font["name"],
+            "styles" => font["styles"].map { |s| filenames.merge(s) } }
+        end
+      end
     end
 
-    def check_and_register_font_formulas
-      $check_and_register_font_formulas ||= Fontist::Formulas.register_formulas
+    def hash_fonts
+      return [] unless @data["fonts"]
+
+      @data["fonts"]
     end
   end
 end

data/lib/fontist/formula_paths.rb

@@ -0,0 +1,43 @@
+module Fontist
+  class FormulaPaths
+    attr_reader :font_paths
+
+    def initialize(font_paths)
+      @font_paths = font_paths
+    end
+
+    def find(font, style = nil)
+      styles = find_styles_by_formulas(font, style)
+      return if styles.empty?
+
+      fonts = styles.uniq { |s| s["font"] }.flat_map do |s|
+        paths = search_font_paths(s["font"])
+        paths.map do |path|
+          { full_name: s["full_name"],
+            path: path }
+        end
+      end
+
+      fonts.empty? ? nil : fonts
+    end
+
+    private
+
+    def find_styles_by_formulas(font, style)
+      if style
+        Formula.find_styles(font, style)
+      else
+        fonts = Formula.find_fonts(font)
+        return [] unless fonts
+
+        fonts.flat_map(&:styles)
+      end
+    end
+
+    def search_font_paths(filename)
+      font_paths.select do |path|
+        File.basename(path) == filename
+      end
+    end
+  end
+end

data/lib/fontist/helpers.rb

@@ -0,0 +1,7 @@
+module Fontist
+  module Helpers
+    def self.parse_to_object(data)
+      JSON.parse(data.to_json, object_class: OpenStruct)
+    end
+  end
+end

data/lib/fontist/import/create_formula.rb

@@ -50,9 +50,10 @@ module Fontist
 
       def save(hash)
         filename = Import.name_to_filename(hash[:name])
+        path = @options[:formula_dir] ? File.join(@options[:formula_dir], filename) : filename
         yaml = YAML.dump(Helpers::HashHelper.stringify_keys(hash))
-        File.write(filename, yaml)
-        filename
+        File.write(path, yaml)
+        path
       end
     end
   end

data/lib/fontist/import/extractors.rb

@@ -3,3 +3,7 @@ require_relative "extractors/zip_extractor"
 require_relative "extractors/ole_extractor"
 require_relative "extractors/seven_zip_extractor"
 require_relative "extractors/cab_extractor"
+require_relative "extractors/rpm_extractor"
+require_relative "extractors/gzip_extractor"
+require_relative "extractors/cpio_extractor"
+require_relative "extractors/tar_extractor"

data/lib/fontist/import/extractors/cpio_extractor.rb

@@ -0,0 +1,39 @@
+module Fontist
+  module Import
+    module Extractors
+      class CpioExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_cpio(@archive, dir)
+          dir
+        end
+
+        def format
+          "cpio"
+        end
+
+        private
+
+        def extract_cpio(archive, dir)
+          archive_file = File.open(archive, "rb")
+
+          reader_class.new(archive_file).each do |entry, file|
+            path = File.join(dir, entry.name)
+            if entry.directory?
+              FileUtils.mkdir_p(path)
+            else
+              File.write(path, file.read)
+            end
+          end
+        end
+
+        def reader_class
+          @reader_class ||= begin
+                              require "fontist/utils/cpio/cpio"
+                              CPIO::ASCIIReader
+                            end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/gzip_extractor.rb

@@ -0,0 +1,27 @@
+module Fontist
+  module Import
+    module Extractors
+      class GzipExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_gzip(@archive, dir)
+          dir
+        end
+
+        def format
+          "gzip"
+        end
+
+        private
+
+        def extract_gzip(archive, dir)
+          Zlib::GzipReader.open(archive) do |gz|
+            basename = File.basename(archive, ".*")
+            path = File.join(dir, basename)
+            File.write(path, gz.read)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/rpm_extractor.rb

@@ -0,0 +1,45 @@
+module Fontist
+  module Import
+    module Extractors
+      class RpmExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_rpm(@archive, dir)
+          dir
+        end
+
+        def format
+          "rpm"
+        end
+
+        private
+
+        def extract_rpm(archive, dir)
+          file = File.open(archive, "rb")
+          rpm = rpm_class.new(file)
+          content = rpm.payload.read
+          path = target_path(archive, rpm.tags, dir)
+
+          File.write(path, content)
+        ensure
+          file.close
+        end
+
+        def rpm_class
+          @rpm_class ||= begin
+                              require "arr-pm"
+                              RPM::File
+                            end
+        end
+
+        def target_path(archive, tags, dir)
+          archive_format = tags[:payloadformat]
+          compression_format = tags[:payloadcompressor] == "gzip" ? "gz" : tags[:payloadcompressor]
+          basename = File.basename(archive, ".*")
+          filename = basename + "." + archive_format + "." + compression_format
+          File.join(dir, filename)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/tar_extractor.rb

@@ -0,0 +1,47 @@
+module Fontist
+  module Import
+    module Extractors
+      class TarExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_tar(@archive, dir)
+          dir
+        end
+
+        def format
+          "tar"
+        end
+
+        private
+
+        def extract_tar(archive, dir)
+          archive_file = File.open(archive, "rb")
+          reader_class.new(archive_file) do |tar|
+            tar.each do |tarfile|
+              save_tar_file(tarfile, dir)
+            end
+          end
+        end
+
+        def reader_class
+          @reader_class ||= begin
+                              require "rubygems/package"
+                              Gem::Package::TarReader
+                            end
+        end
+
+        def save_tar_file(file, dir)
+          path = File.join(dir, file.full_name)
+
+          if file.directory?
+            FileUtils.mkdir_p(path)
+          else
+            File.open(path, "wb") do |f|
+              f.print(file.read)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/google/skiplist.yml

@@ -6,3 +6,6 @@
 - Open Sans
 - Work Sans
 - Fira Code
+- Andika
+- Harmattan
+- Padauk

data/lib/fontist/import/google_check.rb

@@ -12,7 +12,7 @@ module Fontist
       private
 
       def fetch_formulas
-        Formulas.fetch_formulas
+        Formula.update_formulas_repo
       end
 
       def new_fonts

data/lib/fontist/import/google_import.rb

@@ -156,10 +156,9 @@ module Fontist
           h.merge!(family_name: style.family_name,
                    type: style.style,
                    full_name: style.full_name)
-          h.merge!(style.to_h.slice(:post_script_name,
-                                    :version,
-                                    :description,
-                                    :copyright).compact)
+          h.merge!(style.to_h.select do |k, _|
+            %i(post_script_name version description copyright).include?(k)
+          end.compact)
           h.merge!(font: fix_variable_filename(style.filename))
         end
       end

data/lib/fontist/import/otfinfo_generate.rb

@@ -25,7 +25,7 @@ module Fontist
       def font_paths(font)
         formula = Fontist::Formula.find(font)
         font_formula = Object.const_get(formula.installer)
-        font_formula.fetch_font(nil, confirmation: "yes")
+        font_formula.install(confirmation: "yes")
       end
 
       def generate_styles(paths)