isodoc 2.10.0 → 3.0.0

data/lib/isodoc/presentation_function/autonum.rb

@@ -0,0 +1,153 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def prefix_name(node, delims, label, elem)
+      label, delims = prefix_name_defaults(node, delims, label)
+      name, ins, ids, number = prefix_name_prep(node, elem)
+      ins.next = fmt_xref_label(label, number, ids)
+      # autonum can be empty, e.g single note in clause: "NOTE []"
+      number and node["autonum"] = number.gsub(/<[^>]+>/, "")
+      !node.at(ns("./fmt-#{elem}")) &&
+        (c = fmt_caption(label, elem, name, ids, delims)) and ins.next = c
+      prefix_name_postprocess(node, elem)
+    end
+
+    def prefix_name_defaults(node, delims, label)
+      label&.empty? and label = nil
+      delims.nil? and delims = {}
+      [label, delims]
+    end
+
+    def prefix_name_prep(node, elem)
+      lbls = prefix_name_labels(node)
+      name = node.at(ns("./#{elem}")) and name["id"] = lbls[:name]
+      ins = name || node.add_first_child("<sentinel/>").elements.first
+      node["unnumbered"] or
+        number = @xrefs.anchor(node["id"], :value, false)&.strip
+      [name, ins, lbls, number]
+    end
+
+    def prefix_name_labels(node)
+      { elem: node["id"],
+        name: "_#{UUIDTools::UUID.random_create}" }
+    end
+
+    def prefix_name_postprocess(node, elem)
+      node.at(ns("./sentinel"))&.remove
+      strip_duplicate_ids(node, node.at(ns("./#{elem}")),
+                          node.at(ns("./fmt-#{elem}")))
+    end
+
+    def transfer_id(old, new)
+      old["id"] or return
+      new["id"] = old["id"]
+      old["original-id"] = old["id"]
+      old.delete("id")
+    end
+
+    def semx_fmt_dup(elem)
+      elem["id"] ||= "_#{UUIDTools::UUID.random_create}"
+      new = Nokogiri::XML(<<~XML).root
+        <semx xmlns='#{elem.namespace.href}' element='#{elem.name}' source='#{elem['original-id'] || elem['id']}'>#{to_xml(elem.children)}</semx>
+      XML
+      strip_duplicate_ids(nil, elem, new)
+      new
+    end
+
+    def gather_all_ids(elem)
+      elem.xpath(".//*[@id]").each_with_object([]) do |i, m|
+        m << i["id"]
+      end
+    end
+
+    # remove ids duplicated between sem_title and pres_title
+    # index terms are assumed transferred to pres_title from sem_title
+    def strip_duplicate_ids(_node, sem_title, pres_title)
+      sem_title && pres_title or return
+      ids = gather_all_ids(pres_title)
+      sem_title.xpath(".//*[@id]").each do |x|
+        ids.include?(x["id"]) or next
+        x["original-id"] = x["id"]
+        x.delete("id")
+      end
+      sem_title.xpath(ns(".//index")).each(&:remove)
+    end
+
+    def semx(node, label, element = "autonum")
+      id = node["id"] || node[:id]
+      /<semx element='[^']+' source='#{id}'/.match?(label) and return label
+      l = stripsemx(label)
+      %(<semx element='#{element}' source='#{id}'>#{l}</semx>)
+    end
+
+    def autonum(id, num)
+      /<semx/.match?(num) and return num # already contains markup
+      "<semx element='autonum' source='#{id}'>#{num}</semx>"
+    end
+
+    def semx_orig(node, orig = nil)
+      orig ||= node.parent.parent
+      orig.at(".//*[@id = '#{node['source']}']")
+    end
+
+    def labelled_autonum(label, id, num)
+      elem = "<span class='fmt-element-name'>#{label}</span>"
+      num.blank? and return elem
+      l10n("#{elem} #{autonum(id, num)}")
+    end
+
+    def fmt_xref_label(label, _number, ids)
+      label or return ""
+      x = @xrefs.anchor(ids[:elem], :xref, false) or return ""
+      ret = "<fmt-xref-label>#{x}</fmt-xref-label>"
+      container = @xrefs.anchor(ids[:elem], :container, false)
+      y = prefix_container_fmt_xref_label(container, x)
+      y != x and
+        ret += "<fmt-xref-label container='#{container}'>#{y}</fmt-xref-label>"
+      ret
+    end
+
+    def prefix_container_fmt_xref_label(container, xref)
+      container or return xref
+      container_container = @xrefs.anchor(container, :container, false)
+      container_label =
+        prefix_container_fmt_xref_label(container_container,
+                                        @xrefs.anchor(container, :xref, false))
+      l10n(connectives_spans(@i18n.nested_xref
+        .sub("%1", "<span class='fmt-xref-container'>#{container_label}</span>")
+        .sub("%2", xref)))
+    end
+
+    # detect whether string which may contain XML markup is empty
+    def empty_xml?(str)
+      str.blank? and return true
+      x = Nokogiri::XML::DocumentFragment.parse(str)
+      x.to_str.strip.empty?
+    end
+
+    # Remove ".blank?" tests if want empty delim placeholders for manipulation
+    def fmt_caption(label, elem, name, ids, delims)
+      label = fmt_caption_label_wrap(label)
+      c = fmt_caption2(label, elem, name, ids, delims)
+      empty_xml?(c) and return
+      !delims[:label].blank? and
+        f = "<span class='fmt-label-delim'>#{delims[:label]}</span>"
+      "<fmt-#{elem}>#{c}#{f}</fmt-#{elem}>"
+    end
+
+    def fmt_caption_label_wrap(label)
+      empty_xml?(label) || %r{<span class=['"]fmt-caption-label['"]}.match?(label) or
+        label = "<span class='fmt-caption-label'>#{label}</span>"
+      label
+    end
+
+    def fmt_caption2(label, elem, name, ids, delims)
+      if name && !name.children.empty?
+        empty_xml?(label) or
+          d = "<span class='fmt-caption-delim'>#{delims[:caption]}</span>"
+        attr = " element='#{elem}' source='#{ids[:name]}'"
+        "#{label}#{d}<semx #{attr}>#{to_xml(name.children)}</semx>"
+      elsif label then label
+      end
+    end
+  end
+end

data/lib/isodoc/presentation_function/bibdata.rb

@@ -29,11 +29,10 @@ module IsoDoc
 
     def bibdata_current(docxml)
       a = docxml.at(ns("//bibdata")) or return
-      a.xpath(ns("./language")).each do |l|
-        l.text == @lang and l["current"] = "true"
-      end
-      a.xpath(ns("./script")).each do |l|
-        l.text == @script and l["current"] = "true"
+      { language: @lang, script: @script, locale: @locale }.each do |k, v|
+        a.xpath(ns("./#{k}")).each do |l|
+          l.text == v and l["current"] = "true"
+        end
       end
       a
     end

data/lib/isodoc/presentation_function/block.rb

@@ -1,30 +1,23 @@
 require_relative "image"
 require_relative "sourcecode"
+require_relative "autonum"
 require "rouge"
 
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def lower2cap(text)
-      /^[[:upper:]][[:upper:]]/.match?(text) and return text
-      text.capitalize
+      text.nil? and return text
+      x = Nokogiri::XML("<a>#{text}</a>")
+      firsttext = x.at(".//text()[string-length(normalize-space(.))>0]") or return text
+      /^[[:upper:]][[:upper:]]/.match?(firsttext.text) and return text
+      firsttext.replace(firsttext.text.capitalize)
+      to_xml(x.root.children)
     end
 
     def block_delim
       "&#xa0;&#x2014; "
     end
 
-    def prefix_name(node, delim, number, elem)
-      number.nil? || number.empty? and return
-      unless name = node.at(ns("./#{elem}"))
-        (node.children.empty? and node.add_child("<#{elem}></#{elem}>")) or
-          node.children.first.previous = "<#{elem}></#{elem}>"
-        name = node.children.first
-      end
-      if name.children.empty? then name.add_child(cleanup_entities(number.strip))
-      else (name.children.first.previous = "#{number.strip}#{delim}")
-      end
-    end
-
     def formula(docxml)
       docxml.xpath(ns("//formula")).each { |f| formula1(f) }
     end
@@ -32,7 +25,7 @@ module IsoDoc
     def formula1(elem)
       formula_where(elem.at(ns("./dl")))
       lbl = @xrefs.anchor(elem["id"], :label, false)
-      prefix_name(elem, "", lbl, "name")
+      lbl.nil? || lbl.empty? or prefix_name(elem, {}, lbl, "name")
     end
 
     def formula_where(dlist)
@@ -48,25 +41,27 @@ module IsoDoc
 
     def example1(elem)
       n = @xrefs.get[elem["id"]]
-      lbl = if n.nil? || n[:label].nil? || n[:label].empty?
-              @i18n.example
-            else l10n("#{@i18n.example} #{n[:label]}")
-            end
-      prefix_name(elem, block_delim, lbl, "name")
+      lbl = labelled_autonum(@i18n.example, elem["id"], n&.dig(:label))
+      prefix_name(elem, { caption: block_delim }, lbl, "name")
     end
 
     def note(docxml)
       docxml.xpath(ns("//note")).each { |f| note1(f) }
     end
 
+    def note_delim(_elem)
+      "<tab/>"
+    end
+
     def note1(elem)
       %w(bibdata bibitem).include?(elem.parent.name) ||
-        elem["notag"] == "true" and return
+        elem["notag"] == "true" or lbl = note_label(elem)
+      prefix_name(elem, { label: note_delim(elem) }, lbl, "name")
+    end
+
+    def note_label(elem)
       n = @xrefs.get[elem["id"]]
-      lbl = @i18n.note
-      (n.nil? || n[:label].nil? || n[:label].empty?) or
-        lbl = l10n("#{lbl} #{n[:label]}")
-      prefix_name(elem, "", lbl, "name")
+      labelled_autonum(@i18n.note, elem["id"], n&.dig(:label))
     end
 
     def admonition(docxml)
@@ -76,16 +71,30 @@ module IsoDoc
     def admonition1(elem)
       if elem["type"] == "box"
         admonition_numbered1(elem)
+      elsif elem["notag"] == "true" || elem.at(ns("./name"))
+        prefix_name(elem, { label: admonition_delim(elem) }, nil, "name")
       else
-        elem["notag"] == "true" || elem.at(ns("./name")) and return
-        prefix_name(elem, "", @i18n.admonition[elem["type"]]&.upcase, "name")
+        label = admonition_label(elem, nil)
+        prefix_name(elem, { label: admonition_delim(elem) }, label, "name")
       end
     end
 
     def admonition_numbered1(elem)
-      elem["unnumbered"] && !elem.at(ns("./name")) and return
-      n = @xrefs.anchor(elem["id"], :label, false)
-      prefix_name(elem, block_delim, l10n("#{@i18n.box} #{n}"), "name")
+      # elem["unnumbered"] && !elem.at(ns("./name")) and return
+      label = admonition_label(elem, @xrefs.anchor(elem["id"], :label, false))
+      prefix_name(elem, { caption: block_delim }, label, "name")
+    end
+
+    def admonition_label(elem, num)
+      lbl = if elem["type"] == "box" then @i18n.box
+            else @i18n.admonition[elem["type"]]&.upcase end
+      #lbl &&= "<span class='fmt-element-name'>#{lbl}</span>"
+      #num and lbl = l10n("#{lbl} #{autonum(elem['id'], num)}")
+      labelled_autonum(lbl, elem["id"], num)
+    end
+
+    def admonition_delim(_elem)
+      ""
     end
 
     def table(docxml)
@@ -94,11 +103,18 @@ module IsoDoc
     end
 
     def table1(elem)
+      table_fn(elem)
       labelled_ancestor(elem) and return
       elem["unnumbered"] && !elem.at(ns("./name")) and return
       n = @xrefs.anchor(elem["id"], :label, false)
-      prefix_name(elem, block_delim, l10n("#{lower2cap @i18n.table} #{n}"),
-                  "name")
+      #lbl = "<span class='fmt-element-name'>#{lower2cap @i18n.table}</span> "\
+        #"#{autonum(elem['id'], n)}"
+      lbl = labelled_autonum(lower2cap(@i18n.table), elem["id"], n)
+      prefix_name(elem, { caption: table_delim }, l10n(lbl), "name")
+    end
+
+    def table_delim
+      block_delim
     end
 
     def table_long_strings_cleanup(docxml)
@@ -112,16 +128,45 @@ module IsoDoc
       end
     end
 
-    # we use this to eliminate the semantic amend blocks from rendering
+    def table_fn(elem)
+      (elem.xpath(ns(".//fn")) - elem.xpath(ns("./name//fn")))
+        .each_with_index do |f, i|
+          table_fn1(elem, f, i)
+        end
+    end
+
+    def table_fn1(table, fnote, idx); end
+
     def amend(docxml)
       docxml.xpath(ns("//amend")).each { |f| amend1(f) }
     end
 
     def amend1(elem)
-      elem.xpath(ns("./autonumber")).each(&:remove)
-      elem.xpath(ns("./newcontent")).each { |a| a.name = "quote" }
-      elem.xpath(ns("./description")).each { |a| a.replace(a.children) }
-      elem.replace(elem.children)
+      ret = semx_fmt_dup(elem)
+      ret.xpath(ns("./locality | ./localityStack | ./autonumber | " \
+                    "./classification | ./contributor")).each(&:remove)
+      ret.xpath(ns("./newcontent")).each { |a| a.name = "quote" }
+      ret.xpath(ns("./description")).each { |a| a.replace(a.children) }
+      elem.xpath(ns(".//fmt-name | .//fmt-xref-label")).each(&:remove)
+      elem.next = ret
+    end
+
+    def dl(docxml)
+      docxml.xpath(ns("//dl")).each { |f| dl1(f) }
+    end
+
+    def dl1(elem)
+      elem.at(ns("./name")) and
+        prefix_name(elem, {}, "", "name") # copy name to fmt-name
+    end
+
+    def ul(docxml)
+      docxml.xpath(ns("//ul")).each { |f| ul1(f) }
+    end
+
+    def ul1(elem)
+      elem.at(ns("./name")) and
+        prefix_name(elem, {}, "", "name") # copy name to fmt-name
     end
 
     def ol(docxml)
@@ -145,9 +190,8 @@ module IsoDoc
 
     def ol1(elem)
       elem["type"] ||= ol_depth(elem).to_s
-      elem.xpath(ns("./li")).each do |li|
-        li["id"] ||= "_#{UUIDTools::UUID.random_create}"
-      end
+      elem.at(ns("./name")) and
+        prefix_name(elem, {}, "", "name") # copy name to fmt-name
     end
 
     def ol_label(elem)
@@ -180,5 +224,28 @@ module IsoDoc
     def source_modification(mod)
       termsource_modification(mod.parent)
     end
+
+    def quote(docxml)
+      docxml.xpath(ns("//quote")).each { |f| quote1(f) }
+    end
+
+    def quote1(elem)
+      author = elem.at(ns("./author"))
+      source = elem.at(ns("./source"))
+      author.nil? && source.nil? and return
+      p = "&#x2014; "
+      p += to_xml(semx_fmt_dup(author)) if author
+      p += ", " if author && source
+      if source
+        s = semx_fmt_dup(source)
+e = Nokogiri::XML::Node.new("eref", elem.document)
+e << s.children
+s << e
+source.attributes.each_key { |k| e[k] = source[k] }
+e["deleteme"] = "true" # duplicate of source, will be duplicated in fmt-eref, need to delete after
+        p += to_xml(s)
+      end
+      elem << "<attribution><p>#{l10n p}</p></attribution>"
+    end
   end
 end

data/lib/isodoc/presentation_function/concepts.rb

@@ -7,7 +7,8 @@ module IsoDoc
     end
 
     def concept1(node)
-      xref = node&.at(ns("./xref/@target"))&.text or
+      node.ancestors("definition, termsource, related").empty? or return
+      xref = node&.at(ns("./semx/fmt-xref/@target"))&.text or
         return concept_render(node, ital: "true", ref: "true", bold: "false",
                                     linkref: "true", linkmention: "false")
       if @definition_ids[xref]
@@ -19,13 +20,25 @@ module IsoDoc
     end
 
     def concept_render(node, defaults)
-      opts, render, ref = concept_render_init(node, defaults)
-      node&.at(ns("./refterm"))&.remove
+      #require "debug"; binding.b
+      opts, render, ref, ret = concept_render_init(node, defaults)
+      ret&.at(ns("./refterm"))&.remove
       ref && opts[:ref] != "false" and render&.next = " "
       concept1_linkmention(ref, render, opts)
-      concept1_ref(node, ref, opts)
-      concept1_style(node, opts)
-      node.replace(node.children)
+      concept1_ref(ret, ref, opts)
+      concept1_style(ret, opts)
+      concept_dup(node, ret)
+    end
+
+    def concept_dup(node, ret)
+      node.xpath(".//xmlns:semx[xmlns:fmt-xref | xmlns:fmt-eref | xmlns:fmt-origin | xmlns:fmt-link]").each(&:remove)
+      ret.xpath(ns(".//xref | .//eref | .//origin | .//link")).each(&:remove)
+      ret.xpath(ns(".//semx")).each do |s|
+        s.children.empty? and s.remove
+      end
+      f = Nokogiri::XML::Node.new("fmt-concept", node.document)
+      f << ret
+      node.next = f
     end
 
     def concept1_style(node, opts)
@@ -37,25 +50,37 @@ module IsoDoc
     end
 
     def concept_render_init(node, defaults)
-      opts = %i(bold ital ref linkref linkmention)
+      opts = concept_render_opts(node, defaults)
+      ret = semx_fmt_dup(node)
+      ret.children.each { |x| x.text? and x.remove }
+      [opts, ret.at(ns("./renderterm")),
+       ret.at(ns("./semx/fmt-xref | ./semx/fmt-eref | ./termref")), ret]
+    end
+
+    def concept_render_opts(node, defaults)
+      %i(bold ital ref linkref linkmention)
         .each_with_object({}) { |x, m| m[x] = node[x.to_s] || defaults[x] }
-      [opts, node.at(ns("./renderterm")),
-       node.at(ns("./xref | ./eref | ./termref"))]
     end
 
     def concept1_linkmention(ref, renderterm, opts)
       (opts[:linkmention] == "true" && !renderterm.nil? && !ref.nil?) or return
       ref2 = ref.clone
       r2 = renderterm.clone
-      renderterm.replace(ref2).children = r2
+      #renderterm.replace(ref2).children = r2
+      ref2.children = r2
+      if ref.parent.name == "semx"
+        renderterm.replace("<semx element='#{ref.parent['element']}' source='#{ref.parent['source']}'>#{to_xml(ref2)}</semx>")
+      else
+        renderterm.replace(ref2)
+      end
     end
 
     def concept1_ref(_node, ref, opts)
       ref.nil? and return
       opts[:ref] == "false" and return ref.remove
       concept1_ref_content(ref)
-      %w(xref eref).include? ref.name and get_linkend(ref)
-      opts[:linkref] == "false" && %w(xref eref).include?(ref.name) and
+      %w(fmt-xref fmt-eref).include? ref.name and get_linkend(ref)
+      opts[:linkref] == "false" && %w(fmt-xref fmt-eref).include?(ref.name) and
         ref.replace(ref.children)
     end
 
@@ -64,27 +89,167 @@ module IsoDoc
       foll = "]"
       non_locality_elems(ref).select do |c|
         !c.text? || /\S/.match(c)
-      end.empty? and
+      end.empty? or
         (prev, foll = @i18n.term_defined_in.split("%"))
       ref.previous = prev
       ref.next = foll
     end
 
     def related(docxml)
-      docxml.xpath(ns("//related")).each { |f| related1(f) }
+      docxml.xpath(ns("//fmt-related/semx")).each { |f| related1(f) }
     end
 
     def related1(node)
-      p = node.at(ns("./preferred"))
-      ref = node.at(ns("./xref | ./eref | ./termref"))
-      label = @i18n.relatedterms[node["type"]].upcase
+      p, ref, orig = related1_prep(node)
+      label = @i18n.relatedterms[orig["type"]].upcase
       if p && ref
-        node.replace(l10n("<p><strong>#{label}:</strong> " \
+        node.children =(l10n("<p><strong>#{label}:</strong> " \
                           "<em>#{to_xml(p)}</em> (#{Common::to_xml(ref)})</p>"))
       else
-        node.replace(l10n("<p><strong>#{label}:</strong> " \
+        node.children = (l10n("<p><strong>#{label}:</strong> " \
                           "<strong>**RELATED TERM NOT FOUND**</strong></p>"))
       end
     end
+
+    def related1_prep(node)
+      p = node.at(ns("./fmt-preferred"))&.children
+      ref = node.at(ns("./xref | ./eref | ./termref"))
+      orig = semx_orig(node)
+      [p, ref, orig]
+    end
+
+    def related_designation1(desgn)
+      out = desgn.parent.at(ns("./fmt-#{desgn.name}"))
+      d1 = semx_fmt_dup(desgn)
+      %w(preferred admitted deprecates).each do |w|
+        d = d1.at(ns("./#{w}[last()]")) and d.after("<fmt-#{w}/>")
+      end
+      out << d1
+    end
+
+    def designation(docxml)
+      docxml.xpath(ns("//related")).each { |p| related_designation1(p) }
+      docxml.xpath(ns("//preferred | //admitted | //deprecates"))
+        .each { |p| designation1(p) }
+      docxml.xpath(ns("//fmt-preferred | //fmt-admitted | //fmt-deprecates"))
+        .each { |t| merge_second_preferred(t) }
+      docxml.xpath(ns("//fmt-deprecates")).each { |d| deprecates(d) }
+      docxml.xpath(ns("//fmt-admitted")).each { |d| admits(d) }
+    end
+
+    def deprecates(elem)
+      elem.xpath(ns(".//semx[@element = 'deprecates']")).each do |t|
+        t.previous = @i18n.l10n("#{@i18n.deprecated}: ")
+      end
+    end
+
+    def admits(elem); end
+
+    def merge_second_preferred(term)
+      pref = nil
+      out = term.xpath(ns("./semx")).each_with_index
+        .with_object([]) do |(p, i), m|
+        if (i.zero? && (pref = p)) || merge_preferred_eligible?(pref, p)
+          m << p
+        else
+          p.wrap("<p></p>")
+        end
+      end
+      pref&.replace(merge_second_preferred1(out, term))
+    end
+
+    def merge_second_preferred1(desgns, term)
+      desgns[1..].each(&:remove)
+      ret = l10n(desgns.map { |x| to_xml(x) }.join("; "))
+      term.ancestors("fmt-related").empty? and ret = "<p>#{ret}</p>"
+      ret
+    end
+
+    def merge_preferred_eligible?(first, second)
+      orig_first, orig_second, firstex, secondex =
+        merge_preferred_eligible_prep(first, second)
+      orig_first["geographic-area"] == orig_second["geographic-area"] &&
+        firstex["language"] == secondex["language"] &&
+        !orig_first.at(ns("./pronunciation | ./grammar | ./graphical-symbol")) &&
+        !orig_second.at(ns("./pronunciation | ./grammar | ./graphical-symbol")) &&
+        orig_first.name == "preferred" && orig_second.name == "preferred"
+    end
+
+    def merge_preferred_eligible_prep(first, second)
+      orig_first = semx_orig(first)
+      orig_second = semx_orig(second)
+      firstex = orig_first.at(ns("./expression")) || {}
+      secondex = orig_second.at(ns("./expression")) || {}
+      [orig_first, orig_second, firstex, secondex]
+    end
+
+    def designation1(desgn)
+      desgn.parent.name == "related" and return
+      out = desgn.parent.at(ns("./fmt-#{desgn.name}"))
+      d1 = semx_fmt_dup(desgn)
+      s = d1.at(ns("./termsource"))
+      name = d1.at(ns("./expression/name | ./letter-symbol/name | " \
+                         "./graphical-symbol")) or return
+      designation_annotate(d1, name, desgn)
+      out << d1
+      s and out << s.wrap("<fmt-termsource></fmt-termsource>").parent
+    end
+
+    def designation_annotate(desgn, name, orig)
+      designation_boldface(desgn)
+      designation_field(desgn, name, orig)
+      #g = desgn.at(ns("./expression/grammar")) and
+        #name << ", #{designation_grammar(g).join(', ')}"
+      designation_grammar(desgn, name)
+      designation_localization(desgn, name, orig)
+      designation_pronunciation(desgn, name)
+      designation_bookmarks(desgn, name)
+      desgn.children = name.children
+    end
+
+    def designation_boldface(desgn)
+      desgn["element"] == "preferred" or return
+      name = desgn.at(ns("./expression/name | ./letter-symbol/name")) or return
+      name.children = "<strong>#{name.children}</strong>"
+    end
+
+    def designation_field(desgn, name, orig)
+      f = orig.xpath(ns("./field-of-application | ./usage-info"))
+        &.map { |u| to_xml(semx_fmt_dup(u)) }&.join(", ")
+      f&.empty? and return nil
+      name << "<span class='fmt-designation-field'>, &#x3c;#{f}&#x3e;</span>"
+    end
+
+    def designation_grammar(desgn, name)
+      g = desgn.at(ns("./expression/grammar")) or return
+      ret = []
+      g.xpath(ns("./gender | ./number")).each do |x|
+        ret << @i18n.grammar_abbrevs[x.text]
+      end
+      %w(isPreposition isParticiple isAdjective isVerb isAdverb isNoun)
+        .each do |x|
+        g.at(ns("./#{x}[text() = 'true']")) and ret << @i18n.grammar_abbrevs[x]
+      end
+      name << ", #{ret.join(', ')}"
+    end
+
+    def designation_localization(desgn, name, orig_desgn)
+      loc = [desgn.at(ns("./expression/@language"))&.text,
+             desgn.at(ns("./expression/@script"))&.text,
+             orig_desgn.at("./@geographic-area")&.text].compact
+      loc.empty? and return
+      name << ", #{loc.join(' ')}"
+    end
+
+    def designation_pronunciation(desgn, name)
+      f = desgn.at(ns("./expression/pronunciation")) or return
+      name << ", /#{to_xml(f.children)}/"
+    end
+
+    def designation_bookmarks(desgn, name)
+      desgn.xpath(ns(".//bookmark")).each do |b|
+        name << b.remove
+      end
+    end
   end
 end