asciidoctor-gb 0.1.5

data/lib/asciidoctor/gb/metadata.rb

@@ -0,0 +1,186 @@
+require "isodoc"
+
+module Asciidoctor
+  module Gb
+    # A {Converter} implementation that generates GB output, and a document
+    # schema encapsulation of the document for validation
+    class GbConvert < IsoDoc::Convert
+      def init_metadata
+        super
+        set_metadata(:docmaintitlezh, "")
+        set_metadata(:docsubtitlezh, "XXXX")
+        set_metadata(:docparttitlezh, "")
+        set_metadata(:docmaintitleen, "")
+        set_metadata(:docsubtitleen, "XXXX")
+        set_metadata(:docparttitleen, "")
+        set_metadata(:gbequivalence, "")
+        set_metadata(:isostandard, nil)
+        set_metadata(:isostandardtitle, "")
+        set_metadata(:doctitle, "XXXX")
+        set_metadata(:obsoletes, nil)
+        set_metadata(:obsoletes_part, nil)
+      end
+
+      def title(isoxml, _out)
+        intro = isoxml.at(ns("//title-intro[@language='zh']"))
+        main = isoxml.at(ns("//title-main[@language='zh']"))
+        part = isoxml.at(ns("//title-part[@language='zh']"))
+        partnumber = isoxml.at(ns("//project-number/@part"))
+        intro.nil? || set_metadata(:docmaintitlezh, intro.text + "&mdash;")
+        main.nil? || set_metadata(:docsubtitlezh, main.text)
+        partnum = partnumber ? "#{part_label(partnumber, 'zh')}: " : ""
+        part.nil? || set_metadata(:docparttitlezh,
+                                  "&mdash;#{partnum} #{part.text}")
+        set_metadata(:doctitle, get_metadata[:docmaintitlezh] + 
+                     get_metadata[:docsubtitlezh] +
+                     get_metadata[:docparttitlezh])
+      end
+
+      def subtitle(isoxml, _out)
+        intro = isoxml.at(ns("//title-intro[@language='en']"))
+        main = isoxml.at(ns("//title-main[@language='en']"))
+        part = isoxml.at(ns("//title-part[@language='en']"))
+        partnumber = isoxml.at(ns("//project-number/@part"))
+        intro.nil? || set_metadata(:docmaintitleen, intro.text + "&mdash;")
+        main.nil? || set_metadata(:docsubtitleen, main.text)
+        partnum = partnumber ? "#{part_label(partnumber, 'en')}: " : ""
+        part.nil? || set_metadata(:docparttitleen,
+                                  "&mdash;#{partnum} #{part.text}")
+      end
+
+      def author(isoxml, _out)
+        gbcommittee = isoxml.at(ns("//bibdata/gbcommittee"))
+        set_metadata(:committee, gbcommittee.text)
+      end
+
+      def id(isoxml, _out)
+        super
+        gb_identifier(isoxml)
+        gb_library_identifier(isoxml)
+        gb_equivalence(isoxml)
+      end
+
+      ISO_STD_XPATH = "//bibdata/relation[@type = 'equivalent' or "\
+        "@type = 'identical' or @type = 'nonequivalent']/bibitem".freeze
+
+      def gb_equivalence(isoxml)
+        isostdid = isoxml.at(ns("#{ISO_STD_XPATH}/docidentifier")) || return
+        set_metadata(:isostandard, isostdid.text)
+        isostdtitle = isoxml.at(ns("#{ISO_STD_XPATH}/title"))
+        set_metadata(:isostandardtitle, isostdtitle.text) if isostdtitle
+        eq = isoxml.at(ns("//bibdata/relation/@type"))
+        case eq.text
+        when "equivalent" then set_metadata(:gbequivalence, "MOD")
+        when "nonequivalent" then set_metadata(:gbequivalence, "NEQ")
+        when "identical" then set_metadata(:gbequivalence, "IDT")
+        end
+      end
+
+      def docidentifier(gbscope, gbprefix, gbmandate)
+        docnum = get_metadata[:docnumber]
+        dn = if gbscope == "local"
+               "DB#{mandate_suffix(gbprefix, gbmandate)}/#{docnum}".
+                 gsub(%r{/([TZ])/}, "/\\1 ")
+             else
+               "#{mandate_suffix(gbprefix, gbmandate)} #{docnum}"
+             end
+        set_metadata(:docidentifier, dn)
+      end
+
+      def gb_identifier(isoxml)
+        scope = isoxml.at(ns("//gbscope"))&.text || "national"
+        mandate = isoxml.at(ns("//gbmandate"))&.text || "mandatory"
+        prefix = isoxml.at(ns("//gbprefix"))&.text || "XXX"
+        docidentifier(scope, prefix, mandate)
+        set_metadata(:standard_class, standard_class(scope, prefix, mandate))
+        set_metadata(:standard_agency, standard_agency(scope, prefix, mandate))
+        set_metadata(:gbprefix, scope == "local" ? "DB" : prefix)
+      end
+
+      def standard_logo(gbprefix)
+        case gbprefix.downcase
+        when "db" then "gb-standard-db"
+        when "gb" then "gb-standard-gb"
+        when "gjb" then "gb-standard-gjb"
+        when "gm" then "gb-standard-gm"
+        when "jjf" then "gb-standard-jjf"
+        when "zb" then "gb-standard-zb"
+        end
+      end
+
+      def gb_library_identifier(isoxml)
+        ics = isoxml.at(ns("//gblibraryids/ics"))
+        l = isoxml.at(ns("//gblibraryids/l"))
+        set_metadata(:libraryid_ics, ics ? ics.text : "XXX")
+        set_metadata(:libraryid_l, l ? l.text : "XXX")
+      end
+
+      def part_label(partnumber, lang)
+        case lang
+        when "en" then "Part #{partnumber}"
+        when "zh" then "第#{partnumber}部"
+        end
+      end
+
+      def format_logo(prefix, _format)
+        logo = standard_logo(prefix)
+        if logo.nil?
+          "<span style='font-size:36pt;font-weight:bold'>#{prefix}</span>"
+        else
+          logo += ".gif"
+          system "cp #{fileloc(File.join('html/gb-logos', logo))}  #{logo}"
+          "<img width='113' height='56' src='#{logo}' alt='#{prefix}'>"
+        end
+      end
+
+      def format_agency(agency, format)
+        return agency unless agency.is_a?(Array)
+        ret = "<table><tr><td>#{agency[0]}</td>"\
+          "<td rowspan='#{agency.size}'>发布</td></tr>"
+        agency[1..-1].each { |a| ret += "<tr><td>#{a}</td></tr>" }
+        ret += "</table>"
+        ret.gsub!(/<table>/, "<table width='100%'>") if format == :word
+        ret
+      end
+
+      def termref_render(x)
+        parts = x.split(%r{(\s*\[MODIFICATION\]|,)}m)
+        parts[1] = "，定义" if parts.size > 1 && parts[1] == ","
+        parts.map do |p|
+          /\s*\[MODIFICATION\]/.match?(p) ? ", 改写 &mdash; " : p
+        end.join.sub(/\A\s*/m, "【").sub(/\s*\z/m, "】")
+      end
+
+      def termref_resolve(docxml)
+        docxml.split(%r{(\[TERMREF\]|\[/TERMREF\])}).each_slice(4).
+          map do |a|
+          a.size < 3 ? a[0] : a[0] + termref_render(a[2])
+        end.join
+      end
+
+      def populate_template(docxml, format)
+        meta = get_metadata
+        logo = format_logo(meta[:gbprefix], format)
+        docxml = termref_resolve(docxml)
+        docxml.gsub!(/\s*\[ISOSECTION\]/, ", ?~Z?~I")
+        meta[:standard_agency_formatted] =
+          format_agency(meta[:standard_agency], format)
+        meta[:standard_logo] = logo
+        template = Liquid::Template.parse(docxml)
+        template.render(meta.map { |k, v| [k.to_s, v] }.to_h)
+      end
+
+      STAGE_ABBRS = {
+        "00": "PWI",
+        "10": "NWIP",
+        "20": "WD",
+        "30": "CD",
+        "40": "DIS",
+        "50": "FDIS",
+        "60": "IS",
+        "90": "(Review)",
+        "95": "(Withdrawal)",
+      }.freeze
+    end
+  end
+end

data/lib/asciidoctor/gb/section_input.rb

@@ -0,0 +1,168 @@
+module Asciidoctor
+  module Gb
+
+    # A {Converter} implementation that generates GB output, and a document
+    # schema encapsulation of the document for validation
+    class Converter < ISO::Converter
+
+      def term_def_subclause_parse(attrs, xml, node)
+        # subclause contains subclauses
+        sub = node.find_by(context: :section) {|s| s.level == node.level + 1 }
+        sub.empty? || (return term_def_parse(attrs, xml, node, false))
+        (node.title.downcase == "symbols and abbreviated terms" ||
+        node.title == "符号、代号和缩略语") &&
+          (return symbols_parse(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 section(node)
+        a = { id: Asciidoctor::ISO::Utils::anchor_or_uuid(node) }
+        noko do |xml|
+          case sectiontype(node)
+          when "引言" then
+            if node.level == 1 then introduction_parse(a, xml, node)
+            else
+              clause_parse(a, xml, node)
+            end
+          when "patent notice" then patent_notice_parse(xml, node)
+          when "范围", "scope" then scope_parse(a, xml, node)
+          when "规范性引用文件", "normative references"
+            norm_ref_parse(a, xml, node)
+          when "术语和定义", "terms and definitions",
+            "术语、定义、符号、代号和缩略语",
+            "terms, definitions, symbols and abbreviated terms"
+            @term_def = true
+            term_def_parse(a, xml, node, true)
+            @term_def = false
+          when "符号、代号和缩略语", "symbols and abbreviated terms"
+            symbols_parse(a, xml, node)
+          when "参考文献", "bibliography"
+            bibliography_parse(a, xml, node)
+          else
+            if @term_def then term_def_subclause_parse(a, xml, node)
+            elsif @biblio then bibliography_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
+
+=begin
+      def preamble(node)
+        noko do |xml|
+          xml.foreword do |xml_abstract|
+            xml_abstract.title { |t| t << "前言" }
+            content = node.content
+            xml_abstract << content
+            text = Asciidoctor::ISO::Utils::flatten_rawtext(content).join("\n")
+            foreword_style(node, text)
+          end
+        end.join("\n")
+      end
+=end
+
+      def normref_cleanup(xmldoc)
+        q = "//references[title = '规范性引用文件']"
+        r = xmldoc.at(q)
+        if r.nil?
+          warn "You have no normative references!"
+          return
+        end
+        r.elements.each do |n|
+          n.remove unless ["title", "bibitem"].include? n.name
+        end
+      end
+
+      def normref_validate(root)
+        f = root.at("//references[title = '规范性引用文件']") ||
+          return
+        f.at("./references") &&
+          warn("ISO style: normative references contains subsections")
+      end
+
+      def symbols_validate(root)
+        f = root.at("//clause[title = '符号、代号和缩略语']")
+        return if f.nil?
+        f.elements do |e|
+          unless e.name == "dl"
+            warn "ISO style: Symbols and Abbreviations can only contain "\
+              "a definition list"
+            return
+          end
+        end
+      end
+
+      # spec of permissible section sequence
+      SEQ = [
+        { msg: "Initial section must be (content) 前言",
+          val:  [{ tag: "foreword", title: "前言" }], },
+      { msg: "Prefatory material must be followed by (clause) 范围",
+        val:  [{ tag: "introduction", title: "引言" },
+               { tag: "clause", title: "范围" }], },
+      { msg: "Prefatory material must be followed by (clause) 范围",
+        val: [{ tag: "clause", title: "范围" }], },
+      { msg: "规范性引用文件 must be followed by "\
+        "术语和定义",
+        val: [
+          { tag: "terms", title: "术语和定义" },
+          { tag: "terms",
+            title: "术语、定义、符号、代号和缩略语" }
+        ] },
+      ]
+
+      def sections_sequence_validate(root)
+        f = root.xpath(" //foreword | //introduction | //sections/terms | "\
+                       "//sections/clause | ./references | "\
+                       "./annex")
+        names = f.map { |s| { tag: s.name, title: s.at("./title").text } }
+        names = seqcheck(names, SEQ[0][:msg], SEQ[0][:val]) || return
+        n = names[0]
+        names = seqcheck(names, SEQ[1][:msg], SEQ[1][:val]) || return
+        if n == { tag: "introduction", title: "引言" }
+          names = seqcheck(names, SEQ[2][:msg], SEQ[2][:val]) || return
+        end
+        names = seqcheck(names, SEQ[3][:msg], SEQ[3][:val]) || return
+        n = names.shift
+        if n == { tag: "clause", title: "符号、代号和缩略语" }
+          n = names.shift
+        end
+        unless n
+          warn "ISO style: Document must contain at least one clause"
+          return
+        end
+        n[:tag] == "clause" or
+          warn "ISO style: Document must contain at least one clause"
+        (n == { tag: "clause", title: "范围" }) &&
+          warn("ISO style: 范围 must occur before 术语和定义")
+        n = names.shift or return
+        while n[:tag] == "clause"
+          (n[:title] == "范围") &&
+            warn("ISO style: 范围 must occur before 术语和定义")
+          n[:title] == "符号、代号和缩略语" and
+            warn "ISO style: 符号、代号和缩略语 must occur "\
+            "right after Terms and Definitions"
+          n = names.shift or return
+        end
+        unless n[:tag] == "annex" or n[:tag] == "references"
+          warn "ISO style: Only annexes and references can follow clauses"
+        end
+        while n[:tag] == "annex"
+          n = names.shift or return
+        end
+        n == { tag: "references", title: "规范性引用文件" } or
+          warn "ISO style: Document must include (references) 规范性引用文件"
+        n = names.shift
+        n == { tag: "references", title: "参考文献" } or
+          warn "ISO style: Final section must be (references) 参考文献"
+        names.empty? or
+          warn "ISO style: There are sections after the final Bibliography"
+      end
+    end
+  end
+end

data/lib/asciidoctor/gb/section_output.rb

@@ -0,0 +1,38 @@
+module Asciidoctor
+  module Gb
+    class GbConvert < IsoDoc::Convert
+      # putting in tab so that ToC aligns
+      def foreword(isoxml, out)
+        f = isoxml.at(ns("//foreword")) || return
+        page_break(out)
+        out.div do |s|
+          s.h1 **{ class: "ForewordTitle" } do |h1|
+            h1 << "#{@foreword_lbl}&nbsp;"
+            # insert_tab(h1, 1)
+          end
+          f.elements.each { |e| parse(e, s) unless e.name == "title" }
+        end
+      end
+
+      def clause_name_header(num, title, div, header_class)
+        header_class = {} if header_class.nil?
+        div.h1 **attr_code(header_class) do |h1|
+          if num
+            h1 << num
+            h1 << "&nbsp;"
+          end
+          h1 << title
+        end
+        div.parent.at(".//h1")
+      end
+
+      def annex_name(annex, name, div)
+        div.h1 **{ class: "Annex" } do |t|
+          t << "#{get_anchors[annex['id']][:label]}<br/><br/>"
+          t << name.text
+        end
+      end
+
+    end
+  end
+end

data/lib/asciidoctor/gb/version.rb

@@ -0,0 +1,5 @@
+module Asciidoctor
+  module Gb
+    VERSION = "0.1.5"
+  end
+end

data/lib/asciidoctor/gb/xref_gen.rb

@@ -0,0 +1,25 @@
+require "isodoc"
+
+module Asciidoctor
+  module Gb
+    # A {Converter} implementation that generates GB output, and a document
+    # schema encapsulation of the document for validation
+    class GbConvert < IsoDoc::Convert
+      def format_ref(ref, isopub)
+        return "ISO #{ref}" if isopub
+        return "[#{ref}]" if /^\d+$/.match?(ref) && !/^\[.*\]$/.match?(ref)
+        ref
+      end
+
+      def reference_names(ref)
+        isopub = ref.at(ns(ISO_PUBLISHER_XPATH))
+        docid = ref.at(ns("./docidentifier"))
+        return ref_names(ref) unless docid
+        date = ref.at(ns("./date[@type = 'published']"))
+        reference = format_ref(docid.text, isopub)
+        reference += ": #{date.text}" if date && isopub
+        @anchors[ref["id"]] = { xref: reference }
+      end
+    end
+  end
+end

data/lib/asciidoctor/gb.rb

@@ -0,0 +1,7 @@
+require "asciidoctor/gb/version"
+
+module Asciidoctor
+  module Gb
+    # Your code goes here...
+  end
+end

data/lib/asciidoctor-gb.rb

@@ -0,0 +1,4 @@
+require "asciidoctor" unless defined? Asciidoctor::Converter
+require_relative "asciidoctor/gb/converter"
+require_relative "asciidoctor/gb/gbconvert"
+require_relative "asciidoctor/gb/version"