metaobjects 0.15.8__tar.gz → 0.15.9__tar.gz

{metaobjects-0.15.8 → metaobjects-0.15.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.15.8
+Version: 0.15.9
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.15.8 → metaobjects-0.15.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.8"
+version = "0.15.9"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.15.8 → metaobjects-0.15.9}/src/metaobjects/codegen/generators/render_helper_generator.py

@@ -26,10 +26,10 @@ build fail when a mustache references a field the payload VO doesn't declare.
 Reuse, not reimplementation: ``render`` (the emitted runtime call), ``verify`` (the
 build-time gate), ``FilesystemProvider`` (build-time ref resolution), and
 ``EmailDocument`` (email return type). The payload field tree is walked from the VO
-the same way the other generators walk it — but a nested ``field.object``'s
-``@objectRef`` is resolved by BARE short-name (cross-port render-helper consensus:
-TS ``findObject`` / Java ``resolveNestedObjectRef`` / C# ``ResolveNestedObjectRef``),
-only recursing into ``object.value`` targets, cycle-guarded.
+the same way the other generators walk it — a nested ``field.object``'s ``@objectRef``
+is resolved FQN-exact when fully-qualified (ADR-0041) else by short name (cross-port
+render-helper consensus: TS ``refMatchesObject`` / Java+Kotlin ``resolveNestedObjectRef``
+/ C# ``ResolveNestedObjectRef``), only recursing into ``object.value`` targets, cycle-guarded.
 
 Python divergence vs TS / Java / C#: Python's ``RenderRequest`` has NO ``verify``
 field — the Python render engine does not run a runtime drift pass — so the emitted
@@ -75,19 +75,24 @@ def _py_str(s: str) -> str:
 
 
 # ---------------------------------------------------------------------------
-# Payload field-tree walk — nested @objectRef resolved by BARE short-name
-# (cross-port render-helper consensus). Object-ref fields recurse into their
-# target object.value (SUBTYPE_VALUE only); a `seen` set guards reference cycles.
+# Payload field-tree walk — nested @objectRef resolved FQN-exact (ADR-0041).
+# Object-ref fields recurse into their target object.value (SUBTYPE_VALUE only);
+# a `seen` set guards reference cycles.
 # ---------------------------------------------------------------------------
 
 
 def _resolve_nested_object_ref(root: MetaData, reference: str) -> MetaObject | None:
-    """Resolve a ``field.object``'s ``@objectRef`` to its target ``object.value`` by BARE
-    short-name — mirroring the C# ``ResolveNestedObjectRef`` / TS ``findObject`` / Java
-    ``resolveNestedObjectRef``. If the ref carries a package, only the segment after the
-    last ``::`` is compared, against each ``object.value``'s own short name."""
+    """Resolve a ``field.object``'s ``@objectRef`` to its target ``object.value``.
+
+    ADR-0041: a FULLY-QUALIFIED ref (contains ``::``) resolves EXACTLY on the
+    package-qualified name (``resolution_key()``/``fqn()``) — never a bare-tail
+    fallback that would bind a same-named ``object.value`` in the WRONG package on a
+    cross-package short-name collision. A bare ref still matches by short name
+    (first-wins). Mirrors the Java/Kotlin ``resolveNestedObjectRef`` + TS
+    ``refMatchesObject``."""
     if not reference:
         return None
+    fqn = PACKAGE_SEP in reference
     ref_short = reference.rsplit(PACKAGE_SEP, 1)[-1]
     # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
     for child in root.own_children():
@@ -95,7 +100,10 @@ def _resolve_nested_object_ref(root: MetaData, reference: str) -> MetaObject | N
             continue
         if child.sub_type != OBJECT_SUBTYPE_VALUE:
             continue
-        if child.name.rsplit(PACKAGE_SEP, 1)[-1] == ref_short:
+        if fqn:
+            if child.resolution_key() == reference or child.fqn() == reference:
+                return child
+        elif child.name.rsplit(PACKAGE_SEP, 1)[-1] == ref_short:
             return child
     return None
 
@@ -107,9 +115,9 @@ def _derive_payload_field_tree(
     resolvable ``@objectRef`` to an ``object.value`` becomes a context-pushing node whose
     children are the target VO's tree (recursed, cycle-guarded). Every other field is a
     leaf."""
-    if vo is None or vo.name in seen:
+    if vo is None or vo.resolution_key() in seen:
         return []
-    next_seen = seen | {vo.name}
+    next_seen = seen | {vo.resolution_key()}
     fields: list[PayloadField] = []
     for f in vo.children():
         if f.type != TYPE_FIELD or not isinstance(f, MetaField):

{metaobjects-0.15.8 → metaobjects-0.15.9}/tests/codegen/test_render_helper_conformance.py

@@ -27,7 +27,7 @@ from pathlib import Path
 import pytest
 
 import metaobjects.core_types  # noqa: F401  — side-effect: registers attr classes
-from metaobjects import MetaDataLoader
+from metaobjects import InMemoryStringSource, MetaDataLoader
 from metaobjects.codegen.config import GenConfig
 from metaobjects.codegen.generator import GenContext
 from metaobjects.codegen.generators.render_helper_generator import RenderHelperGenerator
@@ -45,6 +45,15 @@ def _load_root(meta_json: Path):
     return res.root
 
 
+def _load_root_from_files(*meta_jsons: Path):
+    # Multi-file (multi-package) load — one InMemoryStringSource per file, merged into a
+    # single root (mirrors fixtures/conformance/loader-same-name-distinct-packages).
+    sources = [InMemoryStringSource(p.read_text()) for p in meta_jsons]
+    res = MetaDataLoader().load(sources)
+    assert res.errors == [], res.errors
+    return res.root
+
+
 def _ctx(root) -> GenContext:
     return GenContext(
         entities=[],
@@ -156,6 +165,35 @@ def test_email_order_email_renders_nested_array_loop_and_partial(tmp_path) -> No
     assert "<hr/>Sent by Acme" in doc.html_body
 
 
+# ---------------------------------------------------------------------------
+# xpkg-collision/ — cross-package short-name collision (ADR-0041). Two packages
+# each declare an object.value `Note` (alpha: alphaText, beta: betaText); the
+# payload `Digest` references BOTH by FULLY-QUALIFIED @objectRef. A bare-tail
+# resolver binds both refs to whichever Note loads first → one field lands on the
+# wrong element type → the drift gate raises. FQN-exact resolution renders both.
+# ---------------------------------------------------------------------------
+
+
+def test_document_digest_doc_resolves_fqn_nested_object_ref_across_collision(tmp_path) -> None:
+    dir_root = CORPUS / "xpkg-collision"
+    root = _load_root_from_files(
+        dir_root / "meta.alpha.json",
+        dir_root / "meta.beta.json",
+        dir_root / "meta.app.json",
+    )
+    templates = str(CORPUS / "templates")
+    # Must NOT raise: the FQN refs resolve to their own package's Note.
+    files = [f for f in RenderHelperGenerator(templates).generate(_ctx(root))
+             if f.path == "digest_doc_render_helper.py"]
+    assert len(files) == 1
+    _materialize_and_import(files, tmp_path)
+    helper = import_module("_rh_conf_pkg.digest_doc_render_helper")
+
+    payload = {"fromAlpha": {"alphaText": "AA"}, "fromBeta": {"betaText": "BB"}}
+    out = helper.render_digest_doc(payload, FilesystemProvider(templates))
+    assert out == "Alpha=AA Beta=BB"
+
+
 # ---------------------------------------------------------------------------
 # drift/ → codegen FAILS (ValueError) with ERR_VAR_NOT_ON_PAYLOAD.
 # ---------------------------------------------------------------------------