metanorma-plugin-lutaml 0.7.55.pre.alpha.2 → 0.7.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4df1a140d2fef0dd3a780ac070ab6f6a3906191da12c6d72b30883ad0217bf25
-  data.tar.gz: ad4569a0ce6ae86577978e7358de9e98c1955227755efa699a7182aca38ab428
+  metadata.gz: 608d678b19ef1c180dc4e244f98d329a8452d9c875469978b6d84247894c09d5
+  data.tar.gz: 64269c82a46666d5b50df626671d985917c6acb845708a8d527b6070a2da9e1e
 SHA512:
-  metadata.gz: 31f6b4b4a670f661412cedc5cdb5538b074054f6618a35e06bfa15080af2dedba5075b237f163e4ba63e8ab99d95b92dc1ed8b99c35111a8abf588616fa62c37
-  data.tar.gz: 3edd282734af0e5b2d3f6e74daa6e5b9a310e51b022baca413ab00aac448a186a76d22ffb8e5924bacdf0c9c4aaf08b50ce877e2f63a22f83c3d536b68219258
+  metadata.gz: 9078948b7bd2f32a925871da5b6f51f54d6613a660c20dff4e0c19d1f72c77814f5877f02700926eb031b33dae6de3aae7bc09668a65581f8d9287db0d29a9ad
+  data.tar.gz: 10fa46ed3a240a00777df9f10621b1cdb5e5e35646958bf9b94b830ebacd8ca8b520dd367dcab4d9019a7042a19ec57270e8cea5d9cb63212ec957fdf0f8d6bf

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

@@ -18,6 +18,10 @@ module Metanorma
       #
       #   [lutaml_data,<definitions.lml>,<context>]
       #
+      # Options can be supplied as a JSON object:
+      #
+      #   [lutaml_data,models.lml,store,options={"include_path":"templates"}]
+      #
       class LutamlDataPreprocessor < BasePreprocessor
         DATA_FILE_EXTENSIONS = %w[.lml .yaml .yml .json].freeze
         DEFAULT_CONTEXT_NAME = "lutaml_data"
@@ -53,7 +57,7 @@ module Metanorma
           return [line] unless block_header_match
 
           definition_file, instance_file, context_name, options =
-            parse_header(block_header_match)
+            parse_header_logged(block_header_match)
 
           end_mark = input_lines.next
           lines = extract_block_lines(input_lines, end_mark)
@@ -68,10 +72,16 @@ module Metanorma
           )
         end
 
+        def parse_header_logged(match)
+          parse_header(match)
+        rescue StandardError => e
+          log_block_failure(e)
+          raise e
+        end
+
         def parse_header(match)
           definition_file = match[:definition_file].strip
-          segments = match[:rest].split(",").map(&:strip)
-          options, segments = split_options(segments)
+          options, segments = split_options(match[:rest])
 
           data_segments, name_segments = segments
             .reject(&:empty?).partition { |segment| data_file?(segment) }
@@ -80,7 +90,18 @@ module Metanorma
            name_segments.last || DEFAULT_CONTEXT_NAME, options]
         end
 
-        def split_options(segments)
+        def split_options(rest)
+          object_options = rest.match(/,\s*options=(\{.*\})\s*,?\s*\z/)
+          if object_options
+            require "json"
+            return [JSON.parse(object_options[1]),
+                    rest[0...object_options.begin(0)].split(",").map(&:strip)]
+          end
+
+          split_inline_options(rest.split(",").map(&:strip))
+        end
+
+        def split_inline_options(segments)
           options_start = segments.index { |segment| segment.include?("=") }
           return [{}, segments] unless options_start
 
@@ -105,12 +126,16 @@ module Metanorma
 
           [render_liquid(lines, document, options, context_name, instances)]
         rescue StandardError => e
+          log_block_failure(e)
+          raise e
+        end
+
+        def log_block_failure(error)
           ::Metanorma::Util.log(
             "[#{self.class.name}] Failed to parse LutaML data block: " \
-            "#{e.message}",
+            "#{error.message}",
             :error,
           )
-          raise e
         end
 
         def render_liquid(lines, document, options, context_name, instances)
@@ -126,7 +151,7 @@ module Metanorma
           case value
           when Hash
             value.transform_keys(&:to_s)
-                 .transform_values { |v| deep_stringify(v) }
+              .transform_values { |v| deep_stringify(v) }
           when Array
             value.map { |v| deep_stringify(v) }
           else

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

@@ -1,7 +1,7 @@
 module Metanorma
   module Plugin
     module Lutaml
-      VERSION = "0.7.55.pre.alpha.2".freeze
+      VERSION = "0.7.55".freeze
     end
   end
 end

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

@@ -4,12 +4,16 @@ module Metanorma
   module Plugin
     module Lutaml
       module XmiContextBuilder
+        MODEL_COLLECTIONS = %i[classes data_types].freeze
+
         def create_context_object( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           lutaml_document, additional_context, options,
           context_name = "context"
         )
-          root_package = package_level(lutaml_document.to_liquid,
-                                       options.package_root_level || 1)
+          root_context = lutaml_document.to_liquid
+          root_package = package_level(
+            root_context, options.package_root_level || 1
+          )
           contexts = create_default_context_object(
             context_name, root_package, additional_context, options
           )
@@ -17,6 +21,7 @@ module Metanorma
           if options.packages.nil?
             contexts[context_name]["render_nested_packages"] = true
             contexts[context_name]["packages"] = root_package.packages
+            add_model_anchor_context(contexts[context_name], root_context)
 
             return contexts
           end
@@ -30,6 +35,7 @@ module Metanorma
               "render_nested_packages" => !!options.render_nested_packages,
             },
           )
+          add_model_anchor_context(contexts[context_name], root_context)
 
           contexts
         end
@@ -42,13 +48,27 @@ module Metanorma
             "name" => root_package.name,
             "root_packages" => [root_package],
             "additional_context" => additional_context
-              .merge("external_classes" => options.external_classes),
+              .merge(
+                "external_classes" => external_model_targets(
+                  options.external_classes,
+                ),
+              ),
             "skip_unrecognized_connector" => !!options
               .skip_unrecognized_connector,
           }
           contexts
         end
 
+        def external_model_targets(external_classes)
+          external_classes&.transform_values do |target|
+            if target.is_a?(String) && target.match?(/\Asection-[^\s#]+\z/)
+              "##{target}"
+            else
+              target
+            end
+          end
+        end
+
         def fill_in_entities_refs_attributes(document, # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
           lutaml_document, _options)
           all_children_packages = lutaml_document.packages
@@ -94,6 +114,96 @@ module Metanorma
             .call(lutaml_document.packages)
             .merge(children_pks_diags)
         end
+
+        def add_model_anchor_context(context, root_package)
+          packages = model_packages(root_package)
+          context["additional_context"]["model_anchors"] =
+            model_reference_targets(packages)
+              .merge(model_anchors(packages))
+              .merge(model_stub_anchors(root_package))
+        end
+
+        # Ids the XMI templates link to (attribute types, association ends),
+        # including ones the XMI never defines. Unnamed; anchors override.
+        def model_reference_targets(packages)
+          model_entities(packages).each_with_object({}) do |entity, targets|
+            Array(entity_list(entity, :attributes)).each do |attribute|
+              add_model_anchor(targets, object_xmi_id(attribute), nil)
+            end
+            Array(entity_list(entity, :associations)).each do |association|
+              add_model_anchor(targets, association_target(association), nil)
+            end
+          end
+        end
+
+        def model_entities(packages)
+          packages.flat_map do |package|
+            MODEL_COLLECTIONS.flat_map do |collection|
+              Array(entity_list(package, collection))
+            end
+          end
+        end
+
+        def entity_list(object, collection)
+          object.public_send(collection) if object.respond_to?(collection)
+        end
+
+        def association_target(association)
+          return unless association.respond_to?(:member_end_xmi_id)
+
+          association.member_end_xmi_id
+        end
+
+        def model_packages(root_package)
+          packages_tree(root_package)
+            .compact
+            .uniq { |package| package_key(package) }
+        end
+
+        def packages_tree(package)
+          [package, *child_packages(package).flat_map do |child|
+            packages_tree(child)
+          end]
+        end
+
+        def child_packages(package)
+          Array(package.packages).compact.uniq { |child| package_key(child) }
+        end
+
+        def package_key(package)
+          xmi_id = package.xmi_id if package.respond_to?(:xmi_id)
+          xmi_id || package.name
+        end
+
+        def model_anchors(packages)
+          collections = %w[classes enums data_types]
+          packages.each_with_object({}) do |package, anchors|
+            add_model_anchor(anchors, object_xmi_id(package), package.name)
+            collections.each do |collection|
+              next unless package.respond_to?(collection)
+
+              Array(package.public_send(collection)).each do |entity|
+                add_model_anchor(anchors, object_xmi_id(entity), entity.name)
+              end
+            end
+          end
+        end
+
+        def object_xmi_id(object)
+          object.xmi_id if object.respond_to?(:xmi_id)
+        end
+
+        def add_model_anchor(anchors, xmi_id, name)
+          anchors[xmi_id] = name if xmi_id.is_a?(String) && !xmi_id.empty?
+        end
+
+        def model_stub_anchors(root_package)
+          xmi_root_model = root_package.instance_variable_get(:@xmi_root_model)
+          Array(xmi_root_model&.extension&.ea_stub)
+            .each_with_object({}) do |stub, anchors|
+              add_model_anchor(anchors, stub.id, stub.name)
+            end
+        end
       end
     end
   end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "asciidoctor"
+require "asciidoctor/extensions"
+
+module Metanorma
+  module Plugin
+    module Lutaml
+      # Resolve model links after every macro has generated its actual anchors.
+      class XmiModelReference < ::Asciidoctor::Extensions::InlineMacroProcessor
+        use_dsl
+        named :lutaml_model_reference
+        parse_content_as :text
+        match(/(?<!\\)&lt;&lt;section-
+          (?<target>(?:(?!&gt;&gt;)[^,\s])+?)
+          (?:,(?<content>.*?))?&gt;&gt;/x)
+
+        INVENTORY_ATTRIBUTE = "lutaml_model_anchors"
+
+        def self.root_document(document)
+          document = document.parent_document while document.parent_document
+          document
+        end
+
+        def self.register(document, anchors)
+          document = root_document(document)
+          unless document.attributes.key?(INVENTORY_ATTRIBUTE)
+            document.attributes[INVENTORY_ATTRIBUTE] = {}
+            document.extensions.inline_macro self
+          end
+          document.attributes[INVENTORY_ATTRIBUTE]
+            .merge!(anchors) { |_, old, new| new || old }
+        end
+
+        def process(parent, target, attrs)
+          document = self.class.root_document(parent.document)
+          inventory = document.attributes.fetch(INVENTORY_ATTRIBUTE, {})
+          name = inventory[target]
+          text = reference_text(parent, attrs["text"], target, name)
+          value = if inventory.key?(target) && !anchored?(document, target)
+                    plain_text(parent, text, target)
+                  else
+                    label = text ? ",#{text}" : ""
+                    "&lt;&lt;section-#{target}#{label}&gt;&gt;"
+                  end
+          create_inline(parent, :quoted, value, type: :unquoted)
+        end
+
+        private
+
+        def anchored?(document, target)
+          document.catalog[:refs].key?("section-#{target}")
+        end
+
+        def plain_text(parent, text, target)
+          text.to_s.strip.empty? ? parent.sub_specialchars(target) : text
+        end
+
+        def reference_text(parent, text, target, name)
+          return text unless name && (text.to_s.strip.empty? || text == target)
+
+          parent.sub_specialchars(name)
+        end
+      end
+    end
+  end
+end

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

@@ -21,20 +21,26 @@ module Metanorma
         }.freeze
         RENDER_STYLE_ATTRIBUTE = "render_style"
 
-        def model_representation(lutaml_doc, document, add_context, options) # rubocop:disable Metrics/MethodLength
+        def model_representation( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          lutaml_doc, document, add_context, options
+        )
           fill_in_entities_refs_attributes(document, lutaml_doc, options)
+          contexts = create_context_object(lutaml_doc, add_context, options,
+                                           "context")
           render_result, errors = Utils.render_liquid_string(
             template_string: template(options.section_depth || 2,
                                       options.render_style,
                                       options.include_root),
-            contexts: create_context_object(lutaml_doc,
-                                            add_context,
-                                            options,
-                                            "context"),
+            contexts: contexts,
             document: document,
             include_path: template_path(document, options.template_path),
           )
           Utils.notify_render_errors(document, errors)
+          additional_context = contexts.fetch("context")
+            .fetch("additional_context", {})
+          XmiModelReference.register(
+            document, additional_context["model_anchors"] || {}
+          )
           render_result.split("\n")
         end
 

data/lib/metanorma/plugin/lutaml.rb

@@ -7,6 +7,7 @@ module Metanorma
       autoload :XmiCache, "metanorma/plugin/lutaml/xmi_cache"
       autoload :XmiConfig, "metanorma/plugin/lutaml/xmi_config"
       autoload :XmiContextBuilder, "metanorma/plugin/lutaml/xmi_context_builder"
+      autoload :XmiModelReference, "metanorma/plugin/lutaml/xmi_model_reference"
       autoload :XmiPackageFilter, "metanorma/plugin/lutaml/xmi_package_filter"
       autoload :XmiRenderer, "metanorma/plugin/lutaml/xmi_renderer"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-plugin-lutaml
 version: !ruby/object:Gem::Version
-  version: 0.7.55.pre.alpha.2
+  version: 0.7.55
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-27 00:00:00.000000000 Z
+date: 2026-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -263,6 +263,7 @@ files:
 - lib/metanorma/plugin/lutaml/xmi_cache.rb
 - lib/metanorma/plugin/lutaml/xmi_config.rb
 - lib/metanorma/plugin/lutaml/xmi_context_builder.rb
+- lib/metanorma/plugin/lutaml/xmi_model_reference.rb
 - lib/metanorma/plugin/lutaml/xmi_package_filter.rb
 - lib/metanorma/plugin/lutaml/xmi_parse_cache.rb
 - lib/metanorma/plugin/lutaml/xmi_partial_load_registry.rb