asciidoctor-iso 0.0.1 → 0.6.0

data/lib/asciidoctor/iso/section.rb

@@ -0,0 +1,164 @@
+require "htmlentities"
+require "uri"
+
+module Asciidoctor
+  module ISO
+    module Section
+      @scope = false
+      @biblio = false
+      @term_def = false
+      @norm_ref = false
+
+      def in_scope
+        @scope
+      end
+
+      def in_biblio
+        @biblio
+      end
+
+      def in_terms
+        @term_def
+      end
+
+      def in_norm_ref
+        @norm_ref
+      end
+
+      def section(node)
+        a = { id: Utils::anchor_or_uuid(node) }
+        noko do |xml|
+          case node.title.downcase
+          when "introduction" then
+            if node.level == 1
+              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" then norm_ref_parse(a, xml, node)
+          when "terms and definitions" 
+            term_def_parse(a, xml, node, node.title.downcase)
+          when "terms, definitions, symbols and abbreviations"
+            term_def_parse(a, xml, node, node.title.downcase)
+          when "symbols and abbreviated terms" 
+            symbols_parse(a, xml, node)
+          when "bibliography" then bibliography_parse(a, xml, node)
+          else
+            if @term_def
+              term_def_subclause_parse(a, xml, node)
+            elsif @biblio
+              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
+
+      def clause_parse(attrs, xml, node)
+        attrs["inline-header".to_sym] = true if node.option? "inline-header"
+        w = "Scope contains subsections: should be succint"
+        style_warning(node, w, nil) if @scope
+        # Not testing max depth of sections: Asciidoctor already limits
+        # it to 5 levels of nesting
+        sect = node.level == 1 ? "clause" : "subsection"
+        xml.send sect, **attr_code(attrs) do |xml_section|
+          xml_section.title { |n| n << node.title } unless node.title.nil?
+          xml_section << node.content
+        end
+      end
+
+      def annex_parse(attrs, xml, node)
+        attrs["inline-header".to_sym] = true if node.option? "inline-header"
+        attrs[:subtype] = "informative"
+        if node.attributes.has_key?("subtype")
+          attrs[:subtype] = node.attr("subtype")
+        end
+        xml.annex **attr_code(attrs) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def bibliography_parse(attrs, xml, node)
+        @biblio = true
+        xml.references **attr_code(attrs) do |xml_section|
+          title = node.level == 1 ? "Bibliography" : node.title
+          xml_section.title { |t| t << title }
+          xml_section << node.content
+        end
+        @biblio = true
+      end
+
+      def symbols_parse(attrs, xml, node)
+        xml.symbols_abbrevs **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      def term_def_subclause_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 term_def_parse(attrs, xml, node, title)
+        @term_def = true
+        xml.terms **attr_code(attrs) do |xml_section|
+          if title == "terms, definitions, symbols and abbreviations"
+            title = "Terms, Definitions, Symbols and Abbreviations"
+          else
+            title = "Terms and Definitions"
+          end
+          xml_section.title { |t| t << title }
+          xml_section << node.content
+        end
+        @term_def = false
+      end
+
+      def norm_ref_parse(attrs, xml, node)
+        @norm_ref = true
+        xml.references **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << "Normative References" }
+          xml_section << node.content
+        end
+        @norm_ref = false
+      end
+
+      def introduction_parse(attrs, xml, node)
+        xml.content **attr_code(attrs) do |xml_section|
+          xml_section.title = "Introduction"
+          content = node.content
+          xml_section << content
+          introduction_style(node,
+                             Utils::flatten_rawtext(content).
+                             join("\n"))
+        end
+      end
+
+      def patent_notice_parse(xml, node)
+        # xml.patent_notice do |xml_section|
+        #  xml_section << node.content
+        # end
+        xml << node.content
+      end
+
+      def scope_parse(attrs, xml, node)
+        @scope = true
+        xml.clause **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << "Scope" }
+          content = node.content
+          xml_section << content
+          c = Utils::flatten_rawtext(content).join("\n")
+          scope_style(node, c)
+        end
+        @scope = false
+      end
+    end
+  end
+end

data/lib/asciidoctor/iso/table.rb

@@ -1,14 +1,17 @@
 module Asciidoctor
   module ISO
     module Table
+      def table_attrs(node)
+        { id: Utils::anchor_or_uuid(node),
+          headerrows: node.attr("headerrows") }
+      end
+
       def table(node)
+        @table_fn_number = "a"
         noko do |xml|
-          has_body = false
-          xml.table **attr_code(anchor: node.id) do |xml_table|
+          xml.table **attr_code(table_attrs(node)) do |xml_table|
             %i(head body foot).reject do |tblsec|
               node.rows[tblsec].empty?
-            end.each do |tblsec|
-              has_body = true if tblsec == :body
             end
             xml_table.name node.title if node.title?
             table_head_body_and_foot node, xml_table
@@ -18,31 +21,31 @@ module Asciidoctor
 
       private
 
+      def table_cell1(cell, thd)
+        if cell.style == :asciidoc
+          thd << cell.content
+        else
+          thd << cell.text
+          style(cell, cell.text)
+        end
+      end
+
+      def table_cell(c, xml_tr, tblsec)
+        cell_attributes = { id: c.id, colspan: c.colspan,
+                            rowspan: c.rowspan, align: c.attr("halign") }
+        cell_tag = "td"
+        cell_tag = "th" if tblsec == :head || c.style == :header
+        xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|
+          table_cell1(c, thd)
+        end
+      end
+
       def table_head_body_and_foot(node, xml)
-        %i(head body foot).reject do |tblsec|
-          node.rows[tblsec].empty?
-        end.each do |tblsec|
-          tblsec_tag = "t#{tblsec}"
-          # "anchor" attribute from tblsec.id not supported
-          xml.send tblsec_tag do |xml_tblsec|
-            node.rows[tblsec].each_with_index do |row, i|
+        %i(head body foot).reject { |s| node.rows[s].empty? }.each do |s|
+          xml.send "t#{s}" do |xml_tblsec|
+            node.rows[s].each do |row|
               xml_tblsec.tr do |xml_tr|
-                rowlength = 0
-                row.each do |cell|
-                  cell_attributes = {
-                    anchor: cell.id,
-                    colspan: cell.colspan,
-                    rowspan: cell.rowspan,
-                    align: cell.attr("halign"),
-                  }
-
-                  cell_tag = "td"
-                  cell_tag = "th" if tblsec == :head || cell.style == :header
-                  rowlength += cell.text.size
-                  xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|
-                    thd << (cell.style == :asciidoc ? cell.content : cell.text)
-                  end
-                end
+                row.each { |cell| table_cell(cell, xml_tr, s) }
               end
             end
           end

data/lib/asciidoctor/iso/utils.rb

@@ -4,165 +4,85 @@ require "htmlentities"
 require "json"
 require "pathname"
 require "open-uri"
+require "uuidtools"
 require "pp"
 
 module Asciidoctor
   module ISO
     module Utils
-      def convert(node, transform = nil, opts = {})
-        transform ||= node.node_name
-        opts.empty? ? (send transform, node) : (send transform, node, opts)
-      end
-
-      def document_ns_attributes(_doc)
-        # ' xmlns="http://riboseinc.com/isoxml"'
-        nil
-      end
-
-      def cleanup(xmldoc)
-        intro_cleanup(xmldoc)
-        termdef_cleanup(xmldoc)
-        isotitle_cleanup(xmldoc)
-        tablenote_cleanup(xmldoc)
-        formula_cleanup(xmldoc)
-        figure_cleanup(xmldoc)
-        back_cleanup(xmldoc)
-        ref_cleanup(xmldoc)
-      end
-
-      def intro_cleanup(xmldoc)
-        intro = xmldoc.at("//introduction")
-        foreword = xmldoc.at("//foreword")
-        front = xmldoc.at("//front")
-        unless foreword.nil? || front.nil?
-          foreword.remove
-          front << foreword
-        end
-        unless intro.nil? || front.nil?
-          intro.remove
-          front << intro
-        end
-      end
-
-      def termdef_cleanup(xmldoc)
-        # release termdef tags from surrounding paras
-        nodes = xmldoc.xpath("//p/admitted_term | //p/termsymbol |
-                             //p/deprecated_term")
-        while !nodes.empty?
-          nodes[0].parent.replace(nodes[0].parent.children)
-          nodes = xmldoc.xpath("//p/admitted_term | //p/termsymbol |
-                               //p/deprecated_term")
-        end
-        xmldoc.xpath("//termdef/p/stem").each do |a|
-          if a.parent.elements.size == 1
-            # para containing just a stem expression
-            t = Nokogiri::XML::Element.new("termsymbol", xmldoc)
-            parent = a.parent
-            a.remove
-            t.children = a
-            parent.replace(t)
-          end
-        end
-        xmldoc.xpath("//p/termdomain").each do |a|
-          prev = a.parent.previous
-          a.remove
-          prev.next = a
-        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
+      class << self
+        def anchor_or_uuid(node = nil)
+          uuid = UUIDTools::UUID.random_create
+          node.nil? || node.id.nil? || node.id.empty? ? "_" + uuid : node.id
+        end
+
+        def current_location(n)
+          return "Line #{n.lineno}" if n.respond_to?(:lineno) &&
+            !n.lineno.nil? && !n.lineno.empty?
+          return "ID #{n.id}" if n.respond_to?(:id) && !n.id.nil?
+          while !n.nil? &&
+              (!n.respond_to?(:level) || n.level.positive?) &&
+              (!n.respond_to?(:context) || n.context != :section)
+            n = n.parent
+            return "Section: #{n.title}" if !n.nil? && n.context == :section
           end
-        end
-      end
-
-      def tablenote_cleanup(xmldoc)
-        # move notes after table footer
-        xmldoc.xpath("//tfoot/tr/td/note | //tfoot/tr/th/note").each do |n|
-          target = n.parent.parent.parent.parent
-          n.remove
-          target << n
-        end
-      end
-
-      def formula_cleanup(xmldoc)
-        # include where definition list inside stem block
-        xmldoc.xpath("//formula").each do |s|
-          if !s.next_element.nil? && s.next_element.name == "p" &&
-              s.next_element.content == "where" &&
-              !s.next_element.next_element.nil? &&
-              s.next_element.next_element.name == "dl"
-            dl = s.next_element.next_element.remove
-            s.next_element.remove
-            s << dl
+          "??"
+        end
+
+        def warning(node, msg, text)
+          warntext = "asciidoctor: WARNING"\
+            "(#{current_location(node)}): #{msg}"
+          warntext += ": #{text}" if text
+          warn warntext
+        end
+
+        # if node contains blocks, flatten them into a single line;
+        # and extract only raw text
+        def flatten_rawtext(node)
+          result = []
+          if node.respond_to?(:blocks) && node.blocks?
+            node.blocks.each { |b| result << flatten_rawtext(b) }
+          elsif node.respond_to?(:lines)
+            node.lines.each do |x|
+              if node.respond_to?(:context) && (node.context == :literal ||
+                  node.context == :listing)
+                result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+              else
+                # strip not only HTML tags <tag>,
+                # but also Asciidoc crossreferences <<xref>>
+                result << x.gsub(/<[^>]*>+/, "")
+              end
+            end
+          elsif node.respond_to?(:text)
+            result << node.text.gsub(/<[^>]*>+/, "")
+          else
+            result << node.content.gsub(/<[^>]*>+/, "")
           end
+          result.reject(&:empty?)
         end
       end
 
-      def figure_cleanup(xmldoc)
-        # include key definition list inside figure
-        xmldoc.xpath("//figure").each do |s|
-          if !s.next_element.nil? && s.next_element.name == "p" &&
-              s.next_element.content =~ /^\s*Key\s*$/m &&
-              !s.next_element.next_element.nil? &&
-              s.next_element.next_element.name == "dl"
-            dl = s.next_element.next_element.remove
-            s.next_element.remove
-            s << dl
-          end
-        end
-
-        # examples containing only figures become subfigures of figures
-        nodes = xmldoc.xpath("//example/figure")
-        while !nodes.empty?
-          nodes[0].parent.name = "figure"
-          nodes = xmldoc.xpath("//example/figure")
-        end
+      def convert(node, transform = nil, opts = {})
+        transform ||= node.node_name
+        opts.empty? ? (send transform, node) : (send transform, node, opts)
       end
 
-      def back_cleanup(xmldoc)
-        # move annex/bibliography to back
-        if !xmldoc.xpath("//annex | //bibliography").empty?
-          b = Nokogiri::XML::Element.new("back", xmldoc)
-          xmldoc.root << b
-          xmldoc.xpath("//annex").each do |e|
-            e.remove
-            b << e
-          end
-          xmldoc.xpath("//bibliography").each do |e|
-            e.remove
-            b << e
-          end
-        end
+      def document_ns_attributes(_doc)
+        nil
       end
 
-      def ref_cleanup(xmldoc)
-        # move ref before p
-        xmldoc.xpath("//p/ref").each do |r|
-          parent = r.parent
-          r.remove
-          parent.previous = r
-        end
-
-        xmldoc
-      end
+      NOKOHEAD = <<~HERE
+          <!DOCTYPE html SYSTEM
+          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+          <html xmlns="http://www.w3.org/1999/xhtml">
+          <head> <title></title> <meta charset="UTF-8" /> </head>
+          <body> </body> </html>
+      HERE
 
       # block for processing XML document fragments as XHTML,
       # to allow for HTMLentities
       def noko(&block)
-        # fragment = ::Nokogiri::XML::DocumentFragment.parse("")
-        # fragment.doc.create_internal_subset("xml", nil, "xhtml.dtd")
-        head = <<HERE
-        <!DOCTYPE html SYSTEM
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml">
-        <head> <title></title> <meta charset="UTF-8" /> </head>
-        <body> </body> </html>
-HERE
-        doc = ::Nokogiri::XML.parse(head)
+        doc = ::Nokogiri::XML.parse(NOKOHEAD)
         fragment = doc.fragment("")
         ::Nokogiri::XML::Builder.with fragment, &block
         fragment.to_xml(encoding: "US-ASCII").lines.map do |l|
@@ -177,48 +97,6 @@ HERE
         end.to_h
       end
 
-      def current_location(node)
-        if node.respond_to?(:lineno) && !node.lineno.nil? &&
-            !node.lineno.empty?
-          return "Line #{node.lineno}"
-        end
-        if node.respond_to?(:id) && !node.id.nil?
-          return "ID #{node.id}"
-        end
-        while !node.nil? && (!node.respond_to?(:level) ||
-            node.level.positive?) && node.context != :section
-          node = node.parent
-          if !node.nil? && node.context == :section
-            return "Section: #{node.title}"
-          end
-        end
-        "??"
-      end
-
-      # if node contains blocks, flatten them into a single line;
-      # and extract only raw text
-      def flatten_rawtext(node)
-        result = []
-        if node.respond_to?(:blocks) && node.blocks?
-          node.blocks.each { |b| result << flatten_rawtext(b) }
-        elsif node.respond_to?(:lines)
-          node.lines.each do |x|
-            if node.respond_to?(:context) && (node.context == :literal ||
-                node.context == :listing)
-              result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
-            else
-              # strip not only HTML tags <tag>,
-              # but also Asciidoc crossreferences <<xref>>
-              result << x.gsub(/<[^>]*>+/, "")
-            end
-          end
-        elsif node.respond_to?(:text)
-          result << node.text.gsub(/<[^>]*>+/, "")
-        else
-          result << node.content.gsub(/<[^>]*>+/, "")
-        end
-        result.reject(&:empty?)
-      end
     end
   end
 end