fontist 1.9.0 → 1.11.1

data/lib/fontist/import/otf_style.rb

@@ -7,8 +7,8 @@ module Fontist
       end
 
       def call
-        style = { family_name: @info["Preferred family"] || @info["Family"],
-                  style: @info["Preferred subfamily"] || @info["Subfamily"],
+        style = { family_name: @info["Family"],
+                  style: @info["Subfamily"],
                   full_name: @info["Full name"],
                   post_script_name: @info["PostScript name"],
                   version: version(@info["Version"]),
@@ -16,6 +16,14 @@ module Fontist
                   filename: File.basename(@path),
                   copyright: @info["Copyright"] }
 
+        if @info["Preferred family"]
+          style[:preferred_family_name] = @info["Preferred family"]
+        end
+
+        if @info["Preferred subfamily"]
+          style[:preferred_style] = @info["Preferred subfamily"]
+        end
+
         OpenStruct.new(style)
       end
 

data/lib/fontist/import/otfinfo/template.erb

@@ -2,6 +2,12 @@
           {
             family_name: "<%= s.family_name %>",
             style: "<%= s.style %>",
+            <%- if s.preferred_family_name -%>
+            preferred_family_name: "<%= s.preferred_family_name %>",
+            <%- end -%>
+            <%- if s.preferred_style -%>
+            preferred_type: "<%= s.preferred_style %>",
+            <%- end -%>
             full_name: "<%= s.full_name %>",
             <%- if s.post_script_name -%>
             post_script_name: "<%= s.post_script_name %>",

data/lib/fontist/index.rb

@@ -19,25 +19,28 @@ module Fontist
     end
 
     def self.do_rebuild_for_main_repo_with
-      Fontist.formula_index_path = Fontist.formulas_repo_path.join("index.yml")
+      Fontist.formula_preferred_family_index_path =
+        Fontist.formulas_repo_path.join("index.yml")
       Fontist.formula_filename_index_path =
         Fontist.formulas_repo_path.join("filename_index.yml")
 
       rebuild
 
-      Fontist.formula_index_path = nil
+      Fontist.formula_preferred_family_index_path = nil
       Fontist.formula_filename_index_path = nil
     end
 
     def self.rebuild
-      Fontist::Indexes::FontIndex.rebuild
+      Fontist::Indexes::DefaultFamilyFontIndex.rebuild
+      Fontist::Indexes::PreferredFamilyFontIndex.rebuild
       Fontist::Indexes::FilenameIndex.rebuild
 
       reset_cache
     end
 
     def self.reset_cache
-      Fontist::Indexes::FontIndex.reset_cache
+      Fontist::Indexes::DefaultFamilyFontIndex.reset_cache
+      Fontist::Indexes::PreferredFamilyFontIndex.reset_cache
       Fontist::Indexes::FilenameIndex.reset_cache
     end
   end

data/lib/fontist/indexes/default_family_font_index.rb

@@ -0,0 +1,21 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class DefaultFamilyFontIndex < 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/font_index.rb

@@ -1,21 +1,16 @@
-require_relative "base_index"
+require_relative "default_family_font_index"
+require_relative "preferred_family_font_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)
+    class FontIndex
+      def self.from_yaml
+        if Fontist.preferred_family?
+          PreferredFamilyFontIndex.from_yaml
+        else
+          DefaultFamilyFontIndex.from_yaml
         end
       end
-
-      def normalize_key(key)
-        key.downcase
-      end
     end
   end
 end

data/lib/fontist/indexes/preferred_family_font_index.rb

@@ -0,0 +1,24 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class PreferredFamilyFontIndex < BaseIndex
+      def self.path
+        Fontist.formula_preferred_family_index_path
+      end
+
+      def add_formula(formula)
+        formula.fonts.each do |font|
+          font.styles.each do |style|
+            font_name = style.preferred_family_name || font.name
+            add_index_formula(font_name, formula.to_index_formula)
+          end
+        end
+      end
+
+      def normalize_key(key)
+        key.downcase
+      end
+    end
+  end
+end

data/lib/fontist/repo.rb

@@ -29,6 +29,12 @@ module Fontist
         Index.rebuild
       end
 
+      def list
+        Dir.glob(Fontist.private_formulas_path.join("*"))
+          .select { |path| File.directory?(path) }
+          .map { |path| File.basename(path) }
+      end
+
       private
 
       def ensure_private_formulas_path_exists

data/lib/fontist/repo_cli.rb

@@ -1,7 +1,8 @@
 module Fontist
   class RepoCLI < Thor
     desc "setup NAME URL",
-         "Setup a custom fontist repo named NAME for the repository at URL"
+         "Setup a custom fontist repo named NAME for the repository at URL " \
+         "and fetches its formulas"
     def setup(name, url)
       Repo.setup(name, url)
       Fontist.ui.success(
@@ -32,6 +33,14 @@ module Fontist
       handle_repo_not_found(name)
     end
 
+    desc "list", "List fontist repos"
+    def list
+      Repo.list.each do |name|
+        Fontist.ui.say(name)
+      end
+      CLI::STATUS_SUCCESS
+    end
+
     private
 
     def handle_repo_not_found(name)

data/lib/fontist/system_font.rb

@@ -3,10 +3,9 @@ require_relative "formula_paths"
 
 module Fontist
   class SystemFont
-    def initialize(font:, style: nil, sources: nil)
+    def initialize(font:, style: nil)
       @font = font
       @style = style
-      @user_sources = sources || []
     end
 
     def self.font_paths
@@ -36,8 +35,8 @@ module Fontist
       Dir.glob(Fontist.fonts_path.join("**"))
     end
 
-    def self.find(font, sources: [])
-      new(font: font, sources: sources).find
+    def self.find(font)
+      new(font: font).find
     end
 
     def self.find_styles(font, style)
@@ -57,18 +56,14 @@ module Fontist
 
     private
 
-    attr_reader :font, :style, :user_sources
+    attr_reader :font, :style
 
     def find_by_index
-      SystemIndex.new(all_paths).find(font, style)
+      SystemIndex.system_index.find(font, style)
     end
 
     def find_by_formulas
-      FormulaPaths.new(all_paths).find(font, style)
-    end
-
-    def all_paths
-      @all_paths ||= Dir.glob(user_sources) + self.class.font_paths
+      FormulaPaths.new(self.class.font_paths).find(font, style)
     end
   end
 end

data/lib/fontist/system_index.rb

@@ -4,22 +4,73 @@ module Fontist
   class SystemIndex
     include Utils::Locking
 
+    class DefaultFamily
+      def family_name(name)
+        name.font_family
+      end
+
+      def type(name)
+        name.font_subfamily
+      end
+    end
+
+    class PreferredFamily
+      def family_name(name)
+        return name.font_family if name.preferred_family.empty?
+
+        name.preferred_family
+      end
+
+      def type(name)
+        return name.font_subfamily if name.preferred_subfamily.empty?
+
+        name.preferred_subfamily
+      end
+    end
+
+    PLATFORM_MACINTOSH = 1
+    PLATFORM_MICROSOFT = 3
+
+    ENCODING_MAC_ROMAN = 0
+    ENCODING_MS_UNICODE_BMP = 1
+
+    LANGUAGE_MAC_ENGLISH = 0
+    LANGUAGE_MS_ENGLISH_AMERICAN = 0x409
+
     attr_reader :font_paths
 
-    def self.find(font, style)
-      new(SystemFont.font_paths).find(font, style)
+    def self.system_index
+      if Fontist.preferred_family?
+        new(Fontist.system_preferred_family_index_path,
+            SystemFont.font_paths,
+            PreferredFamily.new)
+      else
+        new(Fontist.system_index_path,
+            SystemFont.font_paths,
+            DefaultFamily.new)
+      end
     end
 
-    def self.rebuild
-      new(SystemFont.font_paths).rebuild
+    def self.fontist_index
+      if Fontist.preferred_family?
+        new(Fontist.fontist_preferred_family_index_path,
+            SystemFont.fontist_font_paths,
+            PreferredFamily.new)
+      else
+        new(Fontist.fontist_index_path,
+            SystemFont.fontist_font_paths,
+            DefaultFamily.new)
+      end
     end
 
-    def initialize(font_paths)
+    def initialize(index_path, font_paths, family)
+      @index_path = index_path
       @font_paths = font_paths
+      @family = family
     end
 
     def find(font, style)
-      fonts = system_index.select do |file|
+      fonts = index.select do |file|
         file[:family_name].casecmp?(font) &&
           (style.nil? || file[:type].casecmp?(style))
       end
@@ -28,27 +79,27 @@ module Fontist
     end
 
     def rebuild
-      build_system_index
+      build_index
     end
 
     private
 
-    def system_index
-      @system_index ||= build_system_index
+    def index
+      @index ||= build_index
     end
 
-    def build_system_index
+    def build_index
       lock(lock_path) do
-        do_build_system_index
+        do_build_index
       end
     end
 
     def lock_path
-      Fontist.system_index_path.to_s + ".lock"
+      "#{@index_path}.lock"
     end
 
-    def do_build_system_index
-      previous_index = load_system_index
+    def do_build_index
+      previous_index = load_index
       updated_index = detect_paths(font_paths, previous_index)
       updated_index.tap do |index|
         save_index(index) if changed?(updated_index, previous_index)
@@ -59,21 +110,23 @@ module Fontist
       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) : []
+    def load_index
+      index = File.exist?(@index_path) ? YAML.load_file(@index_path) : []
+      check_index(index)
+      index
+    end
 
+    def check_index(index)
       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.
+            You can remove the index file (#{@index_path}) and try again.
           MSG
         end
       end
-
-      index
     end
 
     def detect_paths(paths, index)
@@ -95,14 +148,18 @@ module Fontist
       else
         raise Errors::UnknownFontTypeError.new(path)
       end
+    rescue StandardError
+      Fontist.ui.error($!.message)
+      Fontist.ui.error(
+        "Warning: File at #{path} not recognized as a font file.",
+      )
     end
 
     def detect_file_font(path)
-      file = TTFunk::File.open(path)
+      content = File.read(path, mode: "rb")
+      file = TTFunk::File.new(content)
+
       parse_font(file, path)
-    rescue StandardError
-      warn $!.message
-      warn "Warning: File at #{path} not recognized as a font file."
     end
 
     def detect_collection_fonts(path)
@@ -118,20 +175,42 @@ module Fontist
 
       {
         path: path,
-        full_name: parse_text(x.font_name.first),
-        family_name: parse_text(x.preferred_family.first || x.font_family.first),
-        type: parse_text(x.preferred_subfamily.first || x.font_subfamily.first),
+        full_name: english_name(x.font_name),
+        family_name: english_name(@family.family_name(x)),
+        type: english_name(@family.type(x)),
       }
     end
 
-    def parse_text(text)
+    def english_name(name)
+      visible_characters(find_english(name))
+    end
+
+    def find_english(name)
+      name.find { |x| microsoft_english?(x) } ||
+        name.find { |x| mac_english?(x) } ||
+        name.last
+    end
+
+    def microsoft_english?(string)
+      string.platform_id == PLATFORM_MICROSOFT &&
+        string.encoding_id == ENCODING_MS_UNICODE_BMP &&
+        string.language_id == LANGUAGE_MS_ENGLISH_AMERICAN
+    end
+
+    def mac_english?(string)
+      string.platform_id == PLATFORM_MACINTOSH &&
+        string.encoding_id == ENCODING_MAC_ROMAN &&
+        string.language_id == LANGUAGE_MAC_ENGLISH
+    end
+
+    def visible_characters(text)
       text.gsub(/[^[:print:]]/, "").to_s
     end
 
     def save_index(index)
-      dir = File.dirname(Fontist.system_index_path)
+      dir = File.dirname(@index_path)
       FileUtils.mkdir_p(dir) unless File.exist?(dir)
-      File.write(Fontist.system_index_path, YAML.dump(index))
+      File.write(@index_path, YAML.dump(index))
     end
   end
 end