fontist 1.7.3 → 1.8.5

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

data/lib/fontist/index.rb

@@ -0,0 +1,11 @@
+require_relative "indexes/font_index"
+require_relative "indexes/filename_index"
+
+module Fontist
+  class Index
+    def self.rebuild
+      Fontist::Indexes::FontIndex.rebuild
+      Fontist::Indexes::FilenameIndex.rebuild
+    end
+  end
+end

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

@@ -11,17 +11,16 @@ module Fontist
       private
 
       def file_paths(font, style)
-        paths = super
+        paths = find_font_with_name(font, style)
         return paths unless paths["paths"].empty?
 
         install_font(font)
-        super
+
+        find_font_with_name(font, style)
       end
 
       def install_font(font)
-        Fontist::Font.try_install(font, confirmation: @confirmation)
-      rescue Fontist::Errors::LicensingError
-        [] # try to install other fonts
+        Fontist::Font.install(font, force: true, confirmation: @confirmation)
       end
     end
   end

data/lib/fontist/manifest/locations.rb

@@ -53,7 +53,15 @@ module Fontist
       end
 
       def file_paths(font, style)
-        Fontist::SystemFont.find_with_name(font, style).transform_keys(&:to_s)
+        find_font_with_name(font, style).tap do |x|
+          if x["paths"].empty?
+            raise Errors::MissingFontError.new(font, style)
+          end
+        end
+      end
+
+      def find_font_with_name(font, style)
+        Fontist::SystemFont.find_with_name(font, style).map { |k, v| [k.to_s, v] }.to_h
       end
     end
   end

data/lib/fontist/system_font.rb

@@ -1,4 +1,5 @@
 require_relative "system_index"
+require_relative "formula_paths"
 
 module Fontist
   class SystemFont
@@ -8,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
@@ -35,78 +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
-      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
+      FormulaPaths.new(all_paths).find(font, style)
     end
 
-    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
+    def all_paths
+      @all_paths ||= Dir.glob(user_sources) + self.class.font_paths
     end
   end
 end