metanorma-plugin-lutaml 0.4.19 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 630f5c9adbb662d5f2aea46dd1deb40cd4e6a935133214e10e1cf298dedd9f3b
-  data.tar.gz: 733f2e388c638d3ca3081a220b47624abc505bbef3ad6e414b9d1b12adc508ee
+  metadata.gz: 7f93ed9a874aa04de0ff48ccc747a887ad82f5c024b5e688c09c78e2857d20c5
+  data.tar.gz: f42630b6fe28b47fab6041c7a0638bcb5fccc5080315518f7d5f97355a499a94
 SHA512:
-  metadata.gz: f6dd4a103fff25ec175bd07da453eabfe7e767f0ef6663e22116dc98a85d62549432ad7348c05828cb51ae111293cc308269bfb07465a5d60ed874dc6a8407ae
-  data.tar.gz: cf196784ea5a546c82e560b4dae9234a74a877aa64155f6d7e8a55d6b80acae00f125b6968d90eb18bf9bf3ed977a7bdecd4e2beb92f3de4f7f591fc9860a2fa
+  metadata.gz: b38c3de5ad16450a4fca4dc6b6505d9408de9ec8dce3535689f6419a5ada4d4ee9a42ac88d452f95ad8a852bd8579b4afe41f469d81515c4f3e9a37dc795469d
+  data.tar.gz: 4797711cda34aa4473f4314ad25c1a2e6193a892eb65a7a9600a57147556a8dd921ddf2ac00ef691fd5c9606e5aeb518a1ddf9dfa19c19e3e8fdabccc1ca00d8

data/Gemfile

@@ -1,4 +1,9 @@
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+
 source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}" }
 
-# Specify your gem's dependencies in metanorma-plugin-lutaml.gemspec
 gemspec
+
+eval_gemfile("Gemfile.devel") rescue nil

data/lib/metanorma/plugin/lutaml/asciidoctor/preprocessor.rb

@@ -0,0 +1,14 @@
+module Metanorma
+  module Plugin
+    module Lutaml
+      module Asciidoctor
+        class PreprocessorNoIfdefsReader < ::Asciidoctor::PreprocessorReader
+          def preprocess_conditional_directive(_keyword, _target, _delimiter,
+_text)
+            false # decline to resolve idefs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/plugin/lutaml/express_remarks_decorator.rb

@@ -45,7 +45,8 @@ module Metanorma
         def prefix_relative_paths(line, path_prefix)
           line.gsub(RELATIVE_PREFIX_MACRO_REGEXP) do |_match|
             prefixed_path = File.join(path_prefix, $3.strip)
-            # When we are dealing with arelative path of a template: ../path/to/file we need to transform it into
+            # When we are dealing with a relative path of a template:
+            # ../path/to/file we need to transform it into
             # the absolute one because `image::` macro wont understand it other way
             prefixed_path = File.absolute_path(prefixed_path) if prefixed_path.start_with?('../')
             full_path = File.expand_path(prefixed_path)

data/lib/metanorma/plugin/lutaml/lutaml_diagram_base.rb

@@ -13,7 +13,8 @@ module Metanorma
     module Lutaml
       module LutamlDiagramBase
         def process(parent, reader, attrs)
-          uml_document = ::Lutaml::Uml::Parsers::Dsl.parse(lutaml_file(parent.document, reader))
+          uml_document = ::Lutaml::Uml::Parsers::Dsl
+            .parse(lutaml_file(parent.document, reader))
           filename = generate_file(parent, reader, uml_document)
           through_attrs = generate_attrs(attrs)
           through_attrs["target"] = filename
@@ -23,8 +24,8 @@ module Metanorma
           abort(parent, reader, attrs, e.message)
         end
 
-        def lutaml_file(reader)
-          raise 'Implement me!'
+        def lutaml_file(_reader)
+          raise "Implement me!"
         end
 
         protected
@@ -36,7 +37,7 @@ module Metanorma
           create_listing_block(
             parent,
             source,
-            attrs.reject { |k, _v| k == 1 }
+            attrs.reject { |k, _v| k == 1 },
           )
         end
 
@@ -47,14 +48,16 @@ module Metanorma
 
           path_lutaml = "lutaml"
           imagesdir = if parent.document.attr("imagesdir")
-                        File.join(parent.document.attr("imagesdir"), path_lutaml)
+                        File.join(parent.document.attr("imagesdir"),
+                                  path_lutaml)
                       else
                         path_lutaml
                       end
           result_path = Utils.relative_file_path(parent.document, imagesdir)
           result_pathname = Pathname.new(result_path)
           result_pathname.mkpath
-          File.writable?(result_pathname) || raise("Destination path #{result_path} not writable for Lutaml!")
+          File.writable?(result_pathname) ||
+            raise("Destination path #{result_path} not writable for Lutaml!")
 
           outfile = Tempfile.new(["lutaml", ".png"])
           outfile.binmode
@@ -67,7 +70,7 @@ module Metanorma
           filename = File.basename(outfile.path)
           FileUtils.cp(outfile, result_pathname) && outfile.unlink
 
-          #File.join(result_pathname, filename)
+          # File.join(result_pathname, filename)
           File.join(path_lutaml, filename)
         end
 

data/lib/metanorma/plugin/lutaml/lutaml_diagram_block.rb

@@ -5,7 +5,7 @@ require "metanorma/plugin/lutaml/lutaml_diagram_base"
 module Metanorma
   module Plugin
     module Lutaml
-      class LutamlDiagramBlock < Asciidoctor::Extensions::BlockProcessor
+      class LutamlDiagramBlock < ::Asciidoctor::Extensions::BlockProcessor
         include LutamlDiagramBase
 
         use_dsl
@@ -14,14 +14,14 @@ module Metanorma
         parse_content_as :raw
 
         def lutaml_file(document, reader)
-
           lutaml_temp(document, reader)
         end
 
         private
 
         def lutaml_temp(document, reader)
-          temp_file = Tempfile.new(["lutaml", ".lutaml"], Utils.relative_file_path(document, ''))
+          temp_file = Tempfile.new(["lutaml", ".lutaml"],
+                                   Utils.relative_file_path(document, ""))
           temp_file.puts(reader.read)
           temp_file.rewind
           temp_file

data/lib/metanorma/plugin/lutaml/lutaml_diagram_block_macro.rb

@@ -5,7 +5,7 @@ require "metanorma/plugin/lutaml/lutaml_diagram_base"
 module Metanorma
   module Plugin
     module Lutaml
-      class LutamlDiagramBlockMacro < Asciidoctor::Extensions::BlockMacroProcessor
+      class LutamlDiagramBlockMacro < ::Asciidoctor::Extensions::BlockMacroProcessor
         include LutamlDiagramBase
 
         use_dsl

data/lib/metanorma/plugin/lutaml/lutaml_figure_inline_macro.rb

@@ -3,7 +3,7 @@
 module Metanorma
   module Plugin
     module Lutaml
-      class LutamlFigureInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      class LutamlFigureInlineMacro < ::Asciidoctor::Extensions::InlineMacroProcessor
         include LutamlDiagramBase
 
         use_dsl
@@ -11,11 +11,12 @@ module Metanorma
 
         def process(parent, _target, attrs)
           diagram_key = [attrs["package"], attrs["name"]].compact.join(":")
-          return if parent.document.attributes['lutaml_figure_id'].nil?
-          xmi_id = parent.document.attributes['lutaml_figure_id'][diagram_key]
+          return if parent.document.attributes["lutaml_figure_id"].nil?
+
+          xmi_id = parent.document.attributes["lutaml_figure_id"][diagram_key]
           return unless xmi_id
 
-          %Q(<xref target="figure-#{xmi_id}"></xref>)
+          %(<xref target="figure-#{xmi_id}"></xref>)
         end
       end
     end

data/lib/metanorma/plugin/lutaml/lutaml_preprocessor.rb

@@ -6,30 +6,45 @@ require "asciidoctor/reader"
 require "lutaml"
 require "metanorma/plugin/lutaml/utils"
 require "metanorma/plugin/lutaml/express_remarks_decorator"
+require "metanorma/plugin/lutaml/asciidoctor/preprocessor"
 
 module Metanorma
   module Plugin
     module Lutaml
       # Class for processing Lutaml files
-      class LutamlPreprocessor < Asciidoctor::Extensions::Preprocessor
-        REMARKS_ATTRIBUTE = "remarks".freeze
+      class LutamlPreprocessor < ::Asciidoctor::Extensions::Preprocessor
+        REMARKS_ATTRIBUTE = "remarks"
 
         def process(document, reader)
-          input_lines = reader.readlines.to_enum
+          r = Asciidoctor::PreprocessorNoIfdefsReader.new document, reader.lines
+          input_lines = r.readlines.to_enum
+          has_lutaml = !input_lines.select { |x| lutaml?(x) }.empty?
           express_indexes = Utils.parse_document_express_indexes(
-            document,
-            input_lines
+            document, input_lines
           )
-          result_content = processed_lines(document, input_lines, express_indexes)
-          result_reader = Asciidoctor::PreprocessorReader.new(document, result_content)
-          result_reader
+          result_content = processed_lines(document, input_lines,
+                                           express_indexes)
+          has_lutaml and log(document, result_content)
+          Asciidoctor::PreprocessorNoIfdefsReader.new(document, result_content)
         end
 
         protected
 
+        def log(document, result)
+          File.open("#{document.attr('docfile')}.lutaml.log.txt",
+                    "w:UTF-8") do |f|
+            f.write(result.join("\n"))
+          end
+        end
+
+        def lutaml?(line)
+          line.match(/^\[(?:\blutaml\b|\blutaml_express\b),([^,]+)?,?([^,]+)?,?([^,]+)?\]/)
+        end
+
         def content_from_files(document, file_paths)
           file_list = file_paths.map do |file_path|
-            File.new(Utils.relative_file_path(document, file_path), encoding: "UTF-8")
+            File.new(Utils.relative_file_path(document, file_path),
+                     encoding: "UTF-8")
           end
           ::Lutaml::Parser.parse(file_list)
         end
@@ -43,7 +58,7 @@ module Metanorma
               .push(*process_text_blocks(
                 document,
                 input_lines,
-                express_indexes
+                express_indexes,
               ))
           end
           result
@@ -51,7 +66,7 @@ module Metanorma
 
         def process_text_blocks(document, input_lines, express_indexes)
           line = input_lines.next
-          block_match = line.match(/^\[(?:\blutaml\b|\blutaml_express\b),([^,]+)?,?([^,]+)?,?([^,]+)?\]/)
+          block_match = lutaml?(line)
           return [line] if block_match.nil?
 
           end_mark = input_lines.next
@@ -97,7 +112,8 @@ module Metanorma
           result
         end
 
-        def parse_template(document, current_block, block_match, express_indexes)
+        def parse_template(document, current_block, block_match,
+express_indexes)
           options = parse_options(block_match[3])
           contexts_items(block_match, document, express_indexes)
             .map do |items|
@@ -112,9 +128,9 @@ module Metanorma
                                   context_items: items,
                                   context_name: block_match[2].strip)
             end.flatten
-          rescue StandardError => e
-            document.logger.warn("Failed to parse lutaml block: #{e.message}")
-            []
+        rescue StandardError => e
+          document.logger.warn("Failed to parse lutaml block: #{e.message}")
+          []
         end
 
         def parse_options(options_string)
@@ -155,7 +171,7 @@ module Metanorma
             template_string: context_lines.join("\n"),
             context_items: context_items,
             context_name: context_name,
-            document: document
+            document: document,
           )
           Utils.notify_render_errors(document, errors)
           render_result.split("\n")

data/lib/metanorma/plugin/lutaml/lutaml_table_inline_macro.rb

@@ -3,21 +3,23 @@
 module Metanorma
   module Plugin
     module Lutaml
-      class LutamlTableInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      class LutamlTableInlineMacro < ::Asciidoctor::Extensions::InlineMacroProcessor
         include LutamlDiagramBase
-        SUPPORTED_OPTIONS = %w[class enum data_type]
+        SUPPORTED_OPTIONS = %w[class enum data_type].freeze
 
         use_dsl
         named :lutaml_table
 
         def process(parent, _target, attrs)
           keyword = SUPPORTED_OPTIONS.find { |n| attrs[n] }
-          entity_key = [keyword, attrs["package"], attrs[keyword]].compact.join(":")
-          return if parent.document.attributes['lutaml_entity_id'].nil?
-          xmi_id = parent.document.attributes['lutaml_entity_id'][entity_key]
+          entity_key = [keyword, attrs["package"],
+                        attrs[keyword]].compact.join(":")
+          return if parent.document.attributes["lutaml_entity_id"].nil?
+
+          xmi_id = parent.document.attributes["lutaml_entity_id"][entity_key]
           return unless xmi_id
 
-          %Q(<xref target="section-#{xmi_id}"/>)
+          %(<xref target="section-#{xmi_id}"/>)
         end
       end
     end

data/lib/metanorma/plugin/lutaml/lutaml_uml_attributes_table_preprocessor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "./lutaml_uml_class_preprocessor.rb"
+require "metanorma/plugin/lutaml/asciidoctor/preprocessor"
 
 module Metanorma
   module Plugin
@@ -16,36 +16,35 @@ module Metanorma
           skip_headers = options[:skip_headers]
 
           <<~TEMPLATE
-          #{"=== {{ definition.name }}" unless skip_headers}
-          {{ definition.definition }}
-
-          {% if definition.attributes %}
-          {% if definition.keyword == 'enumeration' %}
-          .{{ definition.name }} values
-          |===
-          |Name |Definition
-
-          {% for item in definition.attributes %}
-          |{{ item.name }} |{{ item.definition }}
-          {% endfor %}
-          |===
-          {% else %}
-          .{{ definition.name }} attributes
-          |===
-          |Name |Definition |Mandatory / Optional / Conditional |Max Occur |Data Type
-
-          {% for item in definition.attributes %}
-          |{{ item.name }} |{% if item.definition %}{{ item.definition }}{% endif %} |{% if item.cardinality.min == "0" %}O{% else %}M{% endif %} |{% if item.cardinality.max == "*" %}N{% else %}1{% endif %} |{% if item.origin %}<<{{ item.origin }}>>{% endif %} `{{ item.type }}`
-          {% endfor %}
-          |===
-          {% endif %}
-          {% endif %}
+            #{'=== {{ definition.name }}' unless skip_headers}
+            {{ definition.definition }}
+
+            {% if definition.attributes %}
+            {% if definition.keyword == 'enumeration' %}
+            .{{ definition.name }} values
+            |===
+            |Name |Definition
+
+            {% for item in definition.attributes %}
+            |{{ item.name }} |{{ item.definition }}
+            {% endfor %}
+            |===
+            {% else %}
+            .{{ definition.name }} attributes
+            |===
+            |Name |Definition |Mandatory / Optional / Conditional |Max Occur |Data Type
+
+            {% for item in definition.attributes %}
+            |{{ item.name }} |{% if item.definition %}{{ item.definition }}{% endif %} |{% if item.cardinality.min == "0" %}O{% else %}M{% endif %} |{% if item.cardinality.max == "*" %}N{% else %}1{% endif %} |{% if item.origin %}<<{{ item.origin }}>>{% endif %} `{{ item.type }}`
+            {% endfor %}
+            |===
+            {% endif %}
+            {% endif %}
 
           TEMPLATE
         end
         # rubocop:enable Layout/IndentHeredoc
       end
-
     end
   end
 end

data/lib/metanorma/plugin/lutaml/lutaml_uml_class_preprocessor.rb

@@ -6,13 +6,14 @@ require "asciidoctor/reader"
 require "lutaml"
 require "lutaml/uml"
 require "metanorma/plugin/lutaml/utils"
+require "metanorma/plugin/lutaml/asciidoctor/preprocessor"
 
 module Metanorma
   module Plugin
     module Lutaml
       #  Macro for quick rendering of datamodel attributes/values table
       #  @example [lutaml_uml_class,path/to/lutaml,EntityName]
-      class LutamlUmlClassPreprocessor < Asciidoctor::Extensions::Preprocessor
+      class LutamlUmlClassPreprocessor < ::Asciidoctor::Extensions::Preprocessor
         MACRO_REGEXP =
           /\[lutaml_uml_class,([^,]+),?([^,]+),?(.+?)?\]/
 
@@ -24,8 +25,10 @@ module Metanorma
         #  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))
+          r = Asciidoctor::PreprocessorNoIfdefsReader.new document, reader.lines
+          input_lines = r.readlines.to_enum
+          Asciidoctor::PreprocessorNoIfdefsReader
+            .new(document, processed_lines(document, input_lines))
         end
 
         private
@@ -34,17 +37,18 @@ module Metanorma
           ::Lutaml::Parser.parse(
             File.new(
               Utils.relative_file_path(document, file_path),
-              encoding: "UTF-8")
-            ).first
+              encoding: "UTF-8",
+            ),
+          ).first
         end
 
-        DEFAULT_OPTIONS = {
-          depth: 2
-        }
+        DEFAULT_OPTIONS = { depth: 2 }.freeze
+
         def parse_options_to_hash(options_string)
-          return DEFAULT_OPTIONS.dup if options_string.nil? || options_string.empty?
+          return DEFAULT_OPTIONS.dup if options_string.nil? ||
+            options_string.empty?
 
-          opts = options_string.split(",").inject({}) do |acc,pair|
+          opts = options_string.split(",").inject({}) do |acc, pair|
             key, value = pair.split("=")
             key = key.to_sym
             value = true if value.nil?
@@ -63,7 +67,8 @@ module Metanorma
               entity_name = match[2]
               options = parse_options_to_hash(match[3])
 
-              result.push(*parse_marco(lutaml_path, entity_name, document, options))
+              result.push(*parse_marco(lutaml_path, entity_name, document,
+                                       options))
             else
               result.push(line)
             end
@@ -87,7 +92,7 @@ module Metanorma
             template_string: template(options),
             context_items: entity_definition,
             context_name: "definition",
-            document: document
+            document: document,
           )
           Utils.notify_render_errors(document, errors)
           render_result.split("\n")
@@ -103,56 +108,56 @@ module Metanorma
           depth = options[:depth]
 
           <<~TEMPLATE
-          {% if definition.keyword == 'enumeration' %}
-          #{equalsigns(depth) + " Enumeration: {{ definition.name }}" unless skip_headers}
-          {% else %}
-          #{equalsigns(depth) + " Class: {{ definition.name }}" unless skip_headers}
-          {% endif %}
+            {% if definition.keyword == 'enumeration' %}
+            #{equalsigns(depth) + ' Enumeration: {{ definition.name }}' unless skip_headers}
+            {% else %}
+            #{equalsigns(depth) + ' Class: {{ definition.name }}' unless skip_headers}
+            {% endif %}
 
-          #{equalsigns(depth+1)} Description
+            #{equalsigns(depth + 1)} Description
 
-          {{ definition.definition }}
+            {{ definition.definition }}
 
-          {% if definition.attributes %}
-          {% if definition.keyword == 'enumeration' %}
-          {% for item in definition.attributes %}
-          #{equalsigns(depth+1)} Enumeration value: {{item.name}}
+            {% if definition.attributes %}
+            {% if definition.keyword == 'enumeration' %}
+            {% for item in definition.attributes %}
+            #{equalsigns(depth + 1)} Enumeration value: {{item.name}}
 
-          {% if item.definition %}
-          {{ item.definition }}
-          {% endif %}
+            {% if item.definition %}
+            {{ item.definition }}
+            {% endif %}
 
-          {% endfor %}
+            {% endfor %}
 
-          {% else %}
+            {% else %}
 
-          {% for item in definition.attributes %}
-          #{equalsigns(depth+1)} Attribute: {{item.name}}
+            {% for item in definition.attributes %}
+            #{equalsigns(depth + 1)} Attribute: {{item.name}}
 
-          {% if item.definition %}
-          {{ item.definition }}
-          {% endif %}
+            {% if item.definition %}
+            {{ item.definition }}
+            {% endif %}
 
-          Value type and multiplicity:
-          {% if item.type -%}{{ item.type }}{% else -%}(no type specified){% endif %}
-          {% if item.cardinality.min -%}
-          {% if item.cardinality.max -%}
-          {blank}[{{item.cardinality.min}}..{{item.cardinality.max}}]
-          {% else -%}
-          {blank}[{{item.cardinality.min}}]
-          {% endif -%}
-          {% else -%}
-          (multiplicity unspecified)
-          {% endif %}
+            Value type and multiplicity:
+            {% if item.type -%}{{ item.type }}{% else -%}(no type specified){% endif %}
+            {% if item.cardinality.min -%}
+            {% if item.cardinality.max -%}
+            {blank}[{{item.cardinality.min}}..{{item.cardinality.max}}]
+            {% else -%}
+            {blank}[{{item.cardinality.min}}]
+            {% endif -%}
+            {% else -%}
+            (multiplicity unspecified)
+            {% endif %}
 
-          {% if item.origin %}
-          Origin: <<{{ item.origin }}>>
-          {% endif %}
+            {% if item.origin %}
+            Origin: <<{{ item.origin }}>>
+            {% endif %}
 
-          {% endfor %}
+            {% endfor %}
 
-          {% endif %}
-          {% endif %}
+            {% endif %}
+            {% endif %}
 
           TEMPLATE
         end

data/lib/metanorma/plugin/lutaml/lutaml_uml_datamodel_description_preprocessor.rb

@@ -6,6 +6,7 @@ require "asciidoctor/reader"
 require "lutaml"
 require "lutaml/uml"
 require "metanorma/plugin/lutaml/utils"
+require "metanorma/plugin/lutaml/asciidoctor/preprocessor"
 
 module Metanorma
   module Plugin
@@ -13,45 +14,48 @@ module Metanorma
       #  Macro for quick rendering of datamodel attributes/values table
       #  @example [lutaml_uml_attributes_table,path/to/lutaml,EntityName]
       class LutamlUmlDatamodelDescriptionPreprocessor <
-          Asciidoctor::Extensions::Preprocessor
+          ::Asciidoctor::Extensions::Preprocessor
         MACRO_REGEXP =
           /\[lutaml_uml_datamodel_description,([^,]+),?(.+)?\]/
         LIQUID_INCLUDE_PATH = File.join(
           Gem.loaded_specs["metanorma-plugin-lutaml"].full_gem_path,
           "lib", "metanorma", "plugin", "lutaml", "liquid_templates"
         )
-        DEFAULT_RENDER_INCLUDE = 'packages'.freeze
+        DEFAULT_RENDER_INCLUDE = "packages"
         RENDER_STYLES_INCLUDES = {
-          'default' => 'packages',
-          'entity_list' => 'packages_entity_list',
-          'entity_list_class' => 'packages_entity_list_class',
-          'data_dictionary' => 'packages_data_dictionary'
+          "default" => "packages",
+          "entity_list" => "packages_entity_list",
+          "entity_list_class" => "packages_entity_list_class",
+          "data_dictionary" => "packages_data_dictionary",
         }.freeze
-        RENDER_STYLE_ATTRIBUTE = 'render_style'.freeze
+        RENDER_STYLE_ATTRIBUTE = "render_style"
         SUPPORTED_NESTED_MACRO = %w[
-          before diagram_include_block after include_block package_text].freeze
+          before diagram_include_block after include_block package_text
+        ].freeze
         # search document for block `lutaml_uml_datamodel_description`
         #  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))
+          r = Asciidoctor::PreprocessorNoIfdefsReader.new document, reader.lines
+          input_lines = r.readlines.to_enum
+          Asciidoctor::PreprocessorNoIfdefsReader
+            .new(document, processed_lines(document, input_lines))
         end
 
         private
 
         def lutaml_document_from_file_or_cache(document, file_path)
           full_path = Utils.relative_file_path(document, file_path)
-          if document.attributes['lutaml_xmi_cache'] &&
-              document.attributes['lutaml_xmi_cache'][full_path]
-            return document.attributes['lutaml_xmi_cache'][full_path]
+          if document.attributes["lutaml_xmi_cache"] &&
+              document.attributes["lutaml_xmi_cache"][full_path]
+            return document.attributes["lutaml_xmi_cache"][full_path]
           end
-          result_document = ::Lutaml::Parser.parse(File.new(full_path,
-                                encoding: "UTF-8"))
-                              .first
-                              result_document
-          document.attributes['lutaml_xmi_cache'] ||= {}
-          document.attributes['lutaml_xmi_cache'][full_path] = result_document
+
+          result_document = ::Lutaml::Parser
+            .parse(File.new(full_path, encoding: "UTF-8")).first
+          result_document
+          document.attributes["lutaml_xmi_cache"] ||= {}
+          document.attributes["lutaml_xmi_cache"][full_path] = result_document
           result_document
         end
 
@@ -59,7 +63,7 @@ module Metanorma
           return {} if file_path.nil?
 
           relative_file_path = Utils.relative_file_path(document, file_path)
-          YAML.load(File.read(relative_file_path, encoding: "UTF-8"))
+          YAML.safe_load(File.read(relative_file_path, encoding: "UTF-8"))
         end
 
         def processed_lines(document, input_lines)
@@ -75,19 +79,22 @@ module Metanorma
           block_match = line.match(MACRO_REGEXP)
           return [line] if block_match.nil?
 
-          lutaml_document = lutaml_document_from_file_or_cache(document, block_match[1])
+          lutaml_document = lutaml_document_from_file_or_cache(document,
+                                                               block_match[1])
           fill_in_diagrams_attributes(document, lutaml_document)
           model_representation(
-            lutaml_document,
-            document,
+            lutaml_document, document,
             collect_additional_context(document, input_lines, input_lines.next),
-            parse_yaml_config_file(document, block_match[2]))
+            parse_yaml_config_file(document, block_match[2])
+          )
         end
 
-        def fill_in_entities_refs_attributes(document, lutaml_document_wrapper, options)
+        def fill_in_entities_refs_attributes(document, lutaml_document_wrapper,
+options)
           lutaml_document = lutaml_document_wrapper.original_document
-          render_style = options.fetch(RENDER_STYLE_ATTRIBUTE, 'default')
-          all_children_packages = lutaml_document.packages.map(&:children_packages).flatten
+          render_style = options.fetch(RENDER_STYLE_ATTRIBUTE, "default")
+          all_children_packages = lutaml_document.packages
+            .map(&:children_packages).flatten
           package_flat_packages = lambda do |pks|
             pks.each_with_object({}) do |package, res|
               res[package.name] = package.xmi_id
@@ -95,7 +102,7 @@ module Metanorma
           end
           children_pks = package_flat_packages.call(all_children_packages)
           ref_dictionary = package_flat_packages.call(lutaml_document.packages)
-                            .merge(children_pks)
+            .merge(children_pks)
           %w[class enum data_type].each do |type|
             package_flat = lambda do |pks|
               pks.each_with_object({}) do |package, res|
@@ -106,46 +113,57 @@ module Metanorma
               end
             end
             children_pks_daigs = package_flat.call(all_children_packages)
-              ref_dictionary = ref_dictionary
-                                .merge(package_flat.call(lutaml_document.packages)
-                                        .merge(children_pks_daigs))
+            ref_dictionary = ref_dictionary
+              .merge(package_flat.call(lutaml_document.packages)
+                                      .merge(children_pks_daigs))
           end
-          document.attributes['lutaml_entity_id'] = ref_dictionary
+          document.attributes["lutaml_entity_id"] = ref_dictionary
         end
 
         def fill_in_diagrams_attributes(document, lutaml_document_wrapper)
           lutaml_document = lutaml_document_wrapper.original_document
           package_flat_diagrams = lambda do |pks|
             pks.each_with_object({}) do |package, res|
-              package.diagrams.map { |diag| res["#{package.name}:#{diag.name}"] = diag.xmi_id }
+              package.diagrams.map do |diag|
+                res["#{package.name}:#{diag.name}"] = diag.xmi_id
+              end
             end
           end
-          children_pks_daigs = package_flat_diagrams.call(lutaml_document.packages.map(&:children_packages).flatten)
-          document.attributes['lutaml_figure_id'] = package_flat_diagrams.call(lutaml_document.packages)
-                                                      .merge(children_pks_daigs)
+          children_pks_daigs = package_flat_diagrams.call(
+            lutaml_document.packages.map(&:children_packages).flatten,
+          )
+          document.attributes["lutaml_figure_id"] = package_flat_diagrams
+            .call(lutaml_document.packages)
+            .merge(children_pks_daigs)
         end
 
         def collect_additional_context(document, input_lines, end_mark)
           additional_context = Hash.new { |hash, key| hash[key] = [] }
-          additional_context['all_macros'] = []
+          additional_context["all_macros"] = []
           block_lines = []
           while (block_line = input_lines.next) != end_mark
             block_lines.push(block_line)
           end
-          processed_lines = self
-                              .process(document, Asciidoctor::Reader.new(block_lines))
-                              .read_lines
-          block_document = (Asciidoctor::Document.new(processed_lines, {})).parse
+          processed_lines =
+            process(document, ::Asciidoctor::PreprocessorReader.new(
+                                document, block_lines
+                              ))
+              .read_lines
+          block_document = ::Asciidoctor::Document
+            .new(processed_lines, {}).parse
           block_document.blocks.each do |block|
-            next unless SUPPORTED_NESTED_MACRO.include?(block.attributes['role'])
+            next unless SUPPORTED_NESTED_MACRO.include?(block.attributes["role"])
 
             attrs = block.attributes
-            name = attrs.delete('role')
-            package = attrs.delete('package')
+            name = attrs.delete("role")
+            package = attrs.delete("package")
             macro_keyword = [name, package].compact.join(";")
-            block_text = block.lines.length > 0 ? block.lines.join("\n") : ''
-            additional_context[macro_keyword].push({ 'text' => block_text }.merge(attrs))
-            additional_context['all_macros'].push({ 'text' => block_text, 'type' => name, 'package' => package }.merge(attrs))
+            block_text = block.lines.length.positive? ? block.lines.join("\n") : ""
+            additional_context[macro_keyword]
+              .push({ "text" => block_text }.merge(attrs))
+            additional_context["all_macros"]
+              .push({ "text" => block_text,
+                      "type" => name, "package" => package }.merge(attrs))
           end
           additional_context
         end
@@ -153,71 +171,80 @@ module Metanorma
         def package_level(lutaml_document, level)
           return lutaml_document if level <= 0
 
-          package_level(lutaml_document['packages'].first, level - 1)
+          package_level(lutaml_document["packages"].first, level - 1)
         end
 
         def create_context_object(lutaml_document, additional_context, options)
-          root_package = package_level(lutaml_document.to_liquid, options['package_root_level'] || 1)
-          if options.length.zero? || options['packages'].nil?
+          root_package = package_level(lutaml_document.to_liquid,
+                                       options["package_root_level"] || 1)
+          if options.empty? || options["packages"].nil?
             return {
-              'render_nested_packages' => true,
-              "packages" => root_package['packages'],
+              "render_nested_packages" => true,
+              "packages" => root_package["packages"],
               "root_packages" => [root_package],
-              "additional_context" => additional_context.merge("external_classes" => options["external_classes"]),
-              "name" => root_package['name']
+              "additional_context" => additional_context
+                  .merge("external_classes" => options["external_classes"]),
+              "name" => root_package["name"],
             }
           end
 
-          all_packages = [root_package, *root_package['children_packages']]
+          all_packages = [root_package, *root_package["children_packages"]]
           {
             "packages" => sort_and_filter_out_packages(all_packages, options),
             "package_entities" => package_entities(options),
             "package_skip_sections" => package_skip_sections(options),
-            "additional_context" => additional_context.merge("external_classes" => options["external_classes"]),
+            "additional_context" => additional_context
+              .merge("external_classes" => options["external_classes"]),
             "root_packages" => [root_package],
-            "name" => root_package['name']
+            "name" => root_package["name"],
           }
         end
 
         def package_entities(options)
-          return {} unless options['packages']
-
-          options['packages']
-            .find_all { |entity| entity.is_a?(Hash) && entity.values.first['render_entities'] }
-            .map { |entity| [entity.keys.first, entity.values.first['render_entities'].map { |n| [n, true] }.to_h] }.to_h
+          options["packages"] or return {}
+          options["packages"]
+            .find_all { |entity| entity.is_a?(Hash) && entity.values.first["render_entities"] }
+            .map do |entity|
+            [entity.keys.first,
+             entity.values.first["render_entities"].map { |n| [n, true] }.to_h]
+          end.to_h
         end
 
         def package_skip_sections(options)
-          return {} unless options['packages']
+          return {} unless options["packages"]
 
-          options['packages']
-            .find_all { |entity| entity.is_a?(Hash) && entity.values.first['skip_tables'] }
-            .map { |entity| [entity.keys.first, entity.values.first['skip_tables'].map { |n| [n, true] }.to_h] }.to_h
+          options["packages"]
+            .find_all { |entity| entity.is_a?(Hash) && entity.values.first["skip_tables"] }
+            .map do |entity|
+            [entity.keys.first, entity.values.first["skip_tables"].map do |n|
+                                  [n, true]
+                                end.to_h]
+          end.to_h
         end
 
         def sort_and_filter_out_packages(all_packages, options)
-          return all_packages if options['packages'].nil?
+          return all_packages if options["packages"].nil?
 
           result = []
           # Step one - filter out all skipped packages
-          options['packages']
-            .find_all { |entity| entity.is_a?(Hash) && entity['skip'] }
+          options["packages"]
+            .find_all { |entity| entity.is_a?(Hash) && entity["skip"] }
             .each do |entity|
-              entity_regexp = config_entity_regexp(entity['skip'])
+              entity_regexp = config_entity_regexp(entity["skip"])
               all_packages
-                .delete_if {|package| package['name'] =~ entity_regexp }
+                .delete_if { |package| package["name"] =~ entity_regexp }
             end
           # Step two - select supplied packages by pattern
-          options['packages']
-            .find_all { |entity| entity.is_a?(String) || (entity.is_a?(Hash) && !entity['skip']) }
+          options["packages"]
+            .find_all { |entity| entity.is_a?(String) || (entity.is_a?(Hash) && !entity["skip"]) }
             .each do |entity_obj|
               entity = entity_obj.is_a?(String) ? entity_obj : entity_obj.keys.first
               entity_regexp = config_entity_regexp(entity)
-              all_packages.each.with_index do |package|
-                if package['name'] =~ entity_regexp
+              all_packages.each do |package|
+                if package["name"]&.match?(entity_regexp)
                   result.push(package)
                   all_packages
-                    .delete_if {|nest_package| nest_package['name'] == package['name'] }
+                    .delete_if { |nest_package| nest_package["name"] == package["name"] }
                 end
               end
             end
@@ -225,34 +252,38 @@ module Metanorma
         end
 
         def config_entity_regexp(entity)
-          additional_sym = '.*' if entity =~ /\*$/
+          additional_sym = ".*" if /\*$/.match?(entity)
           %r{^#{Regexp.escape(entity.gsub('*', ''))}#{additional_sym}$}
         end
 
-        def model_representation(lutaml_document, document, additional_context, options)
+        def model_representation(lutaml_document, document, additional_context,
+options)
           fill_in_entities_refs_attributes(document, lutaml_document, options)
           render_result, errors = Utils.render_liquid_string(
-            template_string: template(options['section_depth'] || 2, options['render_style'], options['include_root']),
+            template_string: template(options["section_depth"] || 2,
+                                      options["render_style"],
+                                      options["include_root"]),
             context_items: create_context_object(lutaml_document,
-                              additional_context,
-                              options),
+                                                 additional_context,
+                                                 options),
             context_name: "context",
             document: document,
-            include_path: LIQUID_INCLUDE_PATH
+            include_path: LIQUID_INCLUDE_PATH,
           )
           Utils.notify_render_errors(document, errors)
           render_result.split("\n")
         end
 
         def template(section_depth, render_style, include_root)
-          include_name = RENDER_STYLES_INCLUDES.fetch(render_style, DEFAULT_RENDER_INCLUDE)
+          include_name = RENDER_STYLES_INCLUDES.fetch(render_style,
+                                                      DEFAULT_RENDER_INCLUDE)
           result = ""
           if include_root
             result += <<~LIQUID
               {% include "#{include_name}", package_skip_sections: context.package_skip_sections, package_entities: context.package_entities, context: context.root_packages, additional_context: context.additional_context, render_nested_packages: false %}
             LIQUID
           end
-          result += <<~LIQUID
+          result + <<~LIQUID
             {% include "#{include_name}", depth: #{section_depth}, package_skip_sections: context.package_skip_sections, package_entities: context.package_entities, context: context, additional_context: context.additional_context, render_nested_packages: context.render_nested_packages %}
           LIQUID
         end

data/lib/metanorma/plugin/lutaml/utils.rb

@@ -17,7 +17,7 @@ module Metanorma
 
         def relative_file_path(document, file_path)
           docfile_directory = File.dirname(
-            document.attributes["docfile"] || "."
+            document.attributes["docfile"] || ".",
           )
           document
             .path_resolver
@@ -28,8 +28,11 @@ module Metanorma
                                  context_name:, document:, include_path: nil)
           liquid_template = ::Liquid::Template.parse(template_string)
           # Allow includes for the template
-          include_paths = [Utils.relative_file_path(document, ""), include_path].compact
-          liquid_template.registers[:file_system] = ::Metanorma::Plugin::Lutaml::Liquid::LocalFileSystem.new(include_paths, ["_%s.liquid", "_%s.adoc"])
+          include_paths = [Utils.relative_file_path(document, ""),
+                           include_path].compact
+          liquid_template.registers[:file_system] =
+            ::Metanorma::Plugin::Lutaml::Liquid::LocalFileSystem
+              .new(include_paths, ["_%s.liquid", "_%s.adoc"])
           rendered_string = liquid_template
             .render(context_name => context_items,
                     strict_variables: true,
@@ -45,8 +48,12 @@ module Metanorma
           end
         end
 
-        def process_express_index(path, cache_path, document, force_read = false)
-          cache_full_path = Utils.relative_file_path(document, cache_path) if cache_path
+        def process_express_index(path, cache_path, document,
+force_read = false)
+          if cache_path
+            cache_full_path = Utils.relative_file_path(document,
+                                                       cache_path)
+          end
           if !force_read && cache_full_path && File.file?(cache_full_path)
             return express_from_cache(cache_full_path)
           end
@@ -54,7 +61,8 @@ module Metanorma
           full_path = Utils.relative_file_path(document, path)
           wrapper = express_from_path(document, full_path)
           if cache_full_path && !File.file?(cache_full_path)
-            express_write_cache(cache_full_path, wrapper.original_document, document)
+            express_write_cache(cache_full_path, wrapper.original_document,
+                                document)
           end
           wrapper
         rescue Expressir::Error
@@ -87,14 +95,17 @@ module Metanorma
         end
 
         def express_from_folder(folder)
-          files = Dir["#{folder}/*.exp"].map { |nested_path| File.new(nested_path, encoding: "UTF-8") }
+          files = Dir["#{folder}/*.exp"].map do |nested_path|
+            File.new(nested_path, encoding: "UTF-8")
+          end
           ::Lutaml::Parser.parse(files)
         end
 
         def express_decorate_wrapper(wrapper, document)
           serialized = wrapper.to_liquid
           serialized["schemas"] = serialized["schemas"].map do |j|
-            j.merge("relative_path_prefix" => Utils.relative_file_path(document, File.dirname(j["file"])))
+            j.merge("relative_path_prefix" => Utils
+              .relative_file_path(document, File.dirname(j["file"])))
           end
           serialized
         end
@@ -105,14 +116,12 @@ module Metanorma
           schemas_paths = yaml_content
             .fetch("schemas")
             .map do |(schema_name, schema_values)|
-            if schema_values["path"]
-              schema_values["path"]
-            else
-              File.join(root_path.to_s, "#{schema_name}.exp")
-            end
+            schema_values["path"] || File.join(root_path.to_s,
+                                               "#{schema_name}.exp")
           end
           files_to_load = schemas_paths.map do |path|
-            File.new(Utils.relative_file_path(document, path), encoding: "UTF-8")
+            File.new(Utils.relative_file_path(document, path),
+                     encoding: "UTF-8")
           end
           ::Lutaml::Parser.parse(files_to_load)
         end
@@ -121,7 +130,7 @@ module Metanorma
           express_indexes = {}
           loop do
             line = input_lines.next
-            break if line.length.zero?
+            break if line.empty?
 
             match = line.match(LUTAML_EXP_IDX_TAG)
             if match
@@ -130,7 +139,8 @@ module Metanorma
               cache = match[:cache_path]
               repositories = process_express_index(path.strip, cache, document)
               if repositories
-                express_indexes[name.strip] = express_decorate_wrapper(repositories, document)
+                express_indexes[name.strip] =
+                  express_decorate_wrapper(repositories, document)
               end
             end
           end

data/lib/metanorma/plugin/lutaml/version.rb

@@ -1,7 +1,7 @@
 module Metanorma
   module Plugin
     module Lutaml
-      VERSION = "0.4.19".freeze
+      VERSION = "0.5.0".freeze
     end
   end
 end

data/lib/metanorma-plugin-lutaml.rb

@@ -13,15 +13,4 @@ module Metanorma
     module Lutaml
     end
   end
-
-  Asciidoctor::Extensions.register do
-    preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
-    preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
-    preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
-    preprocessor Metanorma::Plugin::Lutaml::LutamlUmlClassPreprocessor
-    inline_macro Metanorma::Plugin::Lutaml::LutamlFigureInlineMacro
-    inline_macro Metanorma::Plugin::Lutaml::LutamlTableInlineMacro
-    block_macro Metanorma::Plugin::Lutaml::LutamlDiagramBlockMacro
-    block Metanorma::Plugin::Lutaml::LutamlDiagramBlock
-  end
 end

data/metanorma-plugin-lutaml.gemspec

@@ -17,7 +17,9 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -30,10 +32,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "relaton-cli"
   spec.add_dependency "reverse_adoc"
 
-  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "debug"
   spec.add_development_dependency "equivalent-xml"
   spec.add_development_dependency "metanorma-standoc"
-  spec.add_development_dependency "pry", "~> 0.12.2"
   spec.add_development_dependency "rake", "~> 13"
   spec.add_development_dependency "rspec", "~> 3.6"
   spec.add_development_dependency "rubocop", "= 0.54.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-plugin-lutaml
 version: !ruby/object:Gem::Version
-  version: 0.4.19
+  version: 0.5.0
 platform: ruby
 authors:
 - Ribose Inc.
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-27 00:00:00.000000000 Z
+date: 2024-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -136,20 +136,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.12.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.12.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -270,6 +256,7 @@ files:
 - bin/console
 - bin/setup
 - lib/metanorma-plugin-lutaml.rb
+- lib/metanorma/plugin/lutaml/asciidoctor/preprocessor.rb
 - lib/metanorma/plugin/lutaml/express_remarks_decorator.rb
 - lib/metanorma/plugin/lutaml/liquid/custom_filters.rb
 - lib/metanorma/plugin/lutaml/liquid/multiply_local_file_system.rb
@@ -301,7 +288,7 @@ homepage: https://github.com/metanorma/metanorma-plugin-lutaml
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -316,8 +303,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.3.26
+signing_key: 
 specification_version: 4
 summary: Metanorma plugin for LutaML
 test_files: []