isodoc 2.12.0 → 2.12.2

data/lib/isodoc/xref/xref_gen_seq.rb

@@ -11,6 +11,10 @@ module IsoDoc
         "-"
       end
 
+      def hierreqtsep
+        "-"
+      end
+
       def subfigure_increment(idx, counter, elem)
         if elem.parent.name == "figure" then idx += 1
         else
@@ -30,7 +34,8 @@ module IsoDoc
         clause.xpath(ns(self.class::FIGURE_NO_CLASS)).noblank.each do |t|
           # labelled_ancestor(t, %w(figure)) and next # disable nested figure labelling
           j = subfigure_increment(j, c, t)
-          sequential_figure_body(j, c, t, "figure", container:)
+          sublabel = subfigure_label(j)
+          figure_anchor(t, sublabel, c.print, "figure", container: container)
         end
         sequential_figure_class_names(clause, container:)
       end
@@ -43,24 +48,69 @@ module IsoDoc
           c[t["class"]] ||= Counter.new
           # labelled_ancestor(t, %w(figure)) and next
           j = subfigure_increment(j, c[t["class"]], t)
-          sequential_figure_body(j, c[t["class"]], t, t["class"],
-                                 container:)
+          sublabel = subfigure_label(j)
+          figure_anchor(t, sublabel, c[t["class"]].print, t["class"],
+                        container: container)
         end
       end
 
+      def hier_separator(markup: false)
+        h = hiersep
+        h.blank? || !markup or h = delim_wrap(h)
+        h
+      end
+
       def subfigure_label(subfignum)
-        subfignum.zero? and return ""
-        "#{hierfigsep}#{subfignum}"
+        subfignum.zero? and return
+        subfignum.to_s
+      end
+
+      def subfigure_separator(markup: false)
+        h = hierfigsep
+        h.blank? || !markup or h = delim_wrap(h)
+        h
+      end
+
+      def subreqt_separator(markup: false)
+        h = hierreqtsep
+        h.blank? || !markup or h = delim_wrap(h)
+        h
+      end
+
+      def subfigure_delim
+        ""
+      end
+
+      def figure_anchor(elem, sublabel, label, klass, container: false)
+        if sublabel
+          /<semx/.match?(label) or label = semx(elem.parent, label)
+          subfigure_anchor(elem, sublabel, label, klass, container: false)
+        else
+          @anchors[elem["id"]] = anchor_struct(
+            label, elem, @labels[klass] || klass.capitalize, klass,
+            { unnumb: elem["unnumbered"], container: }
+          )
+        end
+      end
+
+      def fig_subfig_label(label, sublabel)
+        "#{label}#{subfigure_separator}#{sublabel}"
       end
 
-      def sequential_figure_body(subfig, counter, elem, klass, container: false)
-        label = counter.print
-        label &&= label + subfigure_label(subfig)
+      def subfigure_anchor(elem, sublabel, label, klass, container: false)
+        figlabel = fig_subfig_label(label, sublabel)
         @anchors[elem["id"]] = anchor_struct(
-          label, container ? elem : nil,
-          @labels[klass] || klass.capitalize, klass,
-          elem["unnumbered"]
+          figlabel, elem, @labels[klass] || klass.capitalize, klass,
+          { unnumb: elem["unnumbered"] }
         )
+        if elem["unnumbered"] != "true"
+          x = "#{subfigure_separator(markup: true)}#{semx(elem, sublabel)}"
+          @anchors[elem["id"]][:label] = "#{label}#{x}" # "#{semx(elem.parent, label)}#{x}"
+          @anchors[elem["id"]][:xref] = @anchors[elem.parent["id"]][:xref] + x +
+            delim_wrap(subfigure_delim)
+          x = @anchors[elem.parent["id"]][:container] and
+          @anchors[elem["id"]][:container] = x
+        end
       end
 
       def sequential_table_names(clause, container: false)
@@ -68,8 +118,8 @@ module IsoDoc
         clause.xpath(ns(".//table")).noblank.each do |t|
           # labelled_ancestor(t) and next
           @anchors[t["id"]] = anchor_struct(
-            c.increment(t).print, container ? t : nil,
-            @labels["table"], "table", t["unnumbered"]
+            c.increment(t).print, t,
+            @labels["table"], "table", { unnumb: t["unnumbered"], container: container }
           )
         end
       end
@@ -80,7 +130,7 @@ module IsoDoc
           @anchors[t["id"]] = anchor_struct(
             c.increment(t).print, t,
             t["inequality"] ? @labels["inequality"] : @labels["formula"],
-            "formula", t["unnumbered"]
+            "formula", { unnumb: t["unnumbered"], container: true }
           )
         end
       end
@@ -95,39 +145,49 @@ module IsoDoc
         ./permission | ./requirement | ./recommendation
       XPATH
 
-      def sequential_permission_names(clause, container: false)
+      def sequential_permission_names(clause, container: true)
         c = ReqCounter.new
         clause.xpath(ns(FIRST_LVL_REQ)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_label(t, m)
           id = c.increment(label, t).print
-          sequential_permission_body(id, t, label, klass, m,
+          sequential_permission_body(id, nil, t, label, klass, m,
                                      container:)
-          sequential_permission_children(t, id, container:)
+          sequential_permission_children(t, id, klass, container:)
         end
       end
 
-      def sequential_permission_children(elem, lbl, container: false)
+      def sequential_permission_children(elem, lbl, klass, container: false)
         c = ReqCounter.new
         elem.xpath(ns(REQ_CHILDREN)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_nested_label(t, m)
-          id = "#{lbl}#{hierfigsep}#{c.increment(label, t).print}"
-          sequential_permission_body(id, t, label, klass, m,
+          ctr = c.increment(label, t).print
+          id = "#{lbl}#{subreqt_separator}#{ctr}"
+          sequential_permission_body(ctr, lbl, t, label, klass, m,
                                      container:)
-          sequential_permission_children(t, id, container:)
+          sequential_permission_children(t, id, klass, container:)
         end
       end
 
-      def sequential_permission_body(id, elem, label, klass, model,
+      def sequential_permission_body(id, parent_id, elem, label, klass, model,
 container: false)
+        lbl = parent_id ? "#{parent_id}#{subreqt_separator}#{id}" : id
         @anchors[elem["id"]] = model.postprocess_anchor_struct(
-          elem, anchor_struct(id, elem,
-                              label, klass, elem["unnumbered"])
+          elem, anchor_struct(lbl, elem,
+                              label, klass, { unnumb: elem["unnumbered"], container: })
         )
+        @anchors[elem["id"]][:semx] = semx(elem, lbl)
+        if parent_id
+          x = "#{subreqt_separator(markup: true)}#{semx(elem, id)}"
+          @anchors[elem["id"]][:semx] = @anchors[elem.parent["id"]][:semx] + x
+          @anchors[elem["id"]][:label] =
+            "<span class='fmt-element-name'>#{label}</span> #{@anchors[elem["id"]][:semx]}"
+          @anchors[elem["id"]][:xref] =  "<span class='fmt-element-name'>#{label}</span> #{@anchors[elem["id"]][:semx]}"
+        end
         model.permission_parts(elem, id, label, klass).each do |n|
           @anchors[n[:id]] = anchor_struct(n[:number], n[:elem], n[:label],
-                                           n[:klass], false)
+                                           n[:klass], { unnumb: false, container: })
         end
       end
 
@@ -156,44 +216,61 @@ container: false)
         sequential_permission_names(clause, container:)
       end
 
-      def hierarchical_figure_names(clause, num)
+      def nodeSet(clauses)
+        case clauses
+        when Nokogiri::XML::Node
+          [clauses]
+        when Nokogiri::XML::NodeSet
+          clauses
+        end
+      end
+
+      # these can take a NodeSet as argument; semx will point to members of the NodeSet,
+      # but numbering will be consecutive
+      def hierarchical_figure_names(clauses, num)
         c = Counter.new
         j = 0
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(self.class::FIGURE_NO_CLASS)).noblank.each do |t|
           # labelled_ancestor(t, %w(figure)) and next
           j = subfigure_increment(j, c, t)
-          hierarchical_figure_body(num, j, c, t, "figure")
+          sublabel = subfigure_label(j)
+          # hierarchical_figure_body(num, j, c, t, "figure")
+          #figure_anchor(t, sublabel, "#{num}#{hier_separator}#{c.print}", "figure")
+          #require "debug"; binding.b
+          figure_anchor(t, sublabel, hiersemx(clause, num, c, t), "figure")
         end
         hierarchical_figure_class_names(clause, num)
+        end
       end
 
-      def hierarchical_figure_class_names(clause, num)
+      def hierarchical_figure_class_names(clauses, num)
         c = {}
         j = 0
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(".//figure[@class][not(@class = 'pseudocode')]"))
           .noblank.each do |t|
           # labelled_ancestor(t, %w(figure)) and next
           c[t["class"]] ||= Counter.new
           j = subfigure_increment(j, c[t["class"]], t)
-          hierarchical_figure_body(num, j, c[t["class"]], t, t["class"])
+          sublabel = subfigure_label(j)
+          # hierarchical_figure_body(num, j, c[t["class"]], t, t["class"])
+          #figure_anchor(t, sublabel, "#{num}#{hier_separator}#{c[t['class']].print}", t["class"])
+          figure_anchor(t, sublabel, hiersemx(clause, num, c[t["class"]], t), t["class"])
+        end
         end
       end
 
-      def hierarchical_figure_body(num, subfignum, counter, block, klass)
-        label = "#{num}#{hiersep}#{counter.print}" +
-          subfigure_label(subfignum)
-        @anchors[block["id"]] =
-          anchor_struct(label, nil, @labels[klass] || klass.capitalize,
-                        klass, block["unnumbered"])
-      end
-
-      def hierarchical_table_names(clause, num)
+      def hierarchical_table_names(clauses, num)
         c = Counter.new
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(".//table")).noblank.each do |t|
           # labelled_ancestor(t) and next
           @anchors[t["id"]] =
-            anchor_struct("#{num}#{hiersep}#{c.increment(t).print}",
-                          nil, @labels["table"], "table", t["unnumbered"])
+            #anchor_struct("#{num}#{hier_separator}#{c.increment(t).print}",
+            anchor_struct(hiersemx(clause, num, c.increment(t), t),
+                          t, @labels["table"], "table", { unnumb: t["unnumbered"], container: false })
+        end
         end
       end
 
@@ -204,47 +281,59 @@ container: false)
         hierarchical_permission_names(clause, num)
       end
 
-      def hierarchical_formula_names(clause, num)
+      def hierarchical_formula_names(clauses, num)
         c = Counter.new
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(".//formula")).noblank.each do |t|
           @anchors[t["id"]] = anchor_struct(
-            "#{num}#{hiersep}#{c.increment(t).print}", nil,
+            #"#{num}#{hier_separator}#{c.increment(t).print}", t,
+                     hiersemx(clause, num, c.increment(t), t), t,
             t["inequality"] ? @labels["inequality"] : @labels["formula"],
-            "formula", t["unnumbered"]
+            "formula", { unnumb: t["unnumbered"], container: false }
           )
         end
+        end
       end
 
-      def hierarchical_permission_names(clause, num)
+      def hierarchical_permission_names(clauses, num)
         c = ReqCounter.new
+        nodeSet(clauses).each do |clause|
         clause.xpath(ns(FIRST_LVL_REQ)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_label(t, m)
-          id = "#{num}#{hiersep}#{c.increment(label, t).print}"
-          hierarchical_permission_body(id, t, label, klass, m)
-          hierarchical_permission_children(t, id)
+          #id = "#{num}#{hier_separator}#{c.increment(label, t).print}"
+          id = hiersemx(clause, num, c.increment(label, t), t)
+          sequential_permission_body(id, nil, t, label, klass, m, container: false)
+          sequential_permission_children(t, id, klass, container: false)
         end
+       end
       end
 
+      # TODO remove
       def hierarchical_permission_children(block, lbl)
         c = ReqCounter.new
         block.xpath(ns(REQ_CHILDREN)).noblank.each do |t|
           m = @reqt_models.model(t["model"])
           klass, label = reqt2class_nested_label(t, m)
-          id = "#{lbl}#{hierfigsep}#{c.increment(label, t).print}"
-          hierarchical_permission_body(id, t, label, klass, m)
+          id = "#{lbl}#{subreqt_separator}#{c.increment(label, t).print}"
+          sequential_permission_body(c.print, lbl, t, label, klass, m)
           hierarchical_permission_children(t, id)
         end
       end
 
-      def hierarchical_permission_body(id, block, label, klass, model)
-        @anchors[block["id"]] = model.postprocess_anchor_struct(
-          block, anchor_struct(id, nil,
-                               label, klass, block["unnumbered"])
+      # TODO remove
+      def hierarchical_permission_body(id, parent_id, elem, label, klass, model)
+        @anchors[elem["id"]] = model.postprocess_anchor_struct(
+          elem, anchor_struct(id, elem,
+                              label, klass, { unnumb: elem["unnumbered"], container: false })
         )
-        model.permission_parts(block, id, label, klass).each do |n|
-          @anchors[n[:id]] = anchor_struct(n[:number], nil, n[:label],
-                                           n[:klass], false)
+        x = "#{subreqt_separator(markup: true)}#{semx(elem, id)}"
+        @anchors[elem["id"]][:label] = "#{semx(elem.parent, parent_id)}#{x}"
+        @anchors[elem["id"]][:xref] = @anchors[elem.parent["id"]][:xref] + x
+        model.permission_parts(elem, id, label, klass).each do |n|
+          # we don't have an n["id"], so we allow n[:id] in anchor_struct
+          @anchors[n[:id]] = anchor_struct(n[:number], n, n[:label],
+                                           n[:klass], { unnumb: false, container: false })
         end
       end
     end

data/lib/isodoc/xref/xref_sect_gen.rb

@@ -8,9 +8,6 @@ module IsoDoc
           annex_anchor_names(xml)
           back_clauses_anchor_names(xml)
         end
-        if @klass.bibrender && (@parse_settings.empty? || @parse_settings[:refs])
-          references(xml)
-        end
       end
 
       def annex_anchor_names(xml)
@@ -33,11 +30,7 @@ module IsoDoc
         end
       end
 
-      def references(docxml)
-        docxml.xpath(ns("//bibitem[not(ancestor::bibitem)]")).each do |ref|
-          reference_names(ref)
-        end
-      end
+      # NOTE: references processing has moved to Presentation XML
 
       def initial_anchor_names(xml)
         if @parse_settings.empty? || @parse_settings[:clauses]
@@ -83,8 +76,9 @@ module IsoDoc
 
       def clause_title(clause, use_elem_name: false)
         ret = clause.at(ns("./title"))&.text
-        if use_elem_name && !ret
-          clause.name.capitalize
+        if use_elem_name && ret.blank?
+          @i18n.labels[clause.name]&.capitalize ||
+            clause.name.capitalize
         else ret
         end
       end
@@ -107,11 +101,13 @@ module IsoDoc
 
       def unnumbered_names(clause)
         clause.nil? and return
-        preface_name_anchors(clause, 1,
-                             clause_title(clause, use_elem_name: true))
+        title = clause_title(clause, use_elem_name: true)
+        preface_name_anchors(clause, 1, title)
         clause.xpath(ns(SUBCLAUSES)).each_with_index do |c, i|
-          preface_names1(c, c.at(ns("./title"))&.text,
-                         "#{clause_title(clause)}, #{i + 1}", 2)
+          t = c.at(ns("./title"))
+          tt = "#{semx(clause, title, clause.name)}" \
+            "<span class='fmt-comma'>,</span> #{semx(c, i + 1)}"
+          preface_names1(c, t ? semx(c, t.text, c.name) : nil, tt, 2)
         end
       end
 
@@ -119,15 +115,18 @@ module IsoDoc
         label = title || parent_title
         preface_name_anchors(clause, level, title || parent_title)
         clause.xpath(ns(SUBCLAUSES)).each_with_index do |c, i|
-          preface_names1(c, c.at(ns("./title"))&.text, "#{label} #{i + 1}",
+          t = c.at(ns("./title"))
+          preface_names1(c, t ? semx(c, t.text, c.name) : nil,
+                         "#{label} #{semx(c, i + 1)}",
                          level + 1)
         end
       end
 
       def preface_name_anchors(clause, level, title)
+        xref = semx(clause, title, clause.name)
         @anchors[clause["id"]] =
           { label: nil, level:,
-            xref: title, title: nil,
+            xref:, title: nil,
             type: "clause", elem: @labels["clause"] }
       end
 
@@ -142,20 +141,32 @@ module IsoDoc
       def section_names(clause, num, lvl)
         unnumbered_section_name?(clause) and return num
         num.increment(clause)
-        section_name_anchors(clause, num.print, lvl)
+        lbl = semx(clause, num.print)
+        section_name_anchors(clause, lbl, lvl)
         clause.xpath(ns(SUBCLAUSES))
-          .each_with_object(clause_counter(0, prefix: num.print)) do |c, i|
-          section_names1(c, i.increment(c).print, lvl + 1)
+          .each_with_object(clause_counter(0)) do |c, i|
+          section_names1(c, lbl, i.increment(c).print, lvl + 1)
         end
         num
       end
 
-      def section_names1(clause, num, level)
+      def clause_number_semx(parentnum, clause, num)
+        if clause["branch-number"]
+                semx(clause, clause["branch-number"])
+        elsif parentnum.nil?
+          semx(clause, num)
+              else
+                "#{parentnum}#{delim_wrap(clausesep)}#{semx(clause, num)}"
+              end
+      end
+
+      def section_names1(clause, parentnum, num, level)
         unnumbered_section_name?(clause) and return num
-        section_name_anchors(clause, num, level)
-        i = clause_counter(0, prefix: num)
+        lbl = clause_number_semx(parentnum, clause, num)
+        section_name_anchors(clause, lbl, level)
+        i = clause_counter(0)
         clause.xpath(ns(SUBCLAUSES)).each do |c|
-          section_names1(c, i.increment(c).print, level + 1)
+          section_names1(c, lbl, i.increment(c).print, level + 1)
         end
       end
 
@@ -168,10 +179,16 @@ module IsoDoc
         false
       end
 
+      def clausesep
+        "."
+      end
+
       def section_name_anchors(clause, num, level)
+        xref = labelled_autonum(@labels["clause"], num)
+        label = num
+        c = clause_title(clause) and title = semx(clause, c, "title")
         @anchors[clause["id"]] =
-          { label: num, xref: "#{@labels['clause']} #{num}",
-            title: clause_title(clause), level:, type: "clause",
+          { label:, xref:, title:, level:, type: "clause",
             elem: @labels["clause"] }
       end
 
@@ -179,52 +196,52 @@ module IsoDoc
         obl = "(#{@labels['inform_annex']})"
         clause["obligation"] == "normative" and
           obl = "(#{@labels['norm_annex']})"
+        obl = "<span class='fmt-obligation'>#{l10n obl}</fmt>"
         title = Common::case_with_markup(@labels["annex"], "capital",
                                          @script)
-        "<strong>#{title} #{num}</strong><br/>#{obl}"
+        s = labelled_autonum(title, num)
+        "<strong><span class='fmt-caption-label'>#{s}</span></strong><br/>#{obl}"
       end
 
       def annex_name_anchors(clause, num, level)
         label = num
         level == 1 && clause.name == "annex" and
-          label = annex_name_lbl(clause, num)
+          label = annex_name_lbl(clause, label)
+        xref = labelled_autonum(@labels["annex"], num)
+        c = clause_title(clause) and title = semx(clause, c, "title")
         @anchors[clause["id"]] =
-          { label:,
+          { label:, xref:, title:,
             elem: @labels["annex"], type: "clause",
-            subtype: "annex", value: num.to_s, level:,
-            title: clause_title(clause),
-            xref: "#{@labels['annex']} #{num}" }
+            subtype: "annex", value: num.to_s, level: }
       end
 
       def annex_names(clause, num)
-        annex_name_anchors(clause, num, 1)
+        label = semx(clause, num)
+        annex_name_anchors(clause, label, 1)
         if @klass.single_term_clause?(clause)
           annex_names1(clause.at(ns("./references | ./terms | ./definitions")),
-                       num.to_s, 1)
+                       nil, num.to_s, 1)
         else
           clause.xpath(ns(SUBCLAUSES))
-            .each_with_object(clause_counter(0, prefix: num)) do |c, i|
-            annex_names1(c, i.increment(c).print, 2)
+            .each_with_object(clause_counter(0)) do |c, i|
+            annex_names1(c, label, i.increment(c).print, 2)
           end
         end
-        hierarchical_asset_names(clause, num)
+        hierarchical_asset_names(clause, label)
       end
 
-      def annex_names1(clause, num, level)
-        annex_name_anchors(clause, num, level)
-        i = clause_counter(0, prefix: num)
+      def annex_names1(clause, parentnum, num, level)
+        lbl = clause_number_semx(parentnum, clause, num)
+        annex_name_anchors1(clause, lbl, level)
+        i = clause_counter(0)
         clause.xpath(ns(SUBCLAUSES)).each do |c|
-          annex_names1(c, i.increment(c).print, level + 1)
+          annex_names1(c, lbl, i.increment(c).print, level + 1)
         end
       end
 
-      def reference_names(ref)
-        ids = @klass.bibitem_ref_code(ref)
-        identifiers = @klass.render_identifier(ids)
-        reference = @klass
-          .docid_l10n(identifiers[:metanorma] || identifiers[:sdo] ||
-                      identifiers[:ordinal] || identifiers[:doi])
-        @anchors[ref["id"]] = { xref: reference }
+      # subclauses of Annexes
+      def annex_name_anchors1(clause, num, level)
+        annex_name_anchors(clause, num, level)
       end
     end
   end

data/lib/isodoc/xref/xref_util.rb

@@ -6,9 +6,15 @@ module Enumerable
   end
 end
 
+class Object
+  def blank?
+    nil? || empty?
+  end
+end
+
 module IsoDoc
   module XrefGen
-    module Blocks
+    module Util
       def blank?(text)
         text.nil? || text.empty?
       end
@@ -37,6 +43,48 @@ module IsoDoc
 
       CHILD_SECTIONS = "./clause | ./appendix | ./terms | ./definitions | " \
                  "./references".freeze
+
+      def child_sections
+        CHILD_SECTIONS
+      end
+
+      # if hierarchically marked up node in label already,
+      # leave alone, else wrap in semx
+      def semx(node, label, element = "autonum")
+        label = label.to_s
+        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
+
+      # assume parent is already semantically annotated with semx
+      def hiersemx(parent, parentlabel, counter, element, sep: nil)
+        sep ||= hier_separator(markup: true)
+        "#{semx(parent, parentlabel)}#{sep}#{semx(element, counter.print)}"
+      end
+
+      def delim_wrap(delim, klass = "fmt-autonum-delim")
+        delim.blank? and return ""
+        "<span class='#{klass}'>#{delim}</span>"
+      end
+
+      def stripsemx(elem)
+        elem.nil? and return elem
+        xml = Nokogiri::XML::DocumentFragment.parse(elem)
+        xml.traverse do |x|
+          x.name == "semx" ||
+            (x.name == "span" && /^fmt-/.match?(x["class"])) and
+            x.replace(x.children)
+        end
+        xml.to_xml(indent: 0, encoding: "UTF-8",
+                   save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
+      end
+
+      def labelled_autonum(label, autonum)
+        label.blank? and return autonum
+        l10n("<span class='fmt-element-name'>#{label}</span> #{autonum}")
+      end
     end
   end
 end

data/lib/isodoc/xref.rb

@@ -4,6 +4,7 @@ require_relative "xref/xref_counter_types"
 require_relative "xref/xref_gen_seq"
 require_relative "xref/xref_gen"
 require_relative "xref/xref_sect_gen"
+require_relative "xref/xref_util"
 require_relative "class_utils"
 require_relative "function/utils"
 
@@ -92,5 +93,7 @@ module IsoDoc
     def l10n(text, lang = @lang, script = @script, locale = @locale)
       @i18n.l10n(text, lang, script, locale)
     end
+
+    include ::IsoDoc::XrefGen::Util
   end
 end

data/lib/isodoc-yaml/i18n-ar.yaml

@@ -33,15 +33,15 @@ internal_external_terms_boilerplate: |
   لأغراض هذه الوثيقة ،تنطبق المصطلحات والتعاريف الواردة في % وما يلي.
 no_information_available: "[لا توجد معلومات متاحة]"
 term_defined_in: "(%)"
-binary_and: "%1 و %2"
-multiple_and: "%1, و %2"
-binary_or: "%1 او %2"
-multiple_or: "%1, او %2"
-chain_and: "%1 و %2"
-chain_or: "%1 او %2"
-chain_from: "%1 %من 2"
-chain_to: "من %1 إلى %2"
-nested_xref: "%1, %2"
+binary_and: "%1 <conn>ﻭ</conn> %2"
+multiple_and: "%1<enum-comma>,</enum-comma> <conn>ﻭ</conn> %2"
+binary_or: "%1 <conn>ﺍﻭ</conn> %2"
+multiple_or: "%1<enum-comma>,</enum-comma> <conn>ﺍﻭ</conn> %2"
+chain_and: "%1 <conn>ﻭ</conn> %2"
+chain_or: "%1 <conn>ﺍﻭ</conn> %2"
+chain_from: "%1 <conn>%ﻢﻧ</conn> 2"
+chain_to: "<conn>ﻢﻧ</conn> %1 <conn>ﺈﻟﻯ</conn> %2"
+nested_xref: "%1<comma>,</comma> %2"
 list_nested_xref: "%1 %2"
 ordinal_keys: [gender]
 SpelloutRules: