metaobjects 0.23.0__tar.gz → 0.23.1__tar.gz

{metaobjects-0.23.0 → metaobjects-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 0.23.0
+Version: 0.23.1
 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.23.0 → metaobjects-0.23.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.23.0"
+version = "0.23.1"
 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.23.0 → metaobjects-0.23.1}/src/metaobjects/codegen/generators/fr019_shared_enum.py

@@ -66,12 +66,21 @@ def resolve_shared_enum_decl(field: MetaField) -> MetaData | None:
 
 
 def is_provided(decl: MetaData) -> bool:
-    """Effective ``@provided`` truth of an enum declaration.
-
-    ADR-0039 — resolves through ``extends`` (``get_meta_attr``): a concrete enum
-    extending an abstract ``@provided`` enum inherits the flag, so an own-only read
-    would misclassify it."""
-    return decl.get_meta_attr(fc.FIELD_ATTR_PROVIDED) is True
+    """``@provided`` truth of an enum DECLARATION.
+
+    ADR-0039 sanctioned own (Python naming inversion: ``attr()`` is the OWN read,
+    ``get_meta_attr()`` resolves). ``@provided`` is a declaration-layer provenance
+    marker — "THIS type is supplied by hand-written/third-party code", like
+    ``is_abstract`` — and does not flow down an ``extends`` chain.
+
+    This is only ever called on the resolved declaration (see
+    ``shared_enum_for_field``), never on the consuming field, so own and resolving
+    agree for a plain ``field extends @provided decl``. They diverge on a CHAINED
+    declaration (root abstract ``B extends`` root abstract ``@provided A``): a
+    resolving read reports B provided and emits a reference to a hand-written ``B``
+    the adopter never declared, instead of materializing B. Matches the JVM ports.
+    """
+    return decl.attr(fc.FIELD_ATTR_PROVIDED) is True
 
 
 def _meta_package_of(decl: MetaData) -> str:

{metaobjects-0.23.0 → metaobjects-0.23.1}/src/metaobjects/meta/core/requirement/meta_requirement.py

@@ -54,7 +54,8 @@ class MetaRequirement(MetaData):
         return [str(x) for x in v] if isinstance(v, list) else []
 
     def verified_by(self) -> list[str]:
-        """ADR-0039: resolving. Names of the tests proving the behaviour."""
+        """ADR-0039: resolving. Names of tests that ASSERT the behaviour — existence
+        evidence only; verify cannot tell whether a named test verifies this."""
         v = self.get_meta_attr(REQUIREMENT_ATTR_VERIFIED_BY)
         return [str(x) for x in v] if isinstance(v, list) else []
 

metaobjects-0.23.1/src/metaobjects/render/payload_accessors.py

@@ -0,0 +1,134 @@
+"""Derived boolean accessors — ``{{#hasFoo}}`` over a payload field ``foo``.
+
+A prompt needs conditional sections ("include the abilities block only when there ARE
+abilities"), and the payload contract answers that with a DERIVED accessor rather than an
+authored boolean field: the author declares ``abilities`` and ``hasAbilities`` follows
+from it. Declaring both would let them disagree.
+
+THE RULE IS SHARED ACROSS PORTS ON PURPOSE. The JVM has carried it since 7.7.7
+(``com.metaobjects.render.PayloadAccessors``, emitted onto every generated payload record
+and accepted by its ``Verify``), and its comment says the emitter and the verifier share
+one rule so they "can never drift apart". Python had neither half, so the same template
+verified clean on the JVM and reported drift here — and rendered WRONG rather than
+failing, silently dropping the section. Gated cross-port by the
+``render-derived-has-accessor`` conformance case.
+"""
+
+from __future__ import annotations
+
+import numbers
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+__all__ = [
+    "HAS_PREFIX",
+    "has_accessor_name",
+    "capitalize",
+    "accessor_value",
+    "with_derived_accessors",
+    "is_boolean_accessor",
+]
+
+#: The ``has`` prefix every derived boolean accessor carries.
+HAS_PREFIX = "has"
+
+_MAX_DEPTH = 32
+
+
+def capitalize(s: str) -> str:
+    """Capitalize the first character, leaving an already-uppercase one untouched.
+
+    Deliberately NOT ``str.capitalize()``, which also lowercases the remainder.
+    """
+    if not s:
+        return s
+    if s[0].isupper():
+        return s
+    return s[0].upper() + s[1:]
+
+
+def has_accessor_name(field_name: str) -> str:
+    """``"has" + capitalize(name)`` (``abilities`` → ``hasAbilities``).
+
+    Byte-identical to the JVM's ``PayloadAccessors.hasAccessorName``.
+    """
+    return HAS_PREFIX + capitalize(field_name)
+
+
+def accessor_value(value: Any) -> bool | None:
+    """Is ``value`` "present" for the purposes of ``has<Field>``?
+
+    Mirrors the JVM emitter's per-type bodies exactly: string → non-null and non-blank;
+    collection → non-null and non-empty; reference → non-null.
+
+    Returns ``None`` for numbers and booleans, which the JVM deliberately emits NO
+    accessor for — they are always-present scalars, and ``{{#hasCount}}`` over an int is
+    drift rather than a conditional. Returning ``None`` (rather than ``False``) keeps that
+    distinction: nothing is injected, so the name stays unresolved exactly as it is on a
+    generated record with no such method.
+    """
+    if value is None:
+        return False
+    if isinstance(value, str):
+        return bool(value.strip())
+    # bool before int — bool IS an int in Python, and a boolean field gets no accessor.
+    if isinstance(value, numbers.Number):
+        return None
+    if isinstance(value, Mapping):
+        return True
+    if isinstance(value, (Sequence, set, frozenset)):
+        return len(value) > 0
+    return True
+
+
+def with_derived_accessors(payload: Any, depth: int = 0) -> Any:
+    """A view over ``payload`` carrying its derived ``has<Field>`` accessors, recursively.
+
+    NON-MUTATING — the caller's payload is never touched, because a render must not be
+    able to change the object it was handed. An AUTHORED key always wins: if a payload
+    genuinely carries ``hasFoo``, that value is kept rather than shadowed.
+
+    Recursion follows Mustache's own scoping: every nested mapping and every sequence
+    ELEMENT becomes a context in its own right, so a section over ``abilities`` sees the
+    accessors of the ability it is currently iterating.
+    """
+    if depth > _MAX_DEPTH:
+        return payload  # pathological graph; render is not a validator
+    if isinstance(payload, Mapping):
+        out: dict[str, Any] = {
+            k: with_derived_accessors(v, depth + 1) for k, v in payload.items()
+        }
+        for k, v in payload.items():
+            if not isinstance(k, str):
+                continue
+            name = has_accessor_name(k)
+            if name in payload:  # authored wins
+                continue
+            derived = accessor_value(v)
+            if derived is not None:
+                out[name] = derived
+        return out
+    if isinstance(payload, (str, bytes)):
+        return payload
+    if isinstance(payload, Sequence):
+        return [with_derived_accessors(v, depth + 1) for v in payload]
+    return payload
+
+
+def is_boolean_accessor(stack: list[list[Any]], name: str) -> bool:
+    """True when ``name`` is a derived accessor over a field reachable on ``stack``.
+
+    Mirrors the JVM's ``Verify.isBooleanAccessor``, including its deliberate
+    permissiveness: acceptance keys off the FIELD EXISTING, not off its type. Accessors
+    are simple (undotted) names; a dotted path is never an accessor.
+    """
+    if "." in name:
+        return False
+    if not name.startswith(HAS_PREFIX):
+        return False
+    # Mustache outward walk (innermost → outermost).
+    for frame in reversed(stack):
+        for f in frame:
+            if name == has_accessor_name(f.name):
+                return True
+    return False

{metaobjects-0.23.0 → metaobjects-0.23.1}/src/metaobjects/render/renderer.py

@@ -23,6 +23,7 @@ from dataclasses import dataclass, field
 from typing import Any
 
 from . import escapers
+from .payload_accessors import with_derived_accessors
 from .verify import InMemoryProvider, Provider
 
 MAX_DEPTH = 32
@@ -59,7 +60,10 @@ def render(req: RenderRequest) -> str:
     _validate(req)
     body = req.template if req.template is not None else _resolve_or_raise(req.provider, req.ref)
     expanded = _pre_expand_partials(body, req.provider, [])
-    out = _interpret(expanded, req.payload, req.format)
+    # Derived `has<Field>` accessors are part of the payload contract, not of the
+    # caller's object — see payload_accessors. Injected here so a `{{#hasFoo}}` section
+    # resolves the same way it does against a generated JVM payload record.
+    out = _interpret(expanded, with_derived_accessors(req.payload), req.format)
     # @maxChars is a fail-closed render budget: over-budget output RAISES (never
     # silently truncates). Canonical cross-port behavior — message shape matches
     # TS/C#/Java: "render exceeded maxChars budget: <len> > <cap>".

{metaobjects-0.23.0 → metaobjects-0.23.1}/src/metaobjects/render/verify.py

@@ -23,6 +23,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Protocol
 
+from .payload_accessors import is_boolean_accessor
+
 #: A ``{{var}}`` references a field the (contextual) payload does not declare.
 ERR_VAR_NOT_ON_PAYLOAD = "ERR_VAR_NOT_ON_PAYLOAD"
 #: A ``{{> ref}}`` partial does not resolve in the provider.
@@ -215,7 +217,9 @@ def verify(
                     continue  # implicit iterator — always valid
                 if at_root:
                     referenced_at_root.add(tok.value.split(".")[0])
-                if _resolve(stack, tok.value) is None:
+                if _resolve(stack, tok.value) is None and not is_boolean_accessor(
+                    stack, tok.value
+                ):
                     errors.append(VerifyError(ERR_VAR_NOT_ON_PAYLOAD, tok.value))
             elif isinstance(tok, _Section):
                 if tok.value == ".":
@@ -225,6 +229,12 @@ def verify(
                     referenced_at_root.add(tok.value.split(".")[0])
                 field = _resolve(stack, tok.value)
                 if field is None:
+                    # A derived `has<Field>` gate is a BOOLEAN over the current context:
+                    # it resolves nothing and pushes nothing, so walk the body in the SAME
+                    # scope — what `{{#hasAbilities}}{{#abilities}}…` depends on.
+                    if is_boolean_accessor(stack, tok.value):
+                        walk(tok.children, stack, seen)
+                        continue
                     # Unresolved section head is itself drift; skip the body (its
                     # context is unknowable, walking it would cascade false errors).
                     errors.append(VerifyError(ERR_VAR_NOT_ON_PAYLOAD, tok.value))

{metaobjects-0.23.0 → metaobjects-0.23.1}/src/metaobjects/spec_metamodel/requirement.json

@@ -83,7 +83,7 @@
           "isArray": true,
           "min": 0,
           "max": 1,
-          "description": "Names of the tests proving the behaviour. verify checks each exists and is not skipped; it never runs them."
+          "description": "OPTIONAL — omit unless you have opened the test and read what it asserts. Names of tests that assert the behaviour. verify checks each name EXISTS and is not skipped; it never runs them, and it cannot tell whether the named test verifies this requirement — any occurrence in the test corpus satisfies it."
         },
         {
           "type": "attr",
@@ -185,7 +185,7 @@
           "isArray": true,
           "min": 0,
           "max": 1,
-          "description": "Names of the tests proving the policy holds. verify checks each exists and is not skipped; it never runs them."
+          "description": "OPTIONAL — omit unless you have opened the test and read what it asserts. Names of tests that assert the policy holds. verify checks each name EXISTS and is not skipped; it never runs them, and it cannot tell whether the named test verifies this requirement — any occurrence in the test corpus satisfies it."
         },
         {
           "type": "attr",

{metaobjects-0.23.0 → metaobjects-0.23.1}/uv.lock

@@ -250,7 +250,7 @@ wheels = [
 
 [[package]]
 name = "metaobjects"
-version = "0.22.1"
+version = "0.23.0"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },