metanorma 1.1.2 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 969ed76602cb33778779c7ab04c8c4c4be5fd63e83b448c07f96e8fafa6c7afb
-  data.tar.gz: cf467c6615d1e5840a8c3accdd36195f269d4624307e94d2db6d56744a95cacb
+  metadata.gz: f6bdfc7913fb212cb141c23550aacaf2dd5c4261feea33946760a4b22af68298
+  data.tar.gz: 2a2fc2ae5c8b193b21063b368b8f6cac542dc98662e0376787d946020fe1e2b7
 SHA512:
-  metadata.gz: 64d4f4a2f7375bb804a5e0acae3a538e4306a0f0a4cfa5c4b8688a320d0fb65e1b977099a5d413bcf87f74ab084abb11496ed20842daa476c92bb08aa57623d2
-  data.tar.gz: eec76dfa55611c07335aa3c661b7926c0249338b9d6225fb3e58eb78d598b2cfee8fac19ebd1623721fa0fae441b451f04fd536dec7e728ae97d652626fca897
+  metadata.gz: 939e66856ea7e3bcdba7f67771606913e8510be72d52ac09dd22643cdc155b7cc2ed41c09a2a5fed32c322470ca44c2fe975c941eb0d0581d39f5cd775aac723
+  data.tar.gz: f6cf21861fe6154831fb4e47b93b88224bb3d65f37ea2496fd2c0c868e1836d1b590b1a67376229fefed57c019b97ec9ef5adef8a7d84d8ef0f8af9b29c322c8

data/.rubocop.yml

@@ -4,7 +4,3 @@
 
 inherit_from:
   - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
-AllCops:
-  TargetRubyVersion: 2.3
-Rails:
-  Enabled: true

data/lib/metanorma.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "metanorma/version"
 require "asciidoctor"
 require "metanorma/util"
@@ -8,7 +10,10 @@ require "metanorma/registry"
 require "metanorma/processor"
 require "metanorma/asciidoctor_extensions"
 require "metanorma/compile"
+require "metanorma/collection"
+require "metanorma/collection_renderer"
+require "metanorma/document"
 
+# Metanorma module
 module Metanorma
-
 end

data/lib/metanorma/collection.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "relaton"
+require "relaton/cli"
+require "metanorma/collection_manifest"
+
+module Metanorma
+  # Metanorma collection of documents
+  class Collection
+    # @return [String]
+    attr_reader :file
+
+    # @return [Array<String>] documents-inline to inject the XML into
+    #   the collection manifest; documents-external to keeps them outside
+    attr_accessor :directives
+
+    # @return [Hash<String, Metanorma::Document>]
+    attr_accessor :documents
+
+    # @param file [String] path to source file
+    # @param directives [Array<String>] documents-inline to inject the XML into
+    #   the collection manifest; documents-external to keeps them outside
+    # @param bibdata [RelatonBib::BibliographicItem]
+    # @param manifest [Metanorma::CollectionManifest]
+    # @param documents [Hash<String, Metanorma::Document>]
+    # @param prefatory [String]
+    # @param final [String]
+    # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+    def initialize(**args)
+      @file = args[:file]
+      @directives = args[:directives] || []
+      @bibdata = args[:bibdata]
+      @manifest = args[:manifest]
+      @manifest.collection = self
+      @documents = args[:documents] || {}
+      if @documents.any? && !@directives.include?("documents-inline")
+        @directives << "documents-inline"
+      end
+      @documents.merge! @manifest.documents(File.dirname(@file))
+      @prefatory = args[:prefatory]
+      @final = args[:final]
+    end
+    # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+
+    # @return [String] XML
+    def to_xml
+      Nokogiri::XML::Builder.new do |xml|
+        xml.send("metanorma-collection",
+                 "xmlns" => "http://metanorma.org") do |mc|
+          mc << @bibdata.to_xml(bibdata: true, date_format: :full)
+          @manifest.to_xml mc
+          content_to_xml "prefatory", mc
+          doccontainer mc
+          content_to_xml "final", mc
+        end
+      end.to_xml
+    end
+
+    def render(opts)
+      CollectionRenderer.render self, opts
+    end
+
+    class << self
+      # @param file [String]
+      # @return [RelatonBib::BibliographicItem,
+      #   RelatonIso::IsoBibliographicItem]
+      def parse(file)
+        case file
+        when /\.xml$/ then parse_xml(file)
+        when /.ya?ml$/ then parse_yaml(file)
+        end
+      end
+
+      private
+
+      def parse_xml(file)
+        xml = Nokogiri::XML File.read(file, encoding: "UTF-8")
+        if (b = xml.at("/xmlns:metanorma-collection/xmlns:bibdata"))
+          bd = Relaton::Cli.parse_xml b
+        end
+        mnf_xml = xml.at("/xmlns:metanorma-collection/xmlns:manifest")
+        mnf = CollectionManifest.from_xml mnf_xml
+        pref = pref_final_content xml.at("//xmlns:prefatory-content")
+        fnl = pref_final_content xml.at("//xmlns:final-content")
+        new(file: file, bibdata: bd, manifest: mnf,
+            documents: docs_from_xml(xml, mnf), prefatory: pref, final: fnl)
+      end
+
+      def parse_yaml(file)
+        yaml = YAML.load_file file
+        if yaml["bibdata"]
+          bd = Relaton::Cli::YAMLConvertor.convert_single_file yaml["bibdata"]
+        end
+        mnf = CollectionManifest.from_yaml yaml["manifest"]
+        dirs = yaml["directives"]
+        pref = yaml["prefatory-content"]
+        fnl = yaml["final-content"]
+        new(file: file, directives: dirs, bibdata: bd, manifest: mnf,
+            prefatory: pref, final: fnl)
+      end
+
+      # @param xml [Nokogiri::XML::Document]
+      # @parma mnf [Metanorma::CollectionManifest]
+      # @return [Hash{String=>Metanorma::Document}]
+      def docs_from_xml(xml, mnf)
+        xml.xpath("//xmlns:doc-container/*/xmlns:bibdata")
+          .each_with_object({}) do |b, m|
+          bd = Relaton::Cli.parse_xml b
+          docref = mnf.docref_by_id bd.docidentifier.first.id
+          m[docref["identifier"]] = Document.new bd, docref["fileref"]
+          m
+        end
+      end
+
+      # @param xml [Nokogiri::XML::Element, nil]
+      # @return [String, nil]
+      def pref_final_content(xml)
+        return unless xml
+
+        <<~CONT
+
+          == #{xml.at('title')&.text}
+          #{xml.at('p')&.text}
+        CONT
+      end
+    end
+
+    private
+
+    # @return [String, nil]
+    attr_reader :prefatory, :final
+
+    # @return [String]
+    def dummy_header
+      <<~DUMMY
+        = X
+        A
+
+      DUMMY
+    end
+
+    # @param elm [String] 'prefatory' or 'final'
+    # @param builder [Nokogiri::XML::Builder]
+    def content_to_xml(elm, builder)
+      return unless (cnt = send(elm))
+
+      require "metanorma-#{doctype}"
+      out = sections(dummy_header + cnt)
+      builder.send(elm + "-content") { |b| b << out }
+    end
+
+    # @param cnt [String] prefatory/final content
+    # @return [String] XML
+    def sections(cnt)
+      c = Asciidoctor.convert(cnt, backend: doctype.to_sym, header_footer: true)
+      Nokogiri::XML(c).at("//xmlns:sections").children.to_xml
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def doccontainer(builder)
+      return unless Array(@directives).include? "documents-inline"
+
+      documents.each_with_index do |(_, d), i|
+        id = format("doc%<index>09d", index: i)
+        builder.send("doc-container", id: id) { |b| d.to_xml b }
+      end
+    end
+
+    # @return [String]
+    def doctype
+      @doctype ||= fetch_doctype || "standoc"
+    end
+
+    # @return [String]
+    def fetch_doctype
+      docid = @bibdata.docidentifier.first
+      return unless docid
+
+      docid.type&.downcase || docid.id&.sub(/\s.*$/, "")&.downcase
+    end
+  end
+end

data/lib/metanorma/collection_manifest.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Metanorma
+  # Metanorma collection's manifest
+  class CollectionManifest
+    # @return [Metanorma::Collection]
+    attr_reader :collection
+
+    # @param level [String]
+    # @param title [String, nil]
+    # @param docref [Array<Hash{String=>String}>]
+    # @param manifest [Array<Metanorma::CollectionManifest>]
+    def initialize(level, title = nil, docref = [], manifest = [])
+      @level = level
+      @title = title
+      @docref = docref
+      @manifest = manifest
+    end
+
+    class << self
+      # @param mnf [Nokogiri::XML::Element]
+      # @return [Metanorma::CollectionManifest]
+      def from_yaml(mnf)
+        manifest = RelatonBib::HashConverter.array(mnf["manifest"]).map do |m|
+          from_yaml m
+        end
+        docref = RelatonBib::HashConverter.array mnf["docref"]
+        new(mnf["level"], mnf["title"], docref, manifest)
+      end
+
+      # @param mnf [Nokogiri::XML::Element]
+      # @return [Metanorma::CollectionManifest]
+      def from_xml(mnf)
+        level = mnf.at("level").text
+        title = mnf.at("title")&.text
+        manifest = mnf.xpath("xmlns:manifest").map { |m| from_xml(m) }
+        new(level, title, parse_docref(mnf), manifest)
+      end
+
+      private
+
+      # @param mnf [Nokogiri::XML::Element]
+      # @return [Hash{String=>String}]
+      def parse_docref(mnf)
+        mnf.xpath("xmlns:docref").map do |dr|
+          h = { "identifier" => dr.at("identifier").text }
+          h["fileref"] = dr[:fileref] if dr[:fileref]
+          h
+        end
+      end
+    end
+
+    # @param col [Metanorma::Collection]
+    def collection=(col)
+      @collection = col
+      @manifest.each { |mnf| mnf.collection = col }
+    end
+
+    # @param dir [String] path to coolection
+    # @return [Hash<String, Metanorma::Document>]
+    def documents(dir = "")
+      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
+      end
+      @manifest.reduce(docs) do |mem, mnf|
+        mem.merge mnf.documents(dir)
+      end
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.manifest do |b|
+        b.level @level
+        b.title @title if @title
+        docref_to_xml b
+        @manifest.each { |m| m.to_xml b }
+      end
+    end
+
+    # @return [Array<Hash{String=>String}>]
+    def docrefs
+      return @docrefs if @docrefs
+
+      drfs = @docref.map { |dr| dr }
+      @manifest.reduce(drfs) { |mem, mnf| mem + mnf.docrefs }
+    end
+
+    def docref_by_id(docid)
+      refs = docrefs
+      dref = refs.detect { |k| k["identifier"] == docid }
+      dref || docrefs.detect { |k| /^#{k["identifier"]}/ =~ docid }
+    end
+
+    private
+
+    # @param builder [Nokogiri::XML::Builder]
+    def docref_to_xml(builder)
+      @docref.each do |dr|
+        drf = builder.docref { |b| b.identifier dr["identifier"] }
+        drf[:fileref] = dr["fileref"]
+        if collection.directives.include?("documents-inline")
+          id = collection.documents.find_index { |k, _| k == dr["identifier"] }
+          drf[:id] = format("doc%<index>09d", index: id)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/collection_renderer.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require "isodoc"
+
+module Metanorma
+  # XML collection renderer
+  class CollectionRenderer
+    FORMATS = %i[html xml doc pdf].freeze
+
+    # This is only going to render the HTML collection
+    # @param xml [Metanorma::Collection] input XML collection
+    # @param folder [String] input folder
+    # @param options [Hash]
+    # @option options [String] :coverpage cover page HTML (Liquid template)
+    # @option options [Array<Symbol>] :format list of formats (xml,html,doc,pdf)
+    # @option options [String] :ourput_folder output directory
+    #
+    # We presuppose that the bibdata of the document is equivalent to that of
+    # the collection, and that the flavour gem can sensibly process it. We may
+    # need to enhance metadata in the flavour gems isodoc/metadata.rb with
+    # collection metadata
+    def initialize(xml, folder, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      check_options options
+      @xml = Nokogiri::XML xml # @xml is the collection manifest
+      @lang = @xml&.at(ns("//bibdata/language"))&.text || "en"
+      @script = @xml&.at(ns("//bibdata/script"))&.text || "Latn"
+      @doctype = doctype
+      require "metanorma-#{@doctype}"
+
+      # output processor for flavour
+      @isodoc = isodoc
+
+      @outdir = options[:output_folder]
+      @coverpage = options[:coverpage]
+      @format = options[:format]
+
+      # list of files in the collection
+      @files = read_files folder
+      FileUtils.rm_rf @outdir
+      FileUtils.mkdir_p @outdir
+    end
+
+    # @param col [Metanorma::Collection] XML collection
+    # @param options [Hash]
+    # @option options [String] :coverpage cover page HTML (Liquid template)
+    # @option options [Array<Synbol>] :format list of formats
+    # @option options [Strong] :ourput_folder output directory
+    def self.render(col, options = {})
+      folder = File.dirname col.file
+      cr = new(col.to_xml, folder, options)
+      cr.files
+      cr.concatenate(col, options)
+      cr.coverpage if options[:format]&.include?(:html)
+    end
+
+    def concatenate(col, options)
+      options[:format] << :presentation if options[:format].include?(:pdf)
+      options[:format].uniq.each do |e|
+        next unless %i(presentation xml).include?(e)
+        ext = e == :presentation ? "presentation.xml" : e.to_s
+        out = col.clone
+        out.directives << "documents-inline"
+        out.documents.keys.each do |id|
+          filename = @files[id][:outputs][e]
+          out.documents[id] = Metanorma::Document.raw_file(filename)
+        end
+        File.open(File.join(@outdir, "collection.#{ext}"), "w:UTF-8") { |f| f.write(out.to_xml) }
+      end
+      options[:format].include?(:pdf) and
+        pdfconv.convert(File.join(@outdir, "collection.presentation.xml"))
+    end
+
+    def pdfconv
+      x = Asciidoctor.load nil, backend: @doctype.to_sym
+      x.converter.pdf_converter(Dummy.new)
+    end
+
+    # Dummy class
+    class Dummy
+      def attr(_xyz); end
+    end
+
+    # The isodoc class for the metanorma flavour we are using
+    def isodoc # rubocop:disable Metrics/MethodLength
+      x = Asciidoctor.load nil, backend: @doctype.to_sym
+      isodoc = x.converter.html_converter(Dummy.new)
+      isodoc.i18n_init(@lang, @script) # read in internationalisation
+      # create the @meta class of isodoc, with "navigation" set to the index bar
+      # extracted from the manifest
+      nav = indexfile(@xml.at(ns("//manifest")))
+      i18n = isodoc.i18n
+      i18n.set(:navigation, nav)
+      isodoc.metadata_init(@lang, @script, i18n)
+      # populate the @meta class of isodoc with the various metadata fields
+      # native to the flavour; used to populate Liquid
+      isodoc.info(@xml, nil)
+      isodoc
+    end
+
+    # infer the flavour from the first document identifier; relaton does that
+    def doctype
+      if (docid = @xml&.at(ns("//bibdata/docidentifier/@type"))&.text)
+        dt = docid.downcase
+      elsif (docid = @xml&.at(ns("//bibdata/docidentifier"))&.text)
+        dt = docid.sub(/\s.*$/, "").lowercase
+      else return "standoc"
+      end
+      @registry = Metanorma::Registry.instance
+      @registry.alias(dt.to_sym)&.to_s || dt
+    end
+
+    def ns(xpath)
+      IsoDoc::Convert.new({}).ns(xpath)
+    end
+
+    # hash for each document in collection of document identifier to:
+    # document reference (fileref or id), type of document reference,
+    # and bibdata entry for that file
+    # @param path [String] path to collection
+    # @return [Hash{String=>Hash}]
+    def read_files(path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      files = {}
+      @xml.xpath(ns("//docref")).each do |d|
+        identifier = d.at(ns("./identifier")).text
+        files[identifier] = if d["fileref"]
+                              { type: "fileref",
+                                ref: File.join(path, d["fileref"]) }
+                            else { type: "id", ref: d["id"] }
+                            end
+        file, _filename = targetfile(files[identifier], true)
+        xml = Nokogiri::XML(file)
+        files[identifier][:anchors] = read_anchors(xml)
+        files[identifier][:bibdata] = xml.at(ns("//bibdata"))
+      end
+      files
+    end
+
+    # map locality type and label (e.g. "clause" "1") to id = anchor for
+    # a document
+    def read_anchors(xml)
+      ret = {}
+      xrefs = @isodoc.xref_init(@lang, @script, @isodoc, @isodoc.i18n, {})
+      xrefs.parse xml
+      xrefs.get.each do |k, v|
+        v[:label] && v[:type] || next
+        ret[v[:type]] ||= {}
+        ret[v[:type]][v[:label]] = k
+      end
+      ret
+    end
+
+    # populate liquid template of ARGV[1] with metadata extracted from
+    # collection manifest
+    def coverpage
+      File.open(File.join(@outdir, "index.html"), "w:UTF-8") do |f|
+        f.write @isodoc.populate_template(File.read(@coverpage))
+      end
+    end
+
+    # @param elm [Nokogiri::XML::Element]
+    # @return [String]
+    def indexfile_title(elm)
+      lvl = elm&.at(ns("./level"))&.text&.capitalize
+      lbl = elm&.at(ns("./title"))&.text
+      "#{lvl}#{lvl && lbl ? ': ' : ''}#{lbl}"
+    end
+
+    # uses the identifier to label documents; other attributes (title) can be
+    # looked up in @files[id][:bibdata]
+    #
+    # @param elm [Nokogiri::XML::Element]
+    # @param builder [Nokogiri::XML::Builder]
+    def indexfile_docref(elm, builder)
+      return "" unless elm.at(ns("./docref"))
+
+      builder.ul { |b| docrefs(elm, b) }
+    end
+
+    # @param elm [Nokogiri::XML::Element]
+    # @param builder [Nokogiri::XML::Builder]
+    def docrefs(elm, builder)
+      elm.xpath(ns("./docref")).each do |d|
+        identifier = d.at(ns("./identifier")).text
+        link = if d["fileref"] then d["fileref"].sub(/\.xml$/, ".html")
+               else d["id"] + ".html"
+               end
+        builder.li { builder.a identifier, href: link }
+      end
+    end
+
+    # single level navigation list, with hierarchical nesting
+    # if multiple lists are needed as separate HTML fragments, multiple
+    # instances of this function will be needed,
+    # and associated to different variables in the call to @isodoc.metadata_init
+    # (including possibly an array of HTML fragments)
+    #
+    # @param elm [Nokogiri::XML::Element]
+    # @return [String] XML
+    def indexfile(elm)
+      Nokogiri::HTML::Builder.new do |b|
+        b.ul do
+          b.li indexfile_title(elm)
+          indexfile_docref(elm, b)
+          elm.xpath(ns("./manifest")).each do |d|
+            b << indexfile(d)
+          end
+        end
+      end.doc.root.to_html
+    end
+
+    # return file contents + output filename for each file in the collection,
+    # given a docref entry
+    # @param data [Hash]
+    # @param read [Boolean]
+    # @return [Array<String, nil>]
+    def targetfile(data, read = false)
+      if data[:type] == "fileref" then ref_file data[:ref], read
+      else xml_file data[:id], read
+      end
+    end
+
+    # @param ref [String]
+    # @param read [Boolean]
+    # @return [Array<String, nil>]
+    def ref_file(ref, read)
+      file = File.read(ref, encoding: "utf-8") if read
+      filename = ref.sub(/\.xml$/, ".html")
+      [file, filename]
+    end
+
+    # @param id [String]
+    # @param read [Boolean]
+    # @return [Array<String, nil>]
+    def xml_file(id, read)
+      file = @xml.at(ns("//doc-container[@id = '#{id}']")).to_xml if read
+      filename = id + ".html"
+      [file, filename]
+    end
+
+    # @param bib [Nokogiri::XML::Element]
+    # @param identifier [String]
+    def update_bibitem(bib, identifier) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      docid = bib&.at(ns("./docidentifier"))&.text
+      unless @files[docid]
+        warn "Cannot find crossreference to document #{docid} in document "\
+          "#{identifier}!"
+        abort
+      end
+      id = bib["id"]
+      newbib = bib.replace(@files[docid][:bibdata])
+      newbib.name = "bibitem"
+      newbib["id"] = id
+      newbib&.at(ns("./ext"))&.remove
+      _file, url = targetfile(@files[docid], false)
+      uri_node = Nokogiri::XML::Node.new "uri", newbib
+      uri_node[:type] = "citation"
+      uri_node.content = url
+      newbib.at(ns("./docidentifier")).previous = uri_node
+    end
+
+    # TODO: update crossreferences to other files in the selection
+    # repo(current-metanorma-collection/ISO 17301-1:2016)
+    # replaced by
+    # bibdata of "ISO 17301-1:2016" in situ as bibitem
+    # Any erefs to that bibitem id are replaced with relative URL
+    # Preferably with anchor, and is a job to realise dynamic lookup of
+    # localities
+    # @param file [String] XML content
+    # @param identifier [String] docid
+    # @return [String] XML content
+    def update_xrefs(file, identifier)
+      docxml = Nokogiri::XML(file)
+      docxml.xpath(ns("//bibitem[not(ancestor::bibitem)]")).each do |b|
+        docid = b&.at(ns("./docidentifier[@type = 'repository']"))&.text
+        next unless docid && %r{^current-metanorma-collection/}.match(docid)
+
+        update_bibitem(b, identifier)
+        update_anchors(b, docxml, docid)
+      end
+      docxml.to_xml
+    end
+
+    # if there is a crossref to another document, with no anchor, retrieve the
+    # anchor given the locality, and insert it into the crossref
+    def update_anchors(bib, docxml, _id) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      docid = bib&.at(ns("./docidentifier"))&.text
+      docxml.xpath("//xmlns:eref[@citeas = '#{docid}']").each do |e|
+        e.at(ns(".//locality[@type = 'anchor']")).nil? || next
+        ins = e.at(ns("./localityStack")) || next
+        type = ins&.at(ns("./locality/@type"))&.text
+        ref = ins&.at(ns("./locality/referenceFrom"))&.text
+        (anchor = @files[docid][:anchors][type][ref]) || next
+        ref_from = Nokogiri::XML::Node.new "referenceFrom", bib
+        ref_from.content = anchor.sub(/^_/, "")
+        locality = Nokogiri::XML::Node.new "locality", bib
+        locality[:type] = "anchor"
+        locality.add_child ref_from
+        ins << locality
+      end
+    end
+
+    # process each file in the collection
+    # files are held in memory, and altered as postprocessing
+    def files # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @files.each do |identifier, x|
+        file, filename = targetfile(x, true)
+        file = update_xrefs(file, identifier)
+        Tempfile.open(["collection", ".xml"], encoding: "utf-8") do |f|
+          f.write(file)
+          f.close
+          # warn "metanorma compile -x html #{f.path}"
+          c = Compile.new
+          c.compile f.path, format: :asciidoc, extension_keys: @format
+          @files[identifier][:outputs] = {}
+          @format.each do |e|
+            ext = c.processor.output_formats[e]
+            fn = File.basename(filename).sub(/(?<=\.)[^\.]+$/, ext.to_s)
+            FileUtils.mv f.path.sub(/\.xml$/, ".#{ext}"), File.join(@outdir, fn)
+            @files[identifier][:outputs][e] = File.join(@outdir, fn)
+          end
+        end
+      end
+    end
+
+    private
+
+    # @param options [Hash]
+    # @raise [ArgumentError]
+    def check_options(options)
+      unless options[:format].is_a?(Array) && (FORMATS & options[:format]).any?
+        raise ArgumentError, "Need to specify formats (xml,html,pdf,doc)"
+      end
+      return if !options[:format].include?(:html) || options[:coverpage]
+
+      raise ArgumentError, "Need to specify a coverpage to render HTML"
+    end
+  end
+end

data/lib/metanorma/compile.rb

@@ -5,7 +5,7 @@ require "htmlentities"
 module Metanorma
   class Compile
     # @return [Array<String>]
-    attr_reader :errors
+    attr_reader :errors, :processor
 
     def initialize
       @registry = Metanorma::Registry.instance

data/lib/metanorma/document.rb

@@ -1,12 +1,93 @@
 module Metanorma
   class Document
+    # @return [Strin]
+    attr_reader :file
 
-    def initialize
-      @input_file
-      @input_format
-      @document_type
-      @output_formats
+    # @param bibitem [RelatonBib::BibliographicItem]
+    def initialize(bibitem, file, options = {})
+      @bibitem = bibitem
+      @file = file
+      @raw = options[:raw]
     end
 
+    class << self
+      # @param file [String] file path
+      # @return [Metanorma::Document]
+      def parse_file(file)
+        new bibitem(file), file
+      end
+
+      # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]
+      # @return [Metanorma::Document]
+      def parse_xml(xml)
+        new from_xml(xml)
+      end
+
+      # raw XML file, can be used to put in entire file instead of just bibitem
+      def raw_file(filename)
+        doc = Nokogiri::XML(File.read(filename, encoding: "UTF-8"))
+        new(doc, filename, raw: true)
+      end
+
+      private
+
+      # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]
+      # @return [RelatonBib::BibliographicItem,RelatonIso::IsoBibliographicItem]
+      def from_xml(xml)
+        Relaton::Cli.parse_xml xml.at("//xmlns:bibitem|//xmlns:bibdata")
+      end
+
+      # @param file [String]
+      # @return [Symbol] file type
+      def format(file)
+        case file
+        when /\.xml$/ then :xml
+        when /.ya?ml$/ then :yaml
+        end
+      end
+
+      # @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)
+        end
+      end
+    end
+
+    # @param builder [Nokogiri::XML::Builder, nil]
+    # @return [Nokogiri::XML::Builder, String]
+    def to_xml(builder = nil)
+      if builder
+        render_xml builder
+      else
+        Nokogiri::XML::Builder.new do |b|
+          root = render_xml b
+          root["xmlns"] = "http://metanorma.org"
+        end.to_xml
+      end
+    end
+
+    # @return [String]
+    def type
+      @type ||= (@bibitem.docidentifier.first&.type&.downcase ||
+                 @bibitem.docidentifier.first&.id&.match(/^[^\s]+/)&.to_s)&.downcase ||
+      "standoc"
+    end
+
+    private
+
+    def render_xml(builder)
+      if @raw
+        builder << @bibitem.root.to_xml
+      else
+        builder.send(type + "-standard") { |b| b << @bibitem.to_xml(bibdata: true) }
+      end
+    end
   end
 end

data/lib/metanorma/input/asciidoc.rb

@@ -7,8 +7,7 @@ module Metanorma
 
       def process(file, filename, type, options = {})
         require "asciidoctor"
-        ::Asciidoctor.convert(
-          file,
+        out_opts = {
           to_file: false,
           safe: :safe,
           backend: type,
@@ -16,8 +15,28 @@ module Metanorma
           attributes: [
             "nodoc", "stem", "xrefstyle=short", "docfile=#{filename}",
             "output_dir=#{options[:"output-dir"]}"
-          ],
-        )
+          ]
+        }
+        unless asciidoctor_validate(file, filename, out_opts)
+          warn "Cannot continue compiling Asciidoctor document"
+          abort
+        end
+        ::Asciidoctor.convert(file, out_opts)
+      end
+
+      def asciidoctor_validate(file, filename, options)
+        err = nil
+        begin
+          previous_stderr, $stderr = $stderr, StringIO.new
+          ::Asciidoctor.load(file, options)
+          %r{(\n|^)asciidoctor: ERROR: ['"]?#{Regexp.escape(filename || 
+            "<empty>")}['"]?: line \d+: include file not found: }.match($stderr.string) and
+              err = $stderr.string
+        ensure
+          $stderr = previous_stderr
+        end
+        warn err unless err.nil?
+        err.nil?
       end
 
       def extract_metanorma_options(file)

data/lib/metanorma/output/xslfo.rb

@@ -4,10 +4,16 @@ require_relative "./utils.rb"
 module Metanorma
   module Output
     class XslfoPdf < Base
-      def convert(url_path, output_path, xsl_stylesheet)
+      def convert(url_path, output_path, xsl_stylesheet, options = "")
         return if url_path.nil? || output_path.nil? || xsl_stylesheet.nil?
 
-        Mn2pdf.convert(url_path, output_path, xsl_stylesheet)
+        Mn2pdf.convert(quote(url_path), quote(output_path), quote(xsl_stylesheet), options)
+      end
+
+      def quote(x)
+        return x if /^'.*'$/.match(x)
+        return x if /^".*"$/.match(x)
+        %("#{x}")
       end
     end
   end

data/lib/metanorma/version.rb

@@ -1,3 +1,3 @@
 module Metanorma
-  VERSION = "1.1.2"
+  VERSION = "1.1.7"
 end

data/metanorma.gemspec

@@ -27,11 +27,16 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'htmlentities'
   spec.add_runtime_dependency 'nokogiri'
   spec.add_runtime_dependency 'mn2pdf', "~> 1"
+# get relaton-cli to avoic circular reference with metanorma-standoc
+  #spec.add_dependency "relaton-cli"
+  #spec.add_dependency "metanorma-standoc", "~> 1.5.3"
 
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "byebug", "~> 10.0"
   spec.add_development_dependency "rspec-command", "~> 1.0"
   spec.add_development_dependency "equivalent-xml", "~> 0.6"
-  spec.add_development_dependency "metanorma-iso", "~> 1.4"
+  spec.add_development_dependency "metanorma-iso", "~> 1.5.8"
+  spec.add_development_dependency "sassc", "~> 2.4.0"
+  #spec.add_development_dependency "isodoc", "~> 1.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-10 00:00:00.000000000 Z
+date: 2020-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -142,14 +142,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.5.8
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.5.8
+- !ruby/object:Gem::Dependency
+  name: sassc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.0
 description: Library to process any Metanorma standard.
 email:
 - open.source@ribose.com
@@ -182,6 +196,9 @@ files:
 - lib/metanorma.rb
 - lib/metanorma/asciidoctor_extensions.rb
 - lib/metanorma/asciidoctor_extensions/glob_include_processor.rb
+- lib/metanorma/collection.rb
+- lib/metanorma/collection_manifest.rb
+- lib/metanorma/collection_renderer.rb
 - lib/metanorma/compile.rb
 - lib/metanorma/config.rb
 - lib/metanorma/document.rb