asciidoctor-iso 0.10.1 → 0.10.2

data/lib/asciidoctor/iso/ref.rb

@@ -1,187 +0,0 @@
-require "pp"
-
-module Asciidoctor
-  module ISO
-    module Lists
-      def iso_publisher(t, code)
-        code.sub(/ .*$/, "").split(/\//).each do |abbrev|
-          t.contributor do |c|
-            c.role **{ type: "publisher" }
-            c.organization do |org|
-              organization(org, abbrev)
-            end
-          end
-        end
-      end
-
-      def plaintxt
-        { format: "text/plain" }
-      end
-
-      def ref_attributes(m)
-        { id: m[:anchor], type: "standard" }
-      end
-
-      def set_date_range(date, text)
-        matched = /^(?<from>[0-9]+)(-+(?<to>[0-9]+))?$/.match text
-        return unless matched[:from]
-        if matched[:to]
-          date.from matched[:from]
-          date.to matched[:to]
-        else
-          date.on matched[:from]
-        end
-      end
-
-      def use_my_anchor(ref, id)
-        ref.parent.elements.last["id"] = id
-        ref
-      end
-
-      def isorefmatches(xml, m)
-        ref = fetch_ref xml, m[:code], m[:year]
-        return use_my_anchor(ref, m[:anchor]) if ref
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          t.docidentifier m[:code]
-          m[:year] and t.date **{ type: "published" } do |d|
-            set_date_range(d, m[:year])
-          end
-          iso_publisher(t, m[:code])
-        end
-      end
-
-      def isorefmatches2(xml, m)
-        ref = fetch_ref xml, m[:code], nil, no_year: true, note: m[:fn]
-        return use_my_anchor(ref, m[:anchor]) if ref
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          t.docidentifier m[:code]
-          t.date **{ type: "published" } do |d|
-            d.on "--"
-          end
-          iso_publisher(t, m[:code])
-          t.note(**plaintxt) { |p| p << "ISO DATE: #{m[:fn]}" }
-        end
-      end
-
-      def isorefmatches3(xml, m)
-        hasyr =  m.names.include?("year")
-        ref = fetch_ref xml, m[:code], hasyr ? m[:year] : nil, all_parts: true
-        return use_my_anchor(ref, m[:anchor]) if ref
-        xml.bibitem(**attr_code(ref_attributes(m))) do |t|
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          t.docidentifier "#{m[:code]}"
-          hasyr and
-            t.date(**{ type: "published" }) { |d| set_date_range(d, m[:year]) }
-          iso_publisher(t, m[:code])
-          t.allParts "true"
-        end
-      end
-
-      def fetch_ref(xml, code, year, **opts)
-        hit = @bibdb&.fetch(code, year, opts) 
-        return nil if hit.nil?
-        xml.parent.add_child(hit.to_xml)
-        xml
-      rescue Algolia::AlgoliaProtocolError
-        nil # Render reference without an Internet connection.
-      end
-
-      def refitem_render(xml, m)
-        xml.bibitem **attr_code(id: m[:anchor]) do |t|
-          t.formattedref **{ format: "application/x-isodoc+xml" } do |i|
-            i << ref_normalise_no_format(m[:text])
-          end
-          t.docidentifier(/^\d+$/.match(m[:code]) ? "[#{m[:code]}]" : m[:code])
-        end
-      end
-
-      # TODO: alternative where only title is available
-      def refitem(xml, item, node)
-        unless m = NON_ISO_REF.match(item)
-          Utils::warning(node, "no anchor on reference", item) 
-          return
-        end
-        unless m[:code] && /^\d+$/.match(m[:code])
-          ref = fetch_ref xml, m[:code], 
-            m.names.include?("year") ? m[:year] : nil, {}
-          return use_my_anchor(ref, m[:anchor]) if ref
-        end
-        refitem_render(xml, m)
-      end
-
-      def ref_normalise(ref)
-        ref.
-          # gsub(/&#8201;&#8212;&#8201;/, " -- ").
-          gsub(/&amp;amp;/, "&amp;").
-          gsub(%r{^<em>(.*)</em>}, "\\1")
-      end
-
-      def ref_normalise_no_format(ref)
-        ref.
-          # gsub(/&#8201;&#8212;&#8201;/, " -- ").
-          gsub(/&amp;amp;/, "&amp;")
-      end
-
-      ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
-      \[(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+|IEV)
-      (:(?<year>[0-9][0-9-]+))?\]</ref>,?\s
-      (?<text>.*)$}xm
-
-      ISO_REF_NO_YEAR = %r{^<ref\sid="(?<anchor>[^"]+)">
-      \[(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):--\]</ref>,?\s?
-      <fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?(?<text>.*)$}xm
-
-      ISO_REF_ALL_PARTS = %r{^<ref\sid="(?<anchor>[^"]+)">
-      \[(?<code>(ISO|IEC)[^0-9]*\s[0-9]+)(:(?<year>[0-9][0-9-]+))?\s
-      \(all\sparts\)\]</ref>,?\s
-      (?<text>.*)$}xm
-
-      NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
-      \[(?<code>[^\]]+?)([:-](?<year>(19|20)[0-9][0-9]))?\]</ref>,?\s
-      (?<text>.*)$}xm
-
-      # @param item [String]
-      # @return [Array<MatchData>]
-      def reference1_matches(item)
-        matched = ISO_REF.match item
-        matched2 = ISO_REF_NO_YEAR.match item
-        matched3 = ISO_REF_ALL_PARTS.match item
-        [matched, matched2, matched3]
-      end
-
-      # @param node [Asciidoctor::List]
-      # @param item [String]
-      # @param xml [Nokogiri::XML::Builder]
-      def reference1(node, item, xml)
-        matched, matched2, matched3 = reference1_matches(item)
-        if matched3.nil? && matched2.nil? && matched.nil?
-          refitem(xml, item, node)
-          # elsif fetch_ref(matched3 || matched2 || matched, xml)
-        elsif !matched.nil? then isorefmatches(xml, matched)
-        elsif !matched2.nil? then isorefmatches2(xml, matched2)
-        elsif !matched3.nil? then isorefmatches3(xml, matched3)
-        end
-      end
-
-      def reference(node)
-        noko do |xml|
-          node.items.each do |item|
-            reference1(node, item.text, xml)
-          end
-        end.join("\n")
-      end
-
-      def bibliocache_name(global)
-        global ?  "#{Dir.home}/.relaton-bib.pstore" :
-          "#{@filename}.relaton.pstore"
-      end
-
-      def ievcache_name(global)
-        global ?  "#{Dir.home}/.iev.pstore" :
-          "#{@filename}.iev.pstore"
-      end
-    end
-  end
-end

data/lib/asciidoctor/iso/table.rb

@@ -1,61 +0,0 @@
-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|
-          xml.table **attr_code(table_attrs(node)) do |xml_table|
-            table_name(node, xml_table)
-            %i(head body foot).reject do |tblsec|
-              node.rows[tblsec].empty?
-            end
-            table_head_body_and_foot node, xml_table
-          end
-        end
-      end
-
-      private
-
-      def table_name(node, xml_table)
-        if node.title?
-          xml_table.name node.title
-        end
-      end
-
-      def table_cell1(cell, thd)
-        if cell.style == :asciidoc
-          thd << cell.content
-        else
-          thd << 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 { |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|
-                row.each { |cell| table_cell(cell, xml_tr, s) }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/asciidoctor/iso/utils.rb

@@ -1,127 +0,0 @@
-require "date"
-require "nokogiri"
-require "htmlentities"
-require "json"
-require "pathname"
-require "open-uri"
-require "uuidtools"
-require "pp"
-
-module Asciidoctor
-  module ISO
-    module Utils
-      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 "Line #{n.line}" if n.respond_to?(:line) &&
-            !n.line.nil?
-          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&.respond_to?(:context) &&
-              n&.context == :section
-          end
-          "??"
-        end
-
-        def warning(node, msg, text)
-          return if @novalid
-          warntext = "asciidoctor: WARNING"\
-            "(#{current_location(node)}): #{msg}"
-          warntext += ": #{text}" if text
-          warn warntext
-        end
-
-        def flatten_rawtext_lines(node, result)
-          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 <tag>, and Asciidoc xrefs <<xref>>
-              result << x.gsub(/<[^>]*>+/, "")
-            end
-          end
-          result
-        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)
-            result = flatten_rawtext_lines(node, result)
-          elsif node.respond_to?(:text)
-            result << node.text.gsub(/<[^>]*>+/, "")
-          else
-            result << node.content.gsub(/<[^>]*>+/, "")
-          end
-          result.reject(&:empty?)
-        end
-      end
-
-      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)
-        nil
-      end
-
-      NOKOHEAD = <<~HERE.freeze
-          <!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)
-        doc = ::Nokogiri::XML.parse(NOKOHEAD)
-        fragment = doc.fragment("")
-        ::Nokogiri::XML::Builder.with fragment, &block
-        fragment.to_xml(encoding: "US-ASCII").lines.map do |l|
-          l.gsub(/\s*\n/, "")
-        end
-=begin
-f = fragment.to_xml(encoding: "US-ASCII")
-  byebug if @xxxxxx
-  @xxxxxx = false
-[f]
-=end
-      end
-
-      def attr_code(attributes)
-        attributes = attributes.reject { |_, val| val.nil? }.map
-        attributes.map do |k, v|
-          [k, (v.is_a? String) ? HTMLEntities.new.decode(v) : v]
-        end.to_h
-      end
-
-      # if the contents of node are blocks, output them to out;
-      # else, wrap them in <p>
-      def wrap_in_para(node, out)
-        if node.blocks? then out << node.content
-        else
-          out.p { |p| p << node.content }
-        end
-      end
-
-      SUBCLAUSE_XPATH = "//clause[ancestor::clause or ancestor::annex or "\
-        "ancestor::introduction]".freeze
-    end
-  end
-end