fontist 1.8.2 → 1.8.7

data/lib/fontist/font_path.rb

@@ -0,0 +1,29 @@
+require "fontist/indexes/filename_index"
+
+module Fontist
+  class FontPath
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      [].tap do |s|
+        s << "-"
+        s << @path
+        s << "(from #{formulas.join(' or ')} formula)" if formulas.any?
+      end.join(" ")
+    end
+
+    def formulas
+      @formulas ||= if fontist_font?
+                      Indexes::FilenameIndex.from_yaml.load_index_formulas(File.basename(@path)).map(&:name)
+                    else
+                      []
+                    end
+    end
+
+    def fontist_font?
+      @path.start_with?(Fontist.fonts_path.to_s)
+    end
+  end
+end

data/lib/fontist/formula.rb

@@ -21,11 +21,15 @@ module Fontist
     end
 
     def self.find(font_name)
-      Index.from_yaml.load_formulas(font_name).first
+      Indexes::FontIndex.from_yaml.load_formulas(font_name).first
+    end
+
+    def self.find_many(font_name)
+      Indexes::FontIndex.from_yaml.load_formulas(font_name)
     end
 
     def self.find_fonts(font_name)
-      formulas = Index.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
       formulas.map do |formula|
         formula.fonts.select do |f|
@@ -35,7 +39,7 @@ module Fontist
     end
 
     def self.find_styles(font_name, style_name)
-      formulas = Index.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
       formulas.map do |formula|
         formula.fonts.map do |f|
@@ -57,7 +61,7 @@ module Fontist
     end
 
     def to_index_formula
-      IndexFormula.new(path)
+      Indexes::IndexFormula.new(path)
     end
 
     def path

data/lib/fontist/import/extractors.rb

@@ -3,3 +3,7 @@ require_relative "extractors/zip_extractor"
 require_relative "extractors/ole_extractor"
 require_relative "extractors/seven_zip_extractor"
 require_relative "extractors/cab_extractor"
+require_relative "extractors/rpm_extractor"
+require_relative "extractors/gzip_extractor"
+require_relative "extractors/cpio_extractor"
+require_relative "extractors/tar_extractor"

data/lib/fontist/import/extractors/cpio_extractor.rb

@@ -0,0 +1,39 @@
+module Fontist
+  module Import
+    module Extractors
+      class CpioExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_cpio(@archive, dir)
+          dir
+        end
+
+        def format
+          "cpio"
+        end
+
+        private
+
+        def extract_cpio(archive, dir)
+          archive_file = File.open(archive, "rb")
+
+          reader_class.new(archive_file).each do |entry, file|
+            path = File.join(dir, entry.name)
+            if entry.directory?
+              FileUtils.mkdir_p(path)
+            else
+              File.write(path, file.read)
+            end
+          end
+        end
+
+        def reader_class
+          @reader_class ||= begin
+                              require "fontist/utils/cpio/cpio"
+                              CPIO::ASCIIReader
+                            end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/gzip_extractor.rb

@@ -0,0 +1,27 @@
+module Fontist
+  module Import
+    module Extractors
+      class GzipExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_gzip(@archive, dir)
+          dir
+        end
+
+        def format
+          "gzip"
+        end
+
+        private
+
+        def extract_gzip(archive, dir)
+          Zlib::GzipReader.open(archive) do |gz|
+            basename = File.basename(archive, ".*")
+            path = File.join(dir, basename)
+            File.write(path, gz.read)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/rpm_extractor.rb

@@ -0,0 +1,45 @@
+module Fontist
+  module Import
+    module Extractors
+      class RpmExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_rpm(@archive, dir)
+          dir
+        end
+
+        def format
+          "rpm"
+        end
+
+        private
+
+        def extract_rpm(archive, dir)
+          file = File.open(archive, "rb")
+          rpm = rpm_class.new(file)
+          content = rpm.payload.read
+          path = target_path(archive, rpm.tags, dir)
+
+          File.write(path, content)
+        ensure
+          file.close
+        end
+
+        def rpm_class
+          @rpm_class ||= begin
+                              require "arr-pm"
+                              RPM::File
+                            end
+        end
+
+        def target_path(archive, tags, dir)
+          archive_format = tags[:payloadformat]
+          compression_format = tags[:payloadcompressor] == "gzip" ? "gz" : tags[:payloadcompressor]
+          basename = File.basename(archive, ".*")
+          filename = basename + "." + archive_format + "." + compression_format
+          File.join(dir, filename)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/tar_extractor.rb

@@ -0,0 +1,47 @@
+module Fontist
+  module Import
+    module Extractors
+      class TarExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_tar(@archive, dir)
+          dir
+        end
+
+        def format
+          "tar"
+        end
+
+        private
+
+        def extract_tar(archive, dir)
+          archive_file = File.open(archive, "rb")
+          reader_class.new(archive_file) do |tar|
+            tar.each do |tarfile|
+              save_tar_file(tarfile, dir)
+            end
+          end
+        end
+
+        def reader_class
+          @reader_class ||= begin
+                              require "rubygems/package"
+                              Gem::Package::TarReader
+                            end
+        end
+
+        def save_tar_file(file, dir)
+          path = File.join(dir, file.full_name)
+
+          if file.directory?
+            FileUtils.mkdir_p(path)
+          else
+            File.open(path, "wb") do |f|
+              f.print(file.read)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/recursive_extraction.rb

@@ -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

data/lib/fontist/index.rb

@@ -1,72 +1,11 @@
-require_relative "index_formula"
+require_relative "indexes/font_index"
+require_relative "indexes/filename_index"
 
 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
+      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