isodoc 1.7.1 → 1.7.4

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

data/lib/isodoc/function/section_titles.rb

@@ -0,0 +1,82 @@
+module IsoDoc
+  module 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?
+
+        if node["inline-header"] == "true"
+          inline_header_title(out, node, title)
+        else
+          clause_parse_title1(node, div, title, out, header_class)
+        end
+      end
+
+      def clause_parse_title1(node, div, title, _out, header_class = {})
+        depth = clause_title_depth(node, title)
+        div.send "h#{depth}", **attr_code(header_class) do |h|
+          title&.children&.each { |c2| parse(c2, h) }
+          clause_parse_subtitle(title, h)
+        end
+      end
+
+      def clause_title_depth(node, title)
+        depth = node.ancestors("clause, annex, terms, references, "\
+                               "definitions, acknowledgements, introduction, "\
+                               "foreword").size + 1
+        depth = title["depth"] if title && title["depth"]
+        depth
+      end
+
+      def clause_parse_subtitle(title, heading)
+        if var = title&.at("./following-sibling::xmlns:variant-title"\
+                           "[@type = 'sub']")&.remove
+          heading.br nil
+          heading.br nil
+          var.children.each { |c2| parse(c2, heading) }
+        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) }
+            clause_parse_subtitle(title, h1)
+          end
+        end
+        div.parent.at(".//h1")
+      end
+
+      def annex_name(_annex, name, div)
+        return if name.nil?
+
+        div.h1 **{ class: "Annex" } do |t|
+          name.children.each { |c2| parse(c2, t) }
+          clause_parse_subtitle(name, t)
+        end
+      end
+
+      def variant_title(_node, _out); end
+    end
+  end
+end