metaobjects 0.23.0__tar.gz → 0.23.2__tar.gz

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

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

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

@@ -53,6 +53,11 @@ _OPS_STRING: tuple[str, ...] = ("eq", "ne", "in", "like", "isNull")
 # uuid: identity-comparison only — no `like` (not a substring type), no ordering.
 _OPS_UUID: tuple[str, ...] = ("eq", "ne", "in", "isNull")
 _OPS_NUMERIC: tuple[str, ...] = ("eq", "ne", "gt", "gte", "lt", "lte", "in", "isNull")
+# int-backed enum (@intValueMap, design D5): the enum band minus `like` — the column
+# is an integer, and a substring match against an integer is meaningless. Distinct
+# constant from _OPS_UUID despite the identical members: they narrow for different
+# reasons and would diverge independently.
+_OPS_ENUM_INT_BACKED: tuple[str, ...] = ("eq", "ne", "in", "isNull")
 _OPS_BOOLEAN: tuple[str, ...] = ("eq", "isNull")
 
 
@@ -118,6 +123,36 @@ def ops_for_subtype_ordered(sub_type: str | None) -> tuple[str, ...]:
     return ()
 
 
+def ops_for_field_ordered(field: MetaField) -> tuple[str, ...]:
+    """The operator tuple for a FIELD, in canonical operator order.
+
+    The ordered counterpart of ``validation_passes.ops_for_field``, and the entry
+    point for every consumer that has a field in hand: the codegen allowlist emit
+    and the cross-port ``field.filter-ops`` conformance capability.
+
+    Identical to :func:`ops_for_subtype_ordered` except for ONE case: an int-backed
+    ``field.enum`` (one declaring ``@intValueMap``, design D5) persists as an INTEGER
+    column, so ``like`` -- a substring match -- is dropped. ``eq``/``ne``/``in``
+    survive because the member symbol encodes to its integer before it reaches SQL;
+    ``like`` has no such encoding, and an unencoded ``LIKE 'DRAFT'`` against an integer
+    column is a request-time type error.
+
+    ADR-0039: the ``@intValueMap`` read is RESOLVING (``attrs()``, NOT ``attr()`` --
+    Python inverts the TS naming, ``attr()`` here is own-only). Post-#246 the map lives
+    on a shared root-level abstract declaration and consuming fields INHERIT it, so an
+    own-only read would see it absent on exactly the shape adopters are steered toward
+    and wrongly keep ``like``.
+
+    Cross-port: ``fixtures/conformance/filter-ops-matrix`` pins ``fEnum`` vs
+    ``fEnumInt`` in all five ports.
+    """
+    if field.sub_type == fc.FIELD_SUBTYPE_ENUM and isinstance(
+        field.attrs().get(fc.FIELD_ATTR_INT_VALUE_MAP), dict
+    ):
+        return _OPS_ENUM_INT_BACKED
+    return ops_for_subtype_ordered(field.sub_type)
+
+
 def _is_filterable(field: MetaField) -> bool:
     """True iff ``field`` carries ``@filterable: true`` as a metadata attribute.
 
@@ -166,10 +201,10 @@ class FilterAllowlistGenerator:
     name = "filter-allowlist-generator"
 
     def _ops_for_field(self, field: MetaField) -> tuple[str, ...]:
-        """The operator tuple allowed for ``field`` (FR-009 §5 per-subtype matrix by
-        default). Override to customize the per-field operator vocabulary; returning
-        an empty tuple excludes the field from the allowlist."""
-        return ops_for_subtype_ordered(field.sub_type)
+        """The operator tuple allowed for ``field`` (FR-009 §5 matrix by default).
+        Override to customize the per-field operator vocabulary; returning an empty
+        tuple excludes the field from the allowlist."""
+        return ops_for_field_ordered(field)
 
     def _compute_filterable_ops(
         self, entity: MetaObject, object_index: dict[str, MetaObject] | None = None

{metaobjects-0.23.0 → metaobjects-0.23.2}/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.2}/src/metaobjects/core_types.py

@@ -9,6 +9,7 @@ from .meta.core.attr.attr_constants import (
     ATTR_SUBTYPE_EXPRESSION,
     ATTR_SUBTYPE_FILTER,
     ATTR_SUBTYPE_INT,
+    ATTR_SUBTYPE_INT_MAP,
     ATTR_SUBTYPE_STRING,
     ATTR_SUBTYPES,
 )
@@ -19,6 +20,7 @@ from .meta.core.field.field_constants import (
     FIELD_ATTR_AUTO_SET,
     FIELD_ATTR_CURRENCY,
     FIELD_ATTR_DEFAULT,
+    FIELD_ATTR_INT_VALUE_MAP,
     FIELD_ATTR_PROVIDED,
     FIELD_ATTR_MAX_LENGTH,
     FIELD_ATTR_OBJECT_REF,
@@ -472,6 +474,17 @@ core_provider.add(
                 value_type=ATTR_SUBTYPE_BOOLEAN,
                 required=False,
             ),
+            # int-backed-enum-values plan — @intValueMap: optional per-member int
+            # values ({member: int}) switching this enum field's DB persistence
+            # from string+CHECK to integer+CHECK. Keys must exactly match @values;
+            # values must be unique integers (enforced in _validate_enum_values,
+            # Rule 4). Structural (core), like @values / @provided — not a
+            # TS-web-only / prompt-domain overlay.
+            AttrSchema(
+                name=FIELD_ATTR_INT_VALUE_MAP,
+                value_type=ATTR_SUBTYPE_INT_MAP,
+                required=False,
+            ),
             # FR-033 — the field.enum tolerant-extract overlays (@enumAlias / @enumDoc /
             # @coerceDefault / @normalize) are NO LONGER declared here; they are re-homed
             # to the prompt domain provider (`prompt_provider`, metaobjects-prompt) via

{metaobjects-0.23.0 → metaobjects-0.23.2}/src/metaobjects/errors.py

@@ -194,6 +194,12 @@ class ErrorCode(str, Enum):
     # own @values would be silently dropped in codegen. Remove the own @values
     # to inherit the shared set, or extend a concrete (non-shared) enum instead.
     ERR_ENUM_EXTENDS_VALUES_CONFLICT = "ERR_ENUM_EXTENDS_VALUES_CONFLICT"
+    # A field.enum carries @intValueMap together with isArray=true. Int-backing is
+    # a persistence-layer codec and no port implements it element-wise over an
+    # array column, so the combination would silently persist member SYMBOLS into
+    # an integer array. An array-of-enum stays string-backed: drop @intValueMap,
+    # or make the field scalar.
+    ERR_ENUM_INT_VALUE_MAP_ARRAY = "ERR_ENUM_INT_VALUE_MAP_ARRAY"
     ERR_UNKNOWN = "ERR_UNKNOWN"
 
 

{metaobjects-0.23.0 → metaobjects-0.23.2}/src/metaobjects/loader/validation_passes.py

@@ -23,6 +23,7 @@ from ..meta.core.field.field_constants import (
     ENUM_MEMBER_PATTERN,
     FIELD_ATTR_COERCE_DEFAULT,
     FIELD_ATTR_DEFAULT,
+    FIELD_ATTR_INT_VALUE_MAP,
     FIELD_ATTR_OBJECT_REF,
     FIELD_ATTR_REQUIRED,
     FIELD_ATTR_STORAGE,
@@ -60,6 +61,7 @@ from ..meta.persistence.source.source_constants import (
     SOURCE_ROLE_PRIMARY,
 )
 from ..meta.core.attr.attr_constants import (
+    ATTR_SUBTYPE_INT_MAP,
     ATTR_SUBTYPE_PROPERTIES,
     ATTR_SUBTYPE_STRINGARRAY,
 )
@@ -281,6 +283,26 @@ def _type_ok(value: object, value_type: str) -> bool:
         # fails here → ERR_BAD_ATTR_VALUE, matching TS + Java (fail-closed); an object
         # @expr then flows to the closed-grammar check in the origin pass.
         return isinstance(value, dict)
+    if value_type == ATTR_SUBTYPE_INT_MAP:
+        # attr.intMap (int-backed-enum-values plan): an object whose every member
+        # value is an integer (e.g. field.enum's @intValueMap). This port has no
+        # per-attr-class validateValue dispatch (that's TS's architecture); the
+        # generic shape check lives here, mirroring C#'s ValueMatchesType
+        # ATTR_SUBTYPE_INT_MAP case. field.enum's own key-set/uniqueness content
+        # rules run separately in _validate_enum_values (Rule 4), which skips
+        # re-reporting a non-integer member already caught here.
+        #
+        # Final-review fix: also bound every value to the 32-bit signed int range
+        # (inclusive) — the eventual DB column for an int-backed enum is a 32-bit
+        # Postgres/SQLite `integer` (design doc D5), matching Java's
+        # IntMapAttribute#setValueAsString bound check exactly. Python ints have
+        # no fixed width, so this is the only place that boundary is enforced.
+        return isinstance(value, dict) and all(
+            isinstance(v, int)
+            and not isinstance(v, bool)
+            and -2147483648 <= v <= 2147483647
+            for v in value.values()
+        )
     # Unknown value types (e.g. "class") — allow anything.
     return True
 
@@ -544,6 +566,32 @@ def _validate_attr_schema(
 _ENUM_MEMBER_RE = re.compile(ENUM_MEMBER_PATTERN)
 
 
+def _shared_enum_super(node: MetaData) -> MetaData | None:
+    """The shared-enum super of ``node``, or ``None`` when it has none.
+
+    "Shared" (FR-019 / #246) means the immediate super is abstract AND declared at
+    metadata-root — its parent is the ``metadata.root`` node, not an object. Such a
+    declaration is materialized ONCE per port as a single named type, so anything a
+    consuming field re-declares that belongs to the shared TYPE's contract (its
+    ``@values`` member set, or the ``@intValueMap`` integer backing of that set) is a
+    conflict. A concrete super, or a non-root abstract super (e.g. one nested inside
+    an object), is legal and not flagged.
+
+    Immediate-super-only, matching codegen's ``resolve_shared_enum_decl``
+    (``codegen/generators/fr019_shared_enum.py``) so the validator and the
+    shared-enum collapse agree on what "shared" means.
+    """
+    sup = node.super_data
+    if (
+        sup is not None
+        and sup.is_abstract
+        and sup.parent is not None
+        and sup.parent.type == TYPE_METADATA
+    ):
+        return sup
+    return None
+
+
 def _validate_enum_values(
     root: MetaData,
     errors: list[MetaError],
@@ -556,6 +604,21 @@ def _validate_enum_values(
         # @coerceDefault / @default / @normalize while inheriting @values).
         _validate_enum_fr011_attrs(node, errors)
 
+        # Rule 4 (@intValueMap content rules) is independent of whether @values is
+        # own or inherited on THIS node — it must run whenever this node owns
+        # @intValueMap, using the EFFECTIVE @values (own-or-inherited) as the
+        # membership set. Mirrors TS/C#/Java, which all check this unconditionally
+        # (Java's `validateEnumIntValueMap` is a standalone call at the top of
+        # `validateEnumNode`). Deliberately called BEFORE the `own_values is None:
+        # continue` gate below so a concrete field.enum that inherits @values via
+        # `extends` but declares its own @intValueMap is still validated.
+        _validate_enum_int_value_map(node, errors)
+
+        # Design D7, narrowed: int-backing is scalar-only. Separate from the content
+        # rules above because it must fire on the node that combines the two halves,
+        # which is NOT necessarily the node that declares the map.
+        _validate_enum_int_value_map_not_array(node, errors)
+
         # ADR-0039 sanctioned own: validates the AUTHORED @values membership on THIS
         # node (mirrors the TS attr-schema-validate `node.ownAttrs()`); an inherited
         # @values yields None here and is validated on its declaring node.
@@ -607,19 +670,9 @@ def _validate_enum_values(
 
         # #246: own @values AND extends a shared package-level abstract enum —
         # one shared enum type has one member set, so the own @values would be
-        # silently dropped by the shared-enum codegen collapse. "Shared" means
-        # the resolved super is abstract AND declared at metadata-root (its
-        # parent is the metadata.root node, not nested inside an object) — a
-        # concrete super, or a non-root abstract super (e.g. nested inside an
-        # object), is legal and not flagged. Mirrors the TS reference
-        # (attr-schema-validate.ts).
-        sup = node.super_data
-        if (
-            sup is not None
-            and sup.is_abstract
-            and sup.parent is not None
-            and sup.parent.type == TYPE_METADATA
-        ):
+        # silently dropped by the shared-enum codegen collapse. Mirrors the TS
+        # reference (attr-schema-validate.ts).
+        if _shared_enum_super(node) is not None:
             errors.append(
                 MetaError(
                     f"{label} declares its own '@{FIELD_ATTR_VALUES}' but extends "
@@ -633,6 +686,113 @@ def _validate_enum_values(
             )
 
 
+def _validate_enum_int_value_map_not_array(node: MetaData, errors: list[MetaError]) -> None:
+    """``@intValueMap`` is scalar-only (design D7, narrowed).
+
+    Int-backing is a persistence-layer CODEC, and no port implements it
+    element-wise over an array column: this port's ``ObjectManager`` would bind the
+    symbol LIST straight into an ``integer[]``, OMDB's ``EnumCodec`` and Kotlin's
+    ``customEnumeration`` are scalar by construction, and TypeScript's sqlite branch
+    serializes an array as JSON text before the enum case is reached. Two ports that
+    happen to compose (TS/Postgres, C#) are not a feature — shipping a claim four
+    ports silently get wrong is the ``field.byte``/``short``/``class`` mistake.
+
+    BOTH halves are read RESOLVING, unlike the content rules: the illegal thing is
+    the EFFECTIVE combination. Post-#246 the map must live on the shared abstract
+    declaration, so the field that inherits it is exactly where ``isArray`` gets
+    declared — an own-only read would see the two halves on different nodes and
+    never fire.
+    """
+    if not isinstance(node.get_meta_attr(FIELD_ATTR_INT_VALUE_MAP), dict):
+        return
+    if not node.resolved_is_array():
+        return
+    errors.append(
+        MetaError(
+            f"{_node_label(node)} declares '@{FIELD_ATTR_INT_VALUE_MAP}' with isArray=true; "
+            f"int-backing is scalar-only — an array-of-enum persists its member symbols. "
+            f"Remove '@{FIELD_ATTR_INT_VALUE_MAP}', or make the field scalar.",
+            ErrorCode.ERR_ENUM_INT_VALUE_MAP_ARRAY,
+            envelope=node.source,
+        )
+    )
+
+
+def _validate_enum_int_value_map(node: MetaData, errors: list[MetaError]) -> None:
+    """``@intValueMap`` content rules (optional), independent of whether ``@values``
+    is own or inherited on this node. Mirrors TS/C#/Java, which all run this check
+    unconditionally against the node's EFFECTIVE ``@values`` — a concrete
+    ``field.enum`` that inherits ``@values`` via ``extends`` but declares its own
+    ``@intValueMap`` locally must still have that map validated.
+
+      a. Key set must exactly match the EFFECTIVE ``@values`` (own or inherited).
+      b. No two members may share the same int (protobuf's stance — no alias
+         opt-in). Every-value-is-an-integer is already enforced by ``_type_ok``'s
+         ATTR_SUBTYPE_INT_MAP case at parse time.
+    """
+    int_value_map = node.attr(FIELD_ATTR_INT_VALUE_MAP)
+    if not isinstance(int_value_map, dict):
+        return
+
+    label = _node_label(node)
+
+    # #246 (int-backed twin): the symbol->int mapping is a property of the enum
+    # VOCABULARY, not of one column that uses it -- it is @values' numeric half. A
+    # shared enum is materialized once as a single type, so a per-field map would
+    # give one logical type N storage encodings (and, where a port emits per-TYPE
+    # codec artifacts, two same-named declarations). Same remedy as the @values
+    # half: declare it on the shared declaration and inherit it.
+    shared_super = _shared_enum_super(node)
+    if shared_super is not None:
+        errors.append(
+            MetaError(
+                f"{label} declares its own '@{FIELD_ATTR_INT_VALUE_MAP}' but extends "
+                f"a shared package-level abstract enum — a shared enum's integer "
+                f"backing is owned by the shared declaration. Move "
+                f"'@{FIELD_ATTR_INT_VALUE_MAP}' onto the shared declaration to "
+                f"inherit it, or extend a concrete (non-shared) enum instead",
+                ErrorCode.ERR_ENUM_EXTENDS_VALUES_CONFLICT,
+                envelope=node.source,
+            )
+        )
+    effective_values = _effective_enum_values(node)
+    member_set = set(effective_values)
+    key_set = set(int_value_map.keys())
+    missing = [m for m in effective_values if m not in key_set]
+    extra = [k for k in int_value_map if k not in member_set]
+    if missing or extra:
+        parts = []
+        if missing:
+            parts.append(f"missing: {', '.join(missing)}")
+        if extra:
+            parts.append(f"unknown: {', '.join(extra)}")
+        errors.append(
+            MetaError(
+                f"{label} attribute '@{FIELD_ATTR_INT_VALUE_MAP}' keys must exactly match "
+                f"'@{FIELD_ATTR_VALUES}' members ({'; '.join(parts)}).",
+                ErrorCode.ERR_BAD_ATTR_VALUE,
+                envelope=node.source,
+            )
+        )
+
+    seen_values: dict[int, str] = {}
+    for member, value in int_value_map.items():
+        if not isinstance(value, int) or isinstance(value, bool):
+            continue  # _type_ok already reported this
+        owner = seen_values.get(value)
+        if owner is not None:
+            errors.append(
+                MetaError(
+                    f"{label} attribute '@{FIELD_ATTR_INT_VALUE_MAP}' members {owner!r} and {member!r} "
+                    f"share the same value {value}; every member must have a unique int.",
+                    ErrorCode.ERR_BAD_ATTR_VALUE,
+                    envelope=node.source,
+                )
+            )
+        else:
+            seen_values[value] = member
+
+
 def _effective_enum_values(node: MetaData) -> list[str]:
     """The effective ``@values`` members of an enum node (own or inherited via
     ``extends:``). Empty list when absent. Mirrors Java ``effectiveEnumValues``."""
@@ -913,6 +1073,45 @@ def ops_for_subtype(field_subtype: str) -> frozenset[str]:
     return frozenset()
 
 
+# The int-backed-enum band: the enum band minus `like`. Named so the narrowing is
+# one constant rather than a set rebuilt at every call.
+_OPS_ENUM_INT_BACKED: frozenset[str] = frozenset({"eq", "ne", "in", "isNull"})
+
+
+def ops_for_field(field: MetaData) -> frozenset[str]:
+    """The filter-operator band for a FIELD.
+
+    The entry point every consumer that has a field in hand must use (loader
+    validation, the codegen filter-allowlist generator, the cross-port
+    ``field.filter-ops`` capability).
+
+    Identical to :func:`ops_for_subtype` except for ONE case: an int-backed
+    ``field.enum`` (one declaring ``@intValueMap``, design D5) persists as an
+    INTEGER column, so ``like`` -- a substring match -- is dropped.
+    ``eq``/``ne``/``in`` survive because the member symbol encodes to its integer
+    before it reaches SQL; ``like`` has no such encoding, and an unencoded
+    ``LIKE 'DRAFT'`` against an integer column is a request-time type error.
+
+    ``ops_for_subtype`` cannot express this -- it only ever sees the subtype
+    ``"enum"`` -- and is deliberately left unchanged for the one caller that
+    genuinely has no field: the expression grammar's declared operand type.
+
+    ADR-0039: the ``@intValueMap`` read is RESOLVING (``attrs()``, NOT ``attr()``
+    -- Python inverts the TS naming, ``attr()`` here is own-only). Post-#246 the
+    map lives on a shared root-level abstract declaration and consuming fields
+    INHERIT it, so an own-only read would see it absent on exactly the shape
+    adopters are steered toward and wrongly keep ``like``.
+
+    Cross-port: ``fixtures/conformance/filter-ops-matrix`` pins ``fEnum`` vs
+    ``fEnumInt`` in all five ports.
+    """
+    if field.sub_type == FIELD_SUBTYPE_ENUM and isinstance(
+        field.attrs().get(FIELD_ATTR_INT_VALUE_MAP), dict
+    ):
+        return _OPS_ENUM_INT_BACKED
+    return ops_for_subtype(field.sub_type)
+
+
 # ---------------------------------------------------------------------------
 # #195 — attr.expression closed grammar (validate + infer)
 # ---------------------------------------------------------------------------
@@ -1095,8 +1294,10 @@ def _validate_datagrid_filter_values(
             continue
 
         # Build filterable map: field_name → allowed ops set
+        # ops_for_field, not ops_for_subtype — an int-backed field.enum
+        # (@intValueMap) stores as an integer, so `like` is not in its band.
         filterable: dict[str, frozenset[str]] = {
-            f.name: ops_for_subtype(f.sub_type)
+            f.name: ops_for_field(f)
             for f in node.fields()
             if f.attrs().get("filterable") is True
         }

{metaobjects-0.23.0 → metaobjects-0.23.2}/src/metaobjects/meta/core/attr/attr_constants.py

@@ -14,6 +14,13 @@ ATTR_SUBTYPE_CLASS = "class"
 # ATTR_SUBTYPE_EXPRESSION / meta-attr-expression.ts.
 ATTR_SUBTYPE_EXPRESSION = "expression"
 
+# attr.intMap (int-backed-enum-values plan) — an object-shaped attribute whose
+# values are all integers (e.g. field.enum's @intValueMap: {memberSymbol: int}).
+# Generic shape check only; field.enum layers its own semantic rules (key-set
+# membership, uniqueness) in its own content-rule validation pass. Mirrors TS
+# ATTR_SUBTYPE_INT_MAP / C# AttrConstants.ATTR_SUBTYPE_INT_MAP.
+ATTR_SUBTYPE_INT_MAP = "intMap"
+
 # The retired "stringarray" array attr subtype. It is NO LONGER a registered
 # (attr, sub_type) (not in ATTR_SUBTYPES) — array-ness is modeled as a "string"
 # attr with the orthogonal AttrSchema.is_array flag (matching Java's
@@ -33,4 +40,5 @@ ATTR_SUBTYPES = (
     ATTR_SUBTYPE_PROPERTIES,
     ATTR_SUBTYPE_CLASS,
     ATTR_SUBTYPE_EXPRESSION,
+    ATTR_SUBTYPE_INT_MAP,
 )

{metaobjects-0.23.0 → metaobjects-0.23.2}/src/metaobjects/meta/core/attr/meta_attr.py

@@ -12,6 +12,7 @@ from .attr_constants import (
     ATTR_SUBTYPE_EXPRESSION,
     ATTR_SUBTYPE_FILTER,
     ATTR_SUBTYPE_INT,
+    ATTR_SUBTYPE_INT_MAP,
     ATTR_SUBTYPE_LONG,
     ATTR_SUBTYPE_PROPERTIES,
     ATTR_SUBTYPE_STRING,
@@ -134,6 +135,21 @@ class PropertiesAttr(MetaAttr):
         return DataType.OBJECT
 
 
+class IntMapAttr(MetaAttr):
+    """attr.intMap (int-backed-enum-values plan) — an object-shaped attribute
+    whose values are all integers (e.g. field.enum's @intValueMap). Generic
+    shape check only; the deeper "every value is an int" check is enforced by
+    `_type_ok`'s ATTR_SUBTYPE_INT_MAP case in validation_passes.py (this port
+    has no per-attr-class validate_value dispatch — TS's is the one port that
+    does; C# mirrors the same "static type-check function" architecture this
+    port uses). field.enum's own key-set/uniqueness content rules run in a
+    separate pass. Mirrors TS IntMapAttr / C# ATTR_SUBTYPE_INT_MAP shape."""
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.OBJECT
+
+
 class ClassAttr(MetaAttr):
     @property
     def data_type(self) -> DataType:
@@ -145,4 +161,5 @@ register_attr_class(ATTR_SUBTYPE_STRINGARRAY, StringArrayAttr)
 register_attr_class(ATTR_SUBTYPE_FILTER, FilterAttr)
 register_attr_class(ATTR_SUBTYPE_PROPERTIES, PropertiesAttr)
 register_attr_class(ATTR_SUBTYPE_EXPRESSION, ExpressionAttr)
+register_attr_class(ATTR_SUBTYPE_INT_MAP, IntMapAttr)
 register_attr_class(ATTR_SUBTYPE_CLASS, ClassAttr)

{metaobjects-0.23.0 → metaobjects-0.23.2}/src/metaobjects/meta/core/field/field_constants.py

@@ -150,3 +150,10 @@ SORT_ORDER_VALUES = (SORT_ORDER_ASC, SORT_ORDER_DESC)
 # Regex pattern for enum member symbols — must be identifier-safe.
 # Cross-language contract: every port enforces this pattern.
 ENUM_MEMBER_PATTERN = r"^[A-Za-z_][A-Za-z0-9_]*$"
+
+# int-backed-enum-values plan — @intValueMap (field.enum only): optional
+# per-member int values ({member: int}) switching this enum field's DB
+# persistence from string+CHECK to integer+CHECK. Keys must exactly match
+# @values; values must be unique integers. The generated native type and wire
+# format are unchanged in every language. Mirrors TS FIELD_ATTR_INT_VALUE_MAP.
+FIELD_ATTR_INT_VALUE_MAP = "intValueMap"

{metaobjects-0.23.0 → metaobjects-0.23.2}/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.2/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