metanorma-standoc 1.11.1 → 2.0.0

data/lib/metanorma/standoc/cleanup_terms_designations.rb

@@ -0,0 +1,199 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      def termdef_stem_cleanup(xmldoc)
+        termdef_stem2admitted(xmldoc)
+        xmldoc.xpath("//term//expression/name[stem]").each do |n|
+          test = n.dup
+          test.at("./stem").remove
+          next unless test.text.strip.empty?
+
+          n.parent.name = "letter-symbol"
+        end
+      end
+
+      def termdef_stem2admitted(xmldoc)
+        xmldoc.xpath("//term/p/stem").each do |a|
+          if initial_formula(a.parent)
+            parent = a.parent
+            parent.replace("<admitted>#{term_expr(a.to_xml)}</admitted>")
+          end
+        end
+        xmldoc.xpath("//term/formula").each do |a|
+          initial_formula(a) and
+            a.replace("<admitted>#{term_expr(a.children.to_xml)}</admitted>")
+        end
+      end
+
+      def initial_formula(elem)
+        elem.elements.size == 1 && # para contains just stem expression
+          !elem.at("./preceding-sibling::p | ./preceding-sibling::dl | "\
+                   "./preceding-sibling::ol | ./preceding-sibling::ul")
+      end
+
+      # release termdef tags from surrounding paras
+      def termdef_unnest_cleanup(xmldoc)
+        desgn = "//p/admitted | //p/deprecates | //p/preferred | //p//related"
+        nodes = xmldoc.xpath(desgn)
+        while !nodes.empty?
+          nodes[0].parent.replace(nodes[0].parent.children)
+          nodes = xmldoc.xpath(desgn)
+        end
+      end
+
+      def term_dl_to_metadata(xmldoc)
+        xmldoc.xpath("//term[dl[@metadata = 'true']]").each do |t|
+          t.xpath("./dl[@metadata = 'true']").each do |dl|
+            prev = related2pref(dl_to_designation(dl)) or next
+            term_dl_to_designation_metadata(prev, dl)
+            term_dl_to_term_metadata(prev, dl)
+            term_dl_to_expression_metadata(prev, dl)
+            dl.remove
+          end
+        end
+      end
+
+      def term_dl_to_term_metadata(prev, dlist)
+        return unless prev.name == "preferred" &&
+          prev.at("./preceding-sibling::preferred").nil?
+
+        ins = term_element_insert_point(prev)
+        %w(domain subject).each do |a|
+          ins = dl_to_elems(ins, prev.parent, dlist, a)
+        end
+      end
+
+      def term_dl_to_designation_metadata(prev, dlist)
+        %w(absent geographic-area).each do |a|
+          dl_to_attrs(prev, dlist, a)
+        end
+        %w(field-of-application usage-info).reverse.each do |a|
+          dl_to_elems(prev.at("./expression"), prev, dlist, a)
+        end
+      end
+
+      def term_element_insert_point(prev)
+        ins = prev
+        while %w(preferred admitted deprecates related domain dl)
+            .include? ins&.next_element&.name
+          ins = ins.next_element
+        end
+        ins
+      end
+
+      def term_dl_to_expression_metadata(prev, dlist)
+        term_dl_to_expression_root_metadata(prev, dlist)
+        term_dl_to_expression_name_metadata(prev, dlist)
+        term_to_letter_symbol(prev, dlist)
+      end
+
+      def term_dl_to_expression_root_metadata(prev, dlist)
+        %w(isInternational).each do |a|
+          p = prev.at("./expression | ./letter-symbol | ./graphical-symbol")
+          dl_to_attrs(p, dlist, a)
+        end
+        %w(language script type).each do |a|
+          p = prev.at("./expression") or next
+          dl_to_attrs(p, dlist, a)
+        end
+      end
+
+      def term_dl_to_expression_name_metadata(prev, dlist)
+        %w(abbreviation-type pronunciation).reverse.each do |a|
+          dl_to_elems(prev.at("./expression/name"), prev, dlist, a)
+        end
+        g = dlist.at("./dt[text()='grammar']/following::dd//dl") and
+          term_dl_to_expression_grammar(prev, g)
+      end
+
+      def term_dl_to_expression_grammar(prev, dlist)
+        prev.at(".//expression") or return
+        prev.at(".//expression") << "<grammar><sentinel/></grammar>"
+        %w(gender number isPreposition isParticiple isAdjective isAdverb isNoun
+           grammar-value).reverse.each do |a|
+          dl_to_elems(prev.at(".//expression/grammar/*"), prev.elements.last,
+                      dlist, a)
+        end
+        term_dl_to_designation_category(prev, "gender")
+        term_dl_to_designation_category(prev, "number")
+        prev.at(".//expression/grammar/sentinel").remove
+      end
+
+      def term_dl_to_designation_category(prev, category)
+        cat = prev.at(".//expression/grammar/#{category}")
+        /,/.match?(cat&.text) and
+          cat.replace(cat.text.split(/,\s*/)
+            .map { |x| "<#{category}>#{x}</#{category}>" }.join)
+      end
+
+      def term_to_letter_symbol(prev, dlist)
+        ls = dlist.at("./dt[text()='letter-symbol']/following::dd/p")
+        return unless ls&.text == "true"
+
+        prev.at(".//expression").name = "letter-symbol"
+      end
+
+      def dl_to_designation(dlist)
+        prev = dlist.previous_element
+        unless %w(preferred admitted deprecates related).include? prev&.name
+          @log.add("AsciiDoc Input", dlist, "Metadata definition list does "\
+                                            "not follow a term designation")
+          return nil
+        end
+        prev
+      end
+
+      def term_nonverbal_designations(xmldoc)
+        xmldoc.xpath("//term/preferred | //term/admitted | //term/deprecates")
+          .each do |d|
+          d.text.strip.empty? or next
+          n = d.next_element
+          if %w(formula figure).include?(n&.name)
+            term_nonverbal_designations1(d, n)
+          else d.at("./expression/name") or
+            d.children = term_expr("")
+          end
+        end
+      end
+
+      def term_nonverbal_designations1(desgn, elem)
+        desgn = related2pref(desgn)
+        if elem.name == "figure"
+          elem.at("./name").remove
+          desgn.children =
+            "<graphical-symbol>#{elem.remove.to_xml}</graphical-symbol>"
+        else
+          desgn.children = term_expr(elem.at("./stem").to_xml)
+          elem.remove
+        end
+      end
+
+      def term_termsource_to_designation(xmldoc)
+        xmldoc.xpath("//term/termsource").each do |t|
+          p = t.previous_element
+          while %w(domain subject).include? p&.name
+            p = p.previous_element
+          end
+          %w(preferred admitted deprecates related).include?(p&.name) or
+            next
+          related2pref(p) << t.remove
+        end
+      end
+
+      def term_designation_reorder(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          %w(preferred admitted deprecates related)
+            .each_with_object([]) do |tag, m|
+            t.xpath("./#{tag}").each { |x| m << x.remove }
+          end.reverse.each do |x|
+            t.children.first.previous = x
+          end
+        end
+      end
+
+      def related2pref(elem)
+        elem&.name == "related" ? elem = elem.at("./preferred") : elem
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/cleanup_text.rb

@@ -0,0 +1,96 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      def textcleanup(result)
+        text = result.flatten.map { |l| l.sub(/\s*$/, "") } * "\n"
+        !@keepasciimath and text = asciimath2mathml(text)
+        text = text.gsub(/\s+<fn /, "<fn ")
+        text.gsub(%r{<passthrough\s+formats="metanorma">([^<]*)
+                  </passthrough>}mx) { HTMLEntities.new.decode($1) }
+      end
+
+      IGNORE_DUMBQUOTES =
+        "//pre | //pre//* | //tt | //tt//* | "\
+        "//sourcecode | //sourcecode//* | //bibdata//* | //stem | "\
+        "//stem//* | //figure[@class = 'pseudocode'] | "\
+        "//figure[@class = 'pseudocode']//*".freeze
+
+      def smartquotes_cleanup(xmldoc)
+        xmldoc.xpath("//date").each { |d| Metanorma::Utils::endash_date(d) }
+        if @smartquotes then smartquotes_cleanup1(xmldoc)
+        else dumbquote_cleanup(xmldoc)
+        end
+      end
+
+      def smartquotes_cleanup1(xmldoc)
+        uninterrupt_quotes_around_xml(xmldoc)
+        dumb2smart_quotes(xmldoc)
+      end
+
+      # "abc<tag/>", def => "abc",<tag/> def
+=begin
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.xpath("//*[following::text()[1]"\
+                     "[starts-with(., '\"') or starts-with(., \"'\")]]")
+          .each do |x|
+          next if !x.ancestors("pre, tt, sourcecode, stem, figure").empty?
+
+          uninterrupt_quotes_around_xml1(x)
+        end
+      end
+=end
+=begin
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.traverse do |n|
+          next unless n.element? && n&.next&.text? &&
+            n.ancestors("pre, tt, sourcecode, stem, figure").empty?
+          next unless /^['"]/.match?(n.next.text)
+
+          uninterrupt_quotes_around_xml1(n)
+        end
+      end
+=end
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.traverse do |n|
+          next unless n.text? && n&.previous&.element?
+          next unless /^['"]/.match?(n.text)
+          next unless n.previous.ancestors("pre, tt, sourcecode, stem, figure")
+            .empty?
+
+          uninterrupt_quotes_around_xml1(n.previous)
+        end
+      end
+
+      def uninterrupt_quotes_around_xml1(elem)
+        prev = elem.at(".//preceding::text()[1]") or return
+        /\S$/.match?(prev.text) or return
+        foll = elem.at(".//following::text()[1]")
+        m = /^(["'][[:punct:]]*)(\s|$)/
+          .match(HTMLEntities.new.decode(foll&.text)) or return
+        foll.content = foll.text.sub(/^(["'][[:punct:]]*)/, "")
+        prev.content = "#{prev.text}#{m[1]}"
+      end
+
+      def dumb2smart_quotes(xmldoc)
+        (xmldoc.xpath("//*[child::text()]") - xmldoc.xpath(IGNORE_DUMBQUOTES))
+          .each do |x|
+          x.children.each do |n|
+            next unless n.text?
+
+            /[-'"(<>]|\.\.|\dx/.match(n) or next
+
+            n.replace(Metanorma::Utils::smartformat(n.text))
+          end
+        end
+      end
+
+      def dumbquote_cleanup(xmldoc)
+        xmldoc.traverse do |n|
+          next unless n.text?
+
+          n.replace(n.text.gsub(/(?<=\p{Alnum})\u2019(?=\p{Alpha})/, "'")) # .
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/cleanup_toc.rb

@@ -0,0 +1,98 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      def toc_cleanup(xmldoc)
+        toc_cleanup_para(xmldoc)
+        xmldoc.xpath("//toc").each { |t| toc_cleanup1(t, xmldoc) }
+        toc_cleanup_clause(xmldoc)
+        toc_metadata(xmldoc)
+      end
+
+      def toc_cleanup_para(xmldoc)
+        xmldoc.xpath("//p[toc]").each do |x|
+          x.xpath("./toc").reverse.each do |t|
+            x.next = t
+          end
+          x.remove if x.text.strip.empty?
+        end
+      end
+
+      def toc_index(toc, xmldoc)
+        depths = toc_index_depths(toc)
+        depths.keys.each_with_object([]) do |key, arr|
+          xmldoc.xpath(key).each do |x|
+            arr << toc_index1(key, x, depths)
+          end
+        end.sort_by { |a| a[:line] }
+      end
+
+      def toc_index1(key, entry, depths)
+        t = entry.at("./following-sibling::variant-title[@type = 'toc']") and
+          entry = t
+        { text: entry.children.to_xml, depth: depths[key].to_i,
+          target: entry.xpath("(./ancestor-or-self::*/@id)[last()]")[0].text,
+          line: entry.line }
+      end
+
+      def toc_index_depths(toc)
+        toc.xpath("./toc-xpath").each_with_object({}) do |x, m|
+          m[x.text] = x["depth"]
+        end
+      end
+
+      def toc_cleanup1(toc, xmldoc)
+        depth = 1
+        ret = ""
+        toc_index(toc, xmldoc).each do |x|
+          ret = toc_cleanup1_entry(x, depth, ret)
+          depth = x[:depth]
+        end
+        toc.children = "<ul>#{ret}</ul>"
+      end
+
+      def toc_cleanup1_entry(entry, depth, ret)
+        if depth > entry[:depth]
+          ret += "</ul></li>" * (depth - entry[:depth])
+        elsif depth < entry[:depth]
+          ret += "<li><ul>" * (entry[:depth] - depth)
+        end
+        ret + "<li><xref target='#{entry[:target]}'>#{entry[:text]}</xref></li>"
+      end
+
+      def toc_cleanup_clause(xmldoc)
+        xmldoc
+          .xpath("//clause[@type = 'toc'] | //annex[@type = 'toc']").each do |c|
+          c.xpath(".//ul[not(ancestor::ul)]").each do |ul|
+            toc_cleanup_clause_entry(xmldoc, ul)
+            ul.replace("<toc>#{ul.to_xml}</toc>")
+          end
+        end
+      end
+
+      def toc_cleanup_clause_entry(xmldoc, list)
+        list.xpath(".//xref[not(text())]").each do |x|
+          c1 = xmldoc.at("//*[@id = '#{x['target']}']")
+          t = c1.at("./variant-title[@type = 'toc']") || c1.at("./title")
+          x << t.dup.children
+        end
+      end
+
+      def toc_metadata(xmldoc)
+        return unless @htmltoclevels || @doctoclevels || @toclevels
+
+        ins = xmldoc.at("//misc-container") ||
+          xmldoc.at("//bibdata").after("<misc-container/>").next_element
+        toc_metadata1(ins)
+      end
+
+      def toc_metadata1(ins)
+        [[@toclevels, "TOC Heading Levels"],
+         [@toclevels, "TOC Heading Levels"],
+         [@toclevels, "TOC Heading Levels"]].each do |n|
+          n[0] and ins << "<presentation-metadata><name>#{n[1]}</name>"\
+                          "<value>#{n[0]}</value></presentation-metadata>"
+        end
+      end
+    end
+  end
+end

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,124 @@
+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::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
+      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