metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/lists.rb

@@ -0,0 +1,115 @@
+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 ul_li(xml_ul, item)
+        xml_ul.li **ul_li_attrs(item) 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 ul_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)))
+      end
+
+      def ul_li_attrs(node)
+        attr_code(
+          uncheckedcheckbox: node.attr?("checkbox") ? !node.attr?("checked") : nil,
+          checkedcheckbox: node.attr?("checkbox") ? node.attr?("checked") : 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(keep_attrs(node).merge(id: Utils::anchor_or_uuid(node),
+                  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(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 dl_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)))
+      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/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/log.rb

@@ -0,0 +1,50 @@
+module Asciidoctor
+  module Standoc
+    class Log
+      def initialize
+        @log = {}
+      end
+
+      def add(category, loc, msg)
+        return if @novalid
+        @log[category] = [] unless @log[category]
+        @log[category] << { location: current_location(loc), message: msg }
+        loc = loc.nil? ? "" : "(#{current_location(loc)}): "
+        warn "#{category}: #{loc}#{msg}" 
+      end
+
+      def current_location(n)
+        return "" if n.nil?
+        return n if n.is_a? String
+        return "Asciidoctor Line #{"%06d" % n.lineno}" if n.respond_to?(:lineno) &&
+          !n.lineno.nil? && !n.lineno.empty?
+        return "XML Line #{"%06d" % 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 write(file)
+        File.open(file, "w:UTF-8") do |f|
+          f.puts "#{file} errors"
+          @log.keys.each do |key|
+            f.puts "\n\n== #{key}\n\n"
+            @log[key].sort do |a, b|
+              a[:location] <=> b[:location]
+            end.each do |n|
+              loc = n[:location] ? "(#{n[:location]}): " : ""
+              f.puts "#{loc}#{n[:message]}" 
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/macros.rb

@@ -0,0 +1,179 @@
+require "asciidoctor/extensions"
+require "fileutils"
+require "uuidtools"
+require 'yaml'
+require_relative './macros_plantuml.rb'
+require_relative './datamodel/attributes_table_preprocessor.rb'
+require_relative './datamodel/diagram_preprocessor.rb'
+require_relative './macros_yaml2text.rb'
+
+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 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 ConceptInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :concept
+      name_positional_attributes "id", "word", "term"
+      #match %r{concept:(?<target>[^\[]*)\[(?<content>|.*?[^\\])\]$}
+      match /\{\{(?<content>|.*?[^\\])\}\}/
+      using_format :short
+
+      # deal with locality attrs and their disruption of positional attrs
+      def preprocess_attrs(attrs)
+        attrs.delete("term") if attrs["term"] and !attrs["word"]
+        attrs.delete(3) if attrs[3] == attrs["term"]
+        a = attrs.keys.reject { |k| k.is_a? String or [1, 2].include? k }
+        attrs["word"] ||= attrs[a[0]] if a.length() > 0
+        attrs["term"] ||= attrs[a[1]] if a.length() > 1
+        attrs
+      end
+
+      def process(parent, _target, attr)
+        attr = preprocess_attrs(attr)
+        localities = attr.keys.reject { |k| %w(id word term).include? k }.
+          reject { |k| k.is_a? Numeric }.
+          map { |k| "#{k}=#{attr[k]}" }.join(",")
+        text = [localities, attr["word"]].reject{ |k| k.nil? || k.empty? }.
+          join(",")
+        out = Asciidoctor::Inline.new(parent, :quoted, text).convert
+        %{<concept key="#{attr['id']}" term="#{attr['term']}">#{out}</concept>}
+      end
+    end
+
+    class PseudocodeBlockMacro < Asciidoctor::Extensions::BlockProcessor
+      use_dsl
+      named :pseudocode
+      on_context :example, :sourcecode
+
+      def init_indent(s)
+        /^(?<prefix>[ \t]*)(?<suffix>.*)$/ =~ s
+        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) and
+            ignore = !ignore
+          next if l.empty? || l.match(/ \+$/)
+          next if /^\[.*\]$/.match(l)
+          next if 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) }
+        ret = create_block(parent, :example, supply_br(lines),
+                     attrs, content_model: :compound)
+        ret
+      end
+    end
+
+    class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :ruby
+      parse_content_as :text
+      option :pos_attrs, %w(rpbegin rt rpend)
+
+      def process(parent, target, attributes)
+        rpbegin = '('
+        rpend = ')'
+        if attributes.size == 1 and attributes.key?("text")
+          rt = attributes["text"]
+        elsif attributes.size == 2 and attributes.key?(1) and
+          attributes.key?("rpbegin")
+          # for example, html5ruby:楽聖少女[がくせいしょうじょ]
+          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 ToDoAdmonitionBlock < 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 < 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
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/macros_plantuml.rb

@@ -0,0 +1,100 @@
+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"
+        nil
+      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
+      def self.generate_file parent, reader
+        localdir = 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 = 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!"
+
+        # 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.
+        filename = File.basename(outfile.to_s)
+        FileUtils.cp(outfile, path) && outfile.unlink
+
+        imagesdir ? filename : File.join(path, filename)
+      end
+
+      def self.save_plantuml parent, reader, localdir
+        src = reader.source
+        reader.lines.first.sub(/\s+$/, "").match /^@startuml($| )/ or
+          src = "@startuml\n#{src}\n@enduml\n"
+        /^@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.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 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)
+        begin
+          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
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/macros_yaml2text.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Asciidoctor
+  module Standoc
+    class YamlBlockStruct < OpenStruct
+      def to_a
+        @table.to_h.keys
+      end
+
+      def values
+        @table.to_h.values
+      end
+
+      def each
+        return to_a.each unless block_given?
+
+        to_a.each do |key|
+          yield(key)
+        end
+      end
+    end
+
+    class YamlContextRenderer
+      attr_reader :context_object, :context_name
+
+      def initialize(context_object:, context_name:)
+        @context_object = context_object
+        @context_name = context_name
+      end
+
+      def respond_to_missing?(name)
+        respond_to?(name)
+      end
+
+      def method_missing(name, *_args)
+        return context_object if name.to_s == context_name
+
+        super
+      end
+
+      def render(template)
+        ERB.new(template).result(binding)
+      end
+    end
+
+    class Yaml2TextPreprocessor < Asciidoctor::Extensions::Preprocessor
+      BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/
+      BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/
+      # search document for block `yaml2text`
+      #   after that take template from block and read file into this template
+      #   example:
+      #     [yaml2text,foobar.yaml]
+      #     ----
+      #     === {item.name}
+      #     {item.desc}
+      #
+      #     {item.symbol}:: {item.symbol_def}
+      #     ----
+      #
+      #   with content of `foobar.yaml` file equal to:
+      #     - name: spaghetti
+      #       desc: wheat noodles of 9mm diameter
+      #       symbol: SPAG
+      #       symbol_def: the situation is message like spaghetti at a kid's
+      #
+      #   will produce:
+      #     === spaghetti
+      #     wheat noodles of 9mm diameter
+      #
+      #     SPAG:: the situation is message like spaghetti at a kid's meal
+      def process(document, reader)
+        input_lines = reader.readlines.to_enum
+        Reader.new(processed_lines(document, input_lines))
+      end
+
+      private
+
+      def processed_lines(document, input_lines)
+        result = []
+        current_macro_line_num = 0
+        loop do
+          line = input_lines.next
+          current_macro_line_num += 1
+          if yaml_block_match = line.match(/^\[yaml2text,(.+?),(.+?)\]/)
+            mark = input_lines.next
+            current_yaml_block = []
+            while (yaml_block_line = input_lines.next) != mark
+              current_yaml_block.push(yaml_block_line)
+            end
+            result.push(*read_yaml_and_parse_template(current_yaml_block,
+                                                      document,
+                                                      yaml_block_match,
+                                                      current_macro_line_num))
+          else
+            result.push(line)
+          end
+        end
+        result
+      end
+
+      def read_yaml_and_parse_template(current_yaml_block, document, yaml_block_match, current_macro_line_num)
+        content = nested_open_struct_from_yaml(yaml_block_match[1], document)
+        parse_blocks_recursively(lines: current_yaml_block,
+                                 attributes: content,
+                                 context_name: yaml_block_match[2])
+      rescue StandardError => exception
+        document
+          .logger
+          .warn("Failed to parse yaml2text block on line #{current_macro_line_num}: #{exception.message}")
+        []
+      end
+
+      def nested_open_struct_from_yaml(file_path, document)
+        docfile_directory = File.dirname(document.attributes['docfile'] || '.')
+        yaml_file_path = document
+                         .path_resolver
+                         .system_path(file_path, docfile_directory)
+        content = YAML.safe_load(File.read(yaml_file_path))
+        # Load content as json, then parse with JSON as nested open_struct
+        JSON.parse(content.to_json, object_class: YamlBlockStruct)
+      end
+
+      def parse_blocks_recursively(lines:,
+                                   attributes:,
+                                   context_name:)
+        lines = lines.to_enum
+        result = []
+        loop do
+          line = lines.next
+          if line.match?(BLOCK_START_REGEXP)
+            line.gsub!(BLOCK_START_REGEXP,
+                       '<% \1.each&.with_index do |\2,index| %>')
+          end
+
+          if line.strip.match?(BLOCK_END_REGEXP)
+            line.gsub!(BLOCK_END_REGEXP, '<% end %>')
+          end
+          line.gsub!(/{\s*if\s*([^}]+)}/, '<% if \1 %>')
+          line.gsub!(/{\s*?end\s*?}/, '<% end %>')
+          line = line
+                 .gsub(/{(.+?[^}]*)}/, '<%= \1 %>')
+                 .gsub(/[a-z\.]+\#/, 'index')
+          result.push(line)
+        end
+        result = parse_context_block(context_lines: result,
+                                     context_items: attributes,
+                                     context_name: context_name)
+        result
+      end
+
+      def parse_context_block(context_lines:,
+                              context_items:,
+                              context_name:)
+        renderer = YamlContextRenderer
+                   .new(
+                     context_object: context_items,
+                     context_name: context_name
+                   )
+        renderer.render(context_lines.join("\n")).split("\n")
+      end
+    end
+  end
+end