metanorma-plugin-lutaml 0.7.37 → 0.7.39

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

@@ -40,7 +40,7 @@ module Metanorma
             (?<config_path>.+) # Capture config path
           )?                   # End of optional group
           $                    # End of the pattern
-        }x.freeze
+        }x
 
         # search document for block `lutaml_ea_xmi`
         # or `lutaml_uml_datamodel_description`
@@ -63,16 +63,22 @@ module Metanorma
           end
 
           yaml_config.ea_extension&.each do |ea_extension_path|
-            # resolve paths of ea extensions based on the location of
-            # config yaml file
             ea_extension_full_path = File.expand_path(
               ea_extension_path, File.dirname(yaml_config_path)
             )
-            Xmi::EaRoot.load_extension(ea_extension_full_path)
+            unless Xmi::EaRoot.loaded_extensions.value?(ea_extension_full_path)
+              Xmi::EaRoot.load_extension(ea_extension_full_path)
+            end
           end
 
           guidance = get_guidance(document, yaml_config.guidance)
-          result_document = parse_result_document(full_path, guidance)
+          cache_key = [full_path, guidance]
+
+          @@lutaml_doc_cache ||= {}
+          result_document = @@lutaml_doc_cache[cache_key] ||= parse_result_document(
+            full_path, guidance
+          )
+
           document.attributes["lutaml_xmi_cache"] ||= {}
           document.attributes["lutaml_xmi_cache"][full_path] = result_document
           result_document
@@ -203,8 +209,8 @@ module Metanorma
           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
+            pks.to_h do |package|
+              [package.name, package.xmi_id]
             end
           end
           children_pks = package_flat_packages.call(all_children_packages)
@@ -292,7 +298,7 @@ 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( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
@@ -307,12 +313,12 @@ module Metanorma
 
           if options.packages.nil?
             contexts[context_name]["render_nested_packages"] = true
-            contexts[context_name]["packages"] = root_package["packages"]
+            contexts[context_name]["packages"] = root_package.packages
 
             return contexts
           end
 
-          all_packages = [root_package, *root_package["children_packages"]]
+          all_packages = [root_package, *root_package.children_packages]
           contexts[context_name].merge!(
             {
               "packages" => sort_and_filter_out_packages(all_packages, options),
@@ -330,7 +336,7 @@ module Metanorma
         )
           contexts = {}
           contexts[context_name] = {
-            "name" => root_package["name"],
+            "name" => root_package.name,
             "root_packages" => [root_package],
             "additional_context" => additional_context
               .merge("external_classes" => options.external_classes),
@@ -346,7 +352,7 @@ module Metanorma
           result = {}
           packages = options.packages.reject { |p| p.send(key.to_sym).nil? }
           packages.each do |p|
-            result[p.name] = p.send(key.to_sym).map { |n| [n, true] }.to_h
+            result[p.name] = p.send(key.to_sym).to_h { |n| [n, true] }
           end
           result
         end
@@ -370,7 +376,7 @@ module Metanorma
           options.skip.each do |skip_package|
             entity_regexp = config_entity_regexp(skip_package)
             all_packages.delete_if do |package|
-              package["name"] =~ entity_regexp
+              package.name =~ entity_regexp
             end
           end
 
@@ -381,10 +387,10 @@ module Metanorma
           options.packages.each do |package|
             entity_regexp = config_entity_regexp(package.name)
             all_packages.each do |p|
-              if p["name"]&.match?(entity_regexp)
+              if p.name&.match?(entity_regexp)
                 result.push(p)
                 all_packages.delete_if do |nest_package|
-                  nest_package["name"] == p["name"]
+                  nest_package.name == p.name
                 end
               end
             end
@@ -434,6 +440,149 @@ module Metanorma
             {% 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
+
+        def render_table(context, context_name, parent, attrs) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          table_tmpl = get_template(parent.document, attrs)
+          table_tmpl.assigns[context_name] = context
+
+          if attrs["external_data"]
+            data_array = attrs["external_data"].split(";")
+            data_array.each do |data_item|
+              context_name, external_data_path = data_item.split(":")
+              external_data = content_from_file(
+                parent.document, external_data_path.strip
+              )
+              table_tmpl.assigns[context_name.strip] = external_data
+            end
+          end
+
+          rendered_table = table_tmpl.render
+          block = create_open_block(parent, "", attrs)
+          parse_content(block, rendered_table, attrs)
+        end
+
+        def get_template(document, attrs)
+          template = get_default_template
+          template = attrs["template"] if attrs["template"]
+
+          rel_tmpl_path = Utils.relative_file_path(
+            document, template
+          )
+
+          ::Liquid::Template.parse(File.read(rel_tmpl_path))
+        end
+
+        def get_name_path(attrs)
+          return attrs["path"] if attrs["path"]
+
+          return "#{attrs['package']}::#{attrs['name']}" if attrs["package"]
+
+          attrs["name"]
+        end
+
+        # The class methods `serialize_generalization_by_name` and
+        # `serialize_enumeration_by_name` were removed from
+        # `Lutaml::Xmi::Parsers::Xml` in lutaml 0.10. The replacements below
+        # rebuild the same shape of result by reusing the still-available
+        # path-aware finders on the parser instance and the new
+        # `XmiLookupService`, then bridging to the UML object that the
+        # current `KlassDrop` / `EnumDrop` constructors expect.
+        def serialize_klass_drop_by_name(xmi_path, name, document = nil,
+guidance = nil)
+          parser, uml_doc = build_uml_document(xmi_path, document)
+          raw_klass = find_packaged_klass(parser.xmi_index, name)
+          warn "Class not found for name: #{name}" if raw_klass.nil?
+          klass = raw_klass && find_uml_node_by_xmi_id(
+            uml_doc, raw_klass.id, :classes
+          )
+          ::Lutaml::Xmi::LiquidDrops::KlassDrop.new(
+            klass, guidance, build_drop_options(parser)
+          )
+        end
+
+        def serialize_enum_drop_by_name(xmi_path, name, document = nil)
+          parser, uml_doc = build_uml_document(xmi_path, document)
+          raw_enum = find_packaged_enum(parser.xmi_index, name)
+          warn "Enumeration not found for name: #{name}" if raw_enum.nil?
+          enum = raw_enum && find_uml_node_by_xmi_id(
+            uml_doc, raw_enum.id, :enums
+          )
+          ::Lutaml::Xmi::LiquidDrops::EnumDrop.new(
+            enum, build_drop_options(parser)
+          )
+        end
+
+        def build_uml_document(xmi_path, _document = nil)
+          @@uml_doc_cache ||= {}
+          if @@uml_doc_cache[xmi_path]
+            return @@uml_doc_cache[xmi_path]
+          end
+
+          xmi_model = ::Xmi::Sparx::Root.parse_xml(File.read(xmi_path))
+          parser = ::Lutaml::Xmi::Parsers::Xml.new
+          result = [parser, parser.parse(xmi_model)]
+          @@uml_doc_cache[xmi_path] = result
+          result
+        end
+
+        def build_drop_options(parser)
+          lookup = ::Lutaml::Xmi::XmiLookupService.new(
+            parser.xmi_root_model, parser.id_name_mapping
+          )
+          {
+            xmi_root_model: parser.xmi_root_model,
+            id_name_mapping: parser.id_name_mapping,
+            lookup: lookup,
+            with_gen: true,
+            with_absolute_path: true,
+          }
+        end
+
+        def find_uml_node_by_xmi_id(container, xmi_id, collection)
+          found = container.public_send(collection)
+            .find { |node| node.xmi_id == xmi_id }
+          return found if found
+
+          container.packages.each do |pkg|
+            nested = find_uml_node_by_xmi_id(pkg, xmi_id, collection)
+            return nested if nested
+          end
+          nil
+        end
+
+        def find_packaged_klass(index, path)
+          segments = path.split("::")
+          if segments.one?
+            index.find_packaged_by_name_and_types(
+              path, ["uml:Class", "uml:AssociationClass"]
+            )
+          else
+            find_packaged_klass_by_path(index, segments)
+          end
+        end
+
+        def find_packaged_klass_by_path(index, segments)
+          klass_name = segments.pop
+          klass = index.find_packaged_by_name_and_types(
+            klass_name, ["uml:Class", "uml:AssociationClass"]
+          )
+          return unless klass
+
+          # Verify the path by walking up the parent chain
+          current = klass
+          segments.reverse_each do |pkg_name|
+            parent = index.find_parent(current.id)
+            return unless parent && parent.name == pkg_name
+
+            current = parent
+          end
+          klass
+        end
+
+        def find_packaged_enum(index, name)
+          index.packaged_elements_of_type("uml:Enumeration")
+            .find { |e| e.name == name }
+        end
       end
     end
   end

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

@@ -20,12 +20,12 @@ module Metanorma
         include LutamlEaXmiBase
 
         MACRO_REGEXP =
-          /\[lutaml_ea_xmi,([^,]+),?(.+)?\]/.freeze
+          /\[lutaml_ea_xmi,([^,]+),?(.+)?\]/
 
         private
 
         def parse_result_document(full_path, guidance)
-          ::Lutaml::XMI::Parsers::XML.serialize_xmi_to_liquid(
+          ::Lutaml::Xmi::Parsers::Xml.serialize_xmi_to_liquid(
             File.new(full_path, encoding: "UTF-8"),
             guidance,
           )

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

@@ -6,6 +6,7 @@ module Metanorma
       class LutamlEnumTableBlockMacro <
         ::Asciidoctor::Extensions::BlockMacroProcessor
         include LutamlEaXmiBase
+        include Content
 
         DEFAULT_TEMPLATE = File.join(
           Gem::Specification.find_by_name("metanorma-plugin-lutaml").gem_dir,
@@ -13,59 +14,24 @@ module Metanorma
           "_enum_table.liquid"
         )
 
+        CONTEXT_NAME = "enum"
+
         use_dsl
         named :lutaml_enum_table
 
         def process(parent, target, attrs) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           xmi_path = get_xmi_path(parent, target, attrs)
+          path = get_name_path(attrs)
 
-          if attrs["template"]
-            attrs["template"] = Utils.relative_file_path(
-              parent.document, attrs["template"]
-            )
-          end
-
-          path = if !attrs["path"].nil?
-                   attrs["path"]
-                 elsif !attrs["package"].nil? && !attrs["name"].nil?
-                   "#{attrs['package']}::#{attrs['name']}"
-                 else
-                   attrs["name"]
-                 end
-
-          enum = ::Lutaml::XMI::Parsers::XML.serialize_enumeration_by_name(
-            xmi_path, path
-          )
+          enum = serialize_enum_drop_by_name(xmi_path, path, parent.document)
 
-          render(enum, parent, attrs)
+          render_table(enum, CONTEXT_NAME, parent, attrs)
         end
 
         private
 
-        def render(enum, parent, attrs)
-          rendered_table = render_table(enum, parent, attrs)
-
-          block = create_open_block(parent, "", attrs)
-          parse_content(block, rendered_table, attrs)
-        end
-
-        def render_table(enum, parent, attrs)
-          table_tmpl = get_template(parent.document, attrs)
-          table_tmpl.assigns["enum"] = enum
-          table_tmpl.render
-        end
-
-        def get_template(document, attrs)
-          template = DEFAULT_TEMPLATE
-          if attrs["template"]
-            template = attrs["template"]
-          end
-
-          rel_tmpl_path = Utils.relative_file_path(
-            document, template
-          )
-
-          ::Liquid::Template.parse(File.read(rel_tmpl_path))
+        def get_default_template
+          DEFAULT_TEMPLATE
         end
       end
     end

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

@@ -5,6 +5,7 @@ module Metanorma
     module Lutaml
       class LutamlGmlDictionaryBlock < ::Asciidoctor::Extensions::BlockProcessor
         include LutamlGmlDictionaryBase
+
         use_dsl
         named :lutaml_gml_dictionary
         on_context :open

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

@@ -6,6 +6,7 @@ module Metanorma
       class LutamlKlassTableBlockMacro <
         ::Asciidoctor::Extensions::BlockMacroProcessor
         include LutamlEaXmiBase
+        include Content
 
         DEFAULT_TEMPLATE = File.join(
           Gem::Specification.find_by_name("metanorma-plugin-lutaml").gem_dir,
@@ -13,64 +14,30 @@ module Metanorma
           "_klass_table.liquid"
         )
 
+        CONTEXT_NAME = "klass"
+
         use_dsl
         named :lutaml_klass_table
 
         def process(parent, target, attrs) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           xmi_path = get_xmi_path(parent, target, attrs)
-
-          if attrs["template"]
-            attrs["template"] = Utils.relative_file_path(
-              parent.document, attrs["template"]
-            )
-          end
+          path = get_name_path(attrs)
 
           guidance = nil
           if attrs["guidance"]
             guidance = get_guidance(parent.document, attrs["guidance"])
           end
 
-          path = if !attrs["path"].nil?
-                   attrs["path"]
-                 elsif !attrs["package"].nil? && !attrs["name"].nil?
-                   "#{attrs['package']}::#{attrs['name']}"
-                 else
-                   attrs["name"]
-                 end
+          klass = serialize_klass_drop_by_name(xmi_path, path, parent.document,
+                                               guidance)
 
-          klass = ::Lutaml::XMI::Parsers::XML.serialize_generalization_by_name(
-            xmi_path, path, guidance
-          )
-
-          render(klass, parent, attrs)
+          render_table(klass, CONTEXT_NAME, parent, attrs)
         end
 
         private
 
-        def render(klass, parent, attrs)
-          rendered_table = render_table(klass, parent, attrs)
-
-          block = create_open_block(parent, "", attrs)
-          parse_content(block, rendered_table, attrs)
-        end
-
-        def render_table(klass, parent, attrs)
-          table_tmpl = get_template(parent.document, attrs)
-          table_tmpl.assigns["klass"] = klass
-          table_tmpl.render
-        end
-
-        def get_template(document, attrs)
-          template = DEFAULT_TEMPLATE
-          if attrs["template"]
-            template = attrs["template"]
-          end
-
-          rel_tmpl_path = Utils.relative_file_path(
-            document, template
-          )
-
-          ::Liquid::Template.parse(File.read(rel_tmpl_path))
+        def get_default_template
+          DEFAULT_TEMPLATE
         end
       end
     end

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

@@ -13,6 +13,8 @@ module Metanorma
     module Lutaml
       # Class for processing Lutaml files
       class LutamlPreprocessor < ::Asciidoctor::Extensions::Preprocessor
+        include Utils
+
         REMARKS_ATTRIBUTE = "remarks"
         EXPRESS_PREPROCESSOR_REGEX = %r{
           ^                            # Start of line
@@ -26,7 +28,7 @@ module Metanorma
           (?<context_name>[^,]+)?      # Optional context name
           (?<options>,.*)?             # Optional options
           \]                           # Closing bracket
-        }x.freeze
+        }x
 
         def process(document, reader) # rubocop:disable Metrics/MethodLength
           r = Asciidoctor::PreprocessorNoIfdefsReader.new(document,
@@ -83,8 +85,8 @@ module Metanorma
           index_names = block_header_match[:index_names].split(";").map(&:strip)
           context_name = block_header_match[:context_name].strip
 
-          options = block_header_match[:options] &&
-            parse_options(block_header_match[:options].to_s.strip) || {}
+          options = (block_header_match[:options] &&
+            parse_options(block_header_match[:options].to_s.strip)) || {}
 
           end_mark = input_lines.next
 
@@ -225,7 +227,8 @@ module Metanorma
             .new(include_paths, ["%s.liquid", "_%s.liquid", "_%s.adoc"])
 
           # Parse template once outside the loop
-          template = ::Liquid::Template.parse(lines.join("\n"))
+          template = ::Liquid::Template
+            .parse(lines.join("\n"), environment: create_liquid_environment)
           template.registers[:file_system] = file_system
 
           # Render for each item
@@ -274,8 +277,7 @@ module Metanorma
           options_string
             .to_s
             .scan(/,\s*([^=]+?)=(\s*[^,]+)/)
-            .map { |elem| elem.map(&:strip) }
-            .to_h
+            .to_h { |elem| elem.map(&:strip) }
         end
       end
     end

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

@@ -6,6 +6,7 @@ module Metanorma
       class LutamlTableInlineMacro <
         ::Asciidoctor::Extensions::InlineMacroProcessor
         include LutamlDiagramBase
+
         SUPPORTED_OPTIONS = %w[class enum data_type].freeze
 
         use_dsl

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

@@ -20,12 +20,12 @@ module Metanorma
         include LutamlEaXmiBase
 
         MACRO_REGEXP =
-          /\[lutaml_uml_datamodel_description,([^,]+),?(.+)?\]/.freeze
+          /\[lutaml_uml_datamodel_description,([^,]+),?(.+)?\]/
 
         private
 
         def parse_result_document(full_path, guidance)
-          ::Lutaml::XMI::Parsers::XML.serialize_xmi_to_liquid(
+          ::Lutaml::Xmi::Parsers::Xml.serialize_xmi_to_liquid(
             File.new(full_path, encoding: "UTF-8"),
             guidance,
           )

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

@@ -15,12 +15,12 @@ module Metanorma
       class LutamlXmiUmlPreprocessor < ::Asciidoctor::Extensions::Preprocessor
         include LutamlEaXmiBase
 
-        MACRO_REGEXP = /\[lutaml_xmi_uml,([^,]+),?(.+)?\]/.freeze
+        MACRO_REGEXP = /\[lutaml_xmi_uml,([^,]+),?(.+)?\]/
 
         private
 
         def parse_result_document(full_path, _guidance)
-          ::Lutaml::XMI::Parsers::XML.parse(
+          ::Lutaml::Xmi::Parsers::Xml.parse(
             File.new(full_path, encoding: "UTF-8"),
           )
         end

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

@@ -10,17 +10,17 @@ module Metanorma
 
         # example:
         #   - [[abc]]
-        ANCHOR_REGEX_1 = /^\[\[(?<id>[^\]]*)\]\]\s*$/.freeze
+        ANCHOR_REGEX_1 = /^\[\[(?<id>[^\]]*)\]\]\s*$/
 
         # examples:
         #   - [#abc]
         #   - [source#abc,ruby]
-        ANCHOR_REGEX_2 = /^\[[^#,]*#(?<id>[^,\]]*)[,\]]/.freeze
+        ANCHOR_REGEX_2 = /^\[[^#,]*#(?<id>[^,\]]*)[,\]]/
 
         # examples:
         #   - [id=abc]
         #   - [source,id="abc"]
-        ANCHOR_REGEX_3 = /^\[(?:.+,)?id=['"]?(?<id>[^,\]'"]*)['"]?[,\]]/.freeze
+        ANCHOR_REGEX_3 = /^\[(?:.+,)?id=['"]?(?<id>[^,\]'"]*)['"]?[,\]]/
 
         def initialize(document, input_lines)
           @document = document

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

@@ -14,6 +14,24 @@ module Metanorma
     module Lutaml
       # Helpers for lutaml macros
       module Utils
+        # Prepended to Liquid::Context to preserve the original exception
+        # that Liquid 5.x wraps as InternalError (discarding the cause).
+        module LiquidErrorCapturer
+          def handle_error(e, line_number = nil)
+            if e.is_a?(::Liquid::Error)
+              super
+            else
+              ie = ::Liquid::InternalError.new("internal")
+              ie.set_backtrace(e.backtrace)
+              ie.define_singleton_method(:original_error) { e }
+              ie.template_name ||= template_name
+              ie.line_number ||= line_number
+              errors.push(ie)
+              exception_renderer.call(ie).to_s
+            end
+          end
+        end
+
         LUTAML_EXP_IDX_TAG = %r{
           ^:lutaml-express-index: # Start of the pattern
           (?<index_name>.+?)      # Capture index name
@@ -25,7 +43,7 @@ module Metanorma
             (?<cache_path>.+)     # Capture cache path
           )?                      # End of optional group
           $                       # End of the pattern
-        }x.freeze
+        }x
 
         module_function
 
@@ -42,6 +60,10 @@ module Metanorma
           contexts:, document:,
           template_string: nil, include_path: nil, template_path: nil
         )
+          unless ::Liquid::Context <= LiquidErrorCapturer
+            ::Liquid::Context.prepend(LiquidErrorCapturer)
+          end
+
           # Allow includes for the template
           include_paths = [
             Utils.relative_file_path(document, ""),
@@ -85,16 +107,38 @@ module Metanorma
           result
         end
 
+        @seen_liquid_errors = Set.new
+
         def notify_render_errors(_document, errors)
-          errors.each do |error_obj|
-            ::Metanorma::Util.log(
-              "[metanorma-plugin-lutaml] Liquid render error: " \
-              "#{error_obj.message}",
-              :error,
-            )
+          return if errors.empty?
+
+          grouped = errors.group_by { |e| error_signature(e) }
+          grouped.each do |sig, errs|
+            total = errs.size
+            already_seen = @seen_liquid_errors.include?(sig)
+            @seen_liquid_errors << sig
+            next if already_seen
+
+            err = errs.first
+            backtrace = err.backtrace&.first(3)&.join("\n").to_s
+            count_label = total > 1 ? " (#{total}x)" : ""
+            parts = ["[metanorma-plugin-lutaml] Liquid render error#{count_label}:"]
+            parts << "  #{err.class}: #{err.message}"
+            if err.respond_to?(:original_error) && err.original_error
+              orig = err.original_error
+              parts << "  Caused by: #{orig.class}: #{orig.message}"
+            end
+            parts << backtrace unless backtrace.empty?
+            ::Metanorma::Util.log(parts.join("\n"), :error)
           end
         end
 
+        def error_signature(err)
+          orig = err.respond_to?(:original_error) && err.original_error
+          base = "#{err.class}: #{err.message}"
+          orig ? "#{base} (#{orig.class}: #{orig.message})" : base
+        end
+
         def load_express_repositories( # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           path:, cache_path:, document:, force_read: false
         )
@@ -166,7 +210,7 @@ module Metanorma
 
         # TODO: Refactor this using Suma::SchemaConfig
         def load_express_from_index(_document, path) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          yaml_content = YAML.safe_load(File.read(path))
+          yaml_content = YAML.safe_load_file(path)
           schema_yaml_base_path = Pathname.new(File.dirname(path))
 
           # If there is a global root path set, all subsequent paths are

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

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

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

@@ -8,6 +8,7 @@ module Metanorma
     module Lutaml
       class Yaml2TextPreprocessor < BaseStructuredTextPreprocessor
         include Content
+
         # search document for block `yaml2text`
         #   after that take template from block and read file into this template
         #   example: