metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/function/inline_simple.rb

@@ -0,0 +1,72 @@
+module IsoDoc::Function
+  module Inline
+    def section_break(body)
+      body.br
+    end
+
+    def page_break(out)
+      out.br
+    end
+
+    def pagebreak_parse(_node, out)
+      out.br
+    end
+
+    def hr_parse(node, out)
+      out.hr
+    end
+
+    def br_parse(node, out)
+      out.br
+    end
+
+    def index_parse(node, out)
+    end
+
+        def bookmark_parse(node, out)
+      out.a **attr_code(id: node["id"])
+    end
+
+    def keyword_parse(node, out)
+      out.span **{ class: "keyword" } do |s|
+        node.children.each { |n| parse(n, s) }
+      end
+    end
+
+    def em_parse(node, out)
+      out.i do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def strong_parse(node, out)
+      out.b do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def sup_parse(node, out)
+      out.sup do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def sub_parse(node, out)
+      out.sub do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def tt_parse(node, out)
+      out.tt do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def strike_parse(node, out)
+      out.s do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/function/lists.rb

@@ -0,0 +1,94 @@
+module IsoDoc::Function
+  module Lists
+    def ul_attrs(node)
+      { id: node["id"], style: keep_style(node) }
+    end
+
+    def ul_parse(node, out)
+      out.ul **attr_code(ul_attrs(node)) do |ul|
+        node.children.each { |n| parse(n, ul) }
+      end
+    end
+
+    OL_STYLE = {
+      arabic: "1",
+      roman: "i",
+      alphabet: "a",
+      roman_upper: "I",
+      alphabet_upper: "A",
+    }.freeze
+
+    def ol_style(type)
+      type = :alphabet unless type
+      OL_STYLE[type.to_sym]
+    end
+
+    # We don't really want users to specify type of ordered list;
+    # we will use a fixed hierarchy as practiced by ISO (though not
+    # fully spelled out): a) 1) i) A) I)
+
+    def ol_depth(node)
+      depth = node.ancestors("ul, ol").size + 1
+      type = :alphabet
+      type = :arabic if [2, 7].include? depth
+      type = :roman if [3, 8].include? depth
+      type = :alphabet_upper if [4, 9].include? depth
+      type = :roman_upper if [5, 10].include? depth
+      ol_style(type)
+    end
+
+    def ol_attrs(node)
+      { type: ol_depth(node), id: node["id"], style: keep_style(node) }
+    end
+
+    def ol_parse(node, out)
+      out.ol **attr_code(ol_attrs(node)) do |ol|
+        node.children.each { |n| parse(n, ol) }
+      end
+    end
+
+    def li_parse(node, out)
+      out.li  **attr_code(id: node["id"]) do |li|
+        if node["uncheckedcheckbox"] == "true"
+          li << '<span class="zzMoveToFollowing"><input type="checkbox" checked="checked"/></span>'
+        elsif node["checkedcheckbox"] == "true"
+          li << '<span class="zzMoveToFollowing"><input type="checkbox"/></span>'
+        end
+        node.children.each { |n| parse(n, li) }
+      end
+    end
+
+    def dt_parse(dt, term)
+      if dt.elements.empty?
+        #term.p **attr_code(class: note? ? "Note" : nil) do |p|
+        term.p do |p|
+          p << dt.text
+        end
+      else
+        dt.children.each { |n| parse(n, term) }
+      end
+    end
+
+    def dt_dd?(n)
+      %w{dt dd}.include? n.name
+    end
+
+    def dl_attrs(node)
+      attr_code(id: node["id"], style: keep_style(node))
+    end
+
+    def dl_parse(node, out)
+      out.dl  **dl_attrs(node) do |v|
+        node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
+          v.dt **attr_code(id: dt["id"]) do |term|
+            dt_parse(dt, term) 
+          end
+          v.dd  **attr_code(id: dd["id"]) do |listitem|
+            dd.children.each { |n| parse(n, listitem) }
+          end
+        end
+      end
+      node.elements.reject { |n| dt_dd? n }.each { |n| parse(n, out) }
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/function/references.rb

@@ -0,0 +1,214 @@
+module IsoDoc::Function
+  module References
+
+    # This is highly specific to ISO, but it's not a bad precedent for
+    # references anyway; keeping here instead of in IsoDoc::Iso for now
+    def docid_l10n(x)
+      return x if x.nil?
+      x.gsub(/All Parts/i, @i18n.all_parts.downcase) if @i18n.all_parts
+      x
+    end
+
+    # TODO generate formatted ref if not present
+    def nonstd_bibitem(list, b, ordinal, biblio)
+      list.p **attr_code(iso_bibitem_entry_attrs(b, biblio)) do |ref|
+        ids = bibitem_ref_code(b)
+        identifiers = render_identifier(ids)
+        if biblio then ref_entry_code(ref, ordinal, identifiers, ids)
+        else
+          ref << "#{identifiers[0] || identifiers[1]}"
+          ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+        end
+        ref << ", " unless biblio && !identifiers[1]
+        reference_format(b, ref)
+      end
+    end
+
+    def std_bibitem_entry(list, b, ordinal, biblio)
+      list.p **attr_code(iso_bibitem_entry_attrs(b, biblio)) do |ref|
+        identifiers = render_identifier(bibitem_ref_code(b))
+        if biblio then ref_entry_code(ref, ordinal, identifiers, nil)
+        else
+          ref << "#{identifiers[0] || identifiers[1]}"
+          ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+        end
+        date_note_process(b, ref)
+        ref << ", " unless biblio && !identifiers[1]
+        reference_format(b, ref)
+      end
+    end
+
+    # if t is just a number, only use that ([1] Non-Standard)
+    # else, use both ordinal, as prefix, and t
+    def ref_entry_code(r, ordinal, t, id)
+      prefix_bracketed_ref(r, t[0] || "[#{ordinal}]")
+      t[1] and r << "#{t[1]}"
+    end
+
+    def pref_ref_code(b)
+      b.at(ns("./docidentifier[not(@type = 'DOI' or @type = 'metanorma' "\
+              "or @type = 'ISSN' or @type = 'ISBN' or @type = 'rfc-anchor')]"))
+    end
+
+    # returns [metanorma, non-metanorma, DOI/ISSN/ISBN] identifiers
+    def bibitem_ref_code(b)
+      id = b.at(ns("./docidentifier[@type = 'metanorma']"))
+      id1 = pref_ref_code(b)
+      id2 = b.at(ns("./docidentifier[@type = 'DOI' or @type = 'ISSN' or @type = 'ISBN']")) 
+      return [id, id1, id2] if id || id1 || id2
+      id = Nokogiri::XML::Node.new("docidentifier", b.document)
+      id << "(NO ID)"
+      [nil, id, nil]
+    end
+
+    def bracket_if_num(x)
+      return nil if x.nil?
+      x = x.text.sub(/^\[/, "").sub(/\]$/, "")
+      return "[#{x}]" if /^\d+$/.match(x)
+      x
+    end
+
+    def render_identifier(id)
+      [
+        bracket_if_num(id[0]),
+        id[1].nil? ? nil :
+        docid_prefix(id[1]["type"], id[1].text.sub(/^\[/, "").sub(/\]$/, "")),
+        id[2].nil? ? nil :
+        docid_prefix(id[2]["type"], id[2].text.sub(/^\[/, "").sub(/\]$/, "")),
+      ]
+    end
+
+    def docid_prefix(prefix, docid)
+      docid = "#{prefix} #{docid}" if prefix && !omit_docid_prefix(prefix)
+      docid_l10n(docid)
+    end
+
+    def omit_docid_prefix(prefix)
+      return true if prefix.nil? || prefix.empty?
+      return %w(ISO IEC ITU W3C metanorma).include? prefix
+    end
+
+    def date_note_process(b, ref)
+      date_note = b.at(ns("./note[@type = 'ISO DATE']"))
+      return if date_note.nil?
+      date_note.children.first.replace("<p>#{date_note.content}</p>")
+      footnote_parse(date_note, ref)
+    end
+
+    def iso_bibitem_entry_attrs(b, biblio)
+      { id: b["id"], class: biblio ? "Biblio" : "NormRef" }
+    end
+
+    def iso_title(b)
+      title = b.at(ns("./title[@language = '#{@lang}' and @type = 'main']")) ||
+        b.at(ns("./title[@language = '#{@lang}']")) ||
+        b.at(ns("./title[@type = 'main']")) ||
+        b.at(ns("./title"))
+      title
+    end
+
+    # reference not to be rendered because it is deemed implicit
+    # in the standards environment
+    def implicit_reference(b)
+      false
+    end
+
+    def prefix_bracketed_ref(ref, text)
+      ref << text.to_s
+      insert_tab(ref, 1)
+    end
+
+    def reference_format(b, r)
+      if ftitle = b.at(ns("./formattedref"))
+        ftitle&.children&.each { |n| parse(n, r) }
+      else
+        title = iso_title(b)
+        r.i do |i|
+          title&.children&.each { |n| parse(n, i) }
+        end
+      end
+    end
+
+    def is_standard(b)
+      ret = false
+      b.xpath(ns("./docidentifier")).each do |id|
+        next if id["type"].nil? ||
+          %w(metanorma DOI ISSN ISBN).include?(id["type"])
+        ret = true
+      end
+      ret
+    end
+
+    def biblio_list(f, div, biblio)
+      i = 0
+      f.children.each do |b|
+        if b.name == "bibitem"
+          next if implicit_reference(b)
+          i += 1
+          (is_standard(b)) ? std_bibitem_entry(div, b, i, biblio) :
+            nonstd_bibitem(div, b, i, biblio)
+        else
+          parse(b, div) unless %w(title).include? b.name
+        end
+      end
+    end
+
+    def norm_ref_xpath
+      "//bibliography/references[@normative = 'true'] | "\
+        "//bibliography/clause[.//references[@normative = 'true']]"
+    end
+
+    def norm_ref(isoxml, out, num)
+      f = isoxml.at(ns(norm_ref_xpath)) or return num
+      out.div do |div|
+        num = num + 1
+        clause_name(num, f.at(ns("./title")), div, nil)
+        if f.name == "clause"
+          f.elements.each { |e| parse(e, div) unless e.name == "title" }
+        else
+          biblio_list(f, div, false)
+        end
+      end
+      num
+    end
+
+    def bibliography_xpath 
+      "//bibliography/clause[.//references]"\
+        "[not(.//references[@normative = 'true'])] | "\
+        "//bibliography/references[@normative = 'false']"
+    end
+
+    def bibliography(isoxml, out)
+      f = isoxml.at(ns(bibliography_xpath)) || return
+      page_break(out)
+      out.div do |div|
+        #div.h1 @bibliography_lbl, **{ class: "Section3" }
+        div.h1 **{class: "Section3"} do |h1|
+          f&.at(ns("./title"))&.children&.each { |c2| parse(c2, h1) }
+        end
+        biblio_list(f, div, true)
+      end
+    end
+
+    def bibliography_parse(node, out)
+      title = node&.at(ns("./title"))&.text || ""
+      out.div do |div|
+        clause_parse_title(node, div, node.at(ns("./title")), out, { class: "Section3" })
+        biblio_list(node, div, true)
+      end
+    end
+
+    def format_ref(ref, prefix, isopub, date, allparts)
+      ref = docid_prefix(prefix, ref)
+      return "[#{ref}]" if /^\d+$/.match(ref) && !prefix &&
+        !/^\[.*\]$/.match(ref)
+        ref
+    end
+
+    # def ref_names(ref)
+    #  linkend = ref.text
+    # linkend.gsub!(/[\[\]]/, "") unless /^\[\d+\]$/.match linkend
+    # @anchors[ref["id"]] = { xref: linkend }
+    # end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/function/reqt.rb

@@ -0,0 +1,115 @@
+module IsoDoc::Function
+  module Blocks
+    def recommendation_labels(node)
+      [node.at(ns("./label")), node.at(ns("./title")), node.at(ns("./name"))]
+    end
+
+    def recommendation_name(node, out, _type)
+      label, title, lbl = recommendation_labels(node)
+      out.p **{ class: "RecommendationTitle" }  do |b|
+        lbl and lbl.children.each { |n| parse(n, b) }
+        b << l10n(":")
+        if label || title
+          b.br
+          label and label.children.each { |n| parse(n,b) }
+          b << "#{clausedelim} " if label && title
+          title and title.children.each { |n| parse(n,b) }
+        end
+      end
+    end
+
+    def recommendation_attributes1(node) 
+      out = [] 
+      oblig = node["obligation"] and
+        out << l10n("#{@i18n.obligation}: #{oblig}")
+      subj = node&.at(ns("./subject"))&.text and
+        out << l10n("#{@i18n.subject}: #{subj}")
+      node.xpath(ns("./inherit")).each do |i|
+        out << recommendation_attr_parse(i, @i18n.inherits)
+      end
+      node.xpath(ns("./classification")).each do |c|
+        line = recommendation_attr_keyvalue(c, "tag", "value") and out << line
+      end
+      out
+    end
+
+    def recommendation_attr_parse(node, label)
+      noko do |xml|
+        xml << "#{label}: "
+        node.children.each { |n| parse(n, xml) }
+      end.join
+    end
+
+    def recommendation_attr_keyvalue(node, key, value)
+      tag = node.at(ns("./#{key}")) or return nil
+      value = node.at(ns("./#{value}")) or return nil
+      "#{tag.text.capitalize}: #{value.text}"
+    end
+
+    def recommendation_attributes(node, out)
+      ret = recommendation_attributes1(node)
+      return if ret.empty?
+      out.p do |p|
+        p.i do |i|
+          i << ret.join("<br/>")
+        end
+      end
+    end
+
+    def reqt_metadata_node(n)
+      %w(label title subject classification tag value 
+      inherit name).include? n.name
+    end
+
+    def reqt_attrs(node, klass)
+      attr_code(class: klass, id: node["id"], style: keep_style(node))
+    end
+
+    def recommendation_parse(node, out)
+      out.div **reqt_attrs(node, "recommend") do |t|
+        recommendation_name(node, t, @i18n.recommendation)
+        recommendation_attributes(node, out)
+        node.children.each do |n|
+          parse(n, t) unless reqt_metadata_node(n)
+        end
+      end
+    end
+
+    def requirement_parse(node, out)
+      out.div **reqt_attrs(node, "require") do |t|
+        recommendation_name(node, t, @i18n.requirement)
+        recommendation_attributes(node, out)
+        node.children.each do |n|
+          parse(n, t) unless reqt_metadata_node(n)
+        end
+      end
+    end
+
+    def permission_parse(node, out)
+      out.div **reqt_attrs(node, "permission") do |t|
+        recommendation_name(node, t, @i18n.permission)
+        recommendation_attributes(node, out)
+        node.children.each do |n|
+          parse(n, t) unless reqt_metadata_node(n)
+        end
+      end
+    end
+
+    def reqt_component_attrs(node)
+      attr_code(class: "requirement-" + node.name,
+                style: keep_style(node))
+    end
+
+    def requirement_component_parse(node, out)
+      return if node["exclude"] == "true"
+      out.div **reqt_component_attrs(node) do |div|
+        node.children.each do |n|
+          parse(n, div)
+        end
+      end
+    end
+
+    def requirement_skip_parse(node, out)
+    end
+  end
+end