metanorma 1.2.6 → 1.3.2

data/lib/metanorma/collection_manifest.rb

@@ -45,6 +45,7 @@ module Metanorma
         mnf.xpath("xmlns:docref").map do |dr|
           h = { "identifier" => dr.at("identifier").text }
           h["fileref"] = dr[:fileref] if dr[:fileref]
+          h["attachment"] = dr[:attachment] if dr[:attachment]
           h
         end
       end
@@ -62,12 +63,13 @@ module Metanorma
       docs = @docref.each_with_object({}) do |dr, m|
         next m unless dr["fileref"]
 
-        m[dr["identifier"]] = Document.parse_file File.join(dir, dr["fileref"])
+        m[dr["identifier"]] = Document.parse_file(
+          File.join(dir, dr["fileref"]),
+          dr["attachment"], dr["identifier"]
+        )
         m
       end
-      @manifest.reduce(docs) do |mem, mnf|
-        mem.merge mnf.documents(dir)
-      end
+      @manifest.reduce(docs) { |mem, mnf| mem.merge mnf.documents(dir) }
     end
 
     # @param builder [Nokogiri::XML::Builder]
@@ -101,6 +103,7 @@ module Metanorma
       @docref.each do |dr|
         drf = builder.docref { |b| b.identifier dr["identifier"] }
         drf[:fileref] = dr["fileref"]
+        drf[:attachment] = dr["attachment"] if dr["attachment"]
         if collection.directives.include?("documents-inline")
           id = collection.documents.find_index { |k, _| k == dr["identifier"] }
           drf[:id] = format("doc%<index>09d", index: id)

data/lib/metanorma/collection_renderer.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "isodoc"
-require_relative "./collection_fileprocess"
+require_relative "collection_fileprocess"
+require_relative "fontist_utils"
 
 module Metanorma
   # XML collection renderer
@@ -64,6 +65,7 @@ module Metanorma
         out = col.clone
         out.directives << "documents-inline"
         out.documents.keys.each do |id|
+          next if @files[id][:attachment]
           filename = @files[id][:outputs][e]
           out.documents[id] = Metanorma::Document.raw_file(filename)
         end
@@ -74,13 +76,27 @@ module Metanorma
     end
 
     def pdfconv
-      x = Asciidoctor.load nil, backend: @doctype.to_sym
-      x.converter.pdf_converter(Dummy.new)
+      doctype = @doctype.to_sym
+      x = Asciidoctor.load nil, backend: doctype
+      x.converter.pdf_converter(PdfOptionsNode.new(doctype, @compile_options))
+    end
+
+    class PdfOptionsNode
+      def initialize(doctype, options)
+        doc_proc = Metanorma::Registry.instance.find_processor(doctype)
+        @font_locations = FontistUtils.fontist_font_locations(doc_proc, options)
+      end
+
+      def attr(key)
+        if key == "mn2pdf-font-manifest-file" && @font_locations
+          @font_locations.path
+        end
+      end
     end
 
     # Dummy class
     class Dummy
-      def attr(_xyz); end
+      def attr(_key); end
     end
 
     # The isodoc class for the metanorma flavour we are using

data/lib/metanorma/compile.rb

@@ -1,9 +1,11 @@
 require "fileutils"
 require "nokogiri"
 require "htmlentities"
-
+require "yaml"
 require "fontist"
 require "fontist/manifest/install"
+require_relative "compile_validate"
+require_relative "fontist_utils"
 
 module Metanorma
   class Compile
@@ -24,23 +26,19 @@ module Metanorma
       (file, isodoc = process_input(filename, options)) or return nil
       relaton_export(isodoc, options)
       extract(isodoc, options[:extract], options[:extract_type])
-      install_fonts(options)
+      FontistUtils.install_fonts(@processor, options)
       process_extensions(extensions, file, isodoc, options)
     end
 
     def require_libraries(options)
-      if options[:require]
-        options[:require].each do |r|
-          require r
-        end
-      end
+      options&.dig(:require)&.each { |r| require r }
     end
 
     def xml_options_extract(file)
       xml = Nokogiri::XML(file)
       if xml.root
         @registry.root_tags.each do |k, v|
-          return { type: k }  if v == xml.root.name
+          return { type: k } if v == xml.root.name
         end
       end
       {}
@@ -62,48 +60,6 @@ module Metanorma
       options
     end
 
-    def validate_type(options)
-      unless options[:type]
-        Util.log("[metanorma] Error: Please specify a standard type: #{@registry.supported_backends}.", :error)
-        return nil
-      end
-
-      stdtype = options[:type].to_sym
-      metanorma_flavor = "metanorma-#{stdtype}"
-
-      unless @registry.supported_backends.include? stdtype
-        Util.log("[metanorma] Info: Loading `#{metanorma_flavor}` gem for standard type `#{stdtype}`.", :info)
-      end
-
-      begin
-        require "metanorma-#{stdtype}"
-        Util.log("[metanorma] Info: gem `#{metanorma_flavor}` loaded.", :info)
-
-      rescue Gem::ConflictError
-        Util.log("[metanorma] Error: Couldn't resolve dependencies for `metanorma-#{stdtype}`, Please add it to your Gemfile and run bundle install first", :error)
-        return false
-
-      rescue LoadError
-        Util.log("[metanorma] Error: loading gem `#{metanorma_flavor}` failed. Exiting.", :error)
-        return false
-      end
-
-      unless @registry.supported_backends.include? stdtype
-        Util.log("[metanorma] Error: The `#{metanorma_flavor}` gem still doesn't support `#{stdtype}`. Exiting.", :error)
-        return false
-      end
-
-      true
-    end
-
-    def validate_format(options)
-      unless options[:format] == :asciidoc
-        Util.log("[metanorma] Error: Only source file format currently supported is 'asciidoc'.", :error)
-        return false
-      end
-      true
-    end
-
     def get_extensions(options)
       options[:extension_keys] ||= @processor.output_formats.reduce([]) do |memo, (k, _)|
         memo << k
@@ -120,7 +76,7 @@ module Metanorma
       end
       if !extensions.include?(:presentation) and extensions.any? { |e| @processor.use_presentation_xml(e) }
         extensions << :presentation
-        end
+      end
       extensions
     end
 
@@ -186,7 +142,7 @@ module Metanorma
       xml.xpath("//sourcecode | //xmlns:sourcecode").each_with_index do |s, i|
         filename = s["filename"] || sprintf("sourcecode-%04d.txt", i)
         File.open("#{dirname}/sourcecode/#{filename}", "w:UTF-8") do |f|
-          f.write clean_sourcecode(s.dup) 
+          f.write clean_sourcecode(s.dup)
         end
       end
     end
@@ -196,6 +152,7 @@ module Metanorma
       FileUtils.mkdir_p "#{dirname}/image"
       xml.xpath("//image | //xmlns:image").each_with_index do |s, i|
         next unless /^data:image/.match s["src"]
+
         %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"]
         filename = s["filename"] || sprintf("image-%04d.%s", i, imgtype)
         File.open("#{dirname}/image/#{filename}", "wb") do |f|
@@ -221,22 +178,22 @@ module Metanorma
 
     # dependency ordering
     def sort_extensions_execution(ext)
-       case ext
-       when :xml then 0
-       when :rxl then 1
-       when :presentation then 2
-       else
-         99
-       end
+      case ext
+      when :xml then 0
+      when :rxl then 1
+      when :presentation then 2
+      else
+        99
+      end
     end
 
     def wrap_html(options, file_extension, outfilename)
-      if options[:wrapper] and /html$/.match file_extension
-          outfilename = outfilename.sub(/\.html$/, "")
-          FileUtils.mkdir_p outfilename
-          FileUtils.mv "#{outfilename}.html", outfilename
-          FileUtils.mv "#{outfilename}_images", outfilename, force: true
-        end
+      if options[:wrapper] && /html$/.match(file_extension)
+        outfilename = outfilename.sub(/\.html$/, "")
+        FileUtils.mkdir_p outfilename
+        FileUtils.mv "#{outfilename}.html", outfilename
+        FileUtils.mv "#{outfilename}_images", outfilename, force: true
+      end
     end
 
     # isodoc is Raw Metanorma XML
@@ -249,8 +206,14 @@ module Metanorma
       end.each do |ext|
         isodoc_options = @processor.extract_options(file)
         isodoc_options[:datauriimage] = true if options[:datauriimage]
+        isodoc_options[:sourcefilename] = options[:filename]
         file_extension = @processor.output_formats[ext]
         outfilename = f.sub(/\.[^.]+$/, ".#{file_extension}")
+        if ext == :pdf
+          font_locations = FontistUtils.fontist_font_locations(@processor, options)
+          font_locations and
+            isodoc_options[:mn2pdf] = { font_manifest_file: font_locations.path }
+        end
         if ext == :rxl
           options[:relaton] = outfilename
           relaton_export(isodoc, options)
@@ -260,66 +223,20 @@ module Metanorma
               @processor.output(nil, presentationxml_name, outfilename, ext, isodoc_options) :
               @processor.output(isodoc, xml_name, outfilename, ext, isodoc_options)
           rescue StandardError => e
-            puts e.message
-            puts e.backtrace.join("\n")
+            if e.message.include? "Fatal:"
+              @errors << e.message
+            else
+              puts e.message
+              puts e.backtrace.join("\n")
+            end
           end
         end
         wrap_html(options, file_extension, outfilename)
       end
     end
 
-    def install_fonts(options)
-      if options[:no_install_fonts]
-        Util.log("[fontist] Skip font installation because" \
-          " --no-install-fonts argument passed", :debug)
-        return
-      end
-
-      if !@processor.respond_to?(:fonts_manifest) || @processor.fonts_manifest.nil?
-        Util.log("[fontist] Skip font installation because font_manifest is missing", :debug)
-        return
-      end
-
-      @updated_formulas_repo = false
-
-      manifest = @processor.fonts_manifest
-      agree_to_terms = options[:agree_to_terms] || false
-      continue_without_fonts = options[:continue_without_fonts] || false
-
-      install_fonts_safe(manifest, agree_to_terms, continue_without_fonts)
-    end
-
     private
 
-    def install_fonts_safe(manifest, agree, continue)
-      fontist_install(manifest, agree)
-    rescue Fontist::Errors::LicensingError
-      if continue
-        Util.log("[fontist] Processing will continue without fonts installed", :debug)
-      else
-        Util.log("[fontist] Aborting without proper fonts installed," \
-          " make sure that you have set option --agree-to-terms", :fatal)
-      end
-    rescue Fontist::Errors::FontError => e
-      log_level = continue ? :warning : :fatal
-      Util.log("[fontist] '#{e.font}' font is not supported. " \
-        "Please report this issue at github.com/metanorma/metanorma-#{@processor.short}/issues" \
-        " to report this issue.", log_level)
-    rescue Fontist::Errors::FormulaIndexNotFoundError
-      Util.log("[fontist] Bug: formula index not found after 'fontist update'", :fatal) if @updated_formulas_repo
-      Util.log("[fontist] Missing formula index. Fetching it...", :debug)
-      Fontist::Formula.update_formulas_repo
-      @updated_formulas_repo = true
-      install_fonts_safe(manifest, agree, continue)
-    end
-
-    def fontist_install(manifest, agree)
-      Fontist::Manifest::Install.from_hash(
-        manifest,
-        confirmation: agree ? "yes" : "no"
-      )
-    end
-
     # @param options [Hash]
     # @return [String]
     def change_output_dir(options)

data/lib/metanorma/compile_validate.rb

@@ -0,0 +1,45 @@
+module Metanorma
+  class Compile
+    def validate_type(options)
+      unless options[:type]
+        Util.log("[metanorma] Error: Please specify a standard type: "\
+                 "#{@registry.supported_backends}.", :error)
+        return nil
+      end
+      stdtype = options[:type].to_sym
+      metanorma_flavor = "metanorma-#{stdtype}"
+      unless @registry.supported_backends.include? stdtype
+        Util.log("[metanorma] Info: Loading `#{metanorma_flavor}` gem "\
+                 "for standard type `#{stdtype}`.", :info)
+      end
+      begin
+        require "metanorma-#{stdtype}"
+        Util.log("[metanorma] Info: gem `#{metanorma_flavor}` loaded.", :info)
+      rescue Gem::ConflictError
+        Util.log("[metanorma] Error: Couldn't resolve dependencies for "\
+                 "`metanorma-#{stdtype}`, Please add it to your Gemfile "\
+                 "and run bundle install first", :error)
+        return false
+      rescue LoadError
+        Util.log("[metanorma] Error: loading gem `#{metanorma_flavor}` "\
+                 "failed. Exiting.", :error)
+        return false
+      end
+      unless @registry.supported_backends.include? stdtype
+        Util.log("[metanorma] Error: The `#{metanorma_flavor}` gem "\
+                 "still doesn't support `#{stdtype}`. Exiting.", :error)
+        return false
+      end
+      true
+    end
+
+    def validate_format(options)
+      unless options[:format] == :asciidoc
+        Util.log("[metanorma] Error: Only source file format currently "\
+                 "supported is 'asciidoc'.", :error)
+        return false
+      end
+      true
+    end
+  end
+end

data/lib/metanorma/config.rb

@@ -15,7 +15,7 @@ module Metanorma
     attr_accessor :logs
 
     def initialize
-      @logs ||= [:warning, :error, :fatal]
+      @logs ||= %i[warning error fatal]
     end
   end
 

data/lib/metanorma/document.rb

@@ -1,20 +1,25 @@
 module Metanorma
   class Document
     # @return [Strin]
-    attr_reader :file
+    attr_reader :file, :attachment, :bibitem
 
     # @param bibitem [RelatonBib::BibliographicItem]
     def initialize(bibitem, file, options = {})
       @bibitem = bibitem
       @file = file
+      @attachment = options[:attachment]
       @raw = options[:raw]
     end
 
     class << self
       # @param file [String] file path
+      # @param attachment [Bool] is an attachment
+      # @param identifier [String] is the identifier assigned the file
+      # in the collection file
       # @return [Metanorma::Document]
-      def parse_file(file)
-        new bibitem(file), file
+      def parse_file(file, attachment, identifier = nil)
+        new(bibitem(file, attachment, identifier), file,
+            { attachment: attachment })
       end
 
       # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]
@@ -29,6 +34,12 @@ module Metanorma
         new(doc, filename, raw: true)
       end
 
+      def attachment_bibitem(identifier)
+        Nokogiri::XML(
+          "<bibdata><docidentifier>#{identifier}</docidentifier></bibdata>",
+        )
+      end
+
       private
 
       # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]
@@ -49,13 +60,16 @@ module Metanorma
       # @param file [String]
       # @return [RelatonBib::BibliographicItem,
       #   RelatonIso::IsoBibliographicItem]
-      def bibitem(file)
-        case format(file)
-        when :xml
-          from_xml Nokogiri::XML(File.read(file, encoding: "UTF-8"))
-        when :yaml
-          yaml = File.read(file, encoding: "UTF-8")
-          Relaton::Cli::YAMLConvertor.convert_single_file(yaml)
+      def bibitem(file, attachment, identifier)
+        if attachment then attachment_bibitem(identifier)
+        else
+          case format(file)
+          when :xml
+            from_xml Nokogiri::XML(File.read(file, encoding: "UTF-8"))
+          when :yaml
+            yaml = File.read(file, encoding: "UTF-8")
+            Relaton::Cli::YAMLConvertor.convert_single_file(yaml)
+          end
         end
       end
     end

data/lib/metanorma/fontist_utils.rb

@@ -0,0 +1,108 @@
+module Metanorma
+  class FontistUtils
+    class << self
+      private
+
+      def validate_options(options)
+        agree_to_terms = options[:agree_to_terms] || false
+        continue_without_fonts = options[:continue_without_fonts] || false
+        no_progress = options[:no_progress] || false
+
+        [agree_to_terms, continue_without_fonts, no_progress]
+      end
+
+      def validate_install_fonts(processor, options)
+        if options[:no_install_fonts]
+          Util.log("[fontist] Skip font installation because" \
+                   " --no-install-fonts argument passed", :debug)
+          return false
+        elsif missing_fontist_manifest?(processor)
+          Util.log("[fontist] Skip font installation because "\
+                   "font_manifest is missing", :debug)
+          return false
+        end
+        true
+      end
+
+      def install_fonts_safe(manifest, agree, continue, no_progress)
+        fontist_install(manifest, agree, no_progress)
+      rescue Fontist::Errors::LicensingError
+        if continue
+          Util.log(
+            "[fontist] Processing will continue without fonts installed",
+            :debug
+          )
+        else
+          Util.log("[fontist] Aborting without proper fonts installed," \
+                   " make sure that you have set option --agree-to-terms",
+                   :fatal)
+        end
+      rescue Fontist::Errors::FontError => e
+        log_level = continue ? :warning : :fatal
+        Util.log("[fontist] '#{e.font}' font is not supported. " \
+                 "Please report this issue at github.com/metanorma/metanorma" \
+                 "/issues to report this issue.", log_level)
+      rescue Fontist::Errors::FormulaIndexNotFoundError
+        if @@updated_formulas_repo
+          Util.log(
+            "[fontist] Bug: formula index not found after 'fontist update'",
+            :fatal
+          )
+        end
+        Util.log("[fontist] Missing formula index. Fetching it...", :debug)
+        Fontist::Formula.update_formulas_repo
+        @@updated_formulas_repo = true
+        install_fonts_safe(manifest, agree, continue, no_progress)
+      end
+
+      def fontist_install(manifest, agree, no_progress)
+        Fontist::Manifest::Install.from_hash(
+          manifest,
+          confirmation: agree ? "yes" : "no",
+          no_progress: no_progress
+        )
+      end
+
+      def dump_fontist_manifest_locations(manifest)
+        location_manifest = Fontist::Manifest::Locations.from_hash(
+          manifest
+        )
+        location_manifest_file = Tempfile.new(["fontist_locations", ".yml"])
+        location_manifest_file.write location_manifest.to_yaml
+        location_manifest_file.flush
+        location_manifest_file
+      end
+
+      def missing_fontist_manifest?(processor)
+        !processor.respond_to?(:fonts_manifest) || processor.fonts_manifest.nil?
+      end
+    end
+
+    def self.install_fonts(processor, options)
+      return unless validate_install_fonts(processor, options)
+
+      @@updated_formulas_repo = false
+      manifest = processor.fonts_manifest
+      agree_to_terms, can_without_fonts, no_progress = validate_options(options)
+
+      install_fonts_safe(
+        manifest,
+        agree_to_terms,
+        can_without_fonts,
+        no_progress
+      )
+    end
+
+    def self.fontist_font_locations(processor, options)
+      if missing_fontist_manifest?(processor) || options[:no_install_fonts]
+        return nil
+      end
+
+      dump_fontist_manifest_locations(processor.fonts_manifest)
+    rescue Fontist::Errors::FormulaIndexNotFoundError
+      raise unless options[:continue_without_fonts]
+
+      nil
+    end
+  end
+end