metanorma-standoc 1.11.1 → 2.0.0

data/lib/asciidoctor/standoc/lists.rb

@@ -1,120 +1,3 @@
-module Asciidoctor
-  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
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/lists"
 
-      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/asciidoctor/standoc/macros.rb

@@ -1,204 +1,3 @@
-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 "./datamodel/attributes_table_preprocessor"
-require_relative "./datamodel/diagram_preprocessor"
-require "metanorma-plugin-datastruct"
-require "metanorma-plugin-lutaml"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/macros"
 
-module Asciidoctor
-  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 < 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 < 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/asciidoctor/standoc/macros_form.rb

@@ -1,63 +1,3 @@
-module Asciidoctor
-  module Standoc
-    class FormInputMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :input
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/macros_form"
 
-      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/asciidoctor/standoc/macros_note.rb

@@ -1,45 +1,3 @@
-module Asciidoctor
-  module Standoc
-    class ToDoAdmonitionBlock < Extensions::BlockProcessor
-      use_dsl
-      named :TODO
-      on_contexts :example, :paragraph
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/macros_note"
 
-      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 < 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 = 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/asciidoctor/standoc/macros_plantuml.rb

@@ -1,113 +1,3 @@
-module Asciidoctor
-  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
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/macros_plantuml"
 
-      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