fontist 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dc209840287f224caec09be365402ca43e3605debfed69d01f3f89f12d27093
-  data.tar.gz: 2ba6e5c3359cfa30afe30ecf96b4f11311e33c12dcce5053b7e37ea9c1750ce9
+  metadata.gz: 4832b87f5d5535536b6f2f2e2761bf8ff8dbd82770703f93e201e2c7e81f496d
+  data.tar.gz: 32e720d4a33cb78a88bcdd8bf3b80bc24abec544d3dd755a459ae2a1a4a78d6b
 SHA512:
-  metadata.gz: b3e2a83f4c56ca2092954e9602827dcc6fe74ba4ba40d52f5e8ce6b0ca532cec67558fcf5a2e24775b13d263843ff2fab045f66838468a9d5fe0f087c3c08e23
-  data.tar.gz: 5d8968907e2955e7657044ad60c6c8c66ffc0f90d4e06f219b4bde01ad43f949b8dfc24a3477a6eebd269535d14dd26b7222c841c1f2b216f9e5a9111c9c931d
+  metadata.gz: 6567b976d958bc852244e5080753eb1fc2e44f8231fe08f3cded4076d510c553565160cf83c108e2e6c309cce042393acf7e19ab34e5a851f4c879a7f9c642ae
+  data.tar.gz: 2bab58316fdc830954b93daa716deaac90912ee4906510fad27efba2c0323af8cdb9bade71d5a5f257461063576863b44e1bfc0b72f7cdde1839689acb497f95

data/lib/fontist/cli.rb

@@ -12,8 +12,13 @@ module Fontist
     desc "install FONT", "Install font by font or formula"
     option :force, type: :boolean, aliases: :f,
                    desc: "Install even if it's already installed in system"
+    option :confirm_license, type: :boolean, desc: "Confirm license agreement"
     def install(font)
-      Fontist::Font.install(font, force: options[:force])
+      Fontist::Font.install(
+        font,
+        force: options[:force],
+        confirmation: options[:confirm_license] ? "yes" : "no"
+      )
       STATUS_SUCCESS
     rescue Fontist::Errors::NonSupportedFontError
       could_not_find_font(font)
@@ -94,6 +99,7 @@ module Fontist
     option :name, desc: "Example: Times New Roman"
     option :mirror, repeatable: true
     option :subarchive, desc: "Subarchive to choose when there are several ones"
+    option :subdir, desc: "Subdirectory to take fonts from"
     def create_formula(url)
       require "fontist/import/create_formula"
       name = Fontist::Import::CreateFormula.new(url, options).call

data/lib/fontist/errors.rb

@@ -7,6 +7,7 @@ module Fontist
     class InvalidResourceError < StandardError; end
     class TimeoutError < StandardError; end
     class MissingAttributeError < StandardError; end
+    class UnknownFontTypeError < StandardError; end
     class FontNotFoundError < StandardError; end
     class BinaryCallError < StandardError; end
     class ManifestCouldNotBeReadError < StandardError; end

data/lib/fontist/font_formula.rb

@@ -95,8 +95,10 @@ module Fontist
       styles = options.fetch(:extract_styles_from_collection, [])
 
       unless styles.empty?
-        styles.map do |type, file|
-          { type: type, collection: file, font: temp_resource[:filename] }
+        styles.map do |attributes|
+          filenames = temp_resource.slice(:filename, :source_filename)
+          Fontist::Utils::Dsl::CollectionFont.new(attributes.merge(filenames))
+            .attributes
         end
       end
     end
@@ -126,5 +128,31 @@ module Fontist
     def is_progress_bar_enabled
       options.nil? ? true : options.fetch(:progress_bar, true)
     end
+
+    def font_file?(filename)
+      source_files.include?(filename)
+    end
+
+    def source_files
+      @source_files ||= fonts.flat_map do |font|
+        font[:styles].map do |style|
+          style[:source_font] || style[:font]
+        end
+      end
+    end
+
+    def target_filename(source_filename)
+      target_filenames[source_filename]
+    end
+
+    def target_filenames
+      @target_filenames ||= fonts.flat_map do |font|
+        font[:styles].map do |style|
+          source = style[:source_font] || style[:font]
+          target = style[:font]
+          [source, target]
+        end
+      end.to_h
+    end
   end
 end

data/lib/fontist/formula.rb

@@ -19,8 +19,8 @@ module Fontist
       new(font_name: name).find_fonts
     end
 
-    def self.find_styles(font, style)
-      new(font_name: font, style_name: style).find_styles
+    def self.find_styles_with_fonts(font, style)
+      new(font_name: font, style_name: style).find_styles_with_fonts
     end
 
     def all
@@ -37,12 +37,16 @@ module Fontist
       fonts.empty? ? nil : fonts
     end
 
-    def find_styles
+    def find_styles_with_fonts
       formulas.values.flat_map do |formula|
         formula.fonts.flat_map do |f|
-          f.styles.select do |s|
+          selected = f.styles.select do |s|
             f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
           end
+
+          selected.map do |s|
+            { font: f, style: s }
+          end
         end
       end
     end

data/lib/fontist/formula_template.rb

@@ -23,10 +23,23 @@ module Fontist
           formula.font_collections.each do |collection|
             provides_font_collection do
               filename collection.filename
+              source_filename collection.source_filename
 
               collection.fonts.each do |font|
-                styles = font.styles.map { |s| [s.type, s.full_name] }.to_h
-                provides_font font.name, extract_styles_from_collection: styles
+                provides_font(
+                  font.name,
+                  extract_styles_from_collection: font.styles.map do |style|
+                    {
+                      family_name: style.family_name,
+                      style: style.type,
+                      full_name: style.full_name,
+                      post_script_name: style.post_script_name,
+                      version: style.version,
+                      description: style.description,
+                      copyright: style.copyright,
+                    }
+                  end
+                )
               end
             end
           end
@@ -45,6 +58,7 @@ module Fontist
                   version: style.version,
                   description: style.description,
                   filename: style.font,
+                  source_filename: style.source_font,
                   copyright: style.copyright,
                 }
               end

data/lib/fontist/import/create_formula.rb

@@ -8,10 +8,6 @@ require_relative "formula_builder"
 module Fontist
   module Import
     class CreateFormula
-      FONT_PATTERN = /(\.ttf|\.otf)/i.freeze
-      FONT_COLLECTION_PATTERN = /\.ttc/i.freeze
-      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt|COPYING)$/i.freeze
-
       def initialize(url, options = {})
         @url = url
         @options = options
@@ -26,41 +22,30 @@ module Fontist
       def formula
         builder = FormulaBuilder.new
         builder.url = @url
-        builder.archive = download(@url)
-        builder.extractor = extractor(builder.archive)
+        builder.archive = archive
+        builder.extractor = extractor
         builder.options = @options
-        builder.font_files = font_files(builder.extractor)
-        builder.font_collection_files = font_collection_files(builder.extractor)
-        builder.license_text = license_texts(builder.extractor).first
+        builder.font_files = extractor.font_files
+        builder.font_collection_files = extractor.font_collection_files
+        builder.license_text = extractor.license_text
         builder.formula
       end
 
-      def download(url)
-        return url if File.exist?(url)
-
-        Fontist::Utils::Downloader.download(url, progress_bar: true).path
+      def extractor
+        @extractor ||=
+          RecursiveExtraction.new(archive,
+                                  subarchive: @options[:subarchive],
+                                  subdir: @options[:subdir])
       end
 
-      def extractor(archive)
-        RecursiveExtraction.new(archive, subarchive: @options[:subarchive])
+      def archive
+        @archive ||= download(@url)
       end
 
-      def font_files(extractor)
-        extractor.extract(FONT_PATTERN) do |path|
-          Otf::FontFile.new(path)
-        end
-      end
-
-      def font_collection_files(extractor)
-        extractor.extract(FONT_COLLECTION_PATTERN) do |path|
-          Files::CollectionFile.new(path)
-        end
-      end
+      def download(url)
+        return url if File.exist?(url)
 
-      def license_texts(extractor)
-        extractor.extract(LICENSE_PATTERN) do |path|
-          File.read(path)
-        end
+        Fontist::Utils::Downloader.download(url, progress_bar: true).path
       end
 
       def save(hash)

data/lib/fontist/import/files/collection_file.rb

@@ -11,10 +11,15 @@ module Fontist
         def initialize(path)
           @path = path
           @fonts = read
+          @extension = "ttc"
         end
 
         def filename
-          File.basename(@path)
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_filename
+          File.basename(@path) unless filename == File.basename(@path)
         end
 
         private

data/lib/fontist/import/files/file_requirement.rb

@@ -0,0 +1,17 @@
+module Fontist
+  module Import
+    module Files
+      class FileRequirement
+        def initialize
+          `file -v`
+        rescue Errno::ENOENT
+          abort "`file` is not available. (Or is PATH not setup properly?)"
+        end
+
+        def call(path)
+          Helpers::SystemHelper.run("file --brief '#{path}'")
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/files/font_detector.rb

@@ -0,0 +1,48 @@
+require_relative "file_requirement"
+
+module Fontist
+  module Import
+    module Files
+      class FontDetector
+        REQUIREMENTS = { file: FileRequirement.new }.freeze
+
+        FONT_LABELS = ["OpenType font data",
+                       "TrueType Font data"].freeze
+
+        COLLECTION_LABEL = "TrueType font collection data".freeze
+
+        FONT_EXTENSIONS = {
+          "OpenType font data" => "otf",
+          "TrueType Font data" => "ttf",
+          "TrueType font collection data" => "ttc",
+        }.freeze
+
+        def self.detect(path)
+          brief = file_brief(path)
+
+          if brief.start_with?(*FONT_LABELS)
+            :font
+          elsif brief.start_with?(COLLECTION_LABEL)
+            :collection
+          else
+            :other
+          end
+        end
+
+        def self.standard_extension(path)
+          brief = file_brief(path)
+
+          FONT_EXTENSIONS.each do |label, extension|
+            return extension if brief.start_with?(label)
+          end
+
+          raise Errors::UnknownFontTypeError.new(path)
+        end
+
+        def self.file_brief(path)
+          REQUIREMENTS[:file].call(path)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/formula_builder.rb

@@ -107,7 +107,10 @@ module Fontist
 
         collections = @font_collection_files.map do |file|
           fonts = fonts_from_files(file.fonts, :to_collection_style)
-          { filename: file.filename, fonts: fonts }
+
+          { filename: file.filename,
+            source_filename: file.source_filename,
+            fonts: fonts }.compact
         end
 
         collections.sort_by do |x|
@@ -152,8 +155,9 @@ module Fontist
           return
         end
 
-        Fontist.ui.error("WARN: ensure it's an open license, otherwise change \
-                          to 'requires_license_agreement'")
+        Fontist.ui.error("WARN: ensure it's an open license, otherwise " \
+                         "change the 'open_license' attribute to " \
+                         "'requires_license_agreement'")
 
         TextHelper.cleanup(@license_text)
       end

data/lib/fontist/import/otf/font_file.rb

@@ -1,5 +1,6 @@
 require_relative "../otfinfo/otfinfo_requirement"
 require_relative "../text_helper"
+require_relative "../files/font_detector"
 
 module Fontist
   module Import
@@ -10,14 +11,19 @@ module Fontist
         }.freeze
 
         STYLE_ATTRIBUTES = %i[family_name type full_name post_script_name
-                              version description copyright font].freeze
-        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject { |a| a == :font }
+                              version description copyright font
+                              source_font].freeze
+
+        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject do |a|
+          %i[font source_font].include?(a)
+        end
 
         attr_reader :path
 
         def initialize(path)
           @path = path
           @info = read
+          @extension = detect_extension
         end
 
         def to_style
@@ -55,7 +61,11 @@ module Fontist
         end
 
         def font
-          File.basename(@path)
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_font
+          File.basename(@path) unless font == File.basename(@path)
         end
 
         def copyright
@@ -85,6 +95,10 @@ module Fontist
             .map { |x| x.map { |y| Fontist::Import::TextHelper.cleanup(y) } }
             .to_h
         end
+
+        def detect_extension
+          Files::FontDetector.standard_extension(@path)
+        end
       end
     end
   end

data/lib/fontist/import/recursive_extraction.rb

@@ -1,28 +1,40 @@
 require "find"
 require_relative "extractors"
+require_relative "files/font_detector"
 
 module Fontist
   module Import
     class RecursiveExtraction
-      BOTH_FONTS_PATTERN = "**/*.{ttf,otf,ttc}*".freeze
+      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
 
-      def initialize(archive, subarchive: nil)
+      def initialize(archive, subarchive: nil, subdir: nil)
         @archive = archive
         @subarchive = subarchive
+        @subdir = subdir
         @operations = []
+        @font_files = []
+        @collection_files = []
       end
 
       def extension
         File.extname(filename(@archive)).sub(/^\./, "")
       end
 
-      def extract(pattern)
-        Array.new.tap do |results|
-          Find.find(extracted_path) do |path| # rubocop:disable Style/CollectionMethods, Metrics/LineLength
-            results << yield(path) if path.match(pattern)
-          end
-        end
+      def font_files
+        ensure_extracted
+        @font_files
+      end
+
+      def font_collection_files
+        ensure_extracted
+        @collection_files
+      end
+
+      def license_text
+        ensure_extracted
+        @license_text
       end
 
       def operations
@@ -50,7 +62,11 @@ module Fontist
 
       def extract_recursively(archive)
         path = operate_on_archive(archive)
-        return path if fonts_exist?(path)
+        match_files(path)
+        if matched?
+          save_operation_subdir
+          return path
+        end
 
         next_archive = find_archive(path)
         extract_recursively(next_archive)
@@ -84,9 +100,50 @@ module Fontist
         @operations << { format: extractor.format }
       end
 
-      def fonts_exist?(path)
-        fonts = Dir.glob(File.join(path, BOTH_FONTS_PATTERN))
-        !fonts.empty?
+      def match_files(dir_path)
+        Find.find(dir_path) do |entry_path| # rubocop:disable Style/CollectionMethods
+          match_license(entry_path)
+          match_font(entry_path) if font_directory?(entry_path, dir_path)
+        end
+      end
+
+      def match_license(path)
+        @license_text ||= File.read(path) if license?(path)
+      end
+
+      def license?(file)
+        file.match?(LICENSE_PATTERN)
+      end
+
+      def font_directory?(path, base_path)
+        return true unless @subdir
+
+        relative_path = Pathname.new(path).relative_path_from(base_path).to_s
+        dirname = File.dirname(relative_path)
+        normalized_pattern = @subdir.chomp("/")
+        File.fnmatch?(normalized_pattern, dirname)
+      end
+
+      def match_font(path)
+        case Files::FontDetector.detect(path)
+        when :font
+          @font_files << Otf::FontFile.new(path)
+        when :collection
+          @collection_files << Files::CollectionFile.new(path)
+        end
+      end
+
+      def matched?
+        [@font_files, @collection_files].any? do |files|
+          files.size.positive?
+        end
+      end
+
+      def save_operation_subdir
+        return unless @subdir
+
+        @operations.last[:options] ||= {}
+        @operations.last[:options][:fonts_sub_dir] = @subdir
       end
 
       def find_archive(path)

data/lib/fontist/manifest/install.rb

@@ -1,8 +1,8 @@
-require_relative "common"
+require_relative "locations"
 
 module Fontist
   module Manifest
-    class Install < Common
+    class Install < Locations
       def initialize(manifest, confirmation: "no")
         @manifest = manifest
         @confirmation = confirmation
@@ -15,15 +15,11 @@ module Fontist
       private
 
       def file_paths(font, style)
-        paths = find_installed_font(font, style)
-        return paths unless paths.empty?
+        paths = super
+        return paths unless paths["paths"].empty?
 
         install_font(font)
-        find_installed_font(font, style)
-      end
-
-      def find_installed_font(font, style)
-        Fontist::SystemFont.find_with_style(font, style)
+        super
       end
 
       def install_font(font)

data/lib/fontist/manifest/locations.rb

@@ -1,12 +1,59 @@
-require_relative "common"
-
 module Fontist
   module Manifest
-    class Locations < Common
+    class Locations
+      def initialize(manifest)
+        @manifest = manifest
+      end
+
+      def self.call(manifest)
+        new(manifest).call
+      end
+
+      def call
+        font_names.zip(font_paths).to_h
+      end
+
       private
 
+      def font_names
+        fonts.keys
+      end
+
+      def fonts
+        @fonts ||= begin
+          unless File.exist?(@manifest)
+            raise Fontist::Errors::ManifestCouldNotBeFoundError
+          end
+
+          fonts = YAML.load_file(@manifest)
+          unless fonts.is_a?(Hash)
+            raise Fontist::Errors::ManifestCouldNotBeReadError
+          end
+
+          fonts
+        end
+      end
+
+      def font_paths
+        fonts.map do |font, styles|
+          styles_to_ary = [styles].flatten
+          style_paths_map(font, styles_to_ary)
+        end
+      end
+
+      def style_paths_map(font, names)
+        paths = style_paths(font, names)
+        names.zip(paths).to_h
+      end
+
+      def style_paths(font, names)
+        names.map do |style|
+          file_paths(font, style)
+        end
+      end
+
       def file_paths(font, style)
-        Fontist::SystemFont.find_with_style(font, style)
+        Fontist::SystemFont.find_with_style(font, style).transform_keys(&:to_s)
       end
     end
   end

data/lib/fontist/system_font.rb

@@ -22,10 +22,10 @@ module Fontist
     end
 
     def find_with_style
-      paths = lookup_using_font_and_style
-      return paths unless paths.empty?
+      styles = Formula.find_styles_with_fonts(font, style)
 
-      grep_font_paths(font, style)
+      { full_name: style_full_name(styles),
+        paths: style_paths(styles) }
     end
 
     private
@@ -95,9 +95,22 @@ module Fontist
       @default_sources ||= YAML.load(system_path_file)["system"][user_os.to_s]
     end
 
-    def lookup_using_font_and_style
-      styles = Formula.find_styles(font, style)
-      filenames = styles.map(&:font)
+    def style_full_name(styles)
+      return if styles.empty?
+
+      s = styles.first
+      s[:style]["full_name"] || s[:font]["name"]
+    end
+
+    def style_paths(styles)
+      filenames = styles.map { |x| x[:style]["font"] }
+      paths = lookup_using_filenames(filenames)
+      return paths unless paths.empty?
+
+      grep_font_paths(font, style)
+    end
+
+    def lookup_using_filenames(filenames)
       filenames.flat_map do |filename|
         search_font_paths(filename)
       end

data/lib/fontist/utils.rb

@@ -2,6 +2,7 @@ require "fontist/utils/ui"
 require "fontist/utils/system"
 require "fontist/utils/dsl"
 require "fontist/utils/dsl/font"
+require "fontist/utils/dsl/collection_font"
 require "fontist/utils/downloader"
 require "fontist/utils/zip_extractor"
 require "fontist/utils/exe_extractor"

data/lib/fontist/utils/dsl.rb

@@ -47,6 +47,10 @@ module Fontist
         instance.temp_resource.merge!(filename: name)
       end
 
+      def source_filename(name)
+        instance.temp_resource.merge!(source_filename: name)
+      end
+
       def provides_font(font, options = {})
         font_styles = instance.extract_font_styles(options)
         instance.font_list.push(name: font, styles: font_styles)

data/lib/fontist/utils/dsl/collection_font.rb

@@ -0,0 +1,36 @@
+module Fontist
+  module Utils
+    module Dsl
+      class CollectionFont
+        REQUIRED_ATTRIBUTES = %i[style].freeze
+
+        attr_reader :attributes
+
+        def initialize(attributes)
+          REQUIRED_ATTRIBUTES.each do |required_attribute|
+            unless attributes[required_attribute]
+              raise(Fontist::Errors::MissingAttributeError.new(
+                      "Missing attribute: #{required_attribute}"
+                    ))
+            end
+          end
+
+          self.attributes = attributes
+        end
+
+        def attributes=(attrs)
+          @attributes = { family_name: attrs[:family_name],
+                          type: attrs[:style],
+                          collection: attrs[:full_name],
+                          full_name: attrs[:full_name],
+                          post_script_name: attrs[:post_script_name],
+                          version: attrs[:version],
+                          description: attrs[:description],
+                          copyright: attrs[:copyright],
+                          font: attrs[:filename],
+                          source_font: attrs[:source_filename] }
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils/dsl/font.rb

@@ -29,7 +29,8 @@ module Fontist
                           version: attrs[:version],
                           description: attrs[:description],
                           copyright: attrs[:copyright],
-                          font: attrs[:filename] }
+                          font: attrs[:filename],
+                          source_font: attrs[:source_filename] }
         end
       end
     end

data/lib/fontist/utils/exe_extractor.rb

@@ -8,7 +8,7 @@ module Fontist
 
         Fontist.ui.say(%(Installing font "#{key}".))
         cab_file = decompressor.search(exe_file)
-        cabbed_fonts = grep_fonts(cab_file.files, font_ext) || []
+        cabbed_fonts = grep_fonts(cab_file.files) || []
         fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)
 
         block_given? ? yield(fonts_paths) : fonts_paths
@@ -29,10 +29,10 @@ module Fontist
         )
       end
 
-      def grep_fonts(file, font_ext)
+      def grep_fonts(file)
         Array.new.tap do |fonts|
           while file
-            fonts.push(file) if file.filename.match(font_ext)
+            fonts.push(file) if font_file?(file.filename)
             file = file.next
           end
         end
@@ -41,7 +41,8 @@ module Fontist
       def extract_cabbed_fonts_to_assets(cabbed_fonts)
         Array.new.tap do |fonts|
           cabbed_fonts.each do |font|
-            font_path = fonts_path.join(font.filename).to_s
+            target_filename = target_filename(font.filename)
+            font_path = fonts_path.join(target_filename).to_s
             decompressor.extract(font, font_path)
 
             fonts.push(font_path)

data/lib/fontist/utils/zip_extractor.rb

@@ -4,41 +4,49 @@ require "pathname"
 module Fontist
   module Utils
     module ZipExtractor
-      # fonts_sub_dir is unused now, but formulas have this option
-      # rubocop:disable Lint/UnusedMethodArgument
-      def zip_extract(resource, download: true, fonts_sub_dir: "")
+      def zip_extract(resource, download: true, fonts_sub_dir: nil)
         zip_file = download_file(resource) if download
         zip_file ||= resource.urls.first
 
         Fontist.ui.say(%(Installing font "#{key}".))
-        fonts_paths = unzip_fonts(zip_file)
+        fonts_paths = unzip_fonts(zip_file, fonts_sub_dir)
         block_given? ? yield(fonts_paths) : fonts_paths
       end
-      # rubocop:enable Lint/UnusedMethodArgument
 
       alias_method :unzip, :zip_extract
 
       private
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def unzip_fonts(file)
+      def unzip_fonts(file, subdir)
         Zip.on_exists_proc = true
 
         Array.new.tap do |fonts|
           Zip::File.open(file) do |zip_file|
-            zip_file.glob("**/*.{ttf,ttc,otf}").each do |entry|
+            zip_file.each do |entry|
               if entry.name
-                filename = Pathname.new(entry.name).basename
-                font_path = fonts_path.join(filename.to_s)
-                fonts.push(font_path.to_s)
+                filename = Pathname.new(entry.name).basename.to_s
+                if font_directory?(entry.name, subdir) && font_file?(filename)
+                  target_filename = target_filename(filename)
+                  font_path = fonts_path.join(target_filename)
+                  fonts.push(font_path.to_s)
 
-                entry.extract(font_path)
+                  entry.extract(font_path)
+                end
               end
             end
           end
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def font_directory?(path, subdir)
+        return true unless subdir
+
+        dirname = File.dirname(path)
+        normalized_pattern = subdir.chomp("/")
+        File.fnmatch?(normalized_pattern, dirname)
+      end
     end
   end
 end

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "1.6.0".freeze
+  VERSION = "1.7.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontist
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-20 00:00:00.000000000 Z
+date: 2020-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -284,6 +284,8 @@ files:
 - lib/fontist/import/extractors/seven_zip_extractor.rb
 - lib/fontist/import/extractors/zip_extractor.rb
 - lib/fontist/import/files/collection_file.rb
+- lib/fontist/import/files/file_requirement.rb
+- lib/fontist/import/files/font_detector.rb
 - lib/fontist/import/formula_builder.rb
 - lib/fontist/import/formula_serializer.rb
 - lib/fontist/import/google.rb
@@ -306,7 +308,6 @@ files:
 - lib/fontist/import/template_helper.rb
 - lib/fontist/import/text_helper.rb
 - lib/fontist/manifest.rb
-- lib/fontist/manifest/common.rb
 - lib/fontist/manifest/install.rb
 - lib/fontist/manifest/locations.rb
 - lib/fontist/registry.rb
@@ -316,6 +317,7 @@ files:
 - lib/fontist/utils/cache.rb
 - lib/fontist/utils/downloader.rb
 - lib/fontist/utils/dsl.rb
+- lib/fontist/utils/dsl/collection_font.rb
 - lib/fontist/utils/dsl/font.rb
 - lib/fontist/utils/exe_extractor.rb
 - lib/fontist/utils/msi_extractor.rb

data/lib/fontist/manifest/common.rb

@@ -1,60 +0,0 @@
-module Fontist
-  module Manifest
-    class Common
-      def initialize(manifest)
-        @manifest = manifest
-      end
-
-      def self.call(manifest)
-        new(manifest).call
-      end
-
-      def call
-        font_names.zip(font_paths).to_h
-      end
-
-      private
-
-      def font_names
-        fonts.keys
-      end
-
-      def fonts
-        @fonts ||= begin
-          unless File.exist?(@manifest)
-            raise Fontist::Errors::ManifestCouldNotBeFoundError
-          end
-
-          fonts = YAML.load_file(@manifest)
-          unless fonts.is_a?(Hash)
-            raise Fontist::Errors::ManifestCouldNotBeReadError
-          end
-
-          fonts
-        end
-      end
-
-      def font_paths
-        fonts.map do |font, styles|
-          styles_to_ary = [styles].flatten
-          style_paths_map(font, styles_to_ary)
-        end
-      end
-
-      def style_paths_map(font, names)
-        paths = style_paths(font, names)
-        names.zip(paths).to_h
-      end
-
-      def style_paths(font, names)
-        names.map do |style|
-          file_paths(font, style)
-        end
-      end
-
-      def file_paths(_font, _style)
-        raise NotImplementedError.new("Implement #file_paths in child class")
-      end
-    end
-  end
-end