asciidoctor-iso 0.6.1 → 0.7.0

data/lib/asciidoctor/iso/blocks.rb

@@ -4,28 +4,27 @@ require "uri"
 module Asciidoctor
   module ISO
     module Blocks
-
       def id_attr(node = nil)
         { id: Utils::anchor_or_uuid(node) }
       end
 
+      # open block is a container of multiple blocks,
+      # treated as a single block.
+      # We append each contained block to its parent
       def open(node)
-        # open block is a container of multiple blocks,
-        # treated as a single block.
-        # We append each contained block to its parent
         result = []
-        if node.blocks?
-          node.blocks.each do |b|
-            result << send(b.context, b)
-          end
-        else
-          result = paragraph(node)
+        node.blocks.each do |b|
+          result << send(b.context, b)
         end
         result
       end
 
+      def literal(node)
+        open(node)
+      end
+
+      # NOTE: html escaping is performed by Nokogiri
       def stem(node)
-        # NOTE: html escaping is performed by Nokogiri
         stem_content = node.lines.join("\n")
         noko do |xml|
           xml.formula **id_attr(node) do |s|
@@ -36,9 +35,9 @@ module Asciidoctor
       end
 
       def sidebar_attrs(node)
-        date = node.attr("date") || DateTime.now.iso8601.gsub(/\+.*$/, "")
+        date = node.attr("date") || Date.today.iso8601.gsub(/\+.*$/, "")
         date += "T0000" unless /T/.match? date
-        { 
+        {
           reviewer: node.attr("reviewer") || node.attr("source") || "(Unknown)",
           id: Utils::anchor_or_uuid(node),
           date: date.gsub(/[:-]/, ""),
@@ -48,9 +47,8 @@ module Asciidoctor
       end
 
       def sidebar(node)
-        return unless is_draft
-        content = Utils::flatten_rawtext(node.content).join("\n")
-        noko do |xml| 
+        return unless draft?
+        noko do |xml|
           xml.review **attr_code(sidebar_attrs(node)) do |r|
             wrap_in_para(node, r)
           end
@@ -78,9 +76,10 @@ module Asciidoctor
 
       def admonition_attrs(node)
         name = node.attr("name")
-        type = node.attr("type") and
+        if type = node.attr("type")
           ["danger", "safety precautions"].each do |t|
-          name = t if type.casecmp(t).zero?
+            name = t if type.casecmp(t).zero?
+          end
         end
         { id: Utils::anchor_or_uuid(node), type: name }
       end
@@ -112,6 +111,8 @@ module Asciidoctor
           xml.example **id_attr(node) do |ex|
             content = node.content
             ex << content
+            text = Utils::flatten_rawtext(content).join("\n")
+            termexample_style(node, text)
           end
         end.join("\n")
       end
@@ -131,17 +132,25 @@ module Asciidoctor
       def image_attributes(node)
         uri = node.image_uri node.attr("target")
         types = MIME::Types.type_for(uri)
-        { src: uri, 
+        { src: uri,
           id: Utils::anchor_or_uuid,
           imagetype: types.first.sub_type.upcase,
           height: node.attr("height"),
           width: node.attr("width") }
       end
 
+      def figure_title(node, f)
+        if node.title.nil?
+          style_warning(node, "Figure should have title", nil)
+        else
+          f.name { |name| name << node.title }
+        end
+      end
+
       def image(node)
         noko do |xml|
           xml.figure **id_attr(node) do |f|
-            f.name { |name| name << node.title } unless node.title.nil?
+            figure_title(node, f)
             f.image **attr_code(image_attributes(node))
           end
         end
@@ -165,8 +174,8 @@ module Asciidoctor
 
       def quote_attribution(node, out)
         if node.attr("citetitle")
-          m = /^(?<cite>[^,]+)(,(?<text>.*$))?$/.match node.attr("citetitle")
-          out.source m[:text], 
+          m = /^(?<cite>[^,]+)(,(?<text>.*$))?$/m.match node.attr("citetitle")
+          out.source m[:text],
             **attr_code(target: m[:cite], type: "inline")
         end
         if node.attr("attribution")
@@ -186,17 +195,8 @@ module Asciidoctor
       def listing(node)
         # NOTE: html escaping is performed by Nokogiri
         noko do |xml|
-          if node.parent.context != :example
-            xml.example **id_attr(node) do |e|
-              e.sourcecode **id_attr(node) do |s| 
-                s << node.content 
-              end
-            end
-          else
-            xml.sourcecode **id_attr(node) do |s|
-              s << node.content 
-            end
-          end
+          xml.sourcecode(**id_attr(node)) { |s| s << node.content }
+          # xml.sourcecode(**id_attr(node)) { |s| s << node.lines.join("\n") }
         end
       end
     end

data/lib/asciidoctor/iso/cleanup.rb

@@ -15,8 +15,8 @@ module Asciidoctor
 
       def cleanup(xmldoc)
         sections_cleanup(xmldoc)
+        obligations_cleanup(xmldoc)
         termdef_cleanup(xmldoc)
-        isotitle_cleanup(xmldoc)
         table_cleanup(xmldoc)
         formula_cleanup(xmldoc)
         figure_cleanup(xmldoc)
@@ -25,59 +25,68 @@ module Asciidoctor
         normref_cleanup(xmldoc)
         reference_names(xmldoc)
         xref_cleanup(xmldoc)
+        bpart_cleanup(xmldoc)
         quotesource_cleanup(xmldoc)
         para_cleanup(xmldoc)
         callout_cleanup(xmldoc)
         origin_cleanup(xmldoc)
         element_name_cleanup(xmldoc)
         footnote_renumber(xmldoc)
+        empty_element_cleanup(xmldoc)
+        bookmark_cleanup(xmldoc)
         xmldoc
       end
 
+      TEXT_ELEMS =
+        %w{status language script version author name callout phone
+           email street city state country postcode identifier referenceFrom
+           referenceTo docidentifier prefix initial addition surname forename
+           title draft secretariat title-main title-intro title-part}.freeze
+
+      def empty_element_cleanup(xmldoc)
+        xmldoc.xpath("//" + TEXT_ELEMS.join(" | //")).each do |x|
+          x.remove if x.children.empty?
+        end
+      end
+
       def element_name_cleanup(xmldoc)
         xmldoc.traverse { |n| n.name = n.name.gsub(/_/, "-") }
       end
 
-      def callout_cleanup(xmldoc)
+      def link_callouts_to_annotations(callouts, annotations)
+        callouts.each_with_index do |c, i|
+          c["target"] = "_" + UUIDTools::UUID.random_create
+          annotations[i]["id"] = c["target"]
+        end
+      end
+
+      def align_callouts_to_annotations(xmldoc)
         xmldoc.xpath("//sourcecode").each do |x|
           callouts = x.elements.select { |e| e.name == "callout" }
           annotations = x.elements.select { |e| e.name == "annotation" }
           if callouts.size == annotations.size
-            callouts.each_with_index do |c, i|
-              c["target"] = UUIDTools::UUID.random_create
-              annotations[i]["id"] = c["id"]
-            end
+            link_callouts_to_annotations(callouts, annotations)
           else
-            warn "#{x["id"]}: mismatch of callouts and annotations"
+            warn "#{x['id']}: mismatch of callouts and annotations"
           end
         end
       end
 
-      LOCALITY_REGEX_STR = <<~REGEXP
-        ^((?<locality>section|clause|part|paragraph|chapter|page)\\s+
-               (?<ref>\\S+?)|(?<locality>whole))[,:]?\\s*
-         (?<text>.*)$
-      REGEXP
-      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
-                               Regexp::IGNORECASE|Regexp::MULTILINE)
-
-      def termdef_warn(text, re, term, msg)
-        re.match? text and warn "ISO style: #{term}: #{msg}"
+      def merge_annotations_into_sourcecode(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          while x&.next_element&.name == "annotation"
+            x.next_element.parent = x
+          end
+        end
       end
 
-      def termdef_style(xmldoc)
-        xmldoc.xpath("//term").each do |t|
-          para = t.at("./p") or return
-          term = t.at("preferred").text
-          termdef_warn(para.text, /^(the|a)\b/i, term,
-                       "term definition starts with article")
-          termdef_warn(para.text, /\.$/i, term,
-                       "term definition ends with period")
-        end
+      def callout_cleanup(xmldoc)
+        merge_annotations_into_sourcecode(xmldoc)
+        align_callouts_to_annotations(xmldoc)
       end
 
       def termdef_stem_cleanup(xmldoc)
-        xmldoc.xpath("//termdef/p/stem").each do |a|
+        xmldoc.xpath("//term/p/stem").each do |a|
           if a.parent.elements.size == 1
             # para containing just a stem expression
             t = Nokogiri::XML::Element.new("admitted", xmldoc)
@@ -97,7 +106,7 @@ module Asciidoctor
 
       def termdefinition_cleanup(xmldoc)
         xmldoc.xpath("//term").each do |d|
-          first_child = d.at("./p | ./figure | ./formula") or return
+          first_child = d.at("./p | ./figure | ./formula") || return
           t = Nokogiri::XML::Element.new("definition", xmldoc)
           first_child.replace(t)
           t << first_child.remove
@@ -114,29 +123,66 @@ module Asciidoctor
         end
       end
 
+      def termdef_boilerplate_cleanup(xmldoc)
+        xmldoc.xpath("//terms/p | //terms/ul").each do |a|
+          a.remove
+        end
+      end
+
       def termdef_cleanup(xmldoc)
         termdef_unnest_cleanup(xmldoc)
         termdef_stem_cleanup(xmldoc)
         termdomain_cleanup(xmldoc)
         termdefinition_cleanup(xmldoc)
-        termdef_style(xmldoc)
+        termdef_boilerplate_cleanup(xmldoc)
       end
 
-      ELEMS_ALLOW_NOTES = 
-        %w[p formula quote sourcecode example admonition ul ol dl figure]
+      ELEMS_ALLOW_NOTES =
+        %w[p formula quote sourcecode example admonition ul ol dl figure].freeze
 
       # if a note is at the end of a section, it is left alone
-      # if a note is followed by a non-note block, 
+      # if a note is followed by a non-note block,
       # it is moved inside its preceding block
       def note_cleanup(xmldoc)
         q = "//note[following-sibling::*[not(local-name() = 'note')]]"
         xmldoc.xpath(q).each do |n|
           next unless n.ancestors("table").empty?
-          prev = n.previous_element or next
+          prev = n.previous_element || next
           n.parent = prev if ELEMS_ALLOW_NOTES.include? prev.name
         end
       end
 
+      def empty_text_before_first_element(x)
+        x.children.each do |c|
+          if c.text?
+            return false if /\S/.match?(c.text)
+          end
+          return true if c.element?
+        end
+        true
+      end
+
+      def strip_initial_space(x)
+        if x.children[0].text?
+          if !/\S/.match?(x.children[0].text)
+            x.children[0].remove
+          else
+            x.children[0].content =  x.children[0].text.gsub(/^ /, "")
+          end
+        end
+      end
+
+      def bookmark_cleanup(xmldoc)
+        xmldoc.xpath("//li[descendant::bookmark]").each do |x|
+          if x&.elements[0]&.name == "p" &&
+              x&.elements[0]&.elements[0]&.name == "bookmark"
+            if empty_text_before_first_element(x.elements[0])
+              x["id"] = (x.elements[0].elements[0].remove)["id"]
+              strip_initial_space(x.elements[0])
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/iso/cleanup_block.rb

@@ -31,11 +31,20 @@ module Asciidoctor
         end
       end
 
+      def insert_thead(s)
+        thead = s.at("./thead")
+        return thead unless thead.nil?
+        if tname = s.at("./name")
+          thead = tname.add_next_sibling("<thead/>").first
+          return thead
+        end
+        s.children.first.add_previous_sibling("<thead/>").first
+      end
+
       def header_rows_cleanup(xmldoc)
-        q = "//table[@headerrows]"
-        xmldoc.xpath(q).each do |s|
-          thead = s.at("./thead")
-          [1..s["headerrows"].to_i].each do
+        xmldoc.xpath("//table[@headerrows]").each do |s|
+          thead = insert_thead(s)
+          (thead.xpath("./tr").size...s["headerrows"].to_i).each do
             row = s.at("./tbody/tr")
             row.parent = thead
           end
@@ -125,42 +134,86 @@ module Asciidoctor
               outnum = i
               seen[fn.text] = outnum
             end
-            fn["reference"] = (outnum - 1 + 'a'.ord).chr
+            fn["reference"] = (outnum - 1 + "a".ord).chr
             fn["table"] = true
           end
         end
       end
 
-      def other_footnote_renumber(xmldoc)
-        seen, i = {}, 0
-        xmldoc.xpath("//fn | //bibitem/note").each do |fn|
-          unless fn["table"]
-            if seen[fn.text] then outnum = seen[fn.text]
-            else
-              i += 1
-              outnum = i
-              seen[fn.text] = outnum
-            end
-            fn["reference"] = outnum.to_s
+      def other_footnote_renumber1(fn, i, seen, outnum)
+        unless fn["table"]
+          if seen[fn.text] then outnum = seen[fn.text]
+          else
+            i += 1
+            outnum = i
+            seen[fn.text] = outnum
           end
-          fn.delete("table")
+          fn["reference"] = outnum.to_s
+        end
+        [i, seen, outnum]
+      end
+
+      PRE_NORMREF_FOOTNOTES = "//foreword//fn | //introduction//fn |"\
+        "//clause[title = 'Scope']//fn" .freeze
+
+      NORMREF_FOOTNOTES =
+        "//references[title = 'Normative References']//fn |"\
+        "//references[title = 'Normative References']//bibitem/note".freeze
+
+      POST_NORMREF_FOOTNOTES =
+        "//clause[not(title = 'Scope')]//fn | "\
+        "//references[title = 'Bibliography']//fn | "\
+        "//references[title = 'Bibliography']//bibitem/note".freeze
+
+      def other_footnote_renumber(xmldoc)
+        seen = {}
+        i = 0
+        outnum = 0
+        xmldoc.xpath(PRE_NORMREF_FOOTNOTES).each do |fn|
+          i, seen, outnum = other_footnote_renumber1(fn, i, seen, outnum)
+        end
+        xmldoc.xpath(NORMREF_FOOTNOTES).each do |fn|
+          i, seen, outnum = other_footnote_renumber1(fn, i, seen, outnum)
+        end
+        xmldoc.xpath(POST_NORMREF_FOOTNOTES).each do |fn|
+          i, seen, outnum = other_footnote_renumber1(fn, i, seen, outnum)
         end
       end
 
       def footnote_renumber(xmldoc)
         table_footnote_renumber(xmldoc)
         other_footnote_renumber(xmldoc)
+        xmldoc.xpath("//fn").each do |fn|
+          fn.delete("table")
+        end
       end
 
       def sections_cleanup(x)
         s = x.at("//sections")
         foreword = x.at("//foreword")
-        s.previous = foreword.remove
+        s.previous = foreword.remove if foreword
         introduction = x.at("//introduction")
         s.previous = introduction.remove if introduction
         x.xpath("//sections/references").reverse_each { |r| s.next = r.remove }
         x.xpath("//sections/annex").reverse_each { |r| s.next = r.remove }
       end
+
+      def obligations_cleanup(x)
+        (s = x.at("//foreword")) && s["obligation"] = "informative"
+        (s = x.at("//introduction")) && s["obligation"] = "informative"
+        (s = x.at("//clause[title = 'Scope']")) && s["obligation"] = "normative"
+        (s = x.at("//clause[title = 'Symbols and Abbreviated Terms']")) &&
+          s["obligation"] = "normative"
+        x.xpath("//references").each { |r| r["obligation"] = "informative" }
+        x.xpath("//terms").each { |r| r["obligation"] = "normative" }
+        x.xpath("//symbols-abbrevs").each { |r| r["obligation"] = "normative" }
+        x.xpath("//annex | //clause").each do |r|
+          r["obligation"] = "normative" unless r["obligation"]
+        end
+        x.xpath("//subsection").each do |r|
+          r["obligation"] = r.at("./ancestor::*/@obligation").text
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/iso/cleanup_ref.rb

@@ -1,31 +1,41 @@
 module Asciidoctor
   module ISO
     module Cleanup
+      # currently references cannot contain commas!
+      # extending localities to cover ISO referencing
+      LOCALITY_REGEX_STR = <<~REGEXP.freeze
+        ^((?<locality>section|clause|part|paragraph|chapter|page|
+                      table|annex|figure|example|note|formula)\\s+
+               (?<ref>[^ \\t\\n,:-]+)(-(?<to>[^ \\t\\n,:-]+))?|
+          (?<locality>whole))[,:]?\\s*
+         (?<text>.*)$
+      REGEXP
+      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
+                               Regexp::IGNORECASE | Regexp::MULTILINE)
 
       def extract_localities(x)
         text = x.children.first.remove.text
-        m = LOCALITY_RE.match text
-        while !m.nil?
-          ref = m[:ref] ? "<reference>#{m[:ref]}</reference>" : ""
-          locality = m[:locality].downcase
-          x.add_child("<locality type='#{locality}'>#{ref}</locality>")
+        while (m = LOCALITY_RE.match text)
+          ref = m[:ref] ? "<referenceFrom>#{m[:ref]}</referenceFrom>" : ""
+          refto = m[:to] ? "<referenceTo>#{m[:to]}</referenceTo>" : ""
+          x.add_child("<locality type='#{m[:locality].downcase}'>"\
+                      "#{ref}#{refto}</locality>")
           text = m[:text]
-          m = LOCALITY_RE.match text
         end
         x.add_child(text)
       end
 
       def xref_to_eref(x)
         x["bibitemid"] = x["target"]
-        x["citeas"] = @anchors&.dig(x["target"], :xref) or
-          warn "ISO: #{x["target"]} is not a real reference!"
+        x["citeas"] = @anchors&.dig(x["target"], :xref) ||
+          warn("ISO: #{x['target']} is not a real reference!")
         x.delete("target")
         extract_localities(x) unless x.children.empty?
       end
 
       def xref_cleanup(xmldoc)
         xmldoc.xpath("//xref").each do |x|
-          if is_refid? x["target"]
+          if refid? x["target"]
             x.name = "eref"
             xref_to_eref(x)
           else
@@ -34,30 +44,26 @@ module Asciidoctor
         end
       end
 
+      # allows us to deal with doc relation localities,
+      # temporarily stashed to "bpart"
+      def bpart_cleanup(xmldoc)
+        xmldoc.xpath("//relation/bpart").each do |x|
+          extract_localities(x)
+          x.replace(x.children)
+        end
+      end
+
       def quotesource_cleanup(xmldoc)
-        xmldoc.xpath("//quote/source").each do |x|
+        xmldoc.xpath("//quote/source | //terms/source").each do |x|
           xref_to_eref(x)
         end
       end
 
       def origin_cleanup(xmldoc)
         xmldoc.xpath("//origin").each do |x|
-          x["citeas"] = @anchors[x["bibitemid"]][:xref]
-          n = x.next_element
-          if !n.nil? && n.name == "isosection"
-            n.name = "locality"
-            n["type"] = "section"
-            n.parent = x
-          end
-        end
-      end
-
-      def isotitle_cleanup(xmldoc)
-        # Remove italicised ISO titles
-        xmldoc.xpath("//isotitle").each do |a|
-          if a.elements.size == 1 && a.elements[0].name == "em"
-            a.children = a.elements[0].children
-          end
+          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) ||
+            warn("ISO: #{x['bibitemid']} is not a real reference!")
+          extract_localities(x) unless x.children.empty?
         end
       end
 
@@ -67,12 +73,11 @@ module Asciidoctor
           parent = r.parent
           parent.previous = r.remove
         end
-        xmldoc
       end
 
       def normref_cleanup(xmldoc)
         q = "//references[title = 'Normative References']"
-        r = xmldoc.at(q)
+        r = xmldoc.at(q) || return
         r.elements.each do |n|
           n.remove unless ["title", "bibitem"].include? n.name
         end
@@ -87,9 +92,9 @@ module Asciidoctor
       def reference_names(xmldoc)
         xmldoc.xpath("//bibitem").each do |ref|
           isopub = ref.at("./contributor[role/@type = 'publisher']/"\
-                          "organization[name = 'ISO']")
+                          "organization[name = 'ISO' or name = 'IEC']")
           docid = ref.at("./docidentifier")
-          date = ref.at("./publisherdate")
+          date = ref.at("./date[@type = 'published']")
           reference = format_ref(docid.text, isopub)
           reference += ": #{date.text}" if date && isopub
           @anchors[ref["id"]] = { xref: reference }