metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/reqt.rng

@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
+  <!--
+    Presupposes isodoc.rnc, is included in it
+    include "isodoc.rnc" { }
+  -->
+  <define name="requirement">
+    <element name="requirement">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="recommendation">
+    <element name="recommendation">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="permission">
+    <element name="permission">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="RequirementType">
+    <optional>
+      <attribute name="obligation">
+        <ref name="ObligationType"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="unnumbered">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="number"/>
+    </optional>
+    <optional>
+      <attribute name="subsequence"/>
+    </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <attribute name="id">
+      <data type="ID"/>
+    </attribute>
+    <optional>
+      <attribute name="filename"/>
+    </optional>
+    <optional>
+      <attribute name="model"/>
+    </optional>
+    <optional>
+      <attribute name="type"/>
+    </optional>
+    <optional>
+      <ref name="reqtitle"/>
+    </optional>
+    <optional>
+      <ref name="label"/>
+    </optional>
+    <optional>
+      <ref name="subject"/>
+    </optional>
+    <zeroOrMore>
+      <ref name="reqinherit"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <ref name="classification"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <choice>
+        <ref name="measurementtarget"/>
+        <ref name="specification"/>
+        <ref name="verification"/>
+        <ref name="import"/>
+        <ref name="description"/>
+      </choice>
+    </zeroOrMore>
+    <optional>
+      <ref name="reqt_references"/>
+    </optional>
+    <zeroOrMore>
+      <choice>
+        <ref name="requirement"/>
+        <ref name="recommendation"/>
+        <ref name="permission"/>
+      </choice>
+    </zeroOrMore>
+  </define>
+  <define name="reqtitle">
+    <element name="title">
+      <ref name="FormattedString"/>
+    </element>
+  </define>
+  <define name="label">
+    <element name="label">
+      <text/>
+    </element>
+  </define>
+  <define name="subject">
+    <element name="subject">
+      <text/>
+    </element>
+  </define>
+  <define name="reqinherit">
+    <element name="inherit">
+      <text/>
+    </element>
+  </define>
+  <define name="measurementtarget">
+    <element name="measurement-target">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="specification">
+    <element name="specification">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="verification">
+    <element name="verification">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="import">
+    <element name="import">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="description">
+    <element name="description">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="reqt_references">
+    <element name="references">
+      <oneOrMore>
+        <ref name="bibitem"/>
+      </oneOrMore>
+    </element>
+  </define>
+  <define name="RequirementSubpart">
+    <optional>
+      <attribute name="type"/>
+    </optional>
+    <optional>
+      <attribute name="exclude">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <oneOrMore>
+      <ref name="BasicBlock"/>
+    </oneOrMore>
+  </define>
+  <define name="ObligationType">
+    <choice>
+      <value>requirement</value>
+      <value>recommendation</value>
+      <value>permission</value>
+    </choice>
+  </define>
+  <define name="classification">
+    <element name="classification">
+      <ref name="classification_tag"/>
+      <ref name="classification_value"/>
+    </element>
+  </define>
+  <define name="classification_tag">
+    <element name="tag">
+      <text/>
+    </element>
+  </define>
+  <define name="classification_value">
+    <element name="value">
+      <text/>
+    </element>
+  </define>
+</grammar>

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/section.rb

@@ -0,0 +1,244 @@
+require "htmlentities"
+require "uri"
+require_relative "ref_sect"
+
+module Asciidoctor
+  module Standoc
+    module Section
+      @biblio = false
+      @term_def = false
+      @norm_ref = false
+
+      def in_terms?
+        @term_def
+      end
+
+      def sectiontype1(node)
+        node&.attr("heading")&.downcase ||
+          node.title.gsub(/<[^>]+>/, "").downcase
+      end
+
+      def sectiontype(node, level = true)
+        ret = sectiontype1(node)
+        ret1 = sectiontype_streamline(ret)
+        return ret1 if "symbols and abbreviated terms" == ret1
+        return nil unless !level || node.level == 1
+        return nil if @seen_headers.include? ret
+        @seen_headers << ret
+        ret1
+      end
+
+      def sectiontype_streamline(ret)
+        case ret
+        when "terms and definitions",
+          "terms, definitions, symbols and abbreviated terms",
+          "terms, definitions, symbols and abbreviations",
+          "terms, definitions and symbols",
+          "terms, definitions and abbreviations",
+          "terms, definitions and abbreviated terms"
+          "terms and definitions"
+        when "symbols and abbreviated terms",
+          "symbols", "abbreviated terms", "abbreviations"
+          "symbols and abbreviated terms"
+        else
+          ret
+        end
+      end
+
+      def section_attributes(node)
+        { id: Utils::anchor_or_uuid(node),
+          language: node.attributes["language"],
+          script: node.attributes["script"],
+          annex: (
+            ((node.attr("style") == "appendix" || node.role == "appendix") && 
+             node.level == 1) ? true : nil
+          ),
+          preface: (
+            (node.role == "preface" || node.attr("style") == "preface") ?
+            true : nil),
+        }
+      end
+
+      def section(node)
+        a = section_attributes(node)
+        noko do |xml|
+          case sectiontype(node)
+          when "introduction" then introduction_parse(a, xml, node)
+          when "foreword" then foreword_parse(a, xml, node)
+          when "scope" then scope_parse(a, xml, node)
+          when "normative references" then norm_ref_parse(a, xml, node)
+          when "terms and definitions"
+            @term_def = true
+            term_def_parse(a, xml, node, true)
+            @term_def = false
+          when "symbols and abbreviated terms"
+            symbols_parse(symbols_attrs(node, a), xml, node)
+          when "acknowledgements"
+            acknowledgements_parse(a, xml, node)
+          when "bibliography" 
+            bibliography_parse(a, xml, node)
+          else
+            if @term_def then term_def_subclause_parse(a, xml, node)
+            elsif @definitions then symbols_parse(a, xml, node)
+            elsif @norm_ref then norm_ref_parse(a, xml, node)
+            elsif @biblio then bibliography_parse(a, xml, node)
+            elsif node.attr("style") == "bibliography" && sectiontype(node, false) == "normative references"
+              norm_ref_parse(a, xml, node)
+            elsif node.attr("style") == "bibliography" && sectiontype(node, false) == "bibliography"
+              bibliography_parse(a, xml, node)
+            elsif node.attr("style") == "bibliography"
+              bibliography_parse(a, xml, node)
+            elsif node.attr("style") == "abstract" 
+              abstract_parse(a, xml, node)
+            elsif node.attr("style") == "appendix" && node.level == 1
+              annex_parse(a, xml, node)
+            else
+              clause_parse(a, xml, node)
+            end
+          end
+        end.join("\n")
+      end
+
+      def set_obligation(attrs, node)
+        attrs[:obligation] = if node.attributes.has_key?("obligation")
+                               node.attr("obligation")
+                             elsif node.parent.attributes.has_key?("obligation")
+                               node.parent.attr("obligation")
+                             else
+                               "normative"
+                             end
+      end
+
+      def preamble(node)
+        noko do |xml|
+          xml.foreword **attr_code(section_attributes(node)) do |xml_abstract|
+            xml_abstract.title { |t| t << (node.blocks[0].title || @i18n.foreword) }
+            content = node.content
+            xml_abstract << content
+          end
+        end.join("\n")
+      end
+
+      def abstract_parse(attrs, xml, node)
+        xml.abstract **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      def scope_parse(attrs, xml, node)
+        clause_parse(attrs.merge(type: "scope"), xml, node)
+      end
+
+      def clause_parse(attrs, xml, node)
+        attrs["inline-header".to_sym] = node.option? "inline-header"
+        attrs[:bibitem] = true if node.option? "bibitem"
+        attrs[:level] = node.attr("level")
+        set_obligation(attrs, node)
+        xml.send "clause", **attr_code(attrs) do |xml_section|
+          xml_section.title { |n| n << node.title } unless node.title.nil?
+          xml_section << node.content
+        end
+      end
+
+      def annex_parse(attrs, xml, node)
+        attrs["inline-header".to_sym] = node.option? "inline-header"
+        set_obligation(attrs, node)
+        xml.annex **attr_code(attrs) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def nonterm_symbols_parse(attrs, xml, node)
+        @definitions = false
+        clause_parse(attrs, xml, node)
+        @definitions = true
+      end
+
+      def symbols_attrs(node, a)
+        case sectiontype1(node)
+        when "symbols" then a.merge(type: "symbols")
+        when "abbreviated terms", "abbreviations" then a.merge(type: "abbreviated_terms")
+        else
+          a
+        end
+      end
+
+      def symbols_parse(attr, xml, node)
+        node.role == "nonterm" and return nonterm_symbols_parse(attr, xml, node)
+        xml.definitions **attr_code(attr) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          defs = @definitions
+          termdefs = @term_def
+          @definitions = true
+          @term_def = false
+          xml_section << node.content
+          @definitions = defs
+          @term_def = termdefs
+        end
+      end
+
+      def nonterm_term_def_subclause_parse(attrs, xml, node)
+        @term_def = false
+        clause_parse(attrs, xml, node)
+        @term_def = true
+      end
+
+      # subclause contains subclauses
+      def term_def_subclause_parse(attrs, xml, node)
+        node.role == "nonterm"  and
+          return nonterm_term_def_subclause_parse(attrs, xml, node)
+        st = sectiontype(node, false)
+        return symbols_parse(attrs, xml, node) if @definitions
+        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
+        sub.empty? || (return term_def_parse(attrs, xml, node, false))
+        st == "symbols and abbreviated terms" and
+          (return symbols_parse(attrs, xml, node))
+        st == "terms and definitions" and
+          return clause_parse(attrs, xml, node)
+        term_def_subclause_parse1(attrs, xml, node)
+      end
+
+      def term_def_subclause_parse1(attrs, xml, node)
+        xml.term **attr_code(attrs) do |xml_section|
+          xml_section.preferred { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def term_def_parse(attrs, xml, node, toplevel)
+        xml.terms **attr_code(attrs) do |section|
+          section.title { |t| t << node.title }
+          (s = node.attr("source")) && s.split(/,/).each do |s1|
+            section.termdocsource(nil, **attr_code(bibitemid: s1))
+          end
+          section << node.content
+        end
+      end
+
+      def introduction_parse(attrs, xml, node)
+        xml.introduction **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << @i18n.introduction }
+          content = node.content
+          xml_section << content
+        end
+      end
+
+      def foreword_parse(attrs, xml, node)
+        xml.foreword **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          content = node.content
+          xml_section << content
+        end
+      end
+
+      def acknowledgements_parse(attrs, xml, node)
+        xml.acknowledgements **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title || @i18n.acknowledgements }
+          content = node.content
+          xml_section << content
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/table.rb

@@ -0,0 +1,70 @@
+module Asciidoctor
+  module Standoc
+    module Table
+      def table_attrs(node)
+        keep_attrs(node).merge( id: Utils::anchor_or_uuid(node),
+          headerrows: node.attr("headerrows"),
+          unnumbered: node.option?("unnumbered") ? "true" : nil,
+          number: node.attr("number"),
+          subsequence: node.attr("subsequence"),
+          alt: node.attr("alt"),
+          summary: node.attr("summary"),
+          width: node.attr("width"),
+        )
+      end
+
+      def table(node)
+        @table_fn_number = "a"
+        noko do |xml|
+          xml.table **attr_code(table_attrs(node)) do |xml_table|
+            table_name(node, xml_table)
+            %i(head body foot).reject do |tblsec|
+              node.rows[tblsec].empty?
+            end
+            table_head_body_and_foot node, xml_table
+          end
+        end
+      end
+
+      private
+
+      def table_name(node, xml_table)
+        if node.title?
+          xml_table.name do |n|
+            n << node.title
+          end
+        end
+      end
+
+      def table_cell1(cell, thd)
+        if cell.style == :asciidoc
+          thd << cell.content
+        else
+          thd << cell.text
+        end
+      end
+
+      def table_cell(c, xml_tr, tblsec)
+        cell_attributes = { id: c.id, colspan: c.colspan,
+                            rowspan: c.rowspan, align: c.attr("halign") }
+        cell_tag = "td"
+        cell_tag = "th" if tblsec == :head || c.style == :header
+        xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|
+          table_cell1(c, thd)
+        end
+      end
+
+      def table_head_body_and_foot(node, xml)
+        %i(head body foot).reject { |s| node.rows[s].empty? }.each do |s|
+          xml.send "t#{s}" do |xml_tblsec|
+            node.rows[s].each do |row|
+              xml_tblsec.tr do |xml_tr|
+                row.each { |cell| table_cell(cell, xml_tr, s) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end