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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d08e2206e64a9c020c1059501939d9a44cfa5e0412368b84e9702442ed38e5ca
-  data.tar.gz: 3d1bc9fbb60c1a750ab70d2ffcd98e61257e4a7d21f44886cb485456b56af81c
+  metadata.gz: 608d678b19ef1c180dc4e244f98d329a8452d9c875469978b6d84247894c09d5
+  data.tar.gz: 64269c82a46666d5b50df626671d985917c6acb845708a8d527b6070a2da9e1e
 SHA512:
-  metadata.gz: 8777cde7a2a1379e9cabb417192d3bc026786cb04739e10578c2eede1764bdffe2b113be22837f376957c7ba6525ba831fd78192c1c381fc5c70a0ec0151d661
-  data.tar.gz: 6ac5da62726d19874eceeb0c39710ad034e890e78402f41f516d1f00b5954aed441b9176ec403c97cd228d7537e6e8e3cd710495e2bee3c2927ae598d39d84a1
+  metadata.gz: 9078948b7bd2f32a925871da5b6f51f54d6613a660c20dff4e0c19d1f72c77814f5877f02700926eb031b33dae6de3aae7bc09668a65581f8d9287db0d29a9ad
+  data.tar.gz: 10fa46ed3a240a00777df9f10621b1cdb5e5e35646958bf9b94b830ebacd8ca8b520dd367dcab4d9019a7042a19ec57270e8cea5d9cb63212ec957fdf0f8d6bf

data/Gemfile

@@ -37,9 +37,6 @@ gem "leptris", "~> 1.9.361.1"
 gem "isodoc", github: "metanorma/isodoc", branch: "main"
 gem "metanorma-standoc", github: "metanorma/metanorma-standoc", branch: "main"
 gem "suma", github: "metanorma/suma", branch: "main"
-# standoc main's block_attributes reference
-# Metanorma::Document::Components::AncillaryBlocks::SvgmapElement, which
-# the released metanorma-document 0.5.1 predates; ref-pinned to the
-# document main tree the suite is green against
-gem "metanorma-document", github: "metanorma/metanorma-document",
-                          ref: "ca4eb4b26f7ab0d2994a4710d0cf158607a832b4"
+# standoc main (>= 3.5.1.pre.alpha.2) floors metanorma-document at
+# 0.5.2.pre.alpha.1 (SvgmapElement, metanorma-standoc#1303); main carries it
+gem "metanorma-document", github: "metanorma/metanorma-document", branch: "main"

data/Rakefile

@@ -10,6 +10,7 @@ XMI_HEAVY_SPEC_FILES = %w[
 ].freeze
 
 XMI_SPEC_FILES = %w[
+  spec/metanorma/plugin/lutaml/lutaml_ea_uml_preprocessor_spec.rb
   spec/metanorma/plugin/lutaml/lutaml_klass_table_block_macro_spec.rb
   spec/metanorma/plugin/lutaml/lutaml_enum_table_block_macro_spec.rb
   spec/metanorma/plugin/lutaml/lutaml_xmi_index_spec.rb

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "expressir"
+require "pathname"
 
 module Metanorma
   module Plugin
@@ -16,7 +17,17 @@ module Metanorma
           )
           resolved = document.path_resolver
             .system_path(file_path, docfile_directory)
-          File.expand_path(resolved, docfile_directory)
+          # The prefix lands inside emitted image macros, so it must not
+          # carry the absolute build path: two builds of the same tree in
+          # two directories produced different image/@src values
+          # (metanorma/metanorma-plugin-lutaml#325). A path relative to the
+          # docfile resolves to the same schema file at render time and is
+          # byte-identical across build directories.
+          # The docfile directory may be relative ("."): relative_path_from
+          # refuses mixed prefixes, so both sides expand first
+          Pathname.new(File.expand_path(resolved))
+            .relative_path_from(Pathname.new(File.expand_path(docfile_directory)))
+            .to_s
         end
 
         def self.for(model)
@@ -47,6 +58,7 @@ module Metanorma
           end
 
           def decorate_remarks(options)
+            promote_schema_prose
             decorate_own_remarks(options)
             decorate_child_remark_items(options)
             traverse_children(options)
@@ -54,7 +66,29 @@ module Metanorma
 
           private
 
+          # A bare (*"Schema_name" ...*) remark is the schema-level prose:
+          # expressir models it in Schema#remarks, not as a RemarkItem, so
+          # renders that walk remark_items (every clause-4 template) drop
+          # it (iso-10303#720). Promote it to a leading RemarkItem keyed
+          # by the schema path, the same way an entity-tagged remark names
+          # its target. The prose stays in Schema#remarks too; templates
+          # that already render it there keep working unchanged.
+          def promote_schema_prose
+            return unless @model.is_a?(Expressir::Model::Declarations::Schema)
+            return if @model.remarks.to_a.empty?
+
+            items = @model.remark_items.to_a
+            return if items.any? { |ri| ri.id == @model.id }
+
+            prose = Expressir::Model::Declarations::RemarkItem.new(
+              id: @model.id,
+              remarks: @model.remarks.dup,
+            )
+            @model.remark_items = [prose] + items
+          end
+
           def decorate_own_remarks(options)
+
             @model.remarks = ExpressRemarksDecorator.decorate_array(
               @model.remarks, options
             )

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.1".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.1
+  version: 0.7.55
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-22 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