asciidoctor-iso 0.10.1 → 0.10.2

data/lib/asciidoctor/iso/cleanup_block.rb

@@ -1,193 +0,0 @@
-require "date"
-require "nokogiri"
-require "htmlentities"
-require "json"
-require "pathname"
-require "open-uri"
-require "pp"
-
-module Asciidoctor
-  module ISO
-    module Cleanup
-      def para_cleanup(xmldoc)
-        xmldoc.xpath("//p[not(@id)]").each do |x|
-          x["id"] = Utils::anchor_or_uuid
-        end
-        xmldoc.xpath("//note[not(@id)][not(ancestor::bibitem)]"\
-                     "[not(ancestor::table)]").each do |x|
-          x["id"] = Utils::anchor_or_uuid
-        end
-      end
-
-      # move Key dl after table footer
-      def dl_table_cleanup(xmldoc)
-        q = "//table/following-sibling::*[1]"\
-          "[self::p and normalize-space() = 'Key']"
-        xmldoc.xpath(q).each do |s|
-          if !s.next_element.nil? && s.next_element.name == "dl"
-            s.previous_element << s.next_element.remove
-            s.remove
-          end
-        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)
-        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
-          s.delete("headerrows")
-        end
-      end
-
-      def table_cleanup(xmldoc)
-        dl_table_cleanup(xmldoc)
-        notes_table_cleanup(xmldoc)
-        header_rows_cleanup(xmldoc)
-      end
-
-      # move notes into table
-      def notes_table_cleanup(xmldoc)
-        nomatches = false
-        until nomatches
-          q = "//table/following-sibling::*[1][self::note]"
-          nomatches = true
-          xmldoc.xpath(q).each do |n|
-            n.previous_element << n.remove
-            nomatches = false
-          end
-        end
-      end
-
-      # include where definition list inside stem block
-      def formula_cleanup(x)
-        q = "//formula/following-sibling::*[1]"\
-          "[self::p and text() = 'where']"
-        x.xpath(q).each do |s|
-          if !s.next_element.nil? && s.next_element.name == "dl"
-            s.previous_element << s.next_element.remove
-            s.remove
-          end
-        end
-      end
-
-      # include key definition list inside figure
-      def figure_dl_cleanup(xmldoc)
-        q = "//figure/following-sibling::*"\
-          "[self::p and normalize-space() = 'Key']"
-        xmldoc.xpath(q).each do |s|
-          if !s.next_element.nil? && s.next_element.name == "dl"
-            s.previous_element << s.next_element.remove
-            s.remove
-          end
-        end
-      end
-
-      # examples containing only figures become subfigures of figures
-      def subfigure_cleanup(xmldoc)
-        nodes = xmldoc.xpath("//example/figure")
-        while !nodes.empty?
-          nodes[0].parent.name = "figure"
-          nodes = xmldoc.xpath("//example/figure")
-        end
-      end
-
-      def figure_cleanup(xmldoc)
-        figure_footnote_cleanup(xmldoc)
-        figure_dl_cleanup(xmldoc)
-        subfigure_cleanup(xmldoc)
-      end
-
-      def make_preface(x, s)
-        if x.at("//foreword | //introduction")
-          preface = s.add_previous_sibling("<preface/>").first
-          foreword = x.at("//foreword")
-          preface.add_child foreword.remove if foreword
-          introduction = x.at("//introduction")
-          preface.add_child introduction.remove if introduction
-        end
-      end
-
-      def make_bibliography(x, s)
-        if x.at("//sections/references")
-          biblio = s.add_next_sibling("<bibliography/>").first
-          x.xpath("//sections/references").each do |r|
-            biblio.add_child r.remove
-          end
-        end
-      end
-
-      def sections_order_cleanup(x)
-        s = x.at("//sections")
-        make_preface(x, s)
-        make_bibliography(x, s)
-        x.xpath("//sections/annex").reverse_each { |r| s.next = r.remove }
-      end
-
-      def maxlevel(x)
-        max = 5
-        x.xpath("//clause[@level]").each do |c|
-          max = c["level"].to_i if max < c["level"].to_i
-        end
-        max
-      end
-
-      def sections_level_cleanup(x)
-        m = maxlevel(x)
-        return if m < 6
-        m.downto(6).each do |l|
-          x.xpath("//clause[@level = '#{l}']").each do |c|
-            c.delete("level")
-            c.previous_element << c.remove
-          end
-        end
-      end
-
-      def sections_cleanup(x)
-        sections_order_cleanup(x)
-        sections_level_cleanup(x)
-      end
-
-      def obligations_cleanup(x)
-        obligations_cleanup_info(x)
-        obligations_cleanup_norm(x)
-        obligations_cleanup_inherit(x)
-      end
-
-      def obligations_cleanup_info(x)
-        (s = x.at("//foreword")) && s["obligation"] = "informative"
-        (s = x.at("//introduction")) && s["obligation"] = "informative"
-        x.xpath("//references").each { |r| r["obligation"] = "informative" }
-      end
-
-      def obligations_cleanup_norm(x)
-        (s = x.at("//clause[title = 'Scope']")) && s["obligation"] = "normative"
-        (s = x.at("//clause[title = 'Symbols and Abbreviated Terms']")) &&
-          s["obligation"] = "normative"
-        x.xpath("//terms").each { |r| r["obligation"] = "normative" }
-        x.xpath("//symbols-abbrevs").each { |r| r["obligation"] = "normative" }
-      end
-
-      def obligations_cleanup_inherit(x)
-        x.xpath("//annex | //clause").each do |r|
-          r["obligation"] = "normative" unless r["obligation"]
-        end
-        x.xpath(Utils::SUBCLAUSE_XPATH).each do |r|
-          r["obligation"] = r.at("./ancestor::*/@obligation").text
-        end
-      end
-    end
-  end
-end

data/lib/asciidoctor/iso/cleanup_footnotes.rb

@@ -1,96 +0,0 @@
-require "date"
-require "nokogiri"
-require "htmlentities"
-require "json"
-require "pathname"
-require "open-uri"
-require "pp"
-
-module Asciidoctor
-  module ISO
-    module Cleanup
-      # include footnotes inside figure
-      def figure_footnote_cleanup(xmldoc)
-        nomatches = false
-        until nomatches
-          q = "//figure/following-sibling::*[1][self::p and *[1][self::fn]]"
-          nomatches = true
-          xmldoc.xpath(q).each do |s|
-            s.previous_element << s.first_element_child.remove
-            s.remove
-            nomatches = false
-          end
-        end
-      end
-
-      def table_footnote_renumber1(fn, i, seen)
-        if seen[fn.text] then outnum = seen[fn.text]
-        else
-          i += 1
-          outnum = i
-          seen[fn.text] = outnum
-        end
-        fn["reference"] = (outnum - 1 + "a".ord).chr
-        fn["table"] = true
-        [i, seen]
-      end
-
-      def table_footnote_renumber(xmldoc)
-        xmldoc.xpath("//table | //figure").each do |t|
-          seen = {}
-          i = 0
-          t.xpath(".//fn").each do |fn|
-            i, seen = table_footnote_renumber1(fn, i, seen)
-          end
-        end
-      end
-
-      def other_footnote_renumber1(fn, i, seen)
-        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
-        end
-        [i, seen]
-      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
-        xmldoc.xpath(PRE_NORMREF_FOOTNOTES).each do |fn|
-          i, seen = other_footnote_renumber1(fn, i, seen)
-        end
-        xmldoc.xpath(NORMREF_FOOTNOTES).each do |fn|
-          i, seen = other_footnote_renumber1(fn, i, seen)
-        end
-        xmldoc.xpath(POST_NORMREF_FOOTNOTES).each do |fn|
-          i, seen = other_footnote_renumber1(fn, i, seen)
-        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
-    end
-  end
-end

data/lib/asciidoctor/iso/cleanup_ref.rb

@@ -1,125 +0,0 @@
-module Asciidoctor
-  module ISO
-    module Cleanup
-      # extending localities to cover ISO referencing
-      LOCALITY_REGEX_STR = <<~REGEXP.freeze
-        ^((?<locality>section|clause|part|paragraph|chapter|page|
-                      table|annex|figure|example|note|formula|
-                      locality:[^ \\t\\n\\r:,]+)(\\s+|=)
-               (?<ref>[^"][^ \\t\\n,:-]*|"[^"]+")
-                 (-(?<to>[^"][^ \\t\\n,:-]*|"[^"]"))?|
-          (?<locality2>whole|locality:[^ \\t\\n\\r:,]+))[,:]?\\s*
-         (?<text>.*)$
-      REGEXP
-      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
-                               Regexp::IGNORECASE | Regexp::MULTILINE)
-
-      def tq(x)
-        x.sub(/^"/, "").sub(/"$/, "")
-      end
-
-      def extract_localities(x)
-        text = x.children.first.remove.text
-        while (m = LOCALITY_RE.match text)
-          ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
-          refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
-          loc = m[:locality]&.downcase || m[:locality2]&.downcase
-          x.add_child("<locality type='#{loc}'>#{ref}#{refto}</locality>")
-          text = m[:text]
-        end
-        x.add_child(text)
-      end
-
-      def xref_to_eref(x)
-        x["bibitemid"] = x["target"]
-        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 refid? x["target"]
-            x.name = "eref"
-            xref_to_eref(x)
-          else
-            x.delete("type")
-          end
-        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 | //terms/source").each do |x|
-          xref_to_eref(x)
-        end
-      end
-
-      def origin_cleanup(xmldoc)
-        xmldoc.xpath("//origin").each do |x|
-          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
-
-      # move ref before p
-      def ref_cleanup(xmldoc)
-        xmldoc.xpath("//p/ref").each do |r|
-          parent = r.parent
-          parent.previous = r.remove
-        end
-      end
-
-      def normref_cleanup(xmldoc)
-        q = "//references[title = 'Normative References']"
-        r = xmldoc.at(q) || return
-        r.elements.each do |n|
-          n.remove unless ["title", "bibitem"].include? n.name
-        end
-      end
-
-      def format_ref(ref, isopub)
-        return ref if isopub
-        return "[#{ref}]" if /^\d+$/.match(ref) && !/^\[.*\]$/.match(ref)
-        ref
-      end
-
-      ISO_PUBLISHER_XPATH =
-        "./contributor[role/@type = 'publisher']/"\
-        "organization[abbreviation = 'ISO' or abbreviation = 'IEC' or "\
-        "name = 'International Organization for Standardization' or "\
-        "name = 'International Electrotechnical Commission']".freeze
-
-      def date_range(date)
-        from = date.at("./from")
-        to = date.at("./to")
-        on = date.at("./on")
-        return on.text if on
-        ret = "#{from.text}&ndash;"
-        ret += to.text if to
-        ret
-      end
-
-      def reference_names(xmldoc)
-        xmldoc.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
-          isopub = ref.at(ISO_PUBLISHER_XPATH)
-          docid = ref.at("./docidentifier")
-          date = ref.at("./date[@type = 'published']")
-          reference = format_ref(docid.text, isopub)
-          reference += ":#{date_range(date)}" if date && isopub
-          @anchors[ref["id"]] = { xref: reference }
-        end
-      end
-    end
-  end
-end

data/lib/asciidoctor/iso/inline.rb

@@ -1,134 +0,0 @@
-require "asciidoctor/extensions"
-require "htmlentities"
-
-module Asciidoctor
-  module ISO
-    module Inline
-      def refid?(x)
-        @refids.include? x
-      end
-
-      def inline_anchor(node)
-        case node.type
-        when :ref
-          inline_anchor_ref node
-        when :xref
-          inline_anchor_xref node
-        when :link
-          inline_anchor_link node
-        when :bibref
-          inline_anchor_bibref node
-        end
-      end
-
-      def inline_anchor_ref(node)
-        noko do |xml|
-          xml.bookmark nil, **attr_code(id: node.id)
-        end.join
-      end
-
-      def inline_anchor_xref(node)
-        matched = /^fn(:\s*(?<text>.*))?$/.match node.text
-        f = matched.nil? ? "inline" : "footnote"
-        c = matched.nil? ? node.text : matched[:text]
-        t = node.target.gsub(/^#/, "").gsub(%r{(.)(\.xml)?#.*$}, "\\1")
-        noko do |xml|
-          xml.xref **attr_code(target: t, type: f) do |x|
-            x << c
-          end
-        end.join
-      end
-
-      def inline_anchor_link(node)
-        contents = node.text
-        contents = "" if node.target.gsub(%r{^mailto:}, "") == node.text
-        attributes = { "target": node.target }
-        noko do |xml|
-          xml.link **attr_code(attributes) do |l|
-            l << contents
-          end
-        end.join
-      end
-
-      def inline_anchor_bibref(node)
-        eref_contents = node.target == node.text ? nil : node.text
-        eref_attributes = { id: node.target }
-        @refids << node.target
-        noko do |xml|
-          xml.ref **attr_code(eref_attributes) do |r|
-            r << eref_contents
-          end
-        end.join
-      end
-
-      def inline_callout(node)
-        noko do |xml|
-          xml.callout node.text
-        end.join
-      end
-
-      def inline_footnote(node)
-        noko do |xml|
-          @fn_number += 1
-          xml.fn **{ reference: @fn_number } do |fn|
-            fn.p { |p| p << node.text }
-          end
-        end.join("\n")
-      end
-
-      def inline_break(node)
-        noko do |xml|
-          xml << node.text
-          xml.br
-        end.join("\n")
-      end
-
-      def page_break(_node)
-        noko { |xml| xml.pagebreak }.join("\n")
-      end
-
-      def thematic_break(_node)
-        noko { |xml| xml.hr }.join("\n")
-      end
-
-      def stem_parse(text, xml)
-        if /&lt;([^:>&]+:)?math(\s+[^>&]+)?&gt; |
-          <([^:>&]+:)?math(\s+[^>&]+)?>/x.match text
-          math = HTMLEntities.new.encode(text, :basic, :hexadecimal).
-            gsub(/&amp;gt;/, ">").gsub(/\&amp;lt;/, "<").gsub(/&amp;amp;/, "&").
-            gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")
-          xml.stem math, **{ type: "MathML" }
-        else
-          xml.stem text, **{ type: "AsciiMath" }
-        end
-      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 stem_parse(node.text, xml)
-          else
-            case node.role
-              # the following three are legacy, they are now handled by macros
-            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
-            else
-              xml << node.text
-            end
-          end
-        end.join
-      end
-    end
-  end
-end