metanorma 1.7.7 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d25e0a641fe7ce0087e3d06ebb5851e52a3c85924259e6cf39f731f378d7212
-  data.tar.gz: 5ae477f5ad66882bf1b22ee0f9511636c14f937d4f50eb9defa7c8122c874f7c
+  metadata.gz: 92e4b253c6c10fcce6aee6e827adec6281f79cd0e72e2ee84696af2bc288d0b1
+  data.tar.gz: 6bf08b8a123331df15d3ad9fc62d61b31ce3c53208cd14252830fee11c1b8977
 SHA512:
-  metadata.gz: 8375fbebae7cb30ae9775b5329c567274ad47cdfc40652f7cf35f00b3691629198dc3ee56c95f0c332b7edf63788ad0f2586ecb4305c18737bdbeed8c16bff91
-  data.tar.gz: 6e6f57ff7e26d519cfeea98daf8a027ff27fb39f02f0ac8928f2bfab01030fa866992172ef8f8f9ca7f666783afa2e878f412a4a79b7b9d62fbe86d9a2c8c2e7
+  metadata.gz: 9cda0f7b08169d3d9bb7aef6f25a372882f561310f5cf8913cae241398b83acae2c8d160be3d6ec1aa924a030e49d4058f2b42ff7f404c6ff8c4d906d8c126ec
+  data.tar.gz: 810ef3dd1033bcb57e7d097647dc5fa5f360310b15bf0e62d0056d62e67c2d290ec13c68720b0e080e1bc08ed5d13093928fb785c963ee276f9248c6473cf913

data/Gemfile

@@ -6,4 +6,8 @@ git_source(:github) { |repo| "https://github.com/#{repo}" }
 
 gemspec
 
-eval_gemfile("Gemfile.devel") rescue nil
+begin
+  eval_gemfile("Gemfile.devel")
+rescue StandardError
+  nil
+end

data/lib/metanorma/array_monkeypatch.rb

@@ -0,0 +1,9 @@
+# TODO sidesteps bibdata redefinition of filter, will remove
+
+module Metanorma
+  module ArrayMonkeypatch
+    class ::Array
+      alias filter select
+    end
+  end
+end

data/lib/metanorma/asciidoctor_extensions/glob_include_processor.rb

@@ -1,16 +1,18 @@
-module Metanorma::AsciidoctorExtensions
-  class GlobIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
-    def process(_doc, reader, target_glob, attributes)
-      Dir[File.join reader.dir, target_glob].sort.reverse_each do |target|
-        content = IO.readlines target
-        content.unshift "" unless attributes["adjoin-option"]
-        reader.push_include content, target, target, 1, attributes
+module Metanorma
+  module AsciidoctorExtensions
+    class GlobIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      def process(_doc, reader, target_glob, attributes)
+        Dir[File.join reader.dir, target_glob].sort.reverse_each do |target|
+          content = File.readlines target
+          content.unshift "" unless attributes["adjoin-option"]
+          reader.push_include content, target, target, 1, attributes
+        end
+        reader
       end
-      reader
-    end
 
-    def handles?(target)
-      target.include? "*"
+      def handles?(target)
+        target.include? "*"
+      end
     end
   end
 end

data/lib/metanorma/collection/collection.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "relaton"
+require "relaton/cli"
+require "metanorma-utils"
+require_relative "util/util"
+require_relative "util/disambig_files"
+require_relative "config/config"
+require_relative "config/manifest"
+
+module Metanorma
+  class FileNotFoundException < StandardError; end
+
+  class AdocFileNotFoundException < StandardError; end
+
+  # Metanorma collection of documents
+  class Collection
+    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, :documents, :bibdatas, :coverpage, :dirname
+    attr_accessor :disambig, :manifest, :bibdata, :compile, :config
+
+    # @param file [String] path to source file
+    # @param config [Metanorma::Collection::Config]
+    # @param documents [Hash<String, Metanorma::Collection::Document>]
+    def initialize(**args)
+      @file = args[:file]
+      @dirname = File.expand_path(File.dirname(@file)) # feeds @manifest
+      @documents = args[:documents] || {} # feeds initialize_directives
+      @bibdatas = args[:documents] || {}
+      initialize_vars
+      initialize_config(args[:config])
+      initialize_directives
+      @documents.merge! @manifest.documents
+      @bibdatas.merge! @manifest.documents
+      @documents.transform_keys { |k| Util::key(k) }
+      @bibdatas.transform_keys { |k| Util::key(k) }
+    end
+
+    def initialize_vars
+      @compile = Metanorma::Compile.new # feeds @manifest
+      @log = Metanorma::Utils::Log.new
+      @disambig = Util::DisambigFiles.new
+    end
+
+    def initialize_config(config)
+      @config = config
+      @directives = config.directive || [] # feeds initialize_directives
+      @bibdata = config.bibdata
+      @prefatory = config.prefatory_content
+      @final = config.final_content
+      @manifest = ::Metanorma::Collection::Manifest
+        .new(config.manifest, self, @dirname) # feeds initialize_directives
+    end
+
+    def initialize_directives
+      d = @directives.each_with_object({}) { |x, m| m[x.key] = x.value }
+      @coverpage = d["coverpage"]
+      @coverpage_style = d["coverpage-style"]
+      if (@documents.any? || @manifest) && !d.key?("documents-inline") &&
+          !d.key?("documents-external")
+        @directives << ::Metanorma::Collection::Config::Directive
+          .new(key: "documents-inline")
+      end
+    end
+
+    def clean_exit
+      @log.write(File.join(@dirname,
+                           "#{File.basename(@file, '.*')}.err.html"))
+    end
+
+    # @return [String] XML
+    def to_xml
+      c = ::Metanorma::Collection::Config::Config
+        .new(directive: @directives, bibdata: @bibdata,
+             manifest: @manifest.config, documents: @documents,
+             prefatory_content: @prefatory, final_content: @final)
+      c.collection = self
+      c.to_xml # .sub("<metanorma-collection", "<metanorma-collection xmlns='http://metanorma.org'")
+    end
+
+    def render(opts)
+      opts[:format].nil? || opts[:format].empty? and opts[:format] = [:html]
+      ::Metanorma::Collection::Renderer.render self, opts.merge(log: @log)
+      clean_exit
+    end
+
+    # @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)
+      (cnt = send(elm)) or return
+      @compile.load_flavor(doctype)
+      out = sections(dummy_header + cnt.strip)
+      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, &:huge).at("//xmlns:sections").children.to_xml
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def doccontainer(builder)
+      # Array(@directives).include? "documents-inline" or return
+      @directives.detect { |d| d.key == "documents-inline" } or return
+      documents.each_with_index do |(_, d), i|
+        doccontainer1(builder, d, i)
+      end
+    end
+
+    def doccontainer1(builder, doc, idx)
+      id = format("doc%<index>09d", index: idx)
+      builder.send(:"doc-container", id: id) do |b|
+        if doc.attachment
+          doc.bibitem and b << doc.bibitem.root.to_xml
+          b.attachment Vectory::Utils::datauri(doc.file)
+        else
+          doc.to_xml b
+        end
+      end
+    end
+
+    def doctype
+      @doctype ||= fetch_doctype || "standoc"
+    end
+
+    def fetch_doctype
+      docid = @bibdata.docidentifier.first
+      docid or return
+      docid.type&.downcase || docid.id&.sub(/\s.*$/, "")&.downcase
+    end
+
+    class << self
+      # @param Block [Proc]
+      # @note allow user-specific function to run in pre-parse model stage
+      def set_pre_parse_model(&block)
+        @pre_parse_model_proc = block
+      end
+
+      # @param Block [Proc]
+      # @note allow user-specific function to resolve identifier
+      def set_identifier_resolver(&block)
+        @identifier_resolver = block
+      end
+
+      # @param Block [Proc]
+      # @note allow user-specific function to resolve fileref
+      # NOTE: MUST ALWAYS RETURN PATH relative to working directory
+      # (initial YAML file location). @fileref_resolver.call(ref_folder, fileref)
+      # fileref is not what is in the YAML, but the resolved path
+      # relative to the working directory
+      def set_fileref_resolver(&block)
+        @fileref_resolver = block
+      end
+
+      def unset_fileref_resolver
+        @fileref_resolver = nil
+      end
+
+      # @param collection_model [Hash{String=>String}]
+      def pre_parse_model(collection_model)
+        @pre_parse_model_proc or return
+        @pre_parse_model_proc.call(collection_model)
+      end
+
+      # @param identifier [String]
+      # @return [String]
+      def resolve_identifier(identifier)
+        @identifier_resolver or return identifier
+        @identifier_resolver.call(identifier)
+      end
+
+      # @param fileref [String]
+      # @return [String]
+      def resolve_fileref(ref_folder, fileref)
+        unless @fileref_resolver
+          (Pathname.new fileref).absolute? or
+            fileref = File.join(ref_folder, fileref)
+          return fileref
+        end
+
+        @fileref_resolver.call(ref_folder, fileref)
+      end
+
+      # @param filepath
+      # @raise [FileNotFoundException]
+      def check_file_existence(filepath)
+        unless File.exist?(filepath)
+          error_message = "#{filepath} not found!"
+          ::Metanorma::Util.log("[metanorma] Error: #{error_message}", :error)
+          raise FileNotFoundException.new error_message.to_s
+        end
+      end
+
+      def parse(file)
+        # need @dirname initialised before collection object initialisation
+        @dirname = File.expand_path(File.dirname(file))
+        config = case file
+                 when /\.xml$/
+                   ::Metanorma::Collection::Config::Config.from_xml(File.read(file))
+                 when /.ya?ml$/
+                   y = YAML.safe_load(File.read(file))
+                   pre_parse_model(y)
+                   ::Metanorma::Collection::Config::Config.from_yaml(y.to_yaml)
+                 end
+        new(file: file, config: config)
+      end
+    end
+  end
+end

data/lib/metanorma/collection/config/bibdata.rb

@@ -0,0 +1,12 @@
+require "relaton"
+require "shale"
+
+module Metanorma
+  class Collection
+    module Config
+      class Bibdata < ::Shale::Mapper
+        model ::RelatonBib::BibliographicItem
+      end
+    end
+  end
+end

data/lib/metanorma/collection/config/compile_options.rb

@@ -0,0 +1,13 @@
+require "shale"
+
+module Metanorma
+  class Collection
+    module Config
+      class CompileOptions < ::Shale::Mapper
+        attribute :no_install_fonts, ::Shale::Type::Boolean,
+                  default: -> { true }
+        attribute :agree_to_terms, ::Shale::Type::Boolean, default: -> { true }
+      end
+    end
+  end
+end

data/lib/metanorma/collection/config/config.rb

@@ -0,0 +1,163 @@
+require "shale"
+require_relative "../../shale_monkeypatch"
+require_relative "../../array_monkeypatch"
+require_relative "compile_options"
+require_relative "converters"
+require_relative "bibdata"
+require_relative "directive"
+require_relative "manifest"
+
+module Metanorma
+  class Collection
+    module Config
+      require "shale/adapter/nokogiri"
+      ::Shale.xml_adapter = ::Shale::Adapter::Nokogiri
+
+      class Config < ::Shale::Mapper
+        attr_accessor :path, :collection, :from_xml
+
+        attribute :bibdata, Bibdata
+        attribute :directive, Directive, collection: true
+        attribute :manifest, Manifest
+        attribute :format, ::Shale::Type::String, collection: true,
+                                                  default: -> { [:html] }
+        attribute :output_folder, ::Shale::Type::String
+        attribute :coverpage, ::Shale::Type::String, default: -> {
+                                                                "cover.html"
+                                                              }
+        attribute :compile, CompileOptions
+        attribute :prefatory_content, ::Shale::Type::String
+        attribute :final_content, ::Shale::Type::String
+        attribute :documents, Bibdata, collection: true
+        attribute :xmlns, ::Shale::Type::String, default: -> { "http://metanorma.org" }
+
+        yaml do
+          map "directives", using: { from: :directives_from_yaml,
+                                     to: :directives_to_yaml }
+          map "bibdata", using: { from: :bibdata_from_yaml,
+                                  to: :bibdata_to_yaml }
+          map "manifest", to: :manifest
+          map "format", to: :format
+          map "output_folder", to: :output_folder
+          map "coverpage", to: :coverpage
+          map "compile", to: :compile
+          map "prefatory-content", to: :prefatory_content
+          map "final-content", to: :final_content
+        end
+
+        xml do
+          root "metanorma-collection"
+          # namespace "http://metanorma.org", "m"
+          # map_attribute "xmlns", to: :xmlns
+          map_element "bibdata", using: { from: :bibdata_from_xml,
+                                          to: :bibdata_to_xml }
+          map_element "directive", using: { from: :directive_from_xml,
+                                            to: :directive_to_xml }
+          map_element "entry", using: { from: :manifest_from_xml,
+                                        to: :manifest_to_xml }
+          map_element "format", to: :format
+          map_element "output_folder", to: :output_folder
+          map_element "coverpage", to: :coverpage
+          map_element "compile", to: :compile
+          map_element "prefatory-content", using: { from: :prefatory_from_xml,
+                                                    to: :prefatory_to_xml }
+          map_element "doc-container",
+                      using: { from: :documents_from_xml,
+                               to: :documents_to_xml }
+          map_element "final-content", using: { from: :final_from_xml,
+                                                to: :final_to_xml }
+        end
+
+        def manifest_from_xml(model, node)
+          model.manifest = Manifest.from_xml(node.to_xml)
+        end
+
+        def manifest_to_xml(model, parent, doc)
+          model.collection&.manifest&.clean_manifest(model.manifest)
+          doc.add_element(parent, model.manifest.to_xml)
+        end
+
+        def prefatory_from_xml(model, node)
+          model.prefatory_content = node.to_xml
+        end
+
+        def prefatory_to_xml(model, parent, doc)
+          content_to_xml(model, parent, doc, "prefatory")
+        end
+
+        def final_to_xml(model, parent, doc)
+          content_to_xml(model, parent, doc, "final")
+        end
+
+        def content_to_xml(model, parent, doc, type)
+          x = model.send("#{type}_content") or return
+          n = Nokogiri::XML(x)
+          elem = if n.elements.size == 1 then n.root
+                 else
+                   b = Nokogiri::XML::Builder.new
+                   model.collection.content_to_xml(type, b)
+                   b.parent.elements.first
+                 end
+          doc.add_element(parent, elem)
+        end
+
+        def final_from_xml(model, node)
+          model.final_content = node.to_xml
+        end
+
+        def directive_from_xml(model, node)
+          model.directive ||= []
+          model.directive << Directive.from_xml(node.to_xml)
+        end
+
+        def directive_to_xml(model, parent, doc)
+          Array(model.directive).each do |e|
+            elem = e.to_xml
+            doc.add_element(parent, elem)
+          end
+        end
+
+        def directives_from_yaml(model, value)
+          model.directive = value&.each_with_object([]) do |v, m|
+            m << case v
+                 when String then Directive.new(key: v)
+                 when Hash
+                   k = v.keys.first
+                   Directive.new(key: k, value: v[k])
+                 end
+          end
+        end
+
+        def directives_to_yaml(model, doc)
+          doc["directives"] = model.directive.each_with_object([]) do |d, m|
+            m << { d.key => d.value }
+          end
+        end
+
+        def documents_from_xml(model, value)
+          x = if value.is_a?(Shale::Adapter::Nokogiri::Node)
+                value.content
+              else Nokogiri::XML(value)
+              end
+          model.documents = x.xpath(".//bibdata")
+            .each_with_object([]) do |b, m|
+            m << Bibdata.from_xml(b.to_xml)
+          end
+        end
+
+        def documents_to_xml(model, parent, doc)
+          b = Nokogiri::XML::Builder.new do |xml|
+            xml.document do |m|
+              model.collection.doccontainer(m) or return
+            end
+          end
+          b.parent.elements.first.elements.each do |x|
+            doc.add_element(parent, x)
+          end
+        end
+
+        include Converters
+      end
+    end
+  end
+end

data/lib/metanorma/collection/config/converters.rb

@@ -0,0 +1,30 @@
+require "relaton-cli"
+
+module Metanorma
+  class Collection
+    module Config
+      module Converters
+        def bibdata_from_yaml(model, value)
+          value and !value.empty? or return
+          model.bibdata = Relaton::Cli::YAMLConvertor.convert_single_file(value)
+        end
+
+        def bibdata_to_yaml(model, doc)
+          doc["bibdata"] = model.bibdata&.to_hash
+        end
+
+        def bibdata_from_xml(model, node)
+          model.bibdata = Relaton::Cli.parse_xml(node.content)
+        end
+
+        def bibdata_to_xml(model, parent, doc)
+          b = model.bibdata or return
+          elem = b.to_xml(bibdata: true, date_format: :full)
+          doc.add_element(parent, elem)
+        end
+
+        def nop_to_yaml(model, doc); end
+      end
+    end
+  end
+end

data/lib/metanorma/collection/config/directive.rb

@@ -0,0 +1,10 @@
+module Metanorma
+  class Collection
+    module Config
+      class Directive < ::Shale::Mapper
+        attribute :key, ::Shale::Type::String
+        attribute :value, ::Shale::Type::String
+      end
+    end
+  end
+end

data/lib/metanorma/collection/config/manifest.rb

@@ -0,0 +1,88 @@
+require "shale"
+require_relative "../../shale_monkeypatch"
+require_relative "../../array_monkeypatch"
+require_relative "converters"
+require_relative "bibdata"
+
+module Metanorma
+  class Collection
+    module Config
+      require "shale/adapter/nokogiri"
+      ::Shale.xml_adapter = ::Shale::Adapter::Nokogiri
+
+      class Manifest < ::Shale::Mapper
+        attribute :identifier, ::Shale::Type::String,
+                  default: -> { UUIDTools::UUID.random_create.to_s }
+        attribute :id, ::Shale::Type::String
+        attribute :bibdata, Bibdata
+        attribute :type, ::Shale::Type::String
+        attribute :title, ::Shale::Type::String
+        attribute :url, ::Shale::Type::String
+        attribute :attachment, ::Shale::Type::Boolean
+        attribute :sectionsplit, ::Shale::Type::Boolean
+        attribute :index, ::Shale::Type::Boolean, default: -> { true }
+        attribute :entry, Manifest, collection: true
+        attribute :file, ::Shale::Type::String
+
+        yaml do
+          map "identifier", to: :identifier
+          map "type", to: :type
+          map "level", using: { from: :level_from_yaml, to: :nop_to_yaml }
+          map "title", to: :title
+          map "url", to: :url
+          map "attachment", to: :attachment
+          map "sectionsplit", to: :sectionsplit
+          map "index", to: :index
+          map "file", to: :file
+          map "fileref", using: { from: :fileref_from_yaml, to: :nop_to_yaml }
+          map "entry", to: :entry
+          map "docref", using: { from: :docref_from_yaml, to: :nop_to_yaml }
+          map "manifest", using: { from: :docref_from_yaml, to: :nop_to_yaml }
+          map "bibdata", using: { from: :bibdata_from_yaml,
+                                  to: :bibdata_to_yaml }
+        end
+
+        xml do
+          root "entry"
+          map_attribute "id", to: :id
+          map_attribute "attachment", to: :attachment
+          map_attribute "sectionsplit", to: :sectionsplit
+          map_attribute "index", to: :index
+          map_attribute "url", to: :url
+          map_attribute "fileref", to: :file
+          map_element "identifier", to: :identifier
+          map_element "type", to: :type
+          map_element "title", to: :title
+          map_element "bibdata", using: { from: :bibdata_from_xml,
+                                          to: :bibdata_to_xml }
+          map_element "entry", to: :entry # using: { from: :entry_from_xml, to: :entry_to_xml }
+        end
+
+        def entry_from_xml(model, node)
+          model.entry = Manifest.from_xml(node.content)
+        end
+
+        def entry_to_xml(model, parent, doc)
+          Array(model.entry).each do |e|
+            elem = e.to_xml
+            doc.add_element(parent, elem)
+          end
+        end
+
+        def level_from_yaml(model, value)
+          model.type ||= value
+        end
+
+        def fileref_from_yaml(model, value)
+          model.file ||= value
+        end
+
+        def docref_from_yaml(model, value)
+          model.entry = Manifest.from_yaml(value.to_yaml)
+        end
+
+        include Converters
+      end
+    end
+  end
+end