metanorma-standoc 1.11.3 → 2.0.2

data/lib/metanorma/standoc/cleanup_xref.rb

@@ -0,0 +1,107 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      # extending localities to cover ISO referencing
+      LOCALITY_REGEX_STR = <<~REGEXP.freeze
+        ^((?<locality>section|clause|part|paragraph|chapter|page|
+                      table|annex|figure|example|note|formula|list|time|anchor|
+                      locality:[^ \\t\\n\\r:,;=]+)(\\s+|=)
+               (?<ref>[^"][^ \\t\\n,:-]*|"[^"]+")
+                 (-(?<to>[^"][^ \\t\\n,:-]*|"[^"]"))?|
+          (?<locality2>whole|locality:[^ \\t\\n\\r:,;=]+))(?<punct>[,:;]?)\\s*
+         (?<text>.*)$
+      REGEXP
+      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
+                               Regexp::IGNORECASE | Regexp::MULTILINE)
+
+      def tq(text)
+        text.sub(/^"/, "").sub(/"$/, "")
+      end
+
+      def extract_localities(elem)
+        f = elem&.children&.first or return
+        f.text? or return
+        head = f.remove.text
+        tail = elem&.children&.remove
+        extract_localities1(elem, head)
+        tail and elem << tail
+      end
+
+      def extract_localities1(elem, text)
+        b = elem.add_child("<localityStack/>").first if LOCALITY_RE.match text
+        while (m = LOCALITY_RE.match text)
+          ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
+          refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
+          b.add_child("<locality type='#{locality_label(m)}'>#{ref}#{refto}"\
+                      "</locality>")
+          text = m[:text]
+          b = elem.add_child("<localityStack/>").first if m[:punct] == ";"
+        end
+        elem.add_child(text) if text
+      end
+
+      def locality_label(match)
+        loc = match[:locality] || match[:locality2]
+        /^locality:/.match?(loc) ? loc : loc&.downcase
+      end
+
+      def xref_to_eref(elem)
+        elem["bibitemid"] = elem["target"]
+        unless elem["citeas"] = @anchors&.dig(elem["target"], :xref)
+          @internal_eref_namespaces.include?(elem["type"]) or
+            @log.add("Crossreferences", elem,
+                     "#{elem['target']} does not have a corresponding "\
+                     "anchor ID in the bibliography!")
+        end
+        elem.delete("target")
+        extract_localities(elem) unless elem.children.empty?
+      end
+
+      def xref_cleanup(xmldoc)
+        xmldoc.xpath("//xref").each do |x|
+          /:/.match(x["target"]) and xref_to_internal_eref(x)
+          next unless x.name == "xref"
+
+          if refid? x["target"]
+            x.name = "eref"
+            xref_to_eref(x)
+          else x.delete("type")
+          end
+        end
+      end
+
+      def xref_to_internal_eref(elem)
+        a = elem["target"].split(":", 3)
+        unless a.size < 2 || a[0].empty? || a[1].empty?
+          elem["target"] = "#{a[0]}_#{a[1]}"
+          a.size > 2 and
+            elem.children = %{anchor="#{a[2..-1].join}",#{elem&.children&.text}}
+          elem["type"] = a[0]
+          @internal_eref_namespaces << a[0]
+          elem.name = "eref"
+          xref_to_eref(elem)
+        end
+      end
+
+      def quotesource_cleanup(xmldoc)
+        xmldoc.xpath("//quote/source | //terms/source").each do |x|
+          xref_to_eref(x)
+        end
+      end
+
+      def origin_cleanup(xmldoc)
+        xmldoc.xpath("//origin/concept[termref]").each do |x|
+          t = x.at("./termref")
+          x.replace(t)
+        end
+        xmldoc.xpath("//origin").each do |x|
+          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) or
+            @log.add("Crossreferences", x,
+                     "#{x['bibitemid']} does not have a corresponding anchor "\
+                     "ID in the bibliography!")
+          extract_localities(x) unless x.children.empty?
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/converter.rb

@@ -0,0 +1,126 @@
+require "asciidoctor"
+require "metanorma/util"
+require "metanorma/standoc/version"
+require "metanorma/standoc/base"
+require "metanorma/standoc/front"
+require "metanorma/standoc/lists"
+require "metanorma/standoc/ref"
+require "metanorma/standoc/inline"
+require "metanorma/standoc/blocks"
+require "metanorma/standoc/section"
+require "metanorma/standoc/table"
+require "metanorma/standoc/validate"
+require "metanorma/standoc/utils"
+require "metanorma/standoc/cleanup"
+require "metanorma/standoc/reqt"
+require_relative "./macros"
+
+module Metanorma
+  module Standoc
+    # A {Converter} implementation that generates Standoc output, and a document
+    # schema encapsulation of the document for validation
+    class Converter
+      Asciidoctor::Extensions.register do
+        preprocessor Metanorma::Standoc::Datamodel::AttributesTablePreprocessor
+        preprocessor Metanorma::Standoc::Datamodel::DiagramPreprocessor
+        preprocessor Metanorma::Plugin::Datastruct::Json2TextPreprocessor
+        preprocessor Metanorma::Plugin::Datastruct::Yaml2TextPreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
+        inline_macro Metanorma::Standoc::PreferredTermInlineMacro
+        inline_macro Metanorma::Standoc::AltTermInlineMacro
+        inline_macro Metanorma::Standoc::AdmittedTermInlineMacro
+        inline_macro Metanorma::Standoc::DeprecatedTermInlineMacro
+        inline_macro Metanorma::Standoc::RelatedTermInlineMacro
+        inline_macro Metanorma::Standoc::DomainTermInlineMacro
+        inline_macro Metanorma::Standoc::InheritInlineMacro
+        inline_macro Metanorma::Standoc::HTML5RubyMacro
+        inline_macro Metanorma::Standoc::ConceptInlineMacro
+        inline_macro Metanorma::Standoc::AutonumberInlineMacro
+        inline_macro Metanorma::Standoc::VariantInlineMacro
+        inline_macro Metanorma::Standoc::FootnoteBlockInlineMacro
+        inline_macro Metanorma::Standoc::TermRefInlineMacro
+        inline_macro Metanorma::Standoc::SymbolRefInlineMacro
+        inline_macro Metanorma::Standoc::IndexXrefInlineMacro
+        inline_macro Metanorma::Standoc::IndexRangeInlineMacro
+        inline_macro Metanorma::Standoc::AddMacro
+        inline_macro Metanorma::Standoc::DelMacro
+        inline_macro Metanorma::Standoc::FormInputMacro
+        inline_macro Metanorma::Standoc::FormLabelMacro
+        inline_macro Metanorma::Standoc::FormTextareaMacro
+        inline_macro Metanorma::Standoc::FormSelectMacro
+        inline_macro Metanorma::Standoc::FormOptionMacro
+        inline_macro Metanorma::Standoc::ToCInlineMacro
+        inline_macro Metanorma::Standoc::PassInlineMacro
+        inline_macro Metanorma::Plugin::Lutaml::LutamlFigureInlineMacro
+        inline_macro Metanorma::Plugin::Lutaml::LutamlTableInlineMacro
+        block_macro Metanorma::Plugin::Lutaml::LutamlDiagramBlockMacro
+        block Metanorma::Standoc::ToDoAdmonitionBlock
+        treeprocessor Metanorma::Standoc::ToDoInlineAdmonitionBlock
+        block Metanorma::Standoc::PlantUMLBlockMacro
+        block Metanorma::Plugin::Lutaml::LutamlDiagramBlock
+        block Metanorma::Standoc::PseudocodeBlockMacro
+        preprocessor Metanorma::Standoc::EmbedIncludeProcessor
+      end
+
+      include ::Asciidoctor::Converter
+      include ::Asciidoctor::Writer
+
+      include ::Metanorma::Standoc::Base
+      include ::Metanorma::Standoc::Front
+      include ::Metanorma::Standoc::Lists
+      include ::Metanorma::Standoc::Refs
+      include ::Metanorma::Standoc::Inline
+      include ::Metanorma::Standoc::Blocks
+      include ::Metanorma::Standoc::Section
+      include ::Metanorma::Standoc::Table
+      include ::Metanorma::Standoc::Utils
+      include ::Metanorma::Standoc::Cleanup
+      include ::Metanorma::Standoc::Validate
+
+      register_for "standoc"
+
+      $xreftext = {}
+
+      def initialize(backend, opts)
+        super
+        basebackend "html"
+        outfilesuffix ".xml"
+        @libdir = File.dirname(self.class::_file || __FILE__)
+      end
+
+      class << self
+        attr_accessor :_file
+      end
+
+      def self.inherited(konv) # rubocop:disable Lint/MissingSuper
+        konv._file = caller_locations(1..1).first.absolute_path
+      end
+
+      # path to isodoc assets in child gems
+      def html_doc_path(file)
+        File.join(@libdir, "../../isodoc/html", file)
+      end
+
+      def content(node)
+        node.content
+      end
+
+      def skip(node, name = nil)
+        name = name || node.node_name
+        w = "converter missing for #{name} node in Metanorma backend"
+        @log.add("AsciiDoc Input", node, w)
+        nil
+      end
+
+      alias_method :embedded, :content
+      alias_method :verse, :quote
+      alias_method :audio, :skip
+      alias_method :video, :skip
+      alias_method :inline_button, :skip
+      alias_method :inline_kbd, :skip
+      alias_method :inline_menu, :skip
+    end
+  end
+end

data/lib/metanorma/standoc/datamodel/attributes_table_preprocessor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Metanorma
+  module Standoc
+    module Datamodel
+      class AttributesTablePreprocessor < Asciidoctor::Extensions::Preprocessor
+        BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/
+        BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/
+        MARCO_REGEXP = /\[datamodel_attributes_table,([^,]+),?(.+)?\]/
+        TEMPLATES_PATH = File.expand_path("../views/datamodel", __dir__).freeze
+        # search document for block `datamodel_attributes_table`
+        #  read include derectives that goes after that in block and transform
+        #  into yaml2text blocks
+        def process(document, reader)
+          input_lines = reader.readlines.to_enum
+          Asciidoctor::Reader.new(processed_lines(document, input_lines))
+        end
+
+        private
+
+        def processed_lines(document, input_lines)
+          input_lines.each_with_object([]) do |line, result|
+            if match = line.match(MARCO_REGEXP)
+              yaml_path = match[1]
+              result.push(*parse_marco(yaml_path, document))
+            else
+              result.push(line)
+            end
+          end
+        end
+
+        def parse_marco(yaml_path, document)
+          model_representation(yaml_relative_path(yaml_path, document))
+            .split("\n")
+        end
+
+        def model_representation(model_path)
+          template = File.read(File.join(
+                                 TEMPLATES_PATH,
+                                 "model_representation.adoc.erb",
+                               ))
+          file_name = File.basename(model_path).gsub(/\.ya?ml/, "")
+          ERB
+            .new(template)
+            .result(binding)
+        end
+
+        def yaml_relative_path(file_path, document)
+          directory = File.dirname(document.attributes["docfile"] || ".")
+          document.path_resolver.system_path(file_path, directory)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/datamodel/diagram_preprocessor.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "erb"
+require "metanorma/standoc/datamodel/plantuml_renderer"
+
+module Metanorma
+  module Standoc
+    module Datamodel
+      class DiagramPreprocessor < Asciidoctor::Extensions::Preprocessor
+        BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/.freeze
+        BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/.freeze
+        MARCO_REGEXP = /\[datamodel_diagram,([^,]+),?(.+)?\]/.freeze
+        TEMPLATES_PATH = File.expand_path("../views/datamodel", __dir__).freeze
+        # search document for block `datamodel_diagram`
+        #  read include derectives that goes after that in block and transform
+        #  into plantuml block
+        def process(document, reader)
+          input_lines = reader.readlines.to_enum
+          Asciidoctor::Reader.new(processed_lines(document, input_lines))
+        end
+
+        private
+
+        def processed_lines(document, input_lines)
+          input_lines.each_with_object([]) do |line, result|
+            if match = line.match(MARCO_REGEXP)
+              result
+                .push(*parse_datamodel_marco(match[1], match[2], document))
+            else
+              result.push(line)
+            end
+          end
+        end
+
+        def parse_datamodel_marco(yaml_path, include_path, document)
+          include_path ||= File.join(File.dirname(yaml_path), "..", "models")
+          include_path = yaml_relative_path(include_path, document)
+          yaml_relative_to_doc_path = yaml_relative_path(yaml_path, document)
+          view_hash = YAML.safe_load(File.read(yaml_relative_to_doc_path))
+          plantuml_representations(view_hash,
+                                   yaml_relative_to_doc_path,
+                                   include_path)
+        end
+
+        def yaml_relative_path(file_path, document)
+          docfile = document.attributes["docfile"] || "."
+          docfile_directory = File.dirname(docfile)
+          document.path_resolver.system_path(file_path, docfile_directory)
+        end
+
+        def import_format(include_path, import_name, values)
+          include_content = File.read(File.join(
+                                        include_path,
+                                        "#{import_name}.yml",
+                                      ))
+          content = YAML.safe_load(include_content)
+          if values
+            content["skipSection"] = values["skipSection"]
+          end
+          content
+        end
+
+        def format_import_directives(imports, include_path)
+          imports
+            .each_with_object({}) do |(import_name, values), res|
+              full_model_name = import_name.split("/").join
+              content = import_format(include_path, import_name, values)
+              res[content["name"] || full_model_name] = content
+            end.compact
+        end
+
+        def prepare_view_hash(view_hash, all_imports)
+          view_hash.merge!(
+            "classes" => model_type(all_imports, "class"),
+            "enums" => model_type(all_imports, "enum"),
+            "relations" => view_hash["relations"] || [],
+            "fidelity" => (view_hash["fidelity"] || {})
+                          .merge!("classes" => model_type(all_imports,
+                                                          "class")),
+          )
+        end
+
+        def model_type(imports, type)
+          imports
+            .select do |_name, elem|
+              elem["modelType"] == type
+            end
+        end
+
+        def plantuml_representations(view_hash, view_path, include_path)
+          yaml_directory = File.dirname(view_path)
+          all_imports = format_import_directives(view_hash["imports"],
+                                                 include_path)
+          prepare_view_hash(view_hash, all_imports)
+          Metanorma::Datamodel::PlantumlRenderer
+            .new(view_hash, File.join(yaml_directory, ".."))
+            .render
+            .split("\n")
+        end
+      end
+    end
+  end
+end