fontist 1.8.1 → 1.8.6

data/lib/fontist/formula.rb

@@ -21,11 +21,11 @@ module Fontist
     end
 
     def self.find(font_name)
-      Index.from_yaml.load_formulas(font_name).first
+      Indexes::FontIndex.from_yaml.load_formulas(font_name).first
     end
 
     def self.find_fonts(font_name)
-      formulas = Index.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
       formulas.map do |formula|
         formula.fonts.select do |f|
@@ -35,7 +35,7 @@ module Fontist
     end
 
     def self.find_styles(font_name, style_name)
-      formulas = Index.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
       formulas.map do |formula|
         formula.fonts.map do |f|
@@ -57,7 +57,7 @@ module Fontist
     end
 
     def to_index_formula
-      IndexFormula.new(path)
+      Indexes::IndexFormula.new(path)
     end
 
     def path

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/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

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

data/lib/fontist/index.rb

@@ -1,72 +1,11 @@
-require_relative "index_formula"
+require_relative "indexes/font_index"
+require_relative "indexes/filename_index"
 
 module Fontist
   class Index
-    def self.from_yaml
-      unless File.exist?(Fontist.formula_index_path)
-        raise Errors::FormulaIndexNotFoundError.new("Please fetch index with `fontist update`.")
-      end
-
-      data = YAML.load_file(Fontist.formula_index_path)
-      new(data)
-    end
-
     def self.rebuild
-      index = new
-      index.build
-      index.to_yaml
-    end
-
-    def initialize(data = {})
-      @index = {}
-
-      data.each_pair do |font, paths|
-        paths.each do |path|
-          add_index_formula(font, IndexFormula.new(path))
-        end
-      end
-    end
-
-    def build
-      Formula.all.each do |formula|
-        add_formula(formula)
-      end
-    end
-
-    def add_formula(formula)
-      formula.fonts.each do |font|
-        add_index_formula(font.name, formula.to_index_formula)
-      end
-    end
-
-    def add_index_formula(font_raw, index_formula)
-      font = normalize_font(font_raw)
-      @index[font] ||= []
-      @index[font] << index_formula unless @index[font].include?(index_formula)
-    end
-
-    def load_formulas(font)
-      index_formulas(font).map(&:to_full)
-    end
-
-    def to_yaml
-      File.write(Fontist.formula_index_path, YAML.dump(to_h))
-    end
-
-    def to_h
-      @index.map do |font, index_formulas|
-        [font, index_formulas.map(&:to_s)]
-      end.to_h
-    end
-
-    private
-
-    def index_formulas(font)
-      @index[normalize_font(font)] || []
-    end
-
-    def normalize_font(font)
-      font.downcase
+      Fontist::Indexes::FontIndex.rebuild
+      Fontist::Indexes::FilenameIndex.rebuild
     end
   end
 end