fontist 1.0.0 → 1.4.0

data/lib/fontist/formulas.rb

@@ -1,9 +1,45 @@
+require "git"
 require "fontist/utils"
 require "fontist/font_formula"
+require "fontist/formula_template"
 
 module Fontist
   module Formulas
     def self.register_formulas
+      load_formulas
+      update_registry
+    end
+
+    def self.fetch_formulas
+      if Dir.exist?(Fontist.formulas_repo_path)
+        Git.open(Fontist.formulas_repo_path).pull
+      else
+        Git.clone(Fontist.formulas_repo_url,
+                  Fontist.formulas_repo_path,
+                  depth: 1)
+      end
+    end
+
+    def self.load_formulas
+      Dir[Fontist.formulas_path.join("**/*.yml").to_s].sort.each do |file|
+        create_formula_class(file)
+      end
+    end
+
+    def self.create_formula_class(file)
+      formula = parse_to_object(YAML.load_file(file))
+      class_name = name_to_classname(formula.name)
+      return if Formulas.const_defined?(class_name)
+
+      klass = FormulaTemplate.create_formula_class(formula)
+      Formulas.const_set(class_name, klass)
+    end
+
+    def self.parse_to_object(hash)
+      JSON.parse(hash.to_json, object_class: OpenStruct)
+    end
+
+    def self.update_registry
       Formulas.constants.select do |constant|
         if Formulas.const_get(constant).is_a?(Class)
           klass = "Fontist::Formulas::#{constant}"
@@ -11,5 +47,10 @@ module Fontist
         end
       end
     end
+
+    def self.name_to_classname(name)
+      cleanname = name.gsub(/ /, "").sub(/\S/, &:upcase)
+      "#{cleanname}Font"
+    end
   end
 end

data/lib/fontist/import.rb

@@ -0,0 +1,9 @@
+module Fontist
+  module Import
+    class << self
+      def name_to_filename(name)
+        name.downcase.gsub(" ", "_") + ".yml"
+      end
+    end
+  end
+end

data/lib/fontist/import/convert_formulas.rb

@@ -0,0 +1,65 @@
+require_relative "formula_serializer"
+
+module Fontist
+  module Import
+    class ConvertFormulas
+      def call
+        find_formulas.each do |formula|
+          convert_to_yaml(formula)
+        end
+      end
+
+      private
+
+      def find_formulas
+        require_formulas_files
+        formulas_instances
+      end
+
+      def require_formulas_files
+        path = Fontist.lib_path.join("fontist", "converted_formulas")
+        Dir[path.join("**/*.rb").to_s].sort.each do |file|
+          require file
+        end
+      end
+
+      def formulas_instances
+        classes = Formulas.constants.select do |constant|
+          Formulas.const_get(constant).is_a?(Class)
+        end
+
+        classes.map do |constant|
+          Object.const_get("Fontist::Formulas::#{constant}").instance
+        end
+      end
+
+      def convert_to_yaml(formula)
+        hash = formula_hash(formula)
+        write_yaml(formula, hash)
+      end
+
+      def formula_hash(formula)
+        code = File.read(formula_path(formula))
+        FormulaSerializer.new(formula, code).call
+      end
+
+      def formula_path(formula)
+        formula.method(:extract).source_location.first
+      end
+
+      def write_yaml(formula, hash)
+        File.write(yaml_formula_path(formula), YAML.dump(stringify_keys(hash)))
+      end
+
+      def yaml_formula_path(formula)
+        name = formula_path(formula).match(/formulas\/(.*)_fonts?.rb/)[1]
+
+        Fontist.formulas_path.join(name + ".yml")
+      end
+
+      def stringify_keys(hash)
+        JSON.parse(hash.to_json)
+      end
+    end
+  end
+end

data/lib/fontist/import/create_formula.rb

@@ -0,0 +1,74 @@
+require "fontist/import"
+require_relative "recursive_extraction"
+require_relative "otf/font_file"
+require_relative "files/collection_file"
+require_relative "helpers/hash_helper"
+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)$/i.freeze
+
+      def initialize(url, options = {})
+        @url = url
+        @options = options
+      end
+
+      def call
+        save(formula)
+      end
+
+      private
+
+      def formula
+        builder = FormulaBuilder.new
+        builder.url = @url
+        builder.archive = download(@url)
+        builder.extractor = extractor(builder.archive)
+        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.formula
+      end
+
+      def download(url)
+        return url if File.exist?(url)
+
+        Fontist::Utils::Downloader.download(url, progress_bar: true).path
+      end
+
+      def extractor(archive)
+        RecursiveExtraction.new(archive)
+      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 license_texts(extractor)
+        extractor.extract(LICENSE_PATTERN) do |path|
+          File.read(path)
+        end
+      end
+
+      def save(hash)
+        filename = Import.name_to_filename(hash[:name])
+        yaml = YAML.dump(Helpers::HashHelper.stringify_keys(hash))
+        File.write(filename, yaml)
+        filename
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors.rb

@@ -0,0 +1,5 @@
+require_relative "extractors/extractor"
+require_relative "extractors/zip_extractor"
+require_relative "extractors/ole_extractor"
+require_relative "extractors/seven_zip_extractor"
+require_relative "extractors/cab_extractor"

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

@@ -0,0 +1,37 @@
+module Fontist
+  module Import
+    module Extractors
+      class CabExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_exe(@archive, dir)
+          dir
+        end
+
+        def format
+          File.extname(@archive) == ".exe" ? "exe" : "cab"
+        end
+
+        private
+
+        def extract_exe(archive, dir)
+          opened = decompressor.search(archive)
+          file = opened.files
+
+          while file
+            path = File.join(dir, file.filename)
+            decompressor.extract(file, path)
+            file = file.next
+          end
+        end
+
+        def decompressor
+          @decompressor ||= begin
+                              require "libmspack"
+                              LibMsPack::CabDecompressor.new
+                            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fontist
+  module Import
+    module Extractors
+      class Extractor
+        def initialize(archive)
+          @archive = archive
+        end
+
+        def extract
+          raise NotImplementedError.new("You must implement this method")
+        end
+
+        def format
+          raise NotImplementedError.new("You must implement this method")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fontist
+  module Import
+    module Extractors
+      class OleExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_ole(@archive, dir)
+          dir
+        end
+
+        def format
+          "msi"
+        end
+
+        private
+
+        def extract_ole(archive, dir)
+          ole = storage.open(archive)
+          file = the_largest_file(ole)
+
+          content = ole.file.read(file)
+          path = File.join(dir, "data.cab")
+          File.open(path, "wb") { |f| f.write(content) }
+        end
+
+        def storage
+          @storage ||= begin
+                         require "ole/storage"
+                         Ole::Storage
+                       end
+        end
+
+        def the_largest_file(ole)
+          ole.dir.entries(".").max_by do |x|
+            ole.file.size(x)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fontist
+  module Import
+    module Extractors
+      class SevenZipExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_7z(@archive, dir)
+          dir
+        end
+
+        def try
+          File.open(@archive, "rb") do |file|
+            reader.open(file)
+          end
+
+          true
+        rescue StandardError => e
+          return false if e.message.start_with?("Invalid file format")
+
+          raise
+        end
+
+        def format
+          "seven_zip"
+        end
+
+        private
+
+        def extract_7z(archive, dir)
+          File.open(archive, "rb") do |file|
+            reader.extract_all(file, dir)
+          end
+        end
+
+        def reader
+          @reader ||= begin
+                        require "seven_zip_ruby"
+                        SevenZipRuby::Reader
+                      end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "zip"
+
+module Fontist
+  module Import
+    module Extractors
+      class ZipExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_zip(@archive, dir)
+          dir
+        end
+
+        def format
+          "zip"
+        end
+
+        private
+
+        def extract_zip(archive, dir)
+          Zip::File.open(archive) do |zip_file|
+            zip_file.each do |entry|
+              path = File.join(dir, entry.name)
+              FileUtils.mkdir_p(File.dirname(path))
+              entry.extract(path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require "fontist/import/helpers/system_helper"
+require_relative "../otf/font_file"
+
+module Fontist
+  module Import
+    module Files
+      class CollectionFile
+        STRIP_TTC_BINARY = Fontist.root_path.join("bin", "stripttc")
+
+        attr_reader :fonts
+
+        def initialize(path)
+          @path = path
+          @fonts = read
+        end
+
+        def filename
+          File.basename(@path)
+        end
+
+        private
+
+        def read
+          switch_to_temp_dir do |tmp_dir|
+            extract_ttfs(tmp_dir).map do |path|
+              Otf::FontFile.new(path)
+            end
+          end
+        end
+
+        def switch_to_temp_dir
+          Dir.mktmpdir do |tmp_dir|
+            Dir.chdir(tmp_dir) do
+              yield tmp_dir
+            end
+          end
+        end
+
+        def extract_ttfs(tmp_dir)
+          Helpers::SystemHelper.run("#{STRIP_TTC_BINARY} #{@path}")
+
+          basename = File.basename(@path, ".ttc")
+          Dir.glob(File.join(tmp_dir, "#{basename}_[0-9][0-9].ttf"))
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/formula_builder.rb

@@ -0,0 +1,115 @@
+require_relative "text_helper"
+
+module Fontist
+  module Import
+    class FormulaBuilder
+      FORMULA_ATTRIBUTES = %i[name description homepage resources
+                              font_collections fonts extract copyright
+                              license_url open_license].freeze
+
+      attr_accessor :archive,
+                    :url,
+                    :extractor,
+                    :options,
+                    :font_files,
+                    :font_collection_files,
+                    :license_text
+
+      def initialize
+        @options = {}
+      end
+
+      def formula
+        FORMULA_ATTRIBUTES.map { |name| [name, send(name)] }.to_h.compact
+      end
+
+      private
+
+      def name
+        return options[:name] if options[:name]
+
+        unique_names = both_fonts.map(&:family_name).uniq
+        TextHelper.longest_common_prefix(unique_names) ||
+          both_fonts.first.family_name
+      end
+
+      def both_fonts
+        @both_fonts ||= group_fonts
+      end
+
+      def group_fonts
+        files = (@font_files + @font_collection_files.map(&:fonts)).flatten
+        raise FontNotFoundError, "No font found" if files.empty?
+
+        files
+      end
+
+      def description
+        name
+      end
+
+      def homepage
+        both_fonts.first.homepage
+      end
+
+      def resources
+        filename = name.gsub(" ", "_") + "." + @extractor.extension
+
+        options = { urls: [@url] + (@options[:mirror] || []),
+                    sha256: Digest::SHA256.file(@archive).to_s }
+
+        { filename => options }
+      end
+
+      def font_collections
+        return if @font_collection_files.empty?
+
+        collections = @font_collection_files.map do |file|
+          fonts = fonts_from_files(file.fonts, :to_collection_style)
+          { filename: file.filename, fonts: fonts }
+        end
+
+        collections.sort_by do |x|
+          x[:filename]
+        end
+      end
+
+      def fonts
+        return if @font_files.empty?
+
+        fonts_from_files(@font_files, :to_style)
+      end
+
+      def fonts_from_files(files, style_type = :to_style)
+        groups = files.group_by(&:family_name)
+
+        fonts = groups.map do |name, group|
+          { name: name,
+            styles: group.map(&style_type) }
+        end
+
+        fonts.sort_by do |x|
+          x[:name]
+        end
+      end
+
+      def extract
+        @extractor.operations
+      end
+
+      def copyright
+        both_fonts.first.copyright
+      end
+
+      def license_url
+        both_fonts.first.license_url
+      end
+
+      def open_license
+        return unless @license_text
+
+        TextHelper.cleanup(@license_text)
+      end
+    end
+  end
+end