fontist 1.7.2 → 1.8.4

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)

data/lib/fontist/import/recursive_extraction.rb

@@ -7,7 +7,7 @@ module Fontist
     class RecursiveExtraction
       FONTS_PATTERN = "**/*.{ttf,otf,ttc}".freeze
       ARCHIVE_EXTENSIONS = %w[zip msi exe cab].freeze
-      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt|COPYING)$/i.freeze
+      LICENSE_PATTERN = /(ofl\.txt|ufl\.txt|licenses?\.txt|copying)$/i.freeze
 
       def initialize(archive, subarchive: nil, subdir: nil)
         @archive = archive
@@ -19,7 +19,7 @@ module Fontist
       end
 
       def extension
-        File.extname(filename(@archive)).sub(/^\./, "")
+        fetch_extension(@archive)
       end
 
       def font_files
@@ -44,6 +44,10 @@ module Fontist
 
       private
 
+      def fetch_extension(file)
+        File.extname(filename(file)).sub(/^\./, "")
+      end
+
       def filename(file)
         if file.respond_to?(:original_filename)
           file.original_filename
@@ -82,16 +86,26 @@ module Fontist
 
       # rubocop:disable Metrics/MethodLength
       def choose_extractor(archive)
-        case filename(archive)
-        when /\.msi$/i
+        case fetch_extension(archive).downcase
+        when "msi"
           Extractors::OleExtractor.new(archive)
-        when /\.cab$/i
+        when "cab"
           Extractors::CabExtractor.new(archive)
-        when /\.exe$/i
+        when "exe"
           extractor = Extractors::SevenZipExtractor.new(archive)
           extractor.try ? extractor : Extractors::CabExtractor.new(archive)
-        else
+        when "zip"
           Extractors::ZipExtractor.new(archive)
+        when "rpm"
+          Extractors::RpmExtractor.new(archive)
+        when "gz"
+          Extractors::GzipExtractor.new(archive)
+        when "cpio"
+          Extractors::CpioExtractor.new(archive)
+        when "tar"
+          Extractors::TarExtractor.new(archive)
+        else
+          raise Errors::UnknownArchiveError, "Could not unarchive `#{filename(archive)}`."
         end
       end
       # rubocop:enable Metrics/MethodLength
@@ -118,6 +132,9 @@ module Fontist
       def font_directory?(path, base_path)
         return true unless @subdir
 
+        # https://bugs.ruby-lang.org/issues/10011
+        base_path = Pathname.new(base_path)
+
         relative_path = Pathname.new(path).relative_path_from(base_path).to_s
         dirname = File.dirname(relative_path)
         normalized_pattern = @subdir.chomp("/")
@@ -147,7 +164,8 @@ module Fontist
       end
 
       def find_archive(path)
-        paths = Dir.children(path).map { |file| File.join(path, file) }
+        children = Dir.entries(path) - [".", ".."] # ruby 2.4 compat
+        paths = children.map { |file| File.join(path, file) }
         by_subarchive(paths) || by_size(paths)
       end
 

data/lib/fontist/import/sil_import.rb

@@ -0,0 +1,99 @@
+require "nokogiri"
+require "fontist/import/create_formula"
+
+module Fontist
+  module Import
+    class SilImport
+      ROOT = "https://software.sil.org/fonts/".freeze
+
+      def call
+        links = font_links
+        Fontist.ui.success("Found #{links.size} links.")
+
+        paths = []
+        links.each do |link|
+          path = create_formula_by_page_link(link)
+          paths << path if path
+        end
+
+        Fontist::Index.rebuild
+
+        Fontist.ui.success("Created #{paths.size} formulas.")
+      end
+
+      private
+
+      def font_links
+        html = URI.parse(ROOT).open.read
+        document = Nokogiri::HTML.parse(html)
+        document.css("table.products div.title > a")
+      end
+
+      def create_formula_by_page_link(link)
+        url = find_archive_url_by_page_link(link)
+        return unless url
+
+        create_formula_by_archive_url(url)
+      end
+
+      def create_formula_by_archive_url(url)
+        path = Fontist::Import::CreateFormula.new(url, formula_dir: formula_dir).call
+        Fontist.ui.success("Formula has been successfully created: #{path}")
+
+        path
+      end
+
+      def find_archive_url_by_page_link(link)
+        Fontist.ui.print("Searching for an archive of #{link.content}... ")
+
+        page_uri = URI.join(ROOT, link[:href])
+        archive_uri = find_archive_url_by_page_uri(page_uri)
+        unless archive_uri
+          Fontist.ui.error("NOT FOUND")
+          return
+        end
+
+        Fontist.ui.success("DONE")
+
+        archive_uri.to_s
+      end
+
+      def find_archive_url_by_page_uri(uri)
+        response = uri.open
+        current_url = response.base_uri
+        html = response.read
+        document = Nokogiri::HTML.parse(html)
+        link = find_archive_link(document)
+        return URI.join(current_url, link[:href]) if link
+
+        page_link = find_download_page(document)
+        return unless page_link
+
+        page_uri = URI.join(current_url, page_link[:href])
+        find_archive_url_by_page_uri(page_uri)
+      end
+
+      def find_archive_link(document)
+        links = document.css("a.btn-download")
+        download_links = links.select { |tag| tag.content.include?("DOWNLOAD CURRENT VERSION") }
+        return download_links.first unless download_links.empty?
+
+        links = document.css("a")
+        download_links = links.select { |tag| tag.content.match?(/Download.*\.zip/) }
+        download_links.first
+      end
+
+      def find_download_page(document)
+        links = document.css("a.btn-download")
+        page_links = links.select { |tag| tag.content == "DOWNLOADS" }
+        page_links.first
+      end
+
+      def formula_dir
+        @formula_dir ||= Fontist.formulas_path.join("sil").tap do |path|
+          FileUtils.mkdir_p(path) unless File.exist?(path)
+        end
+      end
+    end
+  end
+end