lib/isodoc/presentation_function/terms.rb in isodoc-1.8.1 vs lib/isodoc/presentation_function/terms.rb in isodoc-1.8.2

@@ -26,23 +26,27 @@
       node&.at(ns("./refterm"))&.remove
       r = node.at(ns("./renderterm"))
       ref = node.at(ns("./xref | ./eref | ./termref"))
       ref && opts[:ref] != "false" and r&.next = " "
       opts[:ital] == "true" and r&.name = "em"
-      if opts[:linkmention] == "true" && !r.nil? && !ref.nil?
-        ref2 = ref.clone
-        r2 = r.clone
-        r.replace(ref2).children = r2
-      end
+      concept1_linkmention(ref, r, opts)
       concept1_ref(node, ref, opts)
       if opts[:ital] == "false"
         r = node.at(ns(".//renderterm"))
         r&.replace(r&.children)
       end
       node.replace(node.children)
     end
 
+    def concept1_linkmention(ref, renderterm, opts)
+      if opts[:linkmention] == "true" && !renderterm.nil? && !ref.nil?
+        ref2 = ref.clone
+        r2 = renderterm.clone
+        renderterm.replace(ref2).children = r2
+      end
+    end
+
     def concept1_ref(_node, ref, opts)
       ref.nil? and return
       return ref.remove if opts[:ref] == "false"
 
       r = concept1_ref_content(ref)
@@ -76,67 +80,107 @@
       node.replace(l10n("<p><strong>#{label}:</strong> "\
                         "<em>#{p.to_xml}</em> (#{ref.to_xml})</p>"))
     end
 
     def designation(docxml)
-      docxml.xpath(ns("//preferred | //admitted | //deprecates")).each do |p|
-        designation1(p)
-      end
       docxml.xpath(ns("//term")).each do |t|
         merge_second_preferred(t)
       end
+      docxml.xpath(ns("//preferred | //admitted | //deprecates")).each do |p|
+        designation1(p)
+      end
     end
 
     def merge_second_preferred(term)
       pref = nil
-      term.xpath(ns("./preferred")).each_with_index do |p, i|
+      term.xpath(ns("./preferred[expression/name]")).each_with_index do |p, i|
         if i.zero? then pref = p
-        else
-          pref << l10n("; #{p.children.to_xml}")
+        elsif merge_preferred_eligible?(pref, p)
+          pref.at(ns("./expression/name")) <<
+            l10n("; #{p.at(ns('./expression/name')).children.to_xml}")
           p.remove
         end
       end
     end
 
+    def merge_preferred_eligible?(first, second)
+      firstex = first.at(ns("./expression")) || {}
+      secondex = second.at(ns("./expression")) || {}
+      first["geographic-area"] == second["geographic-area"] &&
+        firstex["language"] == secondex["language"] &&
+        !first.at(ns("./pronunciation | ./grammar")) &&
+        !second.at(ns("./pronunciation | ./grammar"))
+    end
+
     def designation1(desgn)
       s = desgn.at(ns("./termsource"))
       name = desgn.at(ns("./expression/name | ./letter-symbol/name | "\
                          "./graphical-symbol")) or return
 
+      designation_annotate(desgn, name)
+      s and desgn.next = s
+    end
+
+    def designation_annotate(desgn, name)
+      designation_boldface(desgn)
+      designation_field(desgn, name)
       g = desgn.at(ns("./expression/grammar")) and
-        name << " #{designation_grammar(g).join(', ')}"
+        name << ", #{designation_grammar(g).join(', ')}"
+      designation_localization(desgn, name)
+      designation_pronunciation(desgn, name)
       desgn.children = name.children
-      s and desgn.next = s
     end
 
+    def designation_boldface(desgn)
+      desgn.name == "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)
+      f = desgn.xpath(ns("./field-of-application | ./usage-info"))
+        &.map { |u| u.children.to_xml }&.join(", ")
+      return nil if f&.empty?
+
+      name << ", &lt;#{f}&gt;"
+    end
+
     def designation_grammar(grammar)
       ret = []
-      grammar.xpath(ns("./gender")).each do |x|
+      grammar.xpath(ns("./gender | ./number")).each do |x|
         ret << @i18n.grammar_abbrevs[x.text]
       end
       %w(isPreposition isParticiple isAdjective isVerb isAdverb isNoun)
         .each do |x|
         grammar.at(ns("./#{x}[text() = 'true']")) and
           ret << @i18n.grammar_abbrevs[x]
       end
       ret
     end
 
-        def definition1(elem)
-          nodes = Nokogiri::XML::NodeSet.new(elem.document)
-          v = elem&.at(ns("./verbaldefinition"))&.children and nodes += v
-          n = elem&.at(ns("./nonverbalrepresentation"))&.children and nodes += n
-          elem.children = nodes
-        end
+    def designation_localization(desgn, name)
+      loc = [desgn&.at(ns("./expression/@language"))&.text,
+             desgn&.at(ns("./expression/@script"))&.text,
+             desgn&.at(ns("./@geographic-area"))&.text].compact
+      return if loc.empty?
 
-            def termexample(docxml)
+      name << ", #{loc.join(' ')}"
+    end
+
+    def designation_pronunciation(desgn, name)
+      f = desgn.at(ns("./expression/pronunciation")) or return
+
+      name << ", /#{f.children.to_xml}/"
+    end
+
+    def termexample(docxml)
       docxml.xpath(ns("//termexample")).each do |f|
         example1(f)
       end
     end
 
-                def termnote(docxml)
+    def termnote(docxml)
       docxml.xpath(ns("//termnote")).each do |f|
         termnote1(f)
       end
     end
 
@@ -153,11 +197,11 @@
     end
 
     def termdefinition1(elem)
       unwrap_definition(elem)
       multidef(elem) if elem.xpath(ns("./definition")).size > 1
-      end
+    end
 
     def multidef(elem)
       d = elem.at(ns("./definition"))
       d = d.replace("<ol><li>#{d.children.to_xml}</li></ol>").first
       elem.xpath(ns("./definition")).each do |f|
@@ -165,15 +209,15 @@
         d << f
       end
       d.wrap("<definition></definition>")
     end
 
-           def unwrap_definition(elem)
-             elem.xpath(ns("./definition")).each do |d|
-          nodes = Nokogiri::XML::NodeSet.new(elem.document)
-          v = d&.at(ns("./verbaldefinition"))&.children and nodes += v
-          n = d&.at(ns("./nonverbalrepresentation"))&.children and nodes += n
-          d.children = nodes
-             end
+    def unwrap_definition(elem)
+      elem.xpath(ns("./definition")).each do |d|
+        %w(verbal-definition non-verbal-representation).each do |e|
+          v = d&.at(ns("./#{e}"))
+          v&.replace(v.children)
         end
+      end
+    end
   end
 end