fontist 1.8.1 → 1.8.6

data/lib/fontist/indexes/base_index.rb

@@ -0,0 +1,82 @@
+require_relative "index_formula"
+
+module Fontist
+  module Indexes
+    class BaseIndex
+      def self.from_yaml
+        @from_yaml ||= begin
+          unless File.exist?(path)
+            raise Errors::FormulaIndexNotFoundError.new("Please fetch `#{path}` index with `fontist update`.")
+          end
+
+          data = YAML.load_file(path)
+          new(data)
+        end
+      end
+
+      def self.path
+        raise NotImplementedError, "Please define path of an index"
+      end
+
+      def self.rebuild
+        index = new
+        index.build
+        index.to_yaml
+      end
+
+      def initialize(data = {})
+        @index = {}
+
+        data.each_pair do |key, paths|
+          paths.each do |path|
+            add_index_formula(key, IndexFormula.new(path))
+          end
+        end
+      end
+
+      def build
+        Formula.all.each do |formula|
+          add_formula(formula)
+        end
+      end
+
+      def add_formula(_formula)
+        raise NotImplementedError, "Please define how to add formula to an index, use #add_index_formula"
+      end
+
+      def add_index_formula(key_raw, index_formula)
+        key = normalize_key(key_raw)
+        @index[key] ||= []
+        @index[key] << index_formula unless @index[key].include?(index_formula)
+      end
+
+      def load_formulas(key)
+        index_formulas(key).map(&:to_full)
+      end
+
+      def load_index_formulas(key)
+        index_formulas(key)
+      end
+
+      def to_yaml
+        File.write(self.class.path, YAML.dump(to_h))
+      end
+
+      def to_h
+        @index.map do |key, index_formulas|
+          [key, index_formulas.map(&:to_s)]
+        end.to_h
+      end
+
+      private
+
+      def index_formulas(key)
+        @index[normalize_key(key)] || []
+      end
+
+      def normalize_key(key)
+        key
+      end
+    end
+  end
+end

data/lib/fontist/indexes/filename_index.rb

@@ -0,0 +1,19 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class FilenameIndex < BaseIndex
+      def self.path
+        Fontist.formula_filename_index_path
+      end
+
+      def add_formula(formula)
+        formula.fonts.each do |font|
+          font.styles.each do |style|
+            add_index_formula(style.font, formula.to_index_formula)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/indexes/font_index.rb

@@ -0,0 +1,21 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class FontIndex < BaseIndex
+      def self.path
+        Fontist.formula_index_path
+      end
+
+      def add_formula(formula)
+        formula.fonts.each do |font|
+          add_index_formula(font.name, formula.to_index_formula)
+        end
+      end
+
+      def normalize_key(key)
+        key.downcase
+      end
+    end
+  end
+end

data/lib/fontist/indexes/index_formula.rb

@@ -0,0 +1,36 @@
+module Fontist
+  module Indexes
+    class IndexFormula
+      def initialize(path)
+        @path = path
+      end
+
+      def name
+        normalized.sub(/\.yml$/, "")
+      end
+
+      def to_s
+        normalized
+      end
+
+      def to_full
+        Formula.new_from_file(full_path)
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      private
+
+      def normalized
+        escaped = Regexp.escape(Fontist.formulas_path.to_s + "/")
+        @path.sub(Regexp.new("^" + escaped), "")
+      end
+
+      def full_path
+        Fontist.formulas_path.join(normalized).to_s
+      end
+    end
+  end
+end

data/lib/fontist/manifest/install.rb

@@ -3,9 +3,10 @@ require_relative "locations"
 module Fontist
   module Manifest
     class Install < Locations
-      def initialize(manifest, confirmation: "no")
+      def initialize(manifest, confirmation: "no", hide_licenses: false)
         @manifest = manifest
         @confirmation = confirmation
+        @hide_licenses = hide_licenses
       end
 
       private
@@ -20,7 +21,7 @@ module Fontist
       end
 
       def install_font(font)
-        Fontist::Font.install(font, force: true, confirmation: @confirmation)
+        Fontist::Font.install(font, force: true, confirmation: @confirmation, hide_licenses: @hide_licenses)
       end
     end
   end

data/lib/fontist/manifest/locations.rb

@@ -55,7 +55,7 @@ module Fontist
       def file_paths(font, style)
         find_font_with_name(font, style).tap do |x|
           if x["paths"].empty?
-            raise Errors::MissingFontError.new("Could not find font #{font} #{style}.")
+            raise Errors::MissingFontError.new(font, style)
           end
         end
       end

data/lib/fontist/system_font.rb

@@ -9,6 +9,33 @@ module Fontist
       @user_sources = sources || []
     end
 
+    def self.font_paths
+      system_font_paths + fontist_font_paths
+    end
+
+    def self.system_font_paths
+      config_path = Fontist.system_file_path
+      os = Fontist::Utils::System.user_os.to_s
+      templates = YAML.load_file(config_path)["system"][os]["paths"]
+      patterns = expand_paths(templates)
+
+      Dir.glob(patterns)
+    end
+
+    def self.expand_paths(paths)
+      paths.map do |path|
+        require "etc"
+        passwd = Etc.getpwuid
+        username = passwd ? passwd.name : Etc.getlogin
+
+        username ? path.gsub("{username}", username) : path
+      end
+    end
+
+    def self.fontist_font_paths
+      Dir.glob(Fontist.fonts_path.join("**"))
+    end
+
     def self.find(font, sources: [])
       new(font: font, sources: sources).find
     end
@@ -36,50 +63,20 @@ module Fontist
 
     attr_reader :font, :style, :user_sources
 
-    def normalize_default_paths
-      @normalize_default_paths ||= default_sources["paths"].map do |path|
-        require "etc"
-        passwd = Etc.getpwuid
-        username = passwd ? passwd.name : Etc.getlogin
-
-        username ? path.gsub("{username}", username) : path
-      end
-    end
-
-    def font_paths
-      @font_paths ||= Dir.glob((
-        user_sources +
-        normalize_default_paths +
-        [fontist_fonts_path.join("**")]
-      ).flatten.uniq)
-    end
-
-    def fontist_fonts_path
-      @fontist_fonts_path ||= Fontist.fonts_path
-    end
-
-    def user_os
-      Fontist::Utils::System.user_os
-    end
-
-    def system_path_file
-      File.open(Fontist.system_file_path)
-    end
-
-    def default_sources
-      @default_sources ||= YAML.safe_load(system_path_file)["system"][user_os.to_s]
-    end
-
     def find_styles
       find_by_index || find_by_formulas
     end
 
     def find_by_index
-      SystemIndex.new(font_paths).find(font, style)
+      SystemIndex.new(all_paths).find(font, style)
     end
 
     def find_by_formulas
-      FormulaPaths.new(font_paths).find(font, style)
+      FormulaPaths.new(all_paths).find(font, style)
+    end
+
+    def all_paths
+      @all_paths ||= Dir.glob(user_sources) + self.class.font_paths
     end
   end
 end

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,21 +38,49 @@ 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

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