asciidoctor-gb 0.1.5 → 0.2.2

data/lib/asciidoctor/gb/converter.rb

@@ -1,9 +1,9 @@
 require "asciidoctor"
-require "asciidoctor/gb/version"
-require "asciidoctor/gb/gbconvert"
 require "asciidoctor/iso/converter"
+require "asciidoctor/gb/version"
 require_relative "./section_input.rb"
 require_relative "./front.rb"
+require_relative "./validate.rb"
 require "pp"
 
 module Asciidoctor
@@ -29,66 +29,89 @@ module Asciidoctor
         ret1
       end
 
-      def validate(doc)
-        content_validate(doc)
-        schema_validate(formattedstr_strip(doc.dup),
-                        File.join(File.dirname(__FILE__), "gbstandard.rng"))
-      end
-
-      def content_validate(doc)
-        super
-        bilingual_terms_validate(doc.root)
-        doc_converter(nil).gbtype_validate(doc.root)
+      def html_doc_path(file)
+        File.join(File.dirname(__FILE__), File.join("html", file))
       end
 
-      def check_bilingual(t, element)
-        zh = t.at(".//#{element}[@language = 'zh']")
-        en = t.at(".//#{element}[@language = 'en']")
-        (en.nil? || en.text.empty?) && !(zh.nil? || zh.text.empty?) &&
-          warn("GB: #{element} term #{zh.text} has no English counterpart")
-        !(en.nil? || en.text.empty?) && (zh.nil? || zh.text.empty?) &&
-          warn("GB: #{element} term #{en.text} has no Chinese counterpart")
+      def html_converter(node)
+        node.nil? ? IsoDoc::Gb::Convert.new({}) :
+          IsoDoc::Gb::Convert.new(
+            script: node.attr("script"),
+            bodyfont: node.attr("body-font"),
+            headerfont: node.attr("header-font"),
+            monospacefont: node.attr("monospace-font"),
+            titlefont: node.attr("title-font"),
+            i18nyaml: node.attr("i18nyaml"),
+            scope: node.attr("scope"),
+        )
       end
 
-      def bilingual_terms_validate(root)
-        root.xpath("//term").each do |t|
-          check_bilingual(t, "preferred")
-          check_bilingual(t, "admitted")
-          check_bilingual(t, "deprecates")
-        end
+      def doc_converter(node)
+        node.nil? ? IsoDoc::Gb::WordConvert.new({}) :
+        IsoDoc::Gb::WordConvert.new(
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          titlefont: node.attr("title-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+        )
       end
 
-      def html_doc_path(file)
-        File.join(File.dirname(__FILE__), File.join("html", file))
+      def default_fonts(node)
+        script = node.attr("script") || "Hans"
+        b = node.attr("body-font") ||
+          (script == "Hans" ? '"SimSun",serif' :
+           script == "Latn" ? '"Cambria",serif' : '"SimSun",serif' )
+        h = node.attr("header-font") ||
+          (script == "Hans" ? '"SimHei",sans-serif' :
+           script == "Latn" ? '"Calibri",sans-serif' : '"SimHei",sans-serif' )
+        m = node.attr("monospace-font") || '"Courier New",monospace'
+        scope = node.attr("scope") || "national"
+        t = node.attr("title-font") ||
+          (scope == "national" ? (script != "Hans" ? '"Cambria",serif' : '"SimSun",serif' ) :
+           (script == "Hans" ? '"SimHei",sans-serif' : '"Calibri",sans-serif' ))
+        "$bodyfont: #{b};\n$headerfont: #{h};\n$monospacefont: #{m};\n$titlefont: #{t};\n"
       end
 
-      def doc_converter(node)
-        GbConvert.new(
-          htmlstylesheet: html_doc_path("htmlstyle.css"),
-          wordstylesheet: html_doc_path("wordstyle.css"),
-          standardstylesheet: html_doc_path("gb.css"),
-          header: html_doc_path("header.html"),
-          htmlcoverpage: html_doc_path("html_gb_titlepage.html"),
-          wordcoverpage: html_doc_path("word_gb_titlepage.html"),
-          htmlintropage: html_doc_path("html_gb_intro.html"),
-          wordintropage: html_doc_path("word_gb_intro.html"),
-          i18nyaml: node&.attr("i18nyaml"),
-        )
+      def document(node)
+        init(node)
+        ret = makexml(node).to_xml(indent: 2)
+        filename = node.attr("docfile").gsub(/\.adoc$/, "").gsub(%r{^.*/}, "")
+        File.open(filename, "w") { |f| f.write(ret) }
+        unless node.attr("nodoc")
+          #html_converter_alt(node).convert(filename + ".xml")
+          #system "mv #{filename}.html #{filename}_alt.html"
+          html_converter(node).convert(filename + ".xml")
+          doc_converter(node).convert(filename + ".xml")
+        end
+        @files_to_delete.each { |f| system "rm #{f}" }
+        ret
       end
 
       def termdef_cleanup(xmldoc)
         super
-        termdef_localisedstr(xmldoc)
+        localisedstr(xmldoc)
       end
 
       ROMAN_TEXT = /\s*[a-z\u00c0-\u00d6\u00d8-\u00f0\u0100-\u0240]/i
       HAN_TEXT = /\s*[\u4e00-\u9fff]+/
 
-      def termdef_localisedstr(xmldoc)
-        xmldoc.xpath("//admitted | //deprecates | //preferred").each do |zh|
+      LOCALISED_ELEMS = "//admitted | //deprecates | //preferred | //prefix | "\
+        "//initial | //addition | //surname | //forename | //name | "\
+        "//abbreviation | //role/description | //affiliation/description | "\
+        "//bibdata/item | //bibitem/title | //bibdata/formattedref | "\
+        "//bibitem/formattedref | //bibdata/note | //bibitem/note | "\
+        "//bibdata/abstract | //bibitem/note ".freeze
+
+      MUST_LOCALISE_ELEMS = %w{admitted deprecates preferred}.freeze
+
+      def localisedstr(xmldoc)
+        xmldoc.xpath(LOCALISED_ELEMS).each do |zh|
           if zh.at("./string")
             extract_localisedstrings(zh)
-          else
+          elsif MUST_LOCALISE_ELEMS.include? zh.name
             duplicate_localisedstrings(zh)
           end
         end
@@ -116,34 +139,20 @@ module Asciidoctor
       end
 
       def inline_quoted(node)
-        noko do |xml|
-          case node.type
-          when :emphasis then xml.em node.text
-          when :strong then xml.strong node.text
-          when :monospaced then xml.tt node.text
-          when :double then xml << "\"#{node.text}\""
-          when :single then xml << "'#{node.text}'"
-          when :superscript then xml.sup node.text
-          when :subscript then xml.sub node.text
-          when :asciimath then xml.stem node.text, **{ type: "AsciiMath" }
+        ret = noko do |xml|
+          case node.role
+          when "en" then xml.string node.text, **{ language: "en" }
+          when "zh" then xml.string node.text, **{ language: "zh" }
+          when "zh-Hans"
+            xml.string node.text, **{ language: "zh", script: "Hans" }
+          when "zh-Hant"
+            xml.string node.text, **{ language: "zh", script: "Hant" }
           else
-            case node.role
-            when "alt" then xml.admitted { |a| a << node.text }
-            when "deprecated" then xml.deprecates { |a| a << node.text }
-            when "domain" then xml.domain { |a| a << node.text }
-            when "strike" then xml.strike node.text
-            when "smallcap" then xml.smallcap node.text
-            when "en" then xml.string node.text, **{ language: "en" }
-            when "zh" then xml.string node.text, **{ language: "zh" }
-            when "zh-Hans"
-              xml.string node.text, **{ language: "zh", script: "Hans" }
-            when "zh-Hant"
-              xml.string node.text, **{ language: "zh", script: "Hant" }
-            else
-              xml << node.text
-            end
+            nil
           end
         end.join
+        return ret unless ret.nil? or ret.empty?
+        super
       end
 
       def termdef_boilerplate_cleanup(xmldoc)
@@ -153,7 +162,7 @@ module Asciidoctor
       GBCODE = "((AQ|BB|CB|CH|CJ|CY|DA|DB|DL|DZ|EJ|FZ|GA|GH|GM|GY|HB|HG|"\
         "HJ|HS|HY|JB|JC|JG|JR|JT|JY|LB|LD|LS|LY|MH|MT|MZ|NY|QB|QC|QJ|"\
         "QZ|SB|SC|SH|SJ|SN|SY|TB|TD|TJ|TY|WB|WH|WJ|WM|WS|WW|XB|YB|YC|"\
-        "YD|YS|YY|YZ|ZY|GB|GBZ|GJB|GBn|GHZB|GWKB|GWPB|JJF|JJG)(/Z|/T)?)"
+        "YD|YS|YY|YZ|ZY|GB|GBZ|GJB|GBn|GHZB|GWKB|GWPB|JJF|JJG|Q|T)(/Z|/T)?)"
 
       ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<code>(ISO|IEC|#{GBCODE})[^0-9]*\s[0-9-]+)(:(?<year>[0-9]+))?\]</ref>,?\s
@@ -163,7 +172,6 @@ module Asciidoctor
       \[(?<code>(ISO|IEC|#{GBCODE})[^0-9]*\s[0-9-]+):--\]</ref>,?\s?
       <fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?(?<text>.*)$}xm
 
-      # TODO: all parts in ZH
       ISO_REF_ALL_PARTS = %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<code>(ISO|IEC|#{GBCODE})[^0-9]*\s[0-9]+)\s\(all\sparts\)\]</ref>(<p>)?,?\s?
       (?<text>.*)(</p>)?$}xm
@@ -174,6 +182,32 @@ module Asciidoctor
         matched3 = ISO_REF_ALL_PARTS.match item
         [matched, matched2, matched3]
       end
+
+      def cleanup(xmldoc)
+        super
+        contributor_cleanup(xmldoc)
+        xmldoc
+      end
+
+      def contributor_cleanup(xmldoc)
+        issuer = xmldoc.at("//bibdata/contributor[role/@type = 'issuer']/organization/name")
+        scope = xmldoc.at("//gbscope")&.text
+        prefix = xmldoc.at("//gbprefix")&.text
+        mandate = xmldoc.at("//gbmandate")&.text || "mandatory"
+        lang = xmldoc.at("//language")&.text
+        agency = issuer.content
+        agency = IsoDoc::Gb::Convert.new({}).standard_agency1(scope, prefix, mandate) if agency == "GB"
+        agency = "GB" unless agency
+        owner = xmldoc.at("//copyright/owner/organization/name")
+        owner.content = agency
+        owner = xmldoc.at("//contributor[role/@type = 'issuer']/organization/name")
+        owner.content = agency
+        xmldoc.xpath("//gbcommittee").each do |c|
+          xmldoc.at("//bibdata/contributor").next = 
+            "<contributor><role type='technical-committee'/><organization>"\
+            "<name>#{c.text}</name></organization></contributor>"
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/gb/front.rb

@@ -1,20 +1,42 @@
 module Asciidoctor
   module Gb
     class Converter < ISO::Converter
-      def metadata_author(_node, xml)
-        xml.contributor do |c|
-          c.role **{ type: "author" }
-          c.organization do |a|
-            a.name "GB"
+      def standard_type(node)
+        type = node.attr("mandate") || "mandatory"
+        type = "standard" if type == "mandatory"
+        type = "recommendation" if type == "recommended"
+        type
+      end
+
+      def front(node, xml)
+        xml.bibdata **attr_code(type: standard_type(node)) do |b|
+          metadata node, b
+        end
+        metadata_version(node, xml)
+      end
+
+      def metadata_author(node, xml)
+        author = node.attr("author") || return
+        author.split(/, ?/).each do |author|
+          xml.contributor do |c|
+            c.role **{ type: "author" }
+            c.person do |p|
+              p.name do |n|
+                n.surname author
+              end
+            end
           end
         end
       end
 
-      def metadata_publisher(_node, xml)
-        xml.contributor do |c|
-          c.role **{ type: "publisher" }
-          c.organization do |a|
-            a.name "GB"
+      def metadata_contributor1(node, xml, type, role)
+        contrib = node.attr(type) || "GB"
+        contrib.split(/, ?/).each do |c|
+          xml.contributor do |x|
+            x.role **{ type: role }
+            x.organization do |a|
+              a.name { |n| n << c }
+            end
           end
         end
       end
@@ -65,16 +87,24 @@ module Asciidoctor
       end
 
       def get_scope(node)
-        unless scope = node.attr("scope")
-          scope = "national"
-          warn "GB: no scope supplied, defaulting to National"
-        end
-        scope
+        node.attr("scope") and return node.attr("scope")
+        scope = if %r{^[TQ]/}.match? node.attr("prefix")
+                  m = node.attr("prefix").split(%{/})
+                  mandate = m[0] == "T" ? "social" :
+                    m[0] == "Q" ? "enterprise" : nil
+                end
+        return scope unless scope.nil?
+        warn "GB: no scope supplied, defaulting to National"
+        "national"
       end
 
       def get_prefix(node)
         scope = get_scope(node)
-        unless prefix = node.attr("prefix")
+        if prefix = node.attr("prefix")
+          prefix.gsub!(%r{/[TZ]$}, "")
+          prefix.gsub!(%r{^[TQ]/([TZ]/)?}, "")
+          prefix.gsub!(/^DB/, "") if scope == "local"
+        else
           prefix = "GB"
           scope = "national"
           warn "GB: no prefix supplied, defaulting to GB"
@@ -83,95 +113,113 @@ module Asciidoctor
       end
 
       def get_mandate(node)
-        unless mandate = node.attr("mandate")
+        node.attr("mandate") and return node.attr("mandate")
+        p = node.attr("prefix")
+        mandate = %r{/T}.match?(p) ? "recommended" :
+          %r{/Z}.match?(p) ? "guidelines" : nil
+        if mandate.nil?
           mandate = "mandatory"
           warn "GB: no mandate supplied, defaulting to mandatory"
         end
         mandate
       end
 
+      def get_topic(node)
+        node.attr("topic") and return node.attr("topic")
+        warn "GB: no topic supplied, defaulting to basic"
+        "basic"
+      end
+
       def metadata_gbtype(node, xml)
         xml.gbtype do |t|
           scope, prefix = get_prefix(node)
           t.gbscope { |s| s << scope }
           t.gbprefix { |p| p << prefix }
           t.gbmandate { |m| m << get_mandate(node) }
+          t.gbtopic { |t| t << get_topic(node) }
         end
       end
 
+      def metadata_date1(node, xml, type)
+        date = node.attr("#{type}-date")
+        date and xml.date **{ type: type } do |d|
+          d.from date
+        end
+      end
+
+      DATETYPES = %w{ published accessed created implemented obsoleted
+                      confirmed updated issued 
+      }.freeze
+
       def metadata_date(node, xml)
-        pubdate = node.attr("published-date")
-        activdate = node.attr("activated-date")
-        xml.date(pubdate, **{ type: "published" }) if pubdate
-        xml.date(activdate, **{ type: "activated" }) if activdate
+        DATETYPES.each do |t|
+          metadata_date1(node, xml, t)
+        end
       end
 
       def metadata_gblibraryids(node, xml)
-        ics = node.attr("library-ics")
-        l = node.attr("library-l")
-        if ics || l
-          xml.gblibraryids do |g|
-            xml.ics ics if ics
-            xml.l l if l
-          end
+        ccs = node.attr("library-ccs")
+        ccs and ccs.split(/, ?/).each do |l|
+          xml.ccs { |c| c << l }
         end
+        l = node.attr("library-plan")
+        l && xml.plannumber { |plan| plan << l }
+      end
+
+      def metadata_contributors(node, xml)
+        metadata_author(node, xml)
+        metadata_contributor1(node, xml, "author-committee", "author")
+        metadata_contributor1(node, xml, "publisher", "publisher")
+        metadata_contributor1(node, xml, "authority", "authority")
+        metadata_contributor1(node, xml, "proposer", "proposer")
+        metadata_contributor1(node, xml, "issuer", "issuer")
       end
 
       def metadata(node, xml)
         title node, xml
         metadata_id(node, xml)
         metadata_date(node, xml)
-        metadata_author(node, xml)
-        metadata_publisher(node, xml)
+        metadata_contributors(node, xml)
         xml.language (node.attr("language") || "zh")
         xml.script (node.attr("script") || "Hans")
         metadata_status(node, xml)
         metadata_copyright(node, xml)
         metadata_equivalence(node, xml)
         metadata_obsoletes(node, xml)
+        metadata_ics(node, xml)
         metadata_committee(node, xml)
         metadata_gbtype(node, xml)
         metadata_gblibraryids(node, xml)
       end
 
-      def title(node, xml)
-        ["en", "zh"].each do |lang|
-          xml.title do |t|
-            at = { language: lang, format: "plain" }
-            node.attr("title-intro-#{lang}") and
-              t.title_intro **attr_code(at) do |t1|
-              t1 << node.attr("title-intro-#{lang}")
-            end
-            t.title_main **attr_code(at) do |t1|
-              t1 << node.attr("title-main-#{lang}")
-            end
-            node.attr("title-part-#{lang}") and
-              t.title_part **attr_code(at) do |t1|
-              t1 << node.attr("title-part-#{lang}")
-            end
-          end
+      def title_intro(node, lang, t, at)
+        node.attr("title-intro-#{lang}") and
+          t.title_intro **attr_code(at) do |t1|
+          t1 << asciidoc_sub(node.attr("title-intro-#{lang}"))
         end
       end
 
-      def title_intro_validate(root)
-        title_intro_en = root.at("//title-intro[@language='en']")
-        title_intro_zh = root.at("//title-intro[@language='zh']")
-        if title_intro_en.nil? && !title_intro_zh.nil?
-          warn "No English Title Intro!"
-        end
-        if !title_intro_en.nil? && title_intro_zh.nil?
-          warn "No Chinese Title Intro!"
+      def title_main(node, lang, t, at)
+        t.title_main **attr_code(at) do |t1|
+          t1 << asciidoc_sub(node.attr("title-main-#{lang}"))
         end
       end
 
-      def title_part_validate(root)
-        title_part_en = root.at("//title-part[@language='en']")
-        title_part_zh = root.at("//title-part[@language='zh']")
-        if title_part_en.nil? && !title_part_zh.nil?
-          warn "No English Title Part!"
+      def title_part(node, lang, t, at)
+        node.attr("title-part-#{lang}") and
+          t.title_part **attr_code(at) do |t1|
+          t1 << asciidoc_sub(node.attr("title-part-#{lang}"))
         end
-        if !title_part_en.nil? && title_part_zh.nil?
-          warn "No Chinese Title Part!"
+      end
+
+      def title(node, xml)
+        ["en", "zh"].each do |lang|
+          xml.title do |t|
+            at = { language: lang, format: "plain" }
+            title_intro(node, lang, t, at)
+            title_main(node, lang, t, at)
+            title_part(node, lang, t, at)
+          end
         end
       end
     end