metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/fontist-1.2.0/lib/fontist/utils/exe_extractor.rb

@@ -0,0 +1,72 @@
+module Fontist
+  module Utils
+    module ExeExtractor
+      def cab_extract(exe_file, download: true,  font_ext: /.tt|.ttc/i)
+        download = @downloaded === true ? false : download
+
+        exe_file = download_file(exe_file).path if download
+        cab_file = decompressor.search(exe_file)
+        cabbed_fonts = grep_fonts(cab_file.files, font_ext) || []
+        fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)
+
+        yield(fonts_paths) if block_given?
+      end
+
+      def exe_extract(source)
+        cab_file = decompressor.search(download_file(source).path)
+        yield(build_cab_file_hash(cab_file.files)) if block_given?
+      end
+
+      private
+
+      def decompressor
+        @decompressor ||= (
+          require "libmspack"
+          LibMsPack::CabDecompressor.new
+        )
+      end
+
+      def grep_fonts(file, font_ext)
+        Array.new.tap do |fonts|
+          while file
+            fonts.push(file) if file.filename.match(font_ext)
+            file = file.next
+          end
+        end
+      end
+
+      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
+            decompressor.extract(font, font_path)
+
+            fonts.push(font_path)
+          end
+        end
+      end
+
+      def build_cab_file_hash(file)
+        Hash.new.tap do |cab_files|
+          while file
+            filename = file.filename
+            if filename.include?("cab")
+              file_path = temp_dir.join(filename).to_s
+
+              decompressor.extract(file, file_path)
+              cab_files[filename.to_s] = file_path
+            end
+
+            file = file.next
+          end
+        end
+      end
+
+      def temp_dir
+        @temp_dir ||= raise(
+          NotImplementedError.new("You must implement this method"),
+        )
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/lib/fontist/utils/zip_extractor.rb

@@ -0,0 +1,38 @@
+require "zip"
+require "pathname"
+
+module Fontist
+  module Utils
+    module ZipExtractor
+      def zip_extract(resource, download: true, fonts_sub_dir: "")
+        zip_file = download_file(resource) if download
+        zip_file ||= resource.urls.first
+
+        fonts_paths = unzip_fonts(zip_file, fonts_sub_dir)
+        block_given? ? yield(fonts_paths) : fonts_paths
+      end
+
+      alias_method :unzip, :zip_extract
+
+      private
+
+      def unzip_fonts(file, fonts_sub_dir = "")
+        Zip.on_exists_proc = true
+        Array.new.tap do |fonts|
+
+          Zip::File.open(file) do |zip_file|
+            zip_file.glob("#{fonts_sub_dir}*.{ttf,ttc,otf}").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)
+
+                entry.extract(font_path)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/lib/fontist/version.rb

@@ -0,0 +1,3 @@
+module Fontist
+  VERSION = "1.2.0".freeze
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/font_formula_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+RSpec.describe "Fontist::Formulas::DemoFormula" do
+  describe "initialization" do
+    it "registers formula resources through the DSL" do
+      formula = Fontist::Formulas::DemoFormula.instance
+      resource = formula.resources["demo-formula"]
+      demo_font = formula.font_list.first
+
+      expect(formula.key).to eq(:demo_formula)
+      expect(formula.license_required).to be_truthy
+      expect(formula.description).to eq("Demo font formula")
+      expect(formula.license).to eq("Vendor specific font licences")
+      expect(formula.homepage).to eq("https://github.com/fontist/fontist")
+
+      expect(resource[:file_size]).to eq("1234567890")
+      expect(resource[:urls].first).to eq("https://github.com/fontist/fontist")
+      expect(resource[:sha256]).to eq("594e0f42e6581add4dead70c1dfb9")
+
+      expect(demo_font[:styles].count).to eq(2)
+      expect(demo_font[:name]).to eq("Demo font")
+      expect(demo_font[:styles].first[:font]).to eq("demo-font.ttf")
+    end
+  end
+
+  describe "method invokation" do
+    it "invokes the correct method for installation" do
+      expect {
+        Fontist::Formulas::DemoFormula.fetch_font("Demo font", confirmation: "yes")
+      }.not_to raise_error
+    end
+  end
+
+  module Fontist
+    module Formulas
+      class DemoFormula < FontFormula
+        key :demo_formula
+        desc "Demo font formula"
+        homepage "https://github.com/fontist/fontist"
+        requires_license_agreement "Vendor specific font licences"
+
+        resource "demo-formula" do
+          urls [ "https://github.com/fontist/fontist" ]
+          sha256 "594e0f42e6581add4dead70c1dfb9"
+          file_size "1234567890"
+        end
+
+        provides_font "Demo font", match_styles_from_file: {
+          "Regular" => "demo-font.ttf",
+          "Italic" => "demo-fonti.ttf"
+        }
+
+        provides_font_collection("Meiryo Bold") do |coll|
+          filename "demo-font.ttc"
+          provides_font "Demo collection", extract_styles_from_collection: {
+            "Regular" => "demo-col-font.ttf",
+            "Italic" => "demo-col-fonti.ttf"
+          }
+        end
+
+        def extract
+          []
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/font_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+RSpec.describe Fontist::Font do
+  describe ".all" do
+    it "list all supported fonts" do
+      fonts = Fontist::Font.all
+
+      expect(fonts.count).to be > 10
+      expect(fonts.first.name).not_to be_nil
+      expect(fonts.first.styles).not_to be_nil
+    end
+  end
+
+  describe ".find" do
+    context "with valid font name" do
+      it "returns the fonts path" do
+        name = "DejaVuSerif.ttf"
+        stub_system_font_finder_to_fixture(name)
+        dejavu_ttf = Fontist::Font.find(name)
+
+        expect(dejavu_ttf.first).to include(name)
+      end
+    end
+
+    context "with downloadable font name" do
+      it "raises font missing error" do
+        name = "Courier"
+
+        allow(Fontist::SystemFont).to receive(:find).and_return(nil)
+        expect {
+          Fontist::Font.find(name)
+        }.to raise_error(Fontist::Errors::MissingFontError)
+      end
+    end
+
+    context "with invalid font name" do
+      it "raises font unsupported error" do
+        font_name = "InvalidFont.ttf"
+
+        expect {
+          Fontist::Font.find(font_name)
+        }.to raise_error(Fontist::Errors::NonSupportedFontError)
+      end
+    end
+  end
+
+  describe ".install" do
+    context "with valid font name" do
+      it "installs the font and return the paths" do
+        name = "Calibri"
+
+        stub_fontist_path_to_temp_path
+        font_paths = Fontist::Font.install(name, confirmation: "yes")
+
+        expect(font_paths.join("|").downcase).to include("#{name.downcase}.ttf")
+      end
+    end
+
+    context "with existing font name" do
+      it "returns the existing font paths" do
+        name = "Courier"
+        stub_fontist_path_to_temp_path
+        Fontist::Font.install(name, confirmation: "yes")
+
+        font_paths = Fontist::Font.install(name, confirmation: "yes")
+
+        expect(font_paths.count).to be > 3
+        expect(Fontist::Formulas::CourierFont).not_to receive(:fetch_font)
+      end
+    end
+
+    context "with unsupported fonts" do
+      it "raises an unsupported error" do
+        name = "Invalid font name"
+
+        expect {
+          Fontist::Font.install(name, confirmation: "yes")
+        }.to raise_error(Fontist::Errors::NonSupportedFontError)
+      end
+    end
+  end
+
+  def stub_system_font_finder_to_fixture(name)
+    allow(Fontist::SystemFont).to receive(:find).
+      and_return(["spec/fixtures/fonts/#{name}"])
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/formula_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+RSpec.describe Fontist::Formula do
+  describe ".find" do
+    context "by font name" do
+      it "returns the font formulas" do
+        name = "Calibri"
+
+        clear_type = Fontist::Formula.find(name)
+
+        expect(clear_type.fonts.map(&:name)).to include(name)
+        expect(clear_type.installer).to eq("Fontist::Formulas::ClearTypeFonts")
+        expect(clear_type.description).to include("Microsoft ClearType Fonts")
+      end
+    end
+
+    context "by exact font" do
+      it "returns the font formulas" do
+        name = "CAMBRIAI.TTF"
+
+        clear_type = Fontist::Formula.find(name)
+        font_files = clear_type.fonts.map { |font| font.styles.map(&:font) }
+
+        expect(font_files.flatten).to include(name)
+        expect(clear_type.installer).to eq("Fontist::Formulas::ClearTypeFonts")
+        expect(clear_type.description).to include("Microsoft ClearType Fonts")
+      end
+    end
+
+    context "for invalid font" do
+      it "returns nil to the caller" do
+        name = "Calibri Made Up Name"
+        formulas = Fontist::Formula.find(name)
+
+        expect(formulas).to be_nil
+      end
+    end
+  end
+
+  describe ".find_fonts" do
+    it "returns the exact font font names" do
+      name = "Calibri"
+      font = Fontist::Formula.find_fonts(name).last
+
+      expect(font.styles.map(&:font)).to include("CALIBRI.TTF")
+      expect(font.styles.map(&:font)).to include("CALIBRIB.TTF")
+      expect(font.styles.map(&:font)).to include("CALIBRII.TTF")
+    end
+
+    it "returns nil if invalid name provided" do
+      name = "Calibri Invlaid"
+      fonts = Fontist::Formula.find_fonts(name)
+
+      expect(fonts).to be_nil
+    end
+  end
+
+  describe ".all" do
+    it "returns all registered formulas" do
+      formulas = Fontist::Formula.all
+
+      expect(formulas.cleartype.fonts.count).to be > 10
+      expect(formulas.cleartype.homepage).to eq("https://www.microsoft.com")
+      expect(formulas.cleartype.description).to eq("Microsoft ClearType Fonts")
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/formulas/andale_font_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+RSpec.describe Fontist::Formulas::AndaleFont do
+  describe "initializing" do
+    it "builds the data dictionary" do
+      formula = Fontist::Formulas::AndaleFont.instance
+
+      expect(formula.fonts.count).to eq(1)
+      expect(formula.fonts.first[:name]).to eq("Andale Mono")
+    end
+  end
+
+  describe "installation" do
+    context "with valid licence agreement", slow: true do
+      it "installs the valid fonts", skip_in_windows: true do
+        name = "Andale Mono"
+        confirmation = "yes"
+
+        stub_fontist_path_to_temp_path
+        paths = Fontist::Formulas::AndaleFont.fetch_font(
+          name, confirmation: confirmation
+        )
+
+        expect(Fontist::Font.find(name)).not_to be_empty
+        expect(paths.first).to include("fonts/AndaleMo.TTF")
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/formulas/arial_black_font_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+RSpec.describe Fontist::Formulas::ArialBlackFont do
+  describe "initializing" do
+    it "builds the data dictionary" do
+      formula = Fontist::Formulas::ArialBlackFont.instance
+
+      expect(formula.fonts.count).to eq(1)
+      expect(formula.fonts.first[:name]).to eq("Arial Black")
+    end
+  end
+
+  describe "installation" do
+    context "with valid licence agreement", slow: true do
+      it "installs the valid fonts", skip_in_windows: true do
+        name = "Arial Black"
+        confirmation = "yes"
+
+        stub_fontist_path_to_temp_path
+        paths = Fontist::Formulas::ArialBlackFont.fetch_font(
+          name, confirmation: confirmation
+        )
+
+        expect(Fontist::Font.find(name)).not_to be_empty
+        expect(paths.first).to include("fonts/AriBlk.TTF")
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/formulas/cleartype_fonts_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+RSpec.describe Fontist::Formulas::ClearTypeFonts do
+  describe "initializing" do
+    it "builds the data dictionary" do
+      formula = Fontist::Formulas::ClearTypeFonts.instance
+
+      expect(formula.fonts.count).to eq(12)
+      expect(formula.fonts[1][:name]).to eq("Cambria Math")
+      expect(formula.fonts.first[:name]).to eq("Cambria")
+    end
+  end
+
+  describe "installation" do
+    context "with valid licence agreement", slow: true do
+      it "installs the valid fonts", skip_in_windows: true do
+        name = "Calibri"
+        confirmation = "yes"
+
+        paths = Fontist::Formulas::ClearTypeFonts.fetch_font(
+          name, confirmation: confirmation
+        )
+
+        expect(paths.first).to include("fonts/#{name.upcase}.TTF")
+      end
+    end
+
+    context "with missing licence agreement" do
+      it "raises an Fontist::Errors::LicensingError" do
+        name = "Calibri"
+
+        expect {
+          Fontist::Formulas::ClearTypeFonts.fetch_font(name, confirmation: "no")
+        }.to raise_error(Fontist::Errors::LicensingError)
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/fontist-1.2.0/spec/fontist/formulas/comic_font_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+RSpec.describe Fontist::Formulas::ComicFont do
+  describe "initializing" do
+    it "builds the data dictionary" do
+      formula = Fontist::Formulas::ComicFont.instance
+
+      expect(formula.fonts.count).to eq(1)
+      expect(formula.fonts.first[:name]).to eq("Comic Sans")
+    end
+  end
+
+  describe "installation" do
+    context "with valid licence agreement", slow: true do
+      it "installs the valid fonts", skip_in_windows: true do
+        name = "Comic Sans"
+        confirmation = "yes"
+
+        stub_fontist_path_to_temp_path
+        paths = Fontist::Formulas::ComicFont.fetch_font(
+          name, confirmation: confirmation
+        )
+
+        expect(Fontist::Font.find(name)).not_to be_empty
+        expect(paths.first).to include("fonts/Comicbd.TTF")
+      end
+    end
+  end
+end