metanorma 2.2.9 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f949939db63522ce80839447f7a4a2c860f2b6c1a8a8bef299bb12e5a375f23c
-  data.tar.gz: cd92ed471004f16de40d4c0e02bc457a7a2492a4b0a92729a1b36d312eef2672
+  metadata.gz: 19c34c2ef752fa708266aa2ace4d50d685ddd1c6089425988c44a6bd597c1c1c
+  data.tar.gz: 96b255a5cee296cfce50666c4a9e5f90807c61a2242626d60335e33d435d5570
 SHA512:
-  metadata.gz: f85234d7dea81dda16e4c66d1f883666bd1f9b7382ab6bd20770e75f3dc04ad940d78a54a49c2df7dfc25859f1434f5559233ce8c2eb585761397b7fcb0d22af
-  data.tar.gz: 4bddae518329cebca7cf762666c0d769243524a40c595f3ea7e94db33fad26fc3daaf26598c73a85b3ab12d13cd974a5a89ce7a1548ef679bec00156de8e6608
+  metadata.gz: 34240a210ea5f8570f4d3cc422f6fe6e42884dbfef72efb9f19c3087ded496230c5be8565e2d9f3ba2d42d5d7b991da75bad1fa637cc433c5893b86ee41888cb
+  data.tar.gz: eba23b08ef0b0eeb3ea6753bd73695ad84702d1ce5a7f1059f480873989f500e30ccd70bd8318f7570429e8d7f13ca6b4d2d4e6fe413c2bfd3799820472039ca

data/Gemfile

@@ -11,3 +11,17 @@ begin
 rescue StandardError
   nil
 end
+
+gem "debug"
+gem "equivalent-xml"
+#gem "metanorma-iho"
+#gem "metanorma-iso", ">= 3.2.0"
+gem "mnconvert"
+gem "pry"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rspec-command", "~> 1.0"
+gem "rubocop", "~> 1"
+gem "rubocop-performance"
+gem "sassc-embedded", "~> 1"
+gem "simplecov", "~> 0.15"

data/lib/metanorma/collection/collection.rb

@@ -4,6 +4,7 @@ require_relative "util/util"
 require_relative "util/disambig_files"
 require_relative "config/config"
 require_relative "config/manifest"
+require_relative "helpers"
 
 module Metanorma
   class FileNotFoundException < StandardError; end
@@ -12,12 +13,13 @@ module Metanorma
 
   # Metanorma collection of documents
   class Collection
-    attr_reader :file
+    attr_reader :file, :prefatory, :final
 
     # @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
+    attr_accessor :directives, :documents, :bibdatas, :coverpage,
+                  :coverpage_pdf_portfolio, :dirname,
+                  :disambig, :manifest, :bibdata, :compile, :config
 
     # @param file [String] path to source file
     # @param config [Metanorma::Collection::Config]
@@ -64,6 +66,7 @@ module Metanorma
     def initialize_directives
       d = @directives.each_with_object({}) { |x, m| m[x.key] = x.value }
       @coverpage = d["coverpage"]
+      @coverpage_pdf_portfolio = d["coverpage-pdf-portfolio"]
       @coverpage_style = d["coverpage-style"]
       @flavor = d["flavor"]
       if (@documents.any? || @manifest) && !d.key?("documents-inline") &&
@@ -109,39 +112,55 @@ module Metanorma
       warn opts[:output_folder]
     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(flavor)
-      out = sections(dummy_header + cnt.strip)
+      @compile.load_flavor(Util::taste2flavor(flavor))
+      out = prefatory_parse(Util::asciidoc_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: flavor.to_sym, header_footer: true)
+    def prefatory_parse(cnt)
+      x = prefatory_parse_semantic(cnt)
+      _, filepath = Util::nokogiri_to_temp(x, "foo", ".presentation.xml")
+      c1 = Util::isodoc_create(Util::taste2flavor(@flavor), @manifest.lang,
+                               @manifest.script, x,
+                               presxml: true).convert(filepath, nil, true)
+      presxml = Nokogiri::XML(c1)
+      prefatory_extract_xml(presxml)
+    end
+
+    def prefatory_extract_xml(presxml)
+      body = presxml.at("//xmlns:sections")
+      body.at("//xmlns:p[@class = 'zzSTDTitle1']")&.remove
+      body.text.to_s.strip.empty? and body = presxml.at("//xmlns:preface")
+      body.at("//xmlns:clause[@type = 'toc']")&.remove
+      body.children.to_xml
+    end
+
+    def prefatory_parse_semantic(cnt)
+      c = Asciidoctor.convert(cnt, backend: Util::taste2flavor(flavor).to_sym,
+                                   header_footer: true)
       x = Nokogiri::XML(c)
       x.xpath("//xmlns:clause").each { |n| n["unnumbered"] = true }
-      file = Tempfile.new(%w(foo presentation.xml))
-      file.write(x.to_xml(indent: 0))
-      file.close
-      c1 = Util::isodoc_create(@flavor, @manifest.lang, @manifest.script, x, presxml: true)
-        .convert(file.path, nil, true)
-      Nokogiri::XML(c1).at("//xmlns:sections").children.to_xml
+      b = x.at("//xmlns:bibdata")
+      prefatory_parse_fix_bibdata(b)
+      b.children = ::Metanorma::Standoc::Cleanup::MergeBibitems
+        .new(b.to_xml, @bibdata.to_xml(bibdata: true)).merge.to_noko.children
+      x
+    end
+
+    # Stop standoc ownerless copyright from breaking Relaton parse of bibdata
+    def prefatory_parse_fix_bibdata(bibdata)
+      if cop = bibdata.at("//xmlns:copyright")
+        cop.at("./xmlns:owner") or
+          cop.children.first.previous =
+            "<owner><organization><name>SDO</name></organization></owner>"
+      end
+      bibdata
     end
 
     # @param builder [Nokogiri::XML::Builder]
@@ -160,6 +179,7 @@ module Metanorma
           b.attachment Vectory::Utils::datauri(doc.file)
         else
           doc.to_xml b
+          b.parent.children.first["flavor"] = Util::taste2flavor(flavor)
         end
       end
     end
@@ -173,89 +193,11 @@ module Metanorma
     def fetch_flavor
       docid = @bibdata.docidentifier.first or return
       f = docid.type.downcase || docid.id.sub(/\s.*$/, "").downcase or return
+      f = Util::taste2flavor(f)
       require ::Metanorma::Compile.new.stdtype2flavor_gem(f)
       f
     rescue LoadError
       nil
     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)
-        warn ref_folder
-        warn 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/config.rb

@@ -20,6 +20,7 @@ module Metanorma
         attribute :directive, Directive, collection: true
         attribute :manifest, Manifest
         attribute :coverpage, :string, default: -> { "cover.html" }
+        attribute :coverpage_pdf_portfolio, :string
         attribute :format, :string, collection: true, default: -> { [:html] }
         attribute :output_folder, :string
         attribute :compile, CompileOptions
@@ -37,6 +38,8 @@ module Metanorma
           map "format", to: :format, render_default: true
           map "output_folder", to: :output_folder
           map "coverpage", to: :coverpage, render_default: true
+          map "coverpage-pdf-portfolio", to: :coverpage_pdf_portfolio,
+                                         render_default: true
           map "compile", to: :compile, render_default: true
           map "prefatory-content", to: :prefatory_content
           map "final-content", to: :final_content
@@ -54,6 +57,8 @@ module Metanorma
           map_element "format", to: :format, render_default: true
           map_element "output_folder", to: :output_folder
           map_element "coverpage", to: :coverpage, render_default: true
+          map_element "coverpage-pdf-portfolio", to: :coverpage_pdf_portfolio,
+                                                 render_default: true
           map_element "compile", to: :compile, render_default: true
           map_element "prefatory-content",
                       to: :prefatory_content,

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

@@ -46,6 +46,7 @@ module Metanorma
         end
 
         def nop_to_yaml(model, doc); end
+        def nop_to_xml(model, parent, doc); end
 
         def documents_from_xml(model, value)
           model.documents = value

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

@@ -25,10 +25,15 @@ module Metanorma
         attribute :index, :boolean, default: -> { true }
         attribute :entry, Manifest, collection: true
         attribute :file, :string
+        attribute :pdffile, :string
         attribute :format, :string, collection: true
+        attribute :output_filename, :string
+        attribute :sectionsplit_filename, :string
+        attribute :sectionsplit_output, :boolean
 
         yaml do
           map "identifier", to: :identifier
+          map "pdf-file", to: :pdffile
           map "type", to: :type
           map "level", to: :level,
                        with: { from: :level_from_yaml, to: :nop_to_yaml }
@@ -48,6 +53,9 @@ module Metanorma
           map "bibdata", to: :bibdata, with: { from: :bibdata_from_yaml,
                                                to: :bibdata_to_yaml }
           map "format", to: :format, render_default: true
+          map "output-filename", to: :output_filename
+          map "sectionsplit-filename", to: :sectionsplit_filename
+          map "sectionsplit-output", to: :sectionsplit_output
         end
 
         xml do
@@ -57,6 +65,7 @@ module Metanorma
           map_attribute "sectionsplit", to: :sectionsplit
           map_attribute "index", to: :index
           map_attribute "url", to: :url
+          map_attribute "pdf-file", to: :pdffile
           map_attribute "fileref", to: :file
           map_element "identifier", to: :identifier, render_default: true
           map_element "type", to: :type
@@ -65,6 +74,12 @@ module Metanorma
           map_element "bibdata", to: :bibdata, with: { from: :bibdata_from_xml,
                                                        to: :bibdata_to_xml }
           map_element "entry", to: :entry
+          map_element "output-filename", to: :output_filename,
+                                         with: { from: :output_filename_from_xml,
+                                                 to: :nop_to_xml }
+          map_element "sectionsplit-filename", to: :sectionsplit_filename,
+                                               with: { from: :sectionsplit_filename_from_xml,
+                                                       to: :nop_to_xml }
         end
 
         def entry_from_xml(model, node)
@@ -78,6 +93,14 @@ module Metanorma
           end
         end
 
+        def output_filename_from_xml(model, node)
+          model.output_filename ||= node.content
+        end
+
+        def sectionsplit_filename_from_xml(model, node)
+          model.sectionsplit_filename ||= node.content
+        end
+
         def level_from_yaml(model, value)
           model.type ||= value
         end

data/lib/metanorma/collection/document/document.rb

@@ -49,25 +49,47 @@ module Metanorma
         private
 
         def mn2relaton_parser(tag)
-          case tag.sub(/-standard/, "")
-          when "bipm" then ::RelatonBipm::XMLParser
-          when "bsi" then ::RelatonBsi::XMLParser
-          when "ietf" then ::RelatonIetf::XMLParser
-          when "iho" then ::RelatonIho::XMLParser
-          when "itu" then ::RelatonItu::XMLParser
-          when "iec" then ::RelatonIec::XMLParser
-          when "iso" then ::RelatonIsoBib::XMLParser
-          when "nist" then ::RelatonNist::XMLParser
-          when "ogc" then ::RelatonOgc::XMLParser
-          else ::RelatonBib::XMLParser
+          case tag
+          when "bipm"
+            require "relaton_bipm" unless defined?(::RelatonBipm::XMLParser)
+            ::RelatonBipm::XMLParser
+          when "bsi"
+            require "relaton_bsi" unless defined?(::RelatonBsi::XMLParser)
+            ::RelatonBsi::XMLParser
+          when "ietf"
+            require "relaton_ietf" unless defined?(::RelatonIetf::XMLParser)
+            ::RelatonIetf::XMLParser
+          when "iho"
+            require "relaton_iho" unless defined?(::RelatonIho::XMLParser)
+            ::RelatonIho::XMLParser
+          when "itu"
+            require "relaton_itu" unless defined?(::RelatonItu::XMLParser)
+            ::RelatonItu::XMLParser
+          when "iec"
+            require "relaton_iec" unless defined?(::RelatonIec::XMLParser)
+            ::RelatonIec::XMLParser
+          when "iso"
+            require "relaton_iso" unless defined?(::RelatonIsoBib::XMLParser)
+            ::RelatonIsoBib::XMLParser
+          when "nist"
+            require "relaton_nist" unless defined?(::RelatonNist::XMLParser)
+            ::RelatonNist::XMLParser
+          when "ogc"
+            require "relaton_ogc" unless defined?(::RelatonOgc::XMLParser)
+            ::RelatonOgc::XMLParser
+          else
+            ::RelatonBib::XMLParser
           end
+        rescue LoadError => e
+          warn "Warning: Failed to load relaton gem for '#{tag}': #{e.message}. Falling back to RelatonBib::XMLParser"
+          ::RelatonBib::XMLParser
         end
 
         # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]
         # @return [RelatonBib::BibliographicItem,RelatonIso::IsoBibliographicItem]
         def from_xml(xml)
           b = xml.at("//xmlns:bibitem|//xmlns:bibdata")
-          r = mn2relaton_parser(xml.root.name)
+          r = mn2relaton_parser(xml.root["flavor"])
           # Relaton doesn't understand Pres XML tags
           b.xpath("//xmlns:fmt-identifier").each(&:remove)
           r.from_xml(b.to_xml)
@@ -127,7 +149,7 @@ module Metanorma
         if @raw
           builder.parent.add_child(@bibitem.root)
         else
-          builder.send("#{type}-standard") do |b|
+          builder.send("metanorma") do |b|
             b << @bibitem.to_xml(bibdata: true)
           end
         end

data/lib/metanorma/collection/filelookup/base.rb

@@ -0,0 +1,43 @@
+module Metanorma
+  class Collection
+    class FileLookup
+      # are references to the file to be linked to a file in the collection,
+      # or externally? Determines whether file suffix anchors are to be used
+      def url?(ident)
+        data = get(ident) or return false
+        data[:url]
+      end
+
+      def key(ident)
+        @c.decode(ident).gsub(/(\p{Zs})+/, " ")
+          .sub(/^metanorma-collection /, "")
+      end
+
+      def keys
+        @files.keys
+      end
+
+      def get(ident, attr = nil)
+        if attr then @files[key(ident)][attr]
+        else @files[key(ident)]
+        end
+      end
+
+      def set(ident, attr, value)
+        @files[key(ident)][attr] = value
+      end
+
+      def each
+        @files.each
+      end
+
+      def each_with_index
+        @files.each_with_index
+      end
+
+      def ns(xpath)
+        @isodoc.ns(xpath)
+      end
+    end
+  end
+end