isodoc 1.7.3.1 → 1.7.4

data/lib/isodoc/function/references.rb

@@ -1,204 +1,209 @@
-module IsoDoc::Function
-  module References
-    # This is highly specific to ISO, but it's not a bad precedent for
-    # references anyway; keeping here instead of in IsoDoc::Iso for now
-    def docid_l10n(text)
-      return text if text.nil?
-
-      text.gsub(/All Parts/i, @i18n.all_parts.downcase) if @i18n.all_parts
-      text
-    end
+module IsoDoc
+  module Function
+    module References
+      # This is highly specific to ISO, but it's not a bad precedent for
+      # references anyway; keeping here instead of in IsoDoc::Iso for now
+      def docid_l10n(text)
+        return text if text.nil?
+
+        text.gsub(/All Parts/i, @i18n.all_parts.downcase) if @i18n.all_parts
+        text
+      end
 
-    # TODO generate formatted ref if not present
-    def nonstd_bibitem(list, bib, ordinal, biblio)
-      list.p **attr_code(iso_bibitem_entry_attrs(bib, biblio)) do |ref|
-        ids = bibitem_ref_code(bib)
-        identifiers = render_identifier(ids)
-        if biblio then ref_entry_code(ref, ordinal, identifiers, ids)
-        else
-          ref << (identifiers[0] || identifiers[1]).to_s
-          ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+      # TODO generate formatted ref if not present
+      def nonstd_bibitem(list, bib, ordinal, biblio)
+        list.p **attr_code(iso_bibitem_entry_attrs(bib, biblio)) do |ref|
+          ids = bibitem_ref_code(bib)
+          identifiers = render_identifier(ids)
+          if biblio then ref_entry_code(ref, ordinal, identifiers, ids)
+          else
+            ref << (identifiers[0] || identifiers[1]).to_s
+            ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+          end
+          ref << ", " unless biblio && !identifiers[1]
+          reference_format(bib, ref)
         end
-        ref << ", " unless biblio && !identifiers[1]
-        reference_format(bib, ref)
       end
-    end
 
-    def std_bibitem_entry(list, bib, ordinal, biblio)
-      list.p **attr_code(iso_bibitem_entry_attrs(bib, biblio)) do |ref|
-        identifiers = render_identifier(bibitem_ref_code(bib))
-        if biblio then ref_entry_code(ref, ordinal, identifiers, nil)
-        else
-          ref << (identifiers[0] || identifiers[1]).to_s
-          ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+      def std_bibitem_entry(list, bib, ordinal, biblio)
+        list.p **attr_code(iso_bibitem_entry_attrs(bib, biblio)) do |ref|
+          identifiers = render_identifier(bibitem_ref_code(bib))
+          if biblio then ref_entry_code(ref, ordinal, identifiers, nil)
+          else
+            ref << (identifiers[0] || identifiers[1]).to_s
+            ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+          end
+          date_note_process(bib, ref)
+          ref << ", " unless biblio && !identifiers[1]
+          reference_format(bib, ref)
         end
-        date_note_process(bib, ref)
-        ref << ", " unless biblio && !identifiers[1]
-        reference_format(bib, ref)
       end
-    end
 
-    # if t is just a number, only use that ([1] Non-Standard)
-    # else, use both ordinal, as prefix, and t
-    def ref_entry_code(r, ordinal, t, _id)
-      prefix_bracketed_ref(r, t[0] || "[#{ordinal}]")
-      t[1] and r << (t[1]).to_s
-    end
+      # if ids is just a number, only use that ([1] Non-Standard)
+      # else, use both ordinal, as prefix, and ids
+      def ref_entry_code(ref, ordinal, ids, _id)
+        prefix_bracketed_ref(ref, ids[0] || "[#{ordinal}]")
+        ids[1] and ref << (ids[1]).to_s
+      end
 
-    def pref_ref_code(bib)
-      bib.at(ns("./docidentifier[not(@type = 'DOI' or @type = 'metanorma' "\
-              "or @type = 'ISSN' or @type = 'ISBN' or @type = 'rfc-anchor')]"))
-    end
+      def pref_ref_code(bib)
+        bib.at(ns("./docidentifier[not(@type = 'DOI' or @type = 'metanorma' "\
+                  "or @type = 'ISSN' or @type = 'ISBN' or "\
+                  "@type = 'rfc-anchor')]"))
+      end
 
-    # returns [metanorma, non-metanorma, DOI/ISSN/ISBN] identifiers
-    def bibitem_ref_code(bib)
-      id = bib.at(ns("./docidentifier[@type = 'metanorma']"))
-      id1 = pref_ref_code(bib)
-      id2 = bib.at(ns("./docidentifier[@type = 'DOI' or @type = 'ISSN' or "\
-                    "@type = 'ISBN']"))
-      return [id, id1, id2] if id || id1 || id2
-
-      id = Nokogiri::XML::Node.new("docidentifier", bib.document)
-      id << "(NO ID)"
-      [nil, id, nil]
-    end
+      # returns [metanorma, non-metanorma, DOI/ISSN/ISBN] identifiers
+      def bibitem_ref_code(bib)
+        id = bib.at(ns("./docidentifier[@type = 'metanorma']"))
+        id1 = pref_ref_code(bib)
+        id2 = bib.at(ns("./docidentifier[@type = 'DOI' or @type = 'ISSN' or "\
+                        "@type = 'ISBN']"))
+        return [id, id1, id2] if id || id1 || id2
+
+        id = Nokogiri::XML::Node.new("docidentifier", bib.document)
+        id << "(NO ID)"
+        [nil, id, nil]
+      end
 
-    def bracket_if_num(num)
-      return nil if num.nil?
+      def bracket_if_num(num)
+        return nil if num.nil?
 
-      num = num.text.sub(/^\[/, "").sub(/\]$/, "")
-      return "[#{num}]" if /^\d+$/.match?(num)
+        num = num.text.sub(/^\[/, "").sub(/\]$/, "")
+        return "[#{num}]" if /^\d+$/.match?(num)
 
-      num
-    end
+        num
+      end
 
-    def render_identifier(ident)
-      [bracket_if_num(ident[0]),
-       ident[1].nil? ? nil : ident[1].text.sub(/^\[/, "").sub(/\]$/, ""),
-       ident[2].nil? ? nil : ident[2].text.sub(/^\[/, "").sub(/\]$/, "")]
-    end
+      def render_identifier(ident)
+        [bracket_if_num(ident[0]),
+         ident[1].nil? ? nil : ident[1].text.sub(/^\[/, "").sub(/\]$/, ""),
+         ident[2].nil? ? nil : ident[2].text.sub(/^\[/, "").sub(/\]$/, "")]
+      end
 
-    def docid_prefix(prefix, docid)
-      docid = "#{prefix} #{docid}" if prefix && !omit_docid_prefix(prefix) &&
-        !/^#{prefix}\b/.match(docid)
-      docid_l10n(docid)
-    end
+      def docid_prefix(prefix, docid)
+        docid = "#{prefix} #{docid}" if prefix && !omit_docid_prefix(prefix) &&
+          !/^#{prefix}\b/.match(docid)
+        docid_l10n(docid)
+      end
 
-    def omit_docid_prefix(prefix)
-      return true if prefix.nil? || prefix.empty?
+      def omit_docid_prefix(prefix)
+        return true if prefix.nil? || prefix.empty?
 
-      %w(ISO IEC IEV ITU W3C csd metanorma repository rfc-anchor)
-        .include? prefix
-    end
+        %w(ISO IEC IEV ITU W3C csd metanorma repository rfc-anchor)
+          .include? prefix
+      end
 
-    def date_note_process(bib, ref)
-      date_note = bib.at(ns("./note[@type = 'Unpublished-Status']"))
-      return if date_note.nil?
+      def date_note_process(bib, ref)
+        date_note = bib.at(ns("./note[@type = 'Unpublished-Status']"))
+        return if date_note.nil?
 
-      date_note.children.first.replace("<p>#{date_note.content}</p>")
-      footnote_parse(date_note, ref)
-    end
+        date_note.children.first.replace("<p>#{date_note.content}</p>")
+        footnote_parse(date_note, ref)
+      end
 
-    def iso_bibitem_entry_attrs(bib, biblio)
-      { id: bib["id"], class: biblio ? "Biblio" : "NormRef" }
-    end
+      def iso_bibitem_entry_attrs(bib, biblio)
+        { id: bib["id"], class: biblio ? "Biblio" : "NormRef" }
+      end
 
-    def iso_title(bib)
-      bib.at(ns("./title[@language = '#{@lang}' and @type = 'main']")) ||
-        bib.at(ns("./title[@language = '#{@lang}']")) ||
-        bib.at(ns("./title[@type = 'main']")) ||
-        bib.at(ns("./title"))
-    end
+      def iso_title(bib)
+        bib.at(ns("./title[@language = '#{@lang}' and @type = 'main']")) ||
+          bib.at(ns("./title[@language = '#{@lang}']")) ||
+          bib.at(ns("./title[@type = 'main']")) ||
+          bib.at(ns("./title"))
+      end
 
-    # reference not to be rendered because it is deemed implicit
-    # in the standards environment
-    def implicit_reference(bib)
-      bib["hidden"] == "true"
-    end
+      # reference not to be rendered because it is deemed implicit
+      # in the standards environment
+      def implicit_reference(bib)
+        bib["hidden"] == "true"
+      end
 
-    def prefix_bracketed_ref(ref, text)
-      ref << text.to_s
-      insert_tab(ref, 1)
-    end
+      def prefix_bracketed_ref(ref, text)
+        ref << text.to_s
+        insert_tab(ref, 1)
+      end
 
-    def reference_format(bib, out)
-      if ftitle = bib.at(ns("./formattedref"))
-        ftitle&.children&.each { |n| parse(n, out) }
-      else
-        out.i do |i|
-          iso_title(bib)&.children&.each { |n| parse(n, i) }
+      def reference_format(bib, out)
+        if ftitle = bib.at(ns("./formattedref"))
+          ftitle&.children&.each { |n| parse(n, out) }
+        else
+          out.i do |i|
+            iso_title(bib)&.children&.each { |n| parse(n, i) }
+          end
         end
       end
-    end
 
-    def is_standard(bib)
-      ret = false
-      drop = %w(metanorma DOI ISSN ISBN)
-      bib.xpath(ns("./docidentifier")).each do |id|
-        next if id["type"].nil? || drop.include?(id["type"])
+      def is_standard(bib)
+        ret = false
+        drop = %w(metanorma DOI ISSN ISBN)
+        bib.xpath(ns("./docidentifier")).each do |id|
+          next if id["type"].nil? || drop.include?(id["type"])
 
-        ret = true
+          ret = true
+        end
+        ret
       end
-      ret
-    end
 
-    def biblio_list(refs, div, biblio)
-      i = 0
-      refs.children.each do |b|
-        if b.name == "bibitem"
-          next if implicit_reference(b)
-
-          i += 1
-          if is_standard(b) then std_bibitem_entry(div, b, i, biblio)
-          else nonstd_bibitem(div, b, i, biblio)
+      def biblio_list(refs, div, biblio)
+        i = 0
+        refs.children.each do |b|
+          if b.name == "bibitem"
+            next if implicit_reference(b)
+
+            i += 1
+            if is_standard(b) then std_bibitem_entry(div, b, i, biblio)
+            else nonstd_bibitem(div, b, i, biblio)
+            end
+          else
+            parse(b, div) unless %w(title).include? b.name
           end
-        else
-          parse(b, div) unless %w(title).include? b.name
         end
       end
-    end
 
-    def norm_ref_xpath
-      "//bibliography/references[@normative = 'true'] | "\
-        "//bibliography/clause[.//references[@normative = 'true']]"
-    end
+      def norm_ref_xpath
+        "//bibliography/references[@normative = 'true'] | "\
+          "//bibliography/clause[.//references[@normative = 'true']]"
+      end
 
-    def norm_ref(isoxml, out, num)
-      f = isoxml.at(ns(norm_ref_xpath)) and f["hidden"] != "true" or return num
-      out.div do |div|
-        num = num + 1
-        clause_name(num, f.at(ns("./title")), div, nil)
-        if f.name == "clause"
-          f.elements.each { |e| parse(e, div) unless e.name == "title" }
-        else biblio_list(f, div, false)
+      def norm_ref(isoxml, out, num)
+        f = isoxml.at(ns(norm_ref_xpath)) and f["hidden"] != "true" or
+          return num
+        out.div do |div|
+          num = num + 1
+          clause_name(num, f.at(ns("./title")), div, nil)
+          if f.name == "clause"
+            f.elements.each { |e| parse(e, div) unless e.name == "title" }
+          else biblio_list(f, div, false)
+          end
         end
+        num
       end
-      num
-    end
 
-    def bibliography_xpath
-      "//bibliography/clause[.//references]"\
-        "[not(.//references[@normative = 'true'])] | "\
-        "//bibliography/references[@normative = 'false']"
-    end
+      def bibliography_xpath
+        "//bibliography/clause[.//references]"\
+          "[not(.//references[@normative = 'true'])] | "\
+          "//bibliography/references[@normative = 'false']"
+      end
 
-    def bibliography(isoxml, out)
-      f = isoxml.at(ns(bibliography_xpath)) and f["hidden"] != "true" or return
-      page_break(out)
-      out.div do |div|
-        div.h1 **{ class: "Section3" } do |h1|
-          f&.at(ns("./title"))&.children&.each { |c2| parse(c2, h1) }
+      def bibliography(isoxml, out)
+        f = isoxml.at(ns(bibliography_xpath)) and f["hidden"] != "true" or
+          return
+        page_break(out)
+        out.div do |div|
+          div.h1 **{ class: "Section3" } do |h1|
+            f&.at(ns("./title"))&.children&.each { |c2| parse(c2, h1) }
+          end
+          biblio_list(f, div, true)
         end
-        biblio_list(f, div, true)
       end
-    end
 
-    def bibliography_parse(node, out)
-      node["hidden"] != true or return
-      out.div do |div|
-        clause_parse_title(node, div, node.at(ns("./title")), out,
-                           { class: "Section3" })
-        biblio_list(node, div, true)
+      def bibliography_parse(node, out)
+        node["hidden"] != true or return
+        out.div do |div|
+          clause_parse_title(node, div, node.at(ns("./title")), out,
+                             { class: "Section3" })
+          biblio_list(node, div, true)
+        end
       end
     end
   end

data/lib/isodoc/function/section.rb

@@ -1,251 +1,201 @@
-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?
+require_relative "./section_titles"
 
-      if node["inline-header"] == "true"
-        inline_header_title(out, node, title)
-      else
-        depth = if title && title["depth"] then title["depth"]
-                else node.ancestors("clause, annex, terms, references, definitions, "\
-                                    "acknowledgements, introduction, foreword").size + 1
-                end
-        div.send "h#{depth}", **attr_code(header_class) do |h|
-          title&.children&.each { |c2| parse(c2, h) }
-        end
+module IsoDoc
+  module Function
+    module Section
+      def clause_attrs(node)
+        { id: node["id"] }
       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|
-        if title.is_a?(String)
-          h1 << title
-        else
-          title&.children&.each { |c2| parse(c2, h1) }
+      # 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
-      div.parent.at(".//h1")
-    end
 
-    def clause(isoxml, out)
-      isoxml.xpath(ns(middle_clause(isoxml))).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)
+      def clause(isoxml, out)
+        isoxml.xpath(ns(middle_clause(isoxml))).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
-    end
-
-    def annex_name(_annex, name, div)
-      return if name.nil?
 
-      div.h1 **{ class: "Annex" } do |t|
-        name.children.each { |c2| parse(c2, t) }
+      def annex_attrs(node)
+        { id: node["id"], class: "Section3" }
       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)
+      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
-    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"
+      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
-      num
-    end
 
-    TERM_CLAUSE = "//sections/terms | "\
-      "//sections/clause[descendant::terms]".freeze
+      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
+      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
-      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
+      # subclause
+      def terms_parse(isoxml, out)
+        clause_parse(isoxml, out)
       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
-      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"
+      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
-    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" })
-        f.elements.each { |e| parse(e, s) unless e.name == "title" }
+      # subclause
+      def symbols_parse(isoxml, out)
+        isoxml.at(ns("./title")) or
+          isoxml.children.first.previous = "<title>#{@i18n.symbols}</title>"
+        clause_parse(isoxml, out)
       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"
+      def introduction(isoxml, out)
+        f = isoxml.at(ns("//introduction")) || return
+        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
-    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" })
-        f.elements.each { |e| parse(e, s) unless e.name == "title" }
+      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" })
+          f.elements.each { |e| parse(e, s) unless e.name == "title" }
+        end
       end
-    end
 
-    def preface(isoxml, out)
-      isoxml.xpath(ns("//preface/clause | //preface/references | "\
-                      "//preface/definitions | //preface/terms")).each do |f|
+      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, { class: "IntroTitle" })
+          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 is_clause?(name)
-      %w(clause references definitions terms foreword introduction abstract
-         acknowledgements).include? name
-    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" })
+          f.elements.each { |e| parse(e, s) unless e.name == "title" }
+        end
+      end
 
-    def preface_block(isoxml, out)
-      p = isoxml.at(ns("//preface")) or return
-      p.elements.each do |e|
-        next if is_clause?(e.name)
+      def preface(isoxml, out)
+        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, { class: "IntroTitle" })
+            f.elements.each do |e|
+              parse(e, div) unless e.name == "title"
+            end
+          end
+        end
+      end
 
-        parse(e, out)
+      def is_clause?(name)
+        %w(clause references definitions terms foreword introduction abstract
+           acknowledgements).include? name
       end
-    end
 
-    def copyright_parse(node, out)
-      return if @bare
+      def preface_block(isoxml, out)
+        p = isoxml.at(ns("//preface")) or return
+        p.elements.each do |e|
+          next if is_clause?(e.name)
 
-      out.div **{ class: "boilerplate-copyright" } do |div|
-        node.children.each { |n| parse(n, div) }
+          parse(e, out)
+        end
       end
-    end
 
-    def license_parse(node, out)
-      return if @bare
+      def copyright_parse(node, out)
+        return if @bare
 
-      out.div **{ class: "boilerplate-license" } do |div|
-        node.children.each { |n| parse(n, div) }
+        out.div **{ class: "boilerplate-copyright" } do |div|
+          node.children.each { |n| parse(n, div) }
+        end
       end
-    end
 
-    def legal_parse(node, out)
-      return if @bare
+      def license_parse(node, out)
+        return if @bare
 
-      out.div **{ class: "boilerplate-legal" } do |div|
-        node.children.each { |n| parse(n, div) }
+        out.div **{ class: "boilerplate-license" } do |div|
+          node.children.each { |n| parse(n, div) }
+        end
       end
-    end
 
-    def feedback_parse(node, out)
-      return if @bare
+      def legal_parse(node, out)
+        return if @bare
 
-      out.div **{ class: "boilerplate-feedback" } do |div|
-        node.children.each { |n| parse(n, div) }
+        out.div **{ class: "boilerplate-legal" } do |div|
+          node.children.each { |n| parse(n, div) }
+        end
+      end
+
+      def feedback_parse(node, out)
+        return if @bare
+
+        out.div **{ class: "boilerplate-feedback" } do |div|
+          node.children.each { |n| parse(n, div) }
+        end
       end
     end
   end