metanorma-standoc 1.11.3 → 2.0.2

data/lib/metanorma/standoc/lists.rb

@@ -0,0 +1,120 @@
+module Metanorma
+  module Standoc
+    module Lists
+      def li(xml_ul, item)
+        xml_ul.li do |xml_li|
+          if item.blocks?
+            xml_li.p(**attr_code(id_attr(item))) { |t| t << item.text }
+            xml_li << item.content
+          else
+            xml_li.p(**attr_code(id_attr(item))) { |p| p << item.text }
+          end
+        end
+      end
+
+      def ul_li(xml_ul, item)
+        xml_ul.li **ul_li_attrs(item) do |xml_li|
+          xml_li.p(**attr_code(id_attr(item))) { |t| t << item.text }
+          if item.blocks?
+            xml_li << item.content
+          end
+        end
+      end
+
+      def ul_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)))
+      end
+
+      def ul_li_attrs(node)
+        c = node.attr?("checked")
+        attr_code(
+          uncheckedcheckbox: node.attr?("checkbox") ? !c : nil,
+          checkedcheckbox: node.attr?("checkbox") ? c : nil,
+        )
+      end
+
+      def ulist(node)
+        return reference(node) if in_norm_ref? || in_biblio?
+
+        noko do |xml|
+          xml.ul **ul_attrs(node) do |xml_ul|
+            node.items.each do |item|
+              ul_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 ol_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)
+          .merge(type: olist_style(node.style))))
+      end
+
+      def olist(node)
+        noko do |xml|
+          xml.ol **ol_attrs(node) 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(ddefn, xml_dl)
+        if ddefn.nil?
+          xml_dl.dd
+          return
+        end
+        xml_dl.dd do |xml_dd|
+          xml_dd.p { |t| t << ddefn.text } if ddefn.text?
+          xml_dd << ddefn.content if ddefn.blocks?
+        end
+      end
+
+      def dl_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)
+          .merge(
+            metadata: node.option?("metadata") ? "true" : nil,
+            key: node.option?("key") ? "true" : nil,
+          )))
+      end
+
+      def dlist(node)
+        noko do |xml|
+          xml.dl **dl_attrs(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/metanorma/standoc/macros.rb

@@ -0,0 +1,205 @@
+require "asciidoctor/extensions"
+require "fileutils"
+require "uuidtools"
+require "yaml"
+require "csv"
+require_relative "./macros_plantuml"
+require_relative "./macros_terms"
+require_relative "./macros_form"
+require_relative "./macros_note"
+require_relative "./macros_embed"
+require_relative "./datamodel/attributes_table_preprocessor"
+require_relative "./datamodel/diagram_preprocessor"
+require "metanorma-plugin-datastruct"
+require "metanorma-plugin-lutaml"
+
+module Metanorma
+  module Standoc
+    class InheritInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :inherit
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<inherit>#{out}</inherit>}
+      end
+    end
+
+    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :index
+
+      def preprocess_attrs(attrs)
+        return unless attrs.size > 1 && attrs.size < 5
+
+        ret = { primary: attrs[1], target: attrs[attrs.size] }
+        ret[:secondary] = attrs[2] if attrs.size > 2
+        ret[:tertiary] = attrs[3] if attrs.size > 3
+        ret
+      end
+
+      def process(_parent, target, attr)
+        args = preprocess_attrs(attr) or return
+        ret = "<index-xref also='#{target == 'also'}'>"\
+              "<primary>#{args[:primary]}</primary>"
+        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
+        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
+        ret + "<target>#{args[:target]}</target></index-xref>"
+      end
+    end
+
+    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"index-range"
+      parse_content_as :text
+
+      def process(parent, target, attr)
+        text = attr["text"]
+        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
+        out = parent.sub_macros(text)
+        out.sub(/<index>/, "<index to='#{target}'>")
+      end
+    end
+
+    class PseudocodeBlockMacro < Asciidoctor::Extensions::BlockProcessor
+      use_dsl
+      named :pseudocode
+      on_context :example, :sourcecode
+
+      def init_indent(line)
+        /^(?<prefix>[ \t]*)(?<suffix>.*)$/ =~ line
+        prefix = prefix.gsub(/\t/, "\u00a0\u00a0\u00a0\u00a0")
+          .gsub(/ /, "\u00a0")
+        prefix + suffix
+      end
+
+      def supply_br(lines)
+        ignore = false
+        lines.each_with_index do |l, i|
+          /^(--+|====+|\|===|\.\.\.\.+|\*\*\*\*+|\+\+\+\++|````+|____\+)$/
+            .match(l) && (ignore = !ignore)
+          next if l.empty? || l.match(/ \+$/) || /^\[.*\]$/.match?(l) || ignore
+          next if i == lines.size - 1 ||
+            i < lines.size - 1 && lines[i + 1].empty?
+
+          lines[i] += " +"
+        end
+        lines
+      end
+
+      def process(parent, reader, attrs)
+        attrs["role"] = "pseudocode"
+        lines = reader.lines.map { |m| init_indent(m) }
+        create_block(parent, :example, supply_br(lines),
+                     attrs, content_model: :compound)
+      end
+    end
+
+    class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :ruby
+      parse_content_as :text
+      option :pos_attrs, %w(rpbegin rt rpend)
+
+      # for example, html5ruby:楽聖少女[がくせいしょうじょ]
+      def process(_parent, target, attributes)
+        rpbegin = "("
+        rpend = ")"
+        if (attributes.size == 1) && attributes.key?("text")
+          rt = attributes["text"]
+        elsif (attributes.size == 2) && attributes.key?(1) &&
+            attributes.key?("rpbegin")
+          rt = attributes[1] || ""
+        else
+          rpbegin = attributes["rpbegin"]
+          rt = attributes["rt"]
+          rpend = attributes["rpend"]
+        end
+
+        "<ruby>#{target}<rp>#{rpbegin}</rp><rt>#{rt}</rt>"\
+          "<rp>#{rpend}</rp></ruby>"
+      end
+    end
+
+    class AutonumberInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :autonumber
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<autonumber type=#{target}>#{out}</autonumber>}
+      end
+    end
+
+    class VariantInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :lang
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        /^(?<lang>[^-]*)(-(?<script>.*))?$/ =~ target
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        if script
+          %{<variant lang=#{lang} script=#{script}>#{out}</variant>}
+        else
+          %{<variant lang=#{lang}>#{out}</variant>}
+        end
+      end
+    end
+
+    class AddMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :add
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<add>#{out}</add>}
+      end
+    end
+
+    class DelMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :del
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<del>#{out}</del>}
+      end
+    end
+
+    class ToCInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :toc
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        content = CSV.parse_line(out).map do |x|
+          x.sub!(/^(["'])(.+)\1/, "\\2")
+          m = /^(.*?)(:\d+)?$/.match(x)
+          %{<toc-xpath depth='#{m[2]&.sub(/:/, '') || 1}'>#{m[1]}</toc-xpath>}
+        end.join
+        "<toc>#{content}</toc>"
+      end
+    end
+
+    class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"pass-format"
+
+      def process(parent, target, attrs)
+        format = target || "metanorma"
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs[1]).convert
+        %{<passthrough formats="#{format}">#{out}</passthrough>}
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/macros_embed.rb

@@ -0,0 +1,72 @@
+module Metanorma
+  module Standoc
+    class EmbedIncludeProcessor < Asciidoctor::Extensions::Preprocessor
+      def process(doc, reader)
+        return reader if reader.eof?
+
+        lines = reader.readlines
+        while !lines.grep(/^embed::/).empty?
+          headings = lines.grep(/^== /).map(&:strip)
+          lines = lines.map do |line|
+            /^embed::/.match?(line) ? embed(line, doc, reader, headings) : line
+          end.flatten
+        end
+        ::Asciidoctor::Reader.new lines
+      end
+
+      def filename(line, doc, reader)
+        m = /^embed::([^\[]+)\[/.match(line)
+        f = doc.normalize_system_path m[1], reader.dir, nil,
+                                      target_name: "include file"
+        File.exist?(f) ? f : nil
+      end
+
+      def readlines_safe(file)
+        if file.eof? then []
+        else file.readlines
+        end
+      end
+
+      def embed(line, doc, reader, headings)
+        inc_path = filename(line, doc, reader) or return line
+        lines = filter_sections(read(inc_path), headings)
+        doc = Asciidoctor::Document.new [], { safe: :safe }
+        reader = ::Asciidoctor::PreprocessorReader.new doc, lines
+        strip_header(reader.read_lines)
+      end
+
+      def read(inc_path)
+        ::File.open inc_path, "r" do |fd|
+          readlines_safe(fd).map(&:chomp)
+        end
+      end
+
+      def strip_header(lines)
+        return lines unless !lines.empty? && lines.first.start_with?("= ")
+
+        skip = true
+        lines.each_with_object([]) do |l, m|
+          m << l unless skip
+          skip = false if !/\S/.match?(l)
+        end
+      end
+
+      def filter_sections(lines, headings)
+        skip = false
+        lines.each_with_index.with_object([]) do |(l, i), m|
+          if headings.include?(l.strip)
+            skip = true
+            m.unshift while !m.empty? && /^\S/.match?(m[-1])
+          elsif skip && /^== |^embed::|^include::/.match?(l)
+            skip = false
+            j = i
+            j -= 1 while j >= 0 && /^\S/.match?(m[j])
+            lines[j..i].each { |n| m << n }
+          else
+            skip or m << l
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/macros_form.rb

@@ -0,0 +1,63 @@
+module Metanorma
+  module Standoc
+    class FormInputMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :input
+
+      def process(_parent, target, attr)
+        m = %w(id name value disabled readonly checked maxlength minlength)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        %{<input type='#{target}' #{m.join}/>}
+      end
+    end
+
+    class FormLabelMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :label
+      parse_content_as :text
+
+      def process(parent, target, attr)
+        out = Asciidoctor::Inline.new(parent, :quoted, attr["text"]).convert
+        %{<label for="#{target}">#{out}</label>}
+      end
+    end
+
+    class FormTextareaMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :textarea
+      using_format :short
+
+      def process(_parent, _target, attr)
+        m = %w(id name rows cols value)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        %{<textarea #{m.join}/>}
+      end
+    end
+
+    class FormSelectMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :select
+      using_format :short
+
+      def process(parent, _target, attr)
+        m = %w(id name size disabled multiple value)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        out = Asciidoctor::Inline.new(parent, :quoted, attr["text"]).convert
+        %{<select #{m.join}>#{out}</select>}
+      end
+    end
+
+    class FormOptionMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :option
+      using_format :short
+
+      def process(parent, _target, attr)
+        m = %w(disabled value)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        out = Asciidoctor::Inline.new(parent, :quoted, attr["text"]).convert
+        %{<option #{m.join}">#{out}</option>}
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/macros_note.rb

@@ -0,0 +1,45 @@
+module Metanorma
+  module Standoc
+    class ToDoAdmonitionBlock < Asciidoctor::Extensions::BlockProcessor
+      use_dsl
+      named :TODO
+      on_contexts :example, :paragraph
+
+      def process(parent, reader, attrs)
+        attrs["name"] = "todo"
+        attrs["caption"] = "TODO"
+        create_block(parent, :admonition, reader.lines, attrs,
+                     content_model: :compound)
+      end
+    end
+
+    class ToDoInlineAdmonitionBlock < Asciidoctor::Extensions::Treeprocessor
+      def process(document)
+        (document.find_by context: :paragraph).each do |para|
+          next unless /^TODO: /.match? para.lines[0]
+
+          parent = para.parent
+          para.set_attr("name", "todo")
+          para.set_attr("caption", "TODO")
+          para.lines[0].sub!(/^TODO: /, "")
+          todo = Asciidoctor::Block.new(parent, :admonition, attributes: para.attributes,
+                                                             source: para.lines,
+                                                             content_model: :compound)
+          parent.blocks[parent.blocks.index(para)] = todo
+        end
+      end
+    end
+
+    class FootnoteBlockInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :footnoteblock
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<footnoteblock>#{out}</footnoteblock>}
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/macros_plantuml.rb

@@ -0,0 +1,113 @@
+module Metanorma
+  module Standoc
+    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
+        raise "PlantUML not installed"
+      end
+
+      def self.run(umlfile, outfile)
+        system "plantuml #{umlfile.path}" or (warn $? and return false)
+        i = 0
+        until !Gem.win_platform? || File.exist?(outfile) || i == 15
+          sleep(1)
+          i += 1
+        end
+        File.exist?(outfile)
+      end
+
+      # if no :imagesdir: leave image file in plantuml
+      # sleep need for windows because dot works in separate process and
+      # plantuml process may finish earlier then dot, as result png file
+      # maybe not created yet after plantuml finish
+      #
+      # # Warning: metanorma/metanorma-standoc#187
+      # Windows Ruby 2.4 will crash if a Tempfile is "mv"ed.
+      # This is why we need to copy and then unlink.
+      def self.generate_file(parent, reader)
+        localdir = Metanorma::Utils::localdir(parent.document)
+        imagesdir = parent.document.attr("imagesdir")
+        umlfile, outfile = save_plantuml parent, reader, localdir
+        run(umlfile, outfile) or
+          raise "No image output from PlantUML (#{umlfile}, #{outfile})!"
+        umlfile.unlink
+
+        path = path_prep(localdir, imagesdir)
+        filename = File.basename(outfile.to_s)
+        FileUtils.cp(outfile, path) and outfile.unlink
+
+        imagesdir ? filename : File.join(path, filename)
+      end
+
+      def self.path_prep(localdir, imagesdir)
+        path = Pathname.new(localdir) + (imagesdir || "plantuml")
+        File.writable?(localdir) or
+          raise "Destination path #{path} not writable for PlantUML!"
+        path.mkpath
+        File.writable?(path) or
+          raise "Destination path #{path} not writable for PlantUML!"
+        # File.exist?(path) or raise "Destination path #{path} already exists for PlantUML!"
+        path
+      end
+
+      def self.save_plantuml(_parent, reader, _localdir)
+        src = prep_source(reader)
+        /^@startuml (?<fn>[^\n]+)\n/ =~ src
+        Tempfile.open(["plantuml", ".pml"], encoding: "utf-8") do |f|
+          f.write(src)
+          [f, File.join(File.dirname(f.path),
+                        "#{fn || File.basename(f.path, '.pml')}.png")]
+        end
+      end
+
+      def self.prep_source(reader)
+        src = reader.source
+        reader.lines.first.sub(/\s+$/, "").match /^@startuml($| )/ or
+          src = "@startuml\n#{src}\n@enduml\n"
+        %r{@enduml\s*$}m.match?(src) or
+          raise "@startuml without matching @enduml in PlantUML!"
+        src
+      end
+
+      def self.generate_attrs(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 abort(parent, reader, attrs, msg)
+        warn msg
+        attrs["language"] = "plantuml"
+        create_listing_block parent, reader.source,
+                             (attrs.reject { |k, _v| k == 1 })
+      end
+
+      def process(parent, reader, attrs)
+        PlantUMLBlockMacroBackend.plantuml_installed?
+        filename = PlantUMLBlockMacroBackend.generate_file(parent, reader)
+        through_attrs = PlantUMLBlockMacroBackend.generate_attrs attrs
+        through_attrs["target"] = filename
+        create_image_block parent, through_attrs
+      rescue StandardError => e
+        abort(parent, reader, attrs, e.message)
+      end
+    end
+  end
+end