metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,228 @@
+module IsoDoc::Function
+  module Section
+    def clausedelim
+      "."
+    end
+
+    def clausedelimspace(out)
+      insert_tab(out, 1)
+    end
+
+    def inline_header_title(out, node, title)
+      out.span **{ class: "zzMoveToFollowing" } do |s|
+        s.b do |b|
+          title&.children&.each { |c2| parse(c2, b) }
+          clausedelimspace(out) if /\S/.match(title&.text)
+        end
+      end
+    end
+
+    # used for subclauses
+    def clause_parse_title(node, div, title, out, header_class = {})
+      return if title.nil?
+      if node["inline-header"] == "true"
+        inline_header_title(out, node, title)
+      else
+        depth = (title && title["depth"]) ? title["depth"] :
+          node.ancestors("clause, annex, terms, references, definitions, "\
+                        "acknowledgements, introduction, foreword").size + 1
+        div.send "h#{depth}", **attr_code(header_class) do |h|
+          title&.children&.each { |c2| parse(c2, h) }
+        end
+      end
+    end
+
+    def clause_attrs(node)
+      { id: node["id"] }
+    end
+
+    # used for subclauses
+    def clause_parse(node, out)
+      out.div **attr_code(clause_attrs(node)) do |div|
+        clause_parse_title(node, div, node.at(ns("./title")), out)
+        node.children.reject { |c1| c1.name == "title" }.each do |c1|
+          parse(c1, div)
+        end
+      end
+    end
+
+    def clause_name(_num, title, div, header_class)
+      header_class = {} if header_class.nil?
+      div.h1 **attr_code(header_class) do |h1|
+        title.is_a?(String) ? h1 << title :
+          title&.children&.each { |c2| parse(c2, h1) }
+      end
+      div.parent.at(".//h1")
+    end
+
+    def clause(isoxml, out)
+      isoxml.xpath(ns(middle_clause)).each do |c|
+        out.div **attr_code(clause_attrs(c)) do |s|
+          clause_name(nil, c&.at(ns("./title")), s, nil)
+          c.elements.reject { |c1| c1.name == "title" }.each do |c1|
+            parse(c1, s)
+          end
+        end
+      end
+    end
+
+    def annex_name(annex, name, div)
+      return if name.nil?
+      div.h1 **{ class: "Annex" } do |t|
+        name.children.each { |c2| parse(c2, t) }
+      end
+    end
+
+    def annex_attrs(node)
+      { id: node["id"], class: "Section3" }
+    end
+
+    def annex(isoxml, out)
+      isoxml.xpath(ns("//annex")).each do |c|
+        page_break(out)
+        out.div **attr_code(annex_attrs(c)) do |s|
+          c.elements.each do |c1|
+            if c1.name == "title" then annex_name(c, c1, s)
+            else
+              parse(c1, s)
+            end
+          end
+        end
+      end
+    end
+
+    def scope(isoxml, out, num)
+      f = isoxml.at(ns("//clause[@type = 'scope']")) or return num
+      out.div **attr_code(id: f["id"]) do |div|
+        num = num + 1
+        clause_name(num, f&.at(ns("./title")), div, nil)
+        f.elements.each do |e|
+          parse(e, div) unless e.name == "title"
+        end
+      end
+      num
+    end
+
+    TERM_CLAUSE = "//sections/terms | "\
+      "//sections/clause[descendant::terms]".freeze
+
+    def terms_defs(isoxml, out, num)
+      f = isoxml.at(ns(TERM_CLAUSE)) or return num
+      out.div **attr_code(id: f["id"]) do |div|
+        num = num + 1
+        clause_name(num, f&.at(ns("./title")), div, nil)
+        f.elements.each do |e|
+          parse(e, div) unless %w{title source}.include? e.name
+        end
+      end
+      num
+    end
+
+    # subclause
+    def terms_parse(isoxml, out)
+      clause_parse(isoxml, out)
+    end
+
+    def symbols_abbrevs(isoxml, out, num)
+      f = isoxml.at(ns("//sections/definitions")) or return num
+      out.div **attr_code(id: f["id"], class: "Symbols") do |div|
+        num = num + 1
+        clause_name(num, f&.at(ns("./title")) || @i18n.symbols, div, nil)
+        f.elements.each do |e|
+          parse(e, div) unless e.name == "title"
+        end
+      end
+      num
+    end
+
+    # subclause
+    def symbols_parse(isoxml, out)
+      isoxml.at(ns("./title")) or
+        isoxml.children.first.previous = "<title>#{@i18n.symbols}</title>"
+      clause_parse(isoxml, out)
+    end
+
+    def introduction(isoxml, out)
+      f = isoxml.at(ns("//introduction")) || return
+      title_attr = { class: "IntroTitle" }
+      page_break(out)
+      out.div **{ class: "Section3", id: f["id"] } do |div|
+        clause_name(nil, f.at(ns("./title")), div, { class: "IntroTitle" })
+        f.elements.each do |e|
+          parse(e, div) unless e.name == "title"
+        end
+      end
+    end
+
+    def foreword(isoxml, out)
+      f = isoxml.at(ns("//foreword")) || return
+      page_break(out)
+      out.div **attr_code(id: f["id"]) do |s|
+        clause_name(nil, f.at(ns("./title")) || @i18n.foreword, s,
+                    { class: "ForewordTitle" })
+        #s.h1(**{ class: "ForewordTitle" }) { |h1| h1 << @i18n.foreword }
+        f.elements.each { |e| parse(e, s) unless e.name == "title" }
+      end
+    end
+
+    def acknowledgements(isoxml, out)
+      f = isoxml.at(ns("//acknowledgements")) || return
+      title_attr = { class: "IntroTitle" }
+      page_break(out)
+      out.div **{ class: "Section3", id: f["id"] } do |div|
+        clause_name(nil, f&.at(ns("./title")), div, title_attr)
+        f.elements.each do |e|
+          parse(e, div) unless e.name == "title"
+        end
+      end
+    end
+
+    def abstract(isoxml, out)
+      f = isoxml.at(ns("//preface/abstract")) || return
+      page_break(out)
+      out.div **attr_code(id: f["id"]) do |s|
+        clause_name(nil, f.at(ns("./title")), s, { class: "AbstractTitle" })
+        #s.h1(**{ class: "AbstractTitle" }) { |h1| h1 << @i18n.abstract }
+        f.elements.each { |e| parse(e, s) unless e.name == "title" }
+      end
+    end
+
+    def preface(isoxml, out)
+      title_attr = { class: "IntroTitle" }
+      isoxml.xpath(ns("//preface/clause | //preface/references | "\
+                      "//preface/definitions | //preface/terms")).each do |f|
+        page_break(out)
+        out.div **{ class: "Section3", id: f["id"] } do |div|
+          clause_name(nil, f&.at(ns("./title")), div, title_attr)
+          f.elements.each do |e|
+            parse(e, div) unless e.name == "title"
+          end
+        end
+      end
+    end
+
+    def copyright_parse(node, out)
+      out.div **{class: "boilerplate-copyright"} do |div|
+        node.children.each { |n| parse(n, div) }
+      end
+    end
+
+    def license_parse(node, out)
+      out.div **{class: "boilerplate-license"} do |div|
+        node.children.each { |n| parse(n, div) }
+      end
+    end
+
+    def legal_parse(node, out)
+      out.div **{class: "boilerplate-legal"} do |div|
+        node.children.each { |n| parse(n, div) }
+      end
+    end
+
+    def feedback_parse(node, out)
+      out.div **{class: "boilerplate-feedback"} do |div|
+        node.children.each { |n| parse(n, div) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module IsoDoc::Function
+  module Table
+
+    def table_title_parse(node, out)
+      name = node.at(ns("./name")) or return
+      out.p **{ class: "TableTitle", style: "text-align:center;" } do |p|
+        name and name.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def thead_parse(node, t)
+      thead = node.at(ns("./thead"))
+      if thead
+        t.thead do |h|
+          thead.element_children.each_with_index do |n, i|
+            tr_parse(n, h, i, thead.element_children.size, true)
+          end
+        end
+      end
+    end
+
+    def tbody_parse(node, t)
+      tbody = node.at(ns("./tbody")) || return
+      t.tbody do |h|
+        tbody.element_children.each_with_index do |n, i|
+          tr_parse(n, h, i, tbody.element_children.size, false)
+        end
+      end
+    end
+
+    def tfoot_parse(node, t)
+      tfoot = node.at(ns("./tfoot"))
+      if tfoot
+        t.tfoot do |h|
+          tfoot.element_children.each_with_index do |n, i|
+            tr_parse(n, h, i, tfoot.element_children.size, false)
+          end
+        end
+      end
+    end
+
+    def table_attrs(node)
+      width = node["width"] ? "width:#{node['width']};" : nil
+      attr_code(
+        id: node["id"],
+        class: "MsoISOTable",
+        style: "border-width:1px;border-spacing:0;#{width}#{keep_style(node)}",
+        title: node["alt"]
+      )
+    end
+
+    def tcaption(node, t)
+      return unless node["summary"]
+      t.caption do |c|
+        c.span **{ style: "display:none" } do |s|
+          s << node["summary"]
+        end
+      end
+    end
+
+    def table_parse(node, out)
+      @in_table = true
+      table_title_parse(node, out)
+      out.table **table_attrs(node) do |t|
+        tcaption(node, t)
+        thead_parse(node, t)
+        tbody_parse(node, t)
+        tfoot_parse(node, t)
+        (dl = node.at(ns("./dl"))) && parse(dl, out)
+        node.xpath(ns("./note")).each { |n| parse(n, out) }
+      end
+      @in_table = false
+      # out.p { |p| p << "&nbsp;" }
+    end
+
+    SW = "solid windowtext".freeze
+
+    # def make_tr_attr(td, row, totalrows, cols, totalcols, header)
+    # border-left:#{col.zero? ? "#{SW} 1.5pt;" : "none;"}
+    # border-right:#{SW} #{col == totalcols && !header ? "1.5" : "1.0"}pt;
+
+    def make_tr_attr(td, row, totalrows, header)
+      style = td.name == "th" ? "font-weight:bold;" : ""
+      td["align"] and style += "text-align:#{td['align']};"
+      rowmax = td["rowspan"] ? row + td["rowspan"].to_i - 1 : row
+      style += <<~STYLE
+        border-top:#{row.zero? ? "#{SW} 1.5pt;" : 'none;'}
+        border-bottom:#{SW} #{rowmax == totalrows ? '1.5' : '1.0'}pt;
+      STYLE
+      header and scope = (td["colspan"] ? "colgroup" : "col")
+      !header and td.name == "th" and scope =
+        (td["rowspan"] ? "rowgroup" : "row")
+      { rowspan: td["rowspan"], colspan: td["colspan"],
+        style: style.gsub(/\n/, ""), scope: scope }
+    end
+
+    def tr_parse(node, out, ord, totalrows, header)
+      out.tr do |r|
+        node.elements.each do |td|
+          attrs = make_tr_attr(td, ord, totalrows - 1, header)
+          r.send td.name, **attr_code(attrs) do |entry|
+            td.children.each { |n| parse(n, entry) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module IsoDoc::Function
+  module Terms
+    def definition_parse(node, out)
+      node.children.each { |n| parse(n, out) }
+    end
+
+    def modification_parse(node, out)
+      out << "[MODIFICATION]"
+      para = node.at(ns("./p"))
+      para.children.each { |n| parse(n, out) }
+    end
+
+    def deprecated_term_parse(node, out)
+      out.p **{ class: "DeprecatedTerms", style:"text-align:left;" } do |p|
+        p << l10n("#{@i18n.deprecated}: ")
+        node.children.each { |c| parse(c, p) }
+      end
+    end
+
+    def admitted_term_parse(node, out)
+      out.p **{ class: "AltTerms", style:"text-align:left;" } do |p|
+        node.children.each { |c| parse(c, p) }
+      end
+    end
+
+    def term_parse(node, out)
+      out.p **{ class: "Terms", style:"text-align:left;" } do |p|
+        node.children.each { |c| parse(c, p) }
+      end
+    end
+
+    def para_then_remainder(first, node, p, div)
+      if first.name == "p"
+        first.children.each { |n| parse(n, p) }
+        node.elements.drop(1).each { |n| parse(n, div) }
+      else
+        node.elements.each { |n| parse(n, div) }
+      end
+    end
+
+    def termnote_delim
+      l10n(": ")
+    end
+
+    def termnote_parse(node, out)
+      name = node&.at(ns("./name"))&.remove
+      out.div **note_attrs(node) do |div|
+        div.p do |p|
+          if name
+            name.children.each { |n| parse(n, p) }
+            p << termnote_delim
+          end
+          para_then_remainder(node.first_element_child, node, p, div)
+        end
+      end
+    end
+
+    def termref_parse(node, out)
+      out.p do |p|
+        p << "[TERMREF]"
+        node.children.each { |n| parse(n, p) }
+        p << "[/TERMREF]"
+      end
+    end
+
+    def termdef_parse(node, out)
+      name = node&.at(ns("./name"))&.remove
+      out.p **{ class: "TermNum", id: node["id"] } do |p|
+        name&.children&.each { |n| parse(n, p) }
+      end
+      set_termdomain("")
+      node.children.each { |n| parse(n, out) }
+    end
+
+    def termdocsource_parse(_node, _out)
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+require "fileutils"
+require "pathname"
+
+module IsoDoc::Function
+  module ToWordHtml
+
+    def set_termdomain(termdomain)
+      @termdomain = termdomain
+    end
+
+    def in_sourcecode
+      @sourcecode
+    end
+
+    def note?
+      @note
+    end
+
+    def init_file(filename, debug)
+      filepath = Pathname.new(filename)
+      filename = filepath.sub_ext('').sub(/\.presentation$/, "").to_s
+      dir = "#{filename}_files"
+      unless debug
+        Dir.mkdir(dir, 0777) unless File.exists?(dir)
+        FileUtils.rm_rf "#{dir}/*"
+      end
+      @filename = filename
+      @localdir = filepath.parent.to_s + '/'
+      [filename, dir]
+    end
+
+    # tmp image dir is same directory as @filename
+    def tmpimagedir
+      @filename + tmpimagedir_suffix
+    end
+
+    def rel_tmpimagedir
+      Pathname.new(@filename).basename.to_s + tmpimagedir_suffix
+    end
+
+    # isodoc.css overrides any CSS injected by Html2Doc, which
+    # is inserted before this CSS.
+    def define_head(head, filename, _dir)
+      if @standardstylesheet
+        head.style do |style|
+          @standardstylesheet.open
+          stylesheet = @standardstylesheet.read.
+            gsub("FILENAME", File.basename(filename).sub(/\.presentation$/, ""))
+          style.comment "\n#{stylesheet}\n"
+        end
+      end
+    end
+
+    def body_attr
+      { lang: "#{@lang}" }
+    end
+
+    def make_body(xml, docxml)
+      xml.body **body_attr do |body|
+        make_body1(body, docxml)
+        make_body2(body, docxml)
+        make_body3(body, docxml)
+      end
+    end
+
+    def make_body1(body, _docxml)
+      body.div **{ class: "title-section" } do |div1|
+        div1.p { |p| p << "&nbsp;" } # placeholder
+      end
+      section_break(body)
+    end
+
+    def make_body2(body, docxml)
+      body.div **{ class: "prefatory-section" } do |div2|
+        div2.p { |p| p << "&nbsp;" } # placeholder
+      end
+      section_break(body)
+    end
+
+    def make_body3(body, docxml)
+      body.div **{ class: "main-section" } do |div3|
+        boilerplate docxml, div3
+        abstract docxml, div3
+        foreword docxml, div3
+        introduction docxml, div3
+        acknowledgements docxml, div3
+        middle docxml, div3
+        footnotes div3
+        comments div3
+      end
+    end
+
+    def info(isoxml, out)
+      @meta.title isoxml, out
+      @meta.subtitle isoxml, out
+      @meta.docstatus isoxml, out
+      @meta.docid isoxml, out
+      @meta.docnumeric isoxml, out
+      @meta.doctype isoxml, out
+      @meta.author isoxml, out
+      @meta.bibdate isoxml, out
+      @meta.relations isoxml, out
+      @meta.version isoxml, out
+      @meta.url isoxml, out
+      @meta.keywords isoxml, out
+      @meta.get
+    end
+
+    def middle_title(out)
+      out.p(**{ class: "zzSTDTitle1" }) { |p| p << @meta.get[:doctitle] }
+    end
+
+    def middle_admonitions(isoxml, out)
+      isoxml.xpath(ns("//sections/note | //sections/admonition")).each do |x|
+        parse(x, out)
+      end
+    end
+
+    def middle(isoxml, out)
+      middle_title(out)
+      middle_admonitions(isoxml, out)
+      i = scope isoxml, out, 0
+      i = norm_ref isoxml, out, i
+      i = terms_defs isoxml, out, i
+      i = symbols_abbrevs isoxml, out, i
+      clause isoxml, out
+      annex isoxml, out
+      bibliography isoxml, out
+    end
+
+    def boilerplate(node, out)
+      boilerplate = node.at(ns("//boilerplate")) or return
+      out.div **{class: "authority"} do |s|
+        boilerplate.children.each do |n|
+          if n.name == "title"
+            s.h1 do |h|
+              n.children.each { |nn| parse(nn, h) }
+            end
+          else
+            parse(n, s)
+          end
+        end
+      end
+    end
+
+    def parse(node, out)
+      if node.text?
+        text_parse(node, out)
+      else
+        case node.name
+        when "em" then em_parse(node, out)
+        when "strong" then strong_parse(node, out)
+        when "sup" then sup_parse(node, out)
+        when "sub" then sub_parse(node, out)
+        when "tt" then tt_parse(node, out)
+        when "strike" then strike_parse(node, out)
+        when "keyword" then keyword_parse(node, out)
+        when "smallcap" then smallcap_parse(node, out)
+        when "br" then br_parse(node, out)
+        when "hr" then hr_parse(node, out)
+        when "bookmark" then bookmark_parse(node, out)
+        when "pagebreak" then pagebreak_parse(node, out)
+        when "callout" then callout_parse(node, out)
+        when "stem" then stem_parse(node, out)
+        when "clause" then clause_parse(node, out)
+        when "xref" then xref_parse(node, out)
+        when "eref" then eref_parse(node, out)
+        when "origin" then origin_parse(node, out)
+        when "link" then link_parse(node, out)
+        when "ul" then ul_parse(node, out)
+        when "ol" then ol_parse(node, out)
+        when "li" then li_parse(node, out)
+        when "dl" then dl_parse(node, out)
+        when "fn" then footnote_parse(node, out)
+        when "p" then para_parse(node, out)
+        when "quote" then quote_parse(node, out)
+        when "tr" then tr_parse(node, out)
+        when "note" then note_parse(node, out)
+        when "review" then review_note_parse(node, out)
+        when "admonition" then admonition_parse(node, out)
+        when "formula" then formula_parse(node, out)
+        when "table" then table_parse(node, out)
+        when "figure" then figure_parse(node, out)
+        when "example" then example_parse(node, out)
+        when "image" then image_parse(node, out, nil)
+        when "sourcecode" then sourcecode_parse(node, out)
+        when "pre" then pre_parse(node, out)
+        when "annotation" then annotation_parse(node, out)
+        when "term" then termdef_parse(node, out)
+        when "preferred" then term_parse(node, out)
+        when "admitted" then admitted_term_parse(node, out)
+        when "deprecates" then deprecated_term_parse(node, out)
+        when "domain" then set_termdomain(node.text)
+        when "definition" then definition_parse(node, out)
+        when "termsource" then termref_parse(node, out)
+        when "modification" then modification_parse(node, out)
+        when "termnote" then termnote_parse(node, out)
+        when "termexample" then example_parse(node, out)
+        when "terms" then terms_parse(node, out)
+        when "definitions" then symbols_parse(node, out)
+        when "references" then bibliography_parse(node, out)
+        when "termdocsource" then termdocsource_parse(node, out)
+        when "requirement" then requirement_parse(node, out)
+        when "recommendation" then recommendation_parse(node, out)
+        when "permission" then permission_parse(node, out)
+        when "subject" then requirement_skip_parse(node, out)
+        when "classification" then requirement_skip_parse(node, out)
+        when "inherit" then requirement_component_parse(node, out)
+        when "description" then requirement_component_parse(node, out)
+        when "specification" then requirement_component_parse(node, out)
+        when "measurement-target" then requirement_component_parse(node, out)
+        when "verification" then requirement_component_parse(node, out)
+        when "import" then requirement_component_parse(node, out)
+        when "index" then index_parse(node, out)
+        when "concept" then concept_parse(node, out)
+        when "termref" then termrefelem_parse(node, out)
+        when "copyright-statement" then copyright_parse(node, out)
+        when "license-statement" then license_parse(node, out)
+        when "legal-statement" then legal_parse(node, out)
+        when "feedback-statement" then feedback_parse(node, out)
+        when "passthrough" then passthrough_parse(node, out)
+        when "variant" then variant_parse(node, out)
+        when "tab" then clausedelimspace(out) # in Presentation XML only
+        else
+          error_parse(node, out)
+        end
+      end
+    end
+  end
+end