fontist 1.7.1 → 1.8.3

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/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
@@ -118,6 +118,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 +150,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,72 @@
+require_relative "index_formula"
+
+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
+    end
+  end
+end

data/lib/fontist/index_formula.rb

@@ -0,0 +1,30 @@
+module Fontist
+  class IndexFormula
+    def initialize(path)
+      @path = path
+    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

data/lib/fontist/manifest/install.rb

@@ -8,24 +8,19 @@ module Fontist
         @confirmation = confirmation
       end
 
-      def self.call(manifest, confirmation: "no")
-        new(manifest, confirmation: confirmation).call
-      end
-
       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

@@ -5,8 +5,21 @@ module Fontist
         @manifest = manifest
       end
 
-      def self.call(manifest)
-        new(manifest).call
+      def self.from_file(file, **keywords)
+        raise Fontist::Errors::ManifestCouldNotBeFoundError unless File.exist?(file)
+
+        manifest = YAML.load_file(file)
+        raise Fontist::Errors::ManifestCouldNotBeReadError unless manifest.is_a?(Hash)
+
+        from_hash(manifest, **keywords)
+      end
+
+      def self.from_hash(manifest, **keywords)
+        if keywords.empty?
+          new(manifest).call
+        else
+          new(manifest, **keywords).call
+        end
       end
 
       def call
@@ -15,27 +28,14 @@ module Fontist
 
       private
 
-      def font_names
-        fonts.keys
-      end
-
-      def fonts
-        @fonts ||= begin
-          unless File.exist?(@manifest)
-            raise Fontist::Errors::ManifestCouldNotBeFoundError
-          end
+      attr_reader :manifest
 
-          fonts = YAML.load_file(@manifest)
-          unless fonts.is_a?(Hash)
-            raise Fontist::Errors::ManifestCouldNotBeReadError
-          end
-
-          fonts
-        end
+      def font_names
+        manifest.keys
       end
 
       def font_paths
-        fonts.map do |font, styles|
+        manifest.map do |font, styles|
           styles_to_ary = [styles].flatten
           style_paths_map(font, styles_to_ary)
         end
@@ -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,35 +9,21 @@ module Fontist
       @user_sources = sources || []
     end
 
-    def self.find(font, sources: [])
-      new(font: font, sources: sources).find
-    end
-
-    def self.find_with_name(font, style)
-      new(font: font, style: style).find_with_name
+    def self.font_paths
+      system_font_paths + fontist_font_paths
     end
 
-    def find
-      paths = grep_font_paths(font)
-      paths = lookup_using_font_name || []  if paths.empty?
+    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)
 
-      paths.empty? ? nil : paths
+      Dir.glob(patterns)
     end
 
-    def find_with_name
-      styles = find_styles
-      return { full_name: nil, paths: [] } unless styles
-
-      { full_name: styles.first[:full_name],
-        paths: styles.map { |x| x[:path] } }
-    end
-
-    private
-
-    attr_reader :font, :style, :user_sources
-
-    def normalize_default_paths
-      @normalize_default_paths ||= default_sources["paths"].map do |path|
+    def self.expand_paths(paths)
+      paths.map do |path|
         require "etc"
         passwd = Etc.getpwuid
         username = passwd ? passwd.name : Etc.getlogin
@@ -45,97 +32,51 @@ module Fontist
       end
     end
 
-    def grep_font_paths(font, style = nil)
-      pattern = prepare_pattern(font, style)
-
-      paths = font_paths.map { |path| [File.basename(path), path] }.to_h
-      files = paths.keys
-      matched = files.grep(pattern)
-      paths.values_at(*matched).compact
+    def self.fontist_font_paths
+      Dir.glob(Fontist.fonts_path.join("**"))
     end
 
-    def prepare_pattern(font, style = nil)
-      style = nil if style&.casecmp?("regular")
-
-      s = [font, style].compact.map { |x| Regexp.quote(x) }
-        .join(".*")
-        .gsub("\\ ", "\s?") # space independent
-
-      Regexp.new(s, Regexp::IGNORECASE)
+    def self.find(font, sources: [])
+      new(font: font, sources: sources).find
     end
 
-    def font_paths
-      @font_paths ||= Dir.glob((
-        user_sources +
-        normalize_default_paths +
-        [fontist_fonts_path.join("**")]
-      ).flatten.uniq)
+    def self.find_with_name(font, style)
+      new(font: font, style: style).find_with_name
     end
 
-    def lookup_using_font_name
-      font_names = map_name_to_valid_font_names || []
-      font_paths.grep(/#{font_names.join("|")}/i) unless font_names.empty?
-    end
+    def find
+      styles = find_styles
+      return unless styles
 
-    def fontist_fonts_path
-      @fontist_fonts_path ||= Fontist.fonts_path
+      styles.map { |x| x[:path] }
     end
 
-    def user_os
-      Fontist::Utils::System.user_os
-    end
+    def find_with_name
+      styles = find_styles
+      return { full_name: nil, paths: [] } unless styles
 
-    def map_name_to_valid_font_names
-      fonts =  Formula.find_fonts(font)
-      fonts.map { |font| font.styles.map(&:font) }.flatten if fonts
+      { full_name: styles.first[:full_name],
+        paths: styles.map { |x| x[:path] } }
     end
 
-    def system_path_file
-      File.open(Fontist.system_file_path)
-    end
+    private
 
-    def default_sources
-      @default_sources ||= YAML.load(system_path_file)["system"][user_os.to_s]
-    end
+    attr_reader :font, :style, :user_sources
 
     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