fontist 1.7.3 → 1.8.5

data/lib/fontist/system_index.rb

@@ -2,8 +2,18 @@ require "ttfunk"
 
 module Fontist
   class SystemIndex
+    include Utils::Locking
+
     attr_reader :font_paths
 
+    def self.find(font, style)
+      new(SystemFont.font_paths).find(font, style)
+    end
+
+    def self.rebuild
+      new(SystemFont.font_paths).rebuild
+    end
+
     def initialize(font_paths)
       @font_paths = font_paths
     end
@@ -17,6 +27,10 @@ module Fontist
       fonts.empty? ? nil : fonts
     end
 
+    def rebuild
+      build_system_index
+    end
+
     private
 
     def system_index
@@ -24,28 +38,56 @@ module Fontist
     end
 
     def build_system_index
+      lock(lock_path) do
+        do_build_system_index
+      end
+    end
+
+    def lock_path
+      Fontist.system_index_path.to_s + ".lock"
+    end
+
+    def do_build_system_index
       previous_index = load_system_index
       updated_index = detect_paths(font_paths, previous_index)
       updated_index.tap do |index|
-        save_index(index)
+        save_index(index) if changed?(updated_index, previous_index)
       end
     end
 
+    def changed?(this, other)
+      this.map { |x| x[:path] }.uniq.sort != other.map { |x| x[:path] }.uniq.sort
+    end
+
     def load_system_index
       index = File.exist?(Fontist.system_index_path) ? YAML.load_file(Fontist.system_index_path) : []
-      index.group_by { |x| x[:path] }
+
+      index.each do |item|
+        missing_keys = %i[path full_name family_name type] - item.keys
+        unless missing_keys.empty?
+          raise(Errors::FontIndexCorrupted, <<~MSG.chomp)
+            Font index is corrupted.
+            Item #{item.inspect} misses required attributes: #{missing_keys.join(', ')}.
+            You can remove the index file (#{Fontist.system_index_path}) and try again.
+          MSG
+        end
+      end
+
+      index
     end
 
-    def detect_paths(paths, indexed)
+    def detect_paths(paths, index)
+      by_path = index.group_by { |x| x[:path] }
+
       paths.flat_map do |path|
-        next indexed[path] if indexed[path]
+        next by_path[path] if by_path[path]
 
         detect_fonts(path)
       end
     end
 
     def detect_fonts(path)
-      case File.extname(path).delete_prefix(".").downcase
+      case File.extname(path).gsub(/^\./, "").downcase
       when "ttf", "otf"
         detect_file_font(path)
       when "ttc"

data/lib/fontist/utils.rb

@@ -1,4 +1,5 @@
 require "fontist/utils/ui"
+require "fontist/utils/locking"
 require "fontist/utils/system"
 require "fontist/utils/dsl"
 require "fontist/utils/dsl/font"
@@ -8,6 +9,10 @@ require "fontist/utils/zip_extractor"
 require "fontist/utils/exe_extractor"
 require "fontist/utils/msi_extractor"
 require "fontist/utils/seven_zip_extractor"
+require "fontist/utils/rpm_extractor"
+require "fontist/utils/gzip_extractor"
+require "fontist/utils/cpio_extractor"
+require "fontist/utils/tar_extractor"
 
 module Fontist
   module Utils

data/lib/fontist/utils/cache.rb

@@ -1,6 +1,8 @@
 module Fontist
   module Utils
     class Cache
+      include Locking
+
       def fetch(key, bar: nil)
         map = load_cache
         if cache_exist?(map[key])
@@ -26,7 +28,7 @@ module Fontist
       end
 
       def downloaded_file(path)
-        File.new(downloaded_path(path))
+        File.new(downloaded_path(path), "rb")
       end
 
       def cache_exist?(path)
@@ -48,13 +50,19 @@ module Fontist
       def save_cache(generated_file, key)
         path = move_to_downloads(generated_file)
 
-        map = load_cache
-        map[key] = path
-        File.write(cache_map_path, YAML.dump(map))
+        lock(lock_path) do
+          map = load_cache
+          map[key] = path
+          File.write(cache_map_path, YAML.dump(map))
+        end
 
         path
       end
 
+      def lock_path
+        cache_map_path.to_s + ".lock"
+      end
+
       def move_to_downloads(source)
         create_downloads_directory
         path = generate_file_path(source)

data/lib/fontist/utils/cpio/cpio.rb

@@ -0,0 +1,199 @@
+# code is obtained from https://github.com/jordansissel/ruby-arr-pm/blob/8071591173ebb90dea27d5acfdde69a37dcb2744/cpio.rb
+# rubocop:disable all
+class BoundedIO
+  attr_reader :length
+  attr_reader :remaining
+
+  def initialize(io, length, &eof_callback)
+    @io = io
+    @length = length
+    @remaining = length
+
+    @eof_callback = eof_callback
+    @eof = false
+  end
+
+  def read(size=nil)
+    return nil if eof?
+    size = @remaining if size.nil?
+    data = @io.read(size)
+    @remaining -= data.bytesize
+    eof?
+    data
+  end
+
+  def sysread(size)
+    raise EOFError, "end of file reached" if eof?
+    read(size)
+  end
+
+  def eof?
+    return false if @remaining > 0
+    return @eof if @eof
+
+    @eof_callback.call
+    @eof = true
+  end
+end
+
+module CPIO
+  FIELDS = [
+    :magic, :ino, :mode, :uid, :gid, :nlink, :mtime, :filesize, :devmajor,
+    :devminor, :rdevmajor, :rdevminor, :namesize, :check
+  ]
+end
+
+class CPIO::ASCIIReader
+  FIELD_SIZES = {
+    :magic => 6,
+    :ino => 8,
+    :mode => 8,
+    :uid => 8,
+    :gid => 8,
+    :nlink => 8,
+    :mtime => 8,
+    :filesize => 8,
+    :devmajor => 8,
+    :devminor => 8,
+    :rdevmajor => 8,
+    :rdevminor => 8,
+    :namesize => 8,
+    :check => 8
+  }
+  HEADER_LENGTH = FIELD_SIZES.reduce(0) { |m, (_, v)| m + v }
+  HEADER_PACK = FIELD_SIZES.collect { |_, v| "A#{v}" }.join
+
+  FIELD_ORDER = [
+    :magic, :ino, :mode, :uid, :gid, :nlink, :mtime, :filesize, :devmajor,
+    :devminor, :rdevmajor, :rdevminor, :namesize, :check
+  ]
+
+  def initialize(io)
+    @io = io
+  end
+
+  private
+
+  def io
+    @io
+  end
+
+  def each(&block)
+    while true
+      entry = read
+      break if entry.nil?
+      # The CPIO format has the end-of-stream marker as a file called "TRAILER!!!"
+      break if entry.name == "TRAILER!!!"
+      block.call(entry, entry.file)
+      verify_correct_read(entry) unless entry.directory?
+    end
+  end
+
+  def verify_correct_read(entry)
+    # Read and throw away the whole file if not read at all.
+    entry.file.tap do |file|
+      if file.nil? ||  file.remaining == 0
+        # All OK! :)
+      elsif file.remaining == file.length
+        file.read(16384) while !file.eof?
+      else
+        # The file was only partially read? This should be an error by the
+        # user.
+        consumed = file.length - file.remaining
+        raise BadState, "Only #{consumed} bytes were read of the #{file.length} byte file: #{entry.name}"
+      end
+    end
+  end
+
+  def read
+    entry = CPIOEntry.new
+    header = io.read(HEADER_LENGTH)
+    return nil if header.nil?
+    FIELD_ORDER.zip(header.unpack(HEADER_PACK)).each do |field, value|
+      entry.send("#{field}=", value.to_i(16))
+    end
+
+    entry.validate
+    entry.mtime = Time.at(entry.mtime)
+    read_name(entry, @io)
+    read_file(entry, @io)
+    entry
+  end
+
+  def read_name(entry, io)
+    entry.name = io.read(entry.namesize - 1) # - 1 for null terminator
+    nul = io.read(1)
+    raise ArgumentError, "Corrupt CPIO or bug? Name null terminator was not null: #{nul.inspect}" if nul != "\0"
+    padding_data = io.read(padding_name(entry))
+    # Padding should be all null bytes
+    if padding_data != ("\0" * padding_data.bytesize)
+      raise ArgumentError, "Corrupt CPIO or bug? Name null padding was #{padding_name(entry)} bytes: #{padding_data.inspect}"
+    end
+  end
+
+  def read_file(entry, io)
+    if entry.directory?
+      entry.file = nil
+      #read_file_padding(entry, io)
+      nil
+    else
+      entry.file = BoundedIO.new(io, entry.filesize) do
+        read_file_padding(entry, io)
+      end
+    end
+  end
+
+  def read_file_padding(entry, io)
+    padding_data = io.read(padding_file(entry))
+    if padding_data != ("\0" * padding_data.bytesize)
+      raise ArgumentError, "Corrupt CPIO or bug? File null padding was #{padding_file(entry)} bytes: #{padding_data.inspect}"
+    end
+  end
+
+  def padding_name(entry)
+    # name padding is padding up to a multiple of 4 after header+namesize
+    -(HEADER_LENGTH + entry.namesize) % 4
+  end
+
+  def padding_file(entry)
+    (-(HEADER_LENGTH + entry.filesize + 2) % 4)
+  end
+  public(:each)
+end
+
+class CPIOEntry
+  CPIO::FIELDS.each do |field|
+    attr_accessor field
+  end
+
+  attr_accessor :name
+  attr_accessor :file
+
+  DIRECTORY_FLAG = 0040000
+
+  def validate
+    raise "Invalid magic #{magic.inspect}" if magic != 0x070701
+    raise "Invalid ino #{ino.inspect}" if ino < 0
+    raise "Invalid mode #{mode.inspect}" if mode < 0
+    raise "Invalid uid #{uid.inspect}" if uid < 0
+    raise "Invalid gid #{gid.inspect}" if gid < 0
+    raise "Invalid nlink #{nlink.inspect}" if nlink < 0
+    raise "Invalid mtime #{mtime.inspect}" if mtime < 0
+    raise "Invalid filesize #{filesize.inspect}" if filesize < 0
+    raise "Invalid devmajor #{devmajor.inspect}" if devmajor < 0
+    raise "Invalid devminor #{devminor.inspect}" if devminor < 0
+    raise "Invalid rdevmajor #{rdevmajor.inspect}" if rdevmajor < 0
+    raise "Invalid rdevminor #{rdevminor.inspect}" if rdevminor < 0
+    raise "Invalid namesize #{namesize.inspect}" if namesize < 0
+    raise "Invalid check #{check.inspect}" if check < 0
+  end # def validate
+
+  def read(*args)
+    return nil if directory?
+    file.read(*args)
+  end
+
+  def directory?
+    mode & DIRECTORY_FLAG > 0
+  end
+end

data/lib/fontist/utils/cpio_extractor.rb

@@ -0,0 +1,47 @@
+module Fontist
+  module Utils
+    module CpioExtractor
+      def cpio_extract(resource)
+        file = @downloaded ? resource : download_file(resource)
+
+        dir = extract_cpio_file(file)
+
+        largest_file_in_dir(dir)
+      end
+
+      private
+
+      def extract_cpio_file(archive_path)
+        archive_file = File.open(archive_path, "rb")
+        dir = Dir.mktmpdir
+        extract_cpio_file_to_dir(archive_file, dir)
+
+        dir
+      end
+
+      def extract_cpio_file_to_dir(archive_file, dir)
+        cpio_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, mode: "wb")
+          end
+        end
+      end
+
+      def cpio_reader_class
+        @cpio_reader_class ||= begin
+                                 require "fontist/utils/cpio/cpio"
+                                 CPIO::ASCIIReader
+                               end
+      end
+
+      def largest_file_in_dir(dir)
+        Dir.glob(File.join(dir, "**/*")).max_by do |path|
+          File.size(path)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils/exe_extractor.rb

@@ -6,7 +6,7 @@ module Fontist
 
         exe_file = download_file(exe_file).path if download
 
-        Fontist.ui.say(%(Installing font "#{key}".))
+        Fontist.ui.say(%(Installing font "#{formula.key}".))
         cab_file = decompressor.search(exe_file)
         cabbed_fonts = grep_fonts(cab_file.files) || []
         fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)

data/lib/fontist/utils/gzip_extractor.rb

@@ -0,0 +1,24 @@
+module Fontist
+  module Utils
+    module GzipExtractor
+      def gzip_extract(resource)
+        file = @downloaded ? resource : download_file(resource)
+
+        extract_gzip_file(file)
+      end
+
+      private
+
+      def extract_gzip_file(file)
+        Zlib::GzipReader.open(file) do |gz|
+          basename = File.basename(file, ".*")
+          dir = Dir.mktmpdir
+          path = File.join(dir, basename)
+          File.write(path, gz.read, mode: "wb")
+
+          path
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils/locking.rb

@@ -0,0 +1,17 @@
+module Fontist
+  module Utils
+    module Locking
+      def lock(lock_path)
+        File.dirname(lock_path).tap do |dir|
+          FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        end
+
+        f = File.open(lock_path, File::CREAT)
+        f.flock(File::LOCK_EX)
+        yield
+      ensure
+        f.flock(File::LOCK_UN)
+      end
+    end
+  end
+end