metanorma-standoc 0.0.1

data/lib/asciidoctor/standoc/lists.rb

@@ -0,0 +1,87 @@
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    module Lists
+      def li(xml_ul, item)
+        xml_ul.li do |xml_li|
+          if item.blocks?
+            xml_li.p(**id_attr(item)) { |t| t << item.text }
+            xml_li << item.content
+          else
+            xml_li.p(**id_attr(item)) { |p| p << item.text }
+          end
+        end
+      end
+
+      def ulist(node)
+        return reference(node) if in_norm_ref? || in_biblio?
+        noko do |xml|
+          xml.ul **id_attr(node) do |xml_ul|
+            node.items.each do |item|
+              li(xml_ul, item)
+            end
+          end
+        end.join("\n")
+      end
+
+      def olist_style(style)
+        return "alphabet" if style == "loweralpha"
+        return "roman" if style == "lowerroman"
+        return "roman_upper" if style == "upperroman"
+        return "alphabet_upper" if style == "upperalpha"
+        style
+      end
+
+      def olist(node)
+        noko do |xml|
+          xml.ol **attr_code(id: Utils::anchor_or_uuid(node),
+                             type: olist_style(node.style)) do |xml_ol|
+            node.items.each { |item| li(xml_ol, item) }
+          end
+        end.join("\n")
+      end
+
+      def dt(terms, xml_dl)
+        terms.each_with_index do |dt, idx|
+          xml_dl.dt { |xml_dt| xml_dt << dt.text }
+          if idx < terms.size - 1
+            xml_dl.dd
+          end
+        end
+      end
+
+      def dd(dd, xml_dl)
+        if dd.nil?
+          xml_dl.dd
+          return
+        end
+        xml_dl.dd do |xml_dd|
+          xml_dd.p { |t| t << dd.text } if dd.text?
+          xml_dd << dd.content if dd.blocks?
+        end
+      end
+
+      def dlist(node)
+        noko do |xml|
+          xml.dl **id_attr(node) do |xml_dl|
+            node.items.each do |terms, dd|
+              dt(terms, xml_dl)
+              dd(dd, xml_dl)
+            end
+          end
+        end.join("\n")
+      end
+
+      def colist(node)
+        noko do |xml|
+          node.items.each_with_index do |item, i|
+            xml.annotation **attr_code(id: i + 1) do |xml_li|
+              xml_li.p { |p| p << item.text }
+            end
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/macros.rb

@@ -0,0 +1,95 @@
+require "asciidoctor/extensions"
+module Asciidoctor
+  module Standoc
+    class AltTermInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :alt
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<admitted>#{out}</admitted>}
+      end
+    end
+
+    class DeprecatedTermInlineMacro <
+      Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :deprecated
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<deprecates>#{out}</deprecates>}
+      end
+    end
+
+    class DomainTermInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :domain
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<domain>#{out}</domain>}
+      end
+    end
+
+    class PlantUMLBlockMacroBackend
+      # https://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      def self.plantuml_installed?
+        cmd = "plantuml"
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+        nil
+      end
+
+      def self.generate_file parent, reader
+        src = reader.source
+        reader.lines.first.sub(/\s+$/, "") != "@startuml" or
+          src = "@startuml\n#{src}\n@enduml\n"
+        filename = parent.document.reader.lineno
+        system "mkdir -p plantuml"
+        File.open("plantuml/#{filename}.pml", "w") { |f| f.write src }
+        system "plantuml plantuml/#{filename}.pml"
+        filename
+      end
+
+      def self.generate_attrs attrs
+        through_attrs = %w(id align float title role width height alt).
+          inject({}) do |memo, key|
+          memo[key] = attrs[key] if attrs.has_key? key
+          memo
+        end
+      end
+    end
+
+    class PlantUMLBlockMacro < Asciidoctor::Extensions::BlockProcessor
+      use_dsl
+      named :plantuml
+      on_context :literal
+      parse_content_as :raw
+
+      def process(parent, reader, attrs)
+        if PlantUMLBlockMacroBackend.plantuml_installed?
+          filename = PlantUMLBlockMacroBackend.generate_file parent, reader
+          through_attrs = PlantUMLBlockMacroBackend.generate_attrs attrs
+          through_attrs["target"] = "plantuml/#{filename}.png"
+          create_image_block parent, through_attrs
+        else
+          warn "PlantUML not installed"
+          # attrs.delete(1) : remove the style attribute
+          create_listing_block parent, reader.source, attrs.reject { |k, v| k == 1 }
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/ref.rb

@@ -0,0 +1,187 @@
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    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/standoc/section.rb

@@ -0,0 +1,159 @@
+require "htmlentities"
+require "uri"
+
+module Asciidoctor
+  module Standoc
+    module Section
+      @biblio = false
+      @term_def = false
+      @norm_ref = false
+
+      def in_biblio?
+        @biblio
+      end
+
+      def in_terms?
+        @term_def
+      end
+
+      def in_norm_ref?
+        @norm_ref
+      end
+
+      def sectiontype(node)
+        node&.attr("heading")&.downcase || node.title.downcase
+      end
+
+      def section(node)
+        a = { id: Utils::anchor_or_uuid(node) }
+        noko do |xml|
+          case sectiontype(node)
+          when "introduction" then
+            if node.level == 1 then introduction_parse(a, xml, node)
+            else
+              clause_parse(a, xml, node)
+            end
+          when "normative references" then norm_ref_parse(a, xml, node)
+          when "terms and definitions",
+            "terms, definitions, symbols and abbreviated terms",
+            "terms, definitions, symbols and abbreviations",
+            "terms, definitions and symbols",
+            "terms, definitions and abbreviations",
+            "terms, definitions and abbreviated terms"
+            @term_def = true
+            term_def_parse(a, xml, node, true)
+            @term_def = false
+          when "symbols and abbreviated terms"
+            symbols_parse(a, xml, node)
+          when "bibliography" then bibliography_parse(a, xml, node)
+          else
+            if @term_def then term_def_subclause_parse(a, xml, node)
+            elsif @biblio then bibliography_parse(a, xml, node)
+            elsif node.attr("style") == "bibliography" && node.level == 1
+              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 set_obligation(attrs, node)
+        attrs[:obligation] = if node.attributes.has_key?("obligation")
+                               node.attr("obligation")
+                             elsif node.parent.attributes.has_key?("obligation")
+                               node.parent.attr("obligation")
+                             else
+                               "normative"
+                             end
+      end
+
+      def clause_parse(attrs, xml, node)
+        attrs["inline-header".to_sym] = node.option? "inline-header"
+        attrs[:level] = node.attr("level")
+        set_obligation(attrs, node)
+        xml.send "clause", **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] = node.option? "inline-header"
+        set_obligation(attrs, node)
+        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)
+        node.attr("style") == "bibliography" or
+          warn "Section not marked up as [bibliography]!"
+        @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 = false
+      end
+
+      def symbols_parse(attrs, xml, node)
+        xml.definitions **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      # subclause contains subclauses
+      def term_def_subclause_parse(attrs, xml, node)
+        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
+        sub.empty? || (return term_def_parse(attrs, xml, node, false))
+        node.title.casecmp("symbols and abbreviated terms").zero? &&
+          (return symbols_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_title(toplevel, node)
+        return node.title unless toplevel
+        sub = node.find_by(context: :section) do |s|
+          s.title.casecmp("symbols and abbreviated terms").zero?
+        end
+        return "Terms and definitions" if sub.empty?
+        "Terms, definitions, symbols and abbreviated terms"
+      end
+
+      def term_def_parse(attrs, xml, node, toplevel)
+        xml.terms **attr_code(attrs) do |section|
+          section.title { |t| t << term_def_title(toplevel, node) }
+          (s = node.attr("source")) && s.split(/,/).each do |s1|
+            section.termdocsource(nil, **attr_code(bibitemid: s1, type: "inline"))
+          end
+          section << node.content
+        end
+      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.introduction **attr_code(attrs) do |xml_section|
+          xml_section.title = "Introduction"
+          content = node.content
+          xml_section << content
+        end
+      end
+    end
+  end
+end