metanorma 2.0.0 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40466d3eca9782461819ef5828d00dcdc4203e000cc0a6762e658ac75fab81c2
-  data.tar.gz: ff68a9e27dd193c8e1263bcb1200f76d87eaf10363ef4c4eb32b9719e9b82eee
+  metadata.gz: 61f89a2c7a4e3b018425e87162e66fa5e1a8c20a4cf546ff477fd525be04e455
+  data.tar.gz: 3af3ca357995db324f7f8f844ff01a0651e0ba9c4fcd4c4f585c15baa4f33269
 SHA512:
-  metadata.gz: 77388c12e9b2067cd0e319cdacc3ea914984e5185ce130ea5b6dbc893ab4d1d851294b7f3833811235b3952b50c98ad4830614c87a472dac9a26dc644b48f031
-  data.tar.gz: 749c67ae8b9c967a0a2446847fb04fc9b045d5f42d4046a66aa79ce0abd5dc373545af2a1520559fa3fb0db4065a51aa2f043fcbe3007b84990ab89b99a286b9
+  metadata.gz: d8128a3b6b239af0af4e7cef15b5429ac3d4294c4407bcd618d22413ac49f98ee38dcba53c6e78604399321c059f33f93ee4a42d437b258cb5823e609936267c
+  data.tar.gz: 90bcc67a7a066eb8b84bd7abe26398d4cf7513fd8a804fa0cd60944d709ca8352ecfdbc94cc8a02c7d6e423cfddb9abc0754db3e2ecd1d54f3eb95fd64701e37

data/lib/metanorma/collection/collection.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "relaton"
 require "relaton/cli"
 require "metanorma-utils"
@@ -28,11 +26,16 @@ module Metanorma
     def initialize(**args)
       @file = args[:file]
       @dirname = File.expand_path(File.dirname(@file)) # feeds @manifest
-      @documents = args[:documents] || {} # feeds initialize_directives
+      @documents = args[:documents] || {} # feeds initialize_directives, initialize_docs
       @bibdatas = args[:documents] || {}
       initialize_vars
       initialize_config(args[:config])
       initialize_directives
+      initialize_docs
+      validate_flavor(flavor)
+    end
+
+    def initialize_docs
       @documents.merge! @manifest.documents
       @bibdatas.merge! @manifest.documents
       @documents.transform_keys { |k| Util::key(k) }
@@ -53,12 +56,15 @@ module Metanorma
       @final = config.final_content
       @manifest = ::Metanorma::Collection::Manifest
         .new(config.manifest, self, @dirname) # feeds initialize_directives
+      @format = config.format.map(&:to_sym)
+      @format&.empty? and @format = nil
     end
 
     def initialize_directives
       d = @directives.each_with_object({}) { |x, m| m[x.key] = x.value }
       @coverpage = d["coverpage"]
       @coverpage_style = d["coverpage-style"]
+      @flavor = d["flavor"]
       if (@documents.any? || @manifest) && !d.key?("documents-inline") &&
           !d.key?("documents-external")
         @directives << ::Metanorma::Collection::Config::Directive
@@ -66,6 +72,10 @@ module Metanorma
       end
     end
 
+    def validate_flavor(flavor)
+      ::Metanorma::Compile.new.load_flavor(flavor)
+    end
+
     def clean_exit
       @log.write(File.join(@dirname,
                            "#{File.basename(@file, '.*')}.err.html"))
@@ -82,7 +92,12 @@ module Metanorma
     end
 
     def render(opts)
-      ::Metanorma::Collection::Renderer.render self, opts.merge(log: @log)
+      if opts[:format].nil? || opts[:format].empty?
+        opts[:format] = @format || [:html]
+      end
+      opts[:log] = @log
+      opts[:flavor] = @flavor
+      ::Metanorma::Collection::Renderer.render self, opts
       clean_exit
     end
 
@@ -102,7 +117,7 @@ module Metanorma
     # @param builder [Nokogiri::XML::Builder]
     def content_to_xml(elm, builder)
       (cnt = send(elm)) or return
-      @compile.load_flavor(doctype)
+      @compile.load_flavor(flavor)
       out = sections(dummy_header + cnt.strip)
       builder.send("#{elm}-content") { |b| b << out }
     end
@@ -110,13 +125,19 @@ module Metanorma
     # @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
+      c = Asciidoctor.convert(cnt, backend: 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
     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)
@@ -135,14 +156,19 @@ module Metanorma
       end
     end
 
-    def doctype
-      @doctype ||= fetch_doctype || "standoc"
+    def flavor
+      @flavor ||= fetch_flavor || "standoc"
     end
 
-    def fetch_doctype
-      docid = @bibdata.docidentifier.first
-      docid or return
-      docid.type&.downcase || docid.id&.sub(/\s.*$/, "")&.downcase
+    # TODO: retrieve flavor based on @bibdata publisher when lookup implemented
+    # Will still infer based on docid, but will validate it before proceeding
+    def fetch_flavor
+      docid = @bibdata.docidentifier.first or return
+      f = docid.type.downcase || docid.id.sub(/\s.*$/, "").downcase or return
+      require ::Metanorma::Compile.new.stdtype2flavor(f)
+      f
+    rescue LoadError
+      nil
     end
 
     class << self
@@ -188,6 +214,9 @@ module Metanorma
       # @param fileref [String]
       # @return [String]
       def resolve_fileref(ref_folder, fileref)
+        warn ref_folder
+        warn fileref
+        #require "debug"; binding.b
         unless @fileref_resolver
           (Pathname.new fileref).absolute? or
             fileref = File.join(ref_folder, fileref)

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

@@ -1,10 +1,10 @@
 require "relaton"
-require "shale"
+require "lutaml/model"
 
 module Metanorma
   class Collection
     module Config
-      class Bibdata < ::Shale::Mapper
+      class Bibdata < ::Lutaml::Model::Serializable
         model ::RelatonBib::BibliographicItem
       end
     end

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

@@ -1,12 +1,11 @@
-require "shale"
+require "lutaml/model"
 
 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 }
+      class CompileOptions < ::Lutaml::Model::Serializable
+        attribute :install_fonts, :boolean, default: -> { false }
+        attribute :agree_to_terms, :boolean, default: -> { true }
       end
     end
   end

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

@@ -1,5 +1,4 @@
-require "shale"
-require_relative "../../shale_monkeypatch"
+require "lutaml/model"
 require_relative "../../array_monkeypatch"
 require_relative "compile_options"
 require_relative "converters"
@@ -10,37 +9,35 @@ require_relative "manifest"
 module Metanorma
   class Collection
     module Config
-      require "shale/adapter/nokogiri"
-      ::Shale.xml_adapter = ::Shale::Adapter::Nokogiri
+      Lutaml::Model::Config.configure do |config|
+        config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+      end
 
-      class Config < ::Shale::Mapper
+      class Config < ::Lutaml::Model::Serializable
         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 :coverpage, :string, default: -> { "cover.html" }
+        attribute :format, :string, collection: true, default: -> { [:html] }
+        attribute :output_folder, :string
         attribute :compile, CompileOptions
-        attribute :prefatory_content, ::Shale::Type::String
-        attribute :final_content, ::Shale::Type::String
+        attribute :prefatory_content, :string, raw: true
+        attribute :final_content, :string, raw: true
         attribute :documents, Bibdata, collection: true
-        attribute :xmlns, ::Shale::Type::String, default: -> { "http://metanorma.org" }
+        attribute :xmlns, :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 "directives", to: :directive, with: { from: :directives_from_yaml,
+                                                    to: :directives_to_yaml }
+          map "bibdata", to: :bibdata, with: { from: :bibdata_from_yaml,
+                                               to: :bibdata_to_yaml }
           map "manifest", to: :manifest
-          map "format", to: :format
+          map "format", to: :format, render_default: true
           map "output_folder", to: :output_folder
-          map "coverpage", to: :coverpage
-          map "compile", to: :compile
+          map "coverpage", to: :coverpage, render_default: true
+          map "compile", to: :compile, render_default: true
           map "prefatory-content", to: :prefatory_content
           map "final-content", to: :final_content
         end
@@ -49,23 +46,27 @@ module Metanorma
           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 "bibdata", to: :bibdata, with: { from: :bibdata_from_xml,
+                                                       to: :bibdata_to_xml }
+          map_element "directive", to: :directive
+          map_element "entry", to: :manifest, with: { from: :manifest_from_xml,
+                                                      to: :manifest_to_xml }
+          map_element "format", to: :format, render_default: true
           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 "coverpage", to: :coverpage, render_default: true
+          map_element "compile", to: :compile, render_default: true
+          map_element "prefatory-content",
+                      to: :prefatory_content,
+                      with: { 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 }
+                      to: :documents,
+                      with: { from: :documents_from_xml,
+                              to: :documents_to_xml }
+          map_element "final-content",
+                      to: :final_content,
+                      with: { from: :final_from_xml,
+                              to: :final_to_xml }
         end
 
         def manifest_from_xml(model, node)
@@ -78,7 +79,7 @@ module Metanorma
         end
 
         def prefatory_from_xml(model, node)
-          model.prefatory_content = node.to_xml
+          model.prefatory_content = node.children.map(&:to_xml).join
         end
 
         def prefatory_to_xml(model, parent, doc)
@@ -92,7 +93,8 @@ module Metanorma
         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
+          elem = if n.elements.size == 1
+                   "<#{type}-content>#{x}</#{type}-content>" # n.root
                  else
                    b = Nokogiri::XML::Builder.new
                    model.collection.content_to_xml(type, b)
@@ -102,19 +104,7 @@ module Metanorma
         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
+          model.final_content = node.children.map(&:to_xml).join
         end
 
         def directives_from_yaml(model, value)
@@ -134,28 +124,6 @@ module Metanorma
           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

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

@@ -14,7 +14,8 @@ module Metanorma
         end
 
         def bibdata_from_xml(model, node)
-          model.bibdata = Relaton::Cli.parse_xml(node.content)
+          node and
+            model.bibdata = Relaton::Cli.parse_xml(node.adapter_node)
         end
 
         def bibdata_to_xml(model, parent, doc)
@@ -24,6 +25,31 @@ module Metanorma
         end
 
         def nop_to_yaml(model, doc); end
+
+        def documents_from_xml(model, value)
+          model.documents = value
+            .each_with_object([]) do |b, m|
+            m << b
+          end
+        end
+
+        def documents_to_xml(model, parent, doc)
+          documents_to_xml?(doc) or return
+          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 { |x| doc.add_element(parent, x) }
+        end
+
+        def documents_to_xml?(doc)
+          ret = doc.parent.elements.detect do |x|
+            x.name == "doc-container"
+          end
+          !ret
+        end
       end
     end
   end

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

@@ -1,9 +1,15 @@
 module Metanorma
   class Collection
     module Config
-      class Directive < ::Shale::Mapper
-        attribute :key, ::Shale::Type::String
-        attribute :value, ::Shale::Type::String
+      class Directive < ::Lutaml::Model::Serializable
+        attribute :key, :string
+        attribute :value, :string
+
+        xml do
+          root "directive"
+          map_element "key", to: :key
+          map_element "value", to: :value
+        end
       end
     end
   end

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

@@ -1,5 +1,5 @@
-require "shale"
-require_relative "../../shale_monkeypatch"
+require "lutaml/model"
+require "lutaml/model/xml_adapter/nokogiri_adapter"
 require_relative "../../array_monkeypatch"
 require_relative "converters"
 require_relative "bibdata"
@@ -7,59 +7,65 @@ require_relative "bibdata"
 module Metanorma
   class Collection
     module Config
-      require "shale/adapter/nokogiri"
-      ::Shale.xml_adapter = ::Shale::Adapter::Nokogiri
+      Lutaml::Model::Config.configure do |config|
+        config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+      end
 
-      class Manifest < ::Shale::Mapper
-        attribute :identifier, ::Shale::Type::String,
-                  default: -> { UUIDTools::UUID.random_create.to_s }
-        attribute :id, ::Shale::Type::String
+      class Manifest < ::Lutaml::Model::Serializable
+        attribute :identifier, :string,
+          default: -> { UUIDTools::UUID.random_create.to_s }
+        attribute :id, :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 :type, :string
+        attribute :title, :string
+        attribute :url, :string
+        attribute :level, :string
+        attribute :attachment, :boolean
+        attribute :sectionsplit, :boolean
+        attribute :index, :boolean, default: -> { true }
         attribute :entry, Manifest, collection: true
-        attribute :file, ::Shale::Type::String
+        attribute :file, :string
 
         yaml do
           map "identifier", to: :identifier
           map "type", to: :type
-          map "level", using: { from: :level_from_yaml, to: :nop_to_yaml }
+          map "level", to: :level,
+                       with: { 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 "fileref", to: :file,
+                         with: { 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 }
+          map "docref", to: :entry,
+                        with: { from: :docref_from_yaml, to: :nop_to_yaml }
+          map "manifest", to: :entry,
+                          with: { from: :docref_from_yaml, to: :nop_to_yaml }
+          map "bibdata", to: :bibdata, with: { from: :bibdata_from_yaml,
+                                               to: :bibdata_to_yaml }
         end
 
         xml do
           root "entry"
-          map_attribute "id", to: :id
+          map_attribute "target", 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 "identifier", to: :identifier, render_default: true
           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 }
+          map_element "bibdata", to: :bibdata, with: { from: :bibdata_from_xml,
+                                                       to: :bibdata_to_xml }
+          map_element "entry", to: :entry
         end
 
         def entry_from_xml(model, node)
-          model.entry = Manifest.from_xml(node.content)
+          model.entry = Manifest.from_xml(node.node.to_xml)
         end
 
         def entry_to_xml(model, parent, doc)

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

@@ -1,3 +1,5 @@
+require "relaton-cli"
+
 module Metanorma
   class Collection
     class Document
@@ -48,16 +50,16 @@ module Metanorma
 
         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
+          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
           end
         end
 

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

@@ -62,12 +62,24 @@ module Metanorma
           file, _filename = targetfile(entry, read: true)
           xml = Nokogiri::XML(file, &:huge)
           add_document_suffix(ident, xml)
-          entry.merge!(anchors: read_anchors(xml), ids: read_ids(xml),
-                       bibdata: xml.at(ns("//bibdata")),
-                       document_suffix: xml.root["document_suffix"])
+          entry.merge!(bibdata_extract(xml))
         end
       end
 
+      def anchors_lookup(anchors)
+        anchors.values.each_with_object({}) do |v, m|
+          v.each_value { |v1| m[v1] = true }
+        end
+      end
+
+      def bibdata_extract(xml)
+        anchors = read_anchors(xml)
+        { anchors: anchors, anchors_lookup: anchors_lookup(anchors),
+          ids: read_ids(xml),
+          bibdata: xml.at(ns("//bibdata")),
+          document_suffix: xml.root["document_suffix"] }
+      end
+
       def bibitem_process(entry)
         entry[:bibitem] = entry[:bibdata].dup
         entry[:bibitem].name = "bibitem"
@@ -76,7 +88,7 @@ module Metanorma
       end
 
       # ref is the absolute source file address
-      # rel_path is the relative source file address, relative to the YAML locaton
+      # rel_path is the relative source file address, relative to the YAML location
       # out_path is the destination file address, with any references outside
       # the working directory (../../...) truncated, and based on relative path
       # identifier is the id with only spaces, no nbsp
@@ -104,15 +116,15 @@ module Metanorma
         %w(attachment sectionsplit index presentation-xml url
            bare-after-first).each do |s|
           ref.respond_to?(s.to_sym) and
-            ret[s.gsub("-", "").to_sym] = ref.send(s)
+            ret[s.delete("-").to_sym] = ref.send(s)
         end
       end
 
       def add_document_suffix(identifier, doc)
         document_suffix = Metanorma::Utils::to_ncname(identifier)
-        Metanorma::Utils::anchor_attributes.each do |(tag_name, attribute_name)|
-          Util::add_suffix_to_attributes(doc, document_suffix, tag_name,
-                                         attribute_name, @isodoc)
+        Metanorma::Utils::anchor_attributes.each do |(tag_name, attr_name)|
+          Util::add_suffix_to_attrs(doc, document_suffix, tag_name, attr_name,
+                                    @isodoc)
         end
         url_in_css_styles(doc, document_suffix)
         doc.root["document_suffix"] ||= ""
@@ -123,7 +135,7 @@ module Metanorma
       def url_in_css_styles(doc, document_suffix)
         doc.xpath("//*[@style]").each do |s|
           s["style"] = s["style"]
-            .gsub(%r{url\(#([^)]+)\)}, "url(#\\1_#{document_suffix})")
+            .gsub(%r{url\(#([^()]+)\)}, "url(#\\1_#{document_suffix})")
         end
       end
 
@@ -198,10 +210,10 @@ module Metanorma
         ret[val[:type]] ||= {}
         index = if val[:container] || val[:label].nil? || val[:label].empty?
                   UUIDTools::UUID.random_create.to_s
-                else val[:label]
+                else val[:label].gsub(%r{<[^>]+>}, "")
                 end
         ret[val[:type]][index] = key
-        ret[val[:type]][val[:value]] = key if val[:value]
+        v = val[:value] and ret[val[:type]][v.gsub(%r{<[^>]+>}, "")] = key
       end
 
       # Also parse all ids in doc (including ones which won't be xref targets)
@@ -216,8 +228,8 @@ module Metanorma
       end
 
       def key(ident)
-        @c.decode(ident).gsub(/(\p{Zs})+/, " ").sub(/^metanorma-collection /,
-                                                    "")
+        @c.decode(ident).gsub(/(\p{Zs})+/, " ")
+          .sub(/^metanorma-collection /, "")
       end
 
       def keys