metaobjects 1.0.12__tar.gz → 1.0.13__tar.gz

{metaobjects-1.0.12 → metaobjects-1.0.13}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "1.0.12"
+version = "1.0.13"
 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-1.0.12 → metaobjects-1.0.13}/src/metaobjects/apidocs/naming.py

@@ -74,6 +74,52 @@ def _route_snake_case(name: str) -> str:
     return to_snake_case(name)
 
 
+_ALREADY_PLURAL_EXCLUDED_PRECEDING_CHARS = "suia"
+"""The four letters that precede a genuinely SINGULAR "...s" ending in the common
+patterns this codebase's entity names hit — status, address, bonus, alias, gas,
+analysis. Anything else before a final "s" reads as already-plural."""
+
+
+def _is_already_plural(word: str) -> bool:
+    """True when ``word`` already reads as a plural noun, so running it through
+    the ordinary suffix rule would double it — the real defect this exists to
+    fix: ``program_purchase_stats`` -> ``program_purchase_statses`` shipped as a
+    REST collection path in an adopter's app.
+
+    Heuristic, not a dictionary: a word ending in ``s`` is already-plural UNLESS
+    the character immediately before that final ``s`` is one of s/u/i/a
+    (case-insensitive). Covers stats, settings, details, news, analytics,
+    series, photos; leaves status, address, bonus, alias, gas, analysis on the
+    ordinary suffix path (unchanged).
+
+    Known miss, deliberately not fixed here: a genuinely singular word ending in
+    "...s" with none of those four letters before it reads as already-plural too
+    — ``lens`` -> ``lens`` (correct plural ``lenses``). Fixing that needs a real
+    dictionary, which this is not; the heuristic optimizes for the shape the
+    doubling defect actually hits (entity names that are already a plural
+    concept)."""
+    if len(word) < 2:
+        return False
+    lowered = word.lower()
+    if lowered[-1] != "s":
+        return False
+    return lowered[-2] not in _ALREADY_PLURAL_EXCLUDED_PRECEDING_CHARS
+
+
+def _pluralize_legacy_suffix_only(name: str) -> str:
+    """FROZEN — byte-for-byte the pre-fix suffix-only pluralization rule, with no
+    already-plural detection. Exposed only so :func:`pluralize` can fall back to
+    it. The DEFAULT PHYSICAL name fallback lives in a completely separate,
+    independently-frozen implementation (``meta_source._pluralize``) — this is
+    NOT that one, and the two must never be merged into a single call site."""
+    lowered = name.lower()
+    if lowered.endswith(("s", "x", "z", "ch", "sh")):
+        return name + "es"
+    if len(name) >= 2 and lowered[-1] == "y" and lowered[-2] not in "aeiou":
+        return name[:-1] + "ies"
+    return name + "s"
+
+
 def pluralize(name: str) -> str:
     """``post_category`` → ``post_categories``; ``address`` → ``addresses``.
 
@@ -82,13 +128,16 @@ def pluralize(name: str) -> str:
     ``y`` becomes ``ies``; anything else takes ``s``. The cross-port
     byte-identity covers the already-lowercased word :func:`route_path` feeds
     in — suffix tests here run on a lowercased copy, unlike the JVM port's
-    case-sensitive ones, so mixed-case input may diverge."""
-    lowered = name.lower()
-    if lowered.endswith(("s", "x", "z", "ch", "sh")):
-        return name + "es"
-    if len(name) >= 2 and lowered[-1] == "y" and lowered[-2] not in "aeiou":
-        return name[:-1] + "ies"
-    return name + "s"
+    case-sensitive ones, so mixed-case input may diverge.
+
+    Adds already-plural detection (:func:`_is_already_plural`) on top of that
+    historical suffix rule (:func:`_pluralize_legacy_suffix_only`) — API/code-
+    surface pluralization only; the DEFAULT PHYSICAL table name fallback is
+    frozen separately (``meta_source._pluralize``), so an existing adopter
+    database never sees a proposed rename."""
+    if _is_already_plural(name):
+        return name
+    return _pluralize_legacy_suffix_only(name)
 
 
 def model_class_name(obj: MetaData) -> str:

metaobjects-1.0.13/src/metaobjects/codegen/collection_name_collision.py

@@ -0,0 +1,58 @@
+"""Collection-name collision refusal — the single choke point every route/router/
+finder generator path goes through (called once, in ``run_gen``, over the full
+entity set BEFORE any generator runs).
+
+Two DISTINCT entities/projections pluralizing to the SAME API-surface collection
+name (REST path, generated router module/finder names) is reachable from stock
+metadata now that :func:`metaobjects.apidocs.naming.pluralize` no longer doubles an
+already-plural word: ``Address`` (not already-plural: legacy-pluralizes to
+``Addresses``) and ``Addresses`` (already-plural: left unchanged, ALSO
+``Addresses``) collide, where before the fix they did not (``Addresses`` legacy-
+pluralized to ``Addresseses``). Silently letting two entities share one collection
+name would mean whichever generator runs second silently wins, or a straight
+duplicate-module/route registration two files downstream of the real cause. This
+refuses at the one place that can see the WHOLE set, with a message naming both
+entities and the colliding name.
+"""
+from __future__ import annotations
+
+from metaobjects.apidocs.naming import pluralize
+from metaobjects.errors import ErrorCode
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.meta.core.object.object_constants import OBJECT_SUBTYPE_VALUE
+
+ERR_COLLECTION_NAME_COLLISION = ErrorCode.ERR_COLLECTION_NAME_COLLISION.value
+
+
+def assert_no_collection_name_collisions(entities: list[MetaObject]) -> None:
+    """Refuse a generation run in which two DISTINCT entities/projections pluralize
+    to the same API-surface collection name.
+
+    Scope: every object EXCEPT ``object.value`` (a value object never gets a route,
+    router module, or finder name — it is pure shape, so it cannot collide on any of
+    those). A TPH subtype IS included: it gets its own generated names against the
+    shared base table, so two subtypes (or a subtype and an unrelated top-level
+    entity) sharing a pluralized name collide on those generated symbols exactly as
+    two top-level entities would.
+
+    A PURE function of the entity set — never of traversal order: the reported pair
+    is deterministic (first-seen-by-input-order "owner" of a plural; raised as soon
+    as a second, different entity claims the same plural).
+    """
+    owner_of_plural: dict[str, MetaObject] = {}
+    for obj in entities:
+        if obj.sub_type == OBJECT_SUBTYPE_VALUE:
+            continue
+        plural = pluralize(obj.name)
+        existing = owner_of_plural.get(plural)
+        if existing is not None:
+            if existing.resolution_key() != obj.resolution_key():
+                raise ValueError(
+                    f"{ERR_COLLECTION_NAME_COLLISION}: \"{existing.name}\" and \"{obj.name}\" both "
+                    f'pluralize to the API-surface collection name "{plural}" (REST path, generated '
+                    "router module/finder names) — rename one entity so its pluralized name is "
+                    "distinct. Default PHYSICAL table names are unaffected by this rule and are not "
+                    "involved in the collision."
+                )
+        else:
+            owner_of_plural[plural] = obj

{metaobjects-1.0.12 → metaobjects-1.0.13}/src/metaobjects/codegen/runner.py

@@ -10,6 +10,7 @@ from metaobjects.meta.meta_root import MetaRoot
 from metaobjects.meta.meta_data import MetaData
 from metaobjects.meta.core.object.meta_object import MetaObject
 from metaobjects.shared.base_types import TYPE_OBJECT
+from .collection_name_collision import assert_no_collection_name_collisions
 from .config import GenConfig
 from .constants import generated_package_init
 from .generator import GenContext, Generator
@@ -107,6 +108,10 @@ def run_gen(
     if not safe:
         return result
 
+    # Refuse before any generator runs — the one choke point that sees the WHOLE
+    # entity set every route/router-emitting generator below reads from.
+    assert_no_collection_name_collisions(safe)
+
     emitted: dict[str, tuple[str, str]] = {}  # full_path -> (content, generated_by)
     for gen in generators:
         ctx = GenContext(

{metaobjects-1.0.12 → metaobjects-1.0.13}/src/metaobjects/errors.py

@@ -200,6 +200,12 @@ class ErrorCode(str, Enum):
     # Codegen (ADR-0044): two value-object FQNs in one payload artifact derive the same
     # emitted record name even after package-qualification. Peer of ERR_VAR_NOT_ON_PAYLOAD.
     ERR_PAYLOAD_NAME_COLLISION = "ERR_PAYLOAD_NAME_COLLISION"
+    # Codegen: two DISTINCT entities/projections in one generation run pluralize to the
+    # SAME API-surface collection name (route path, generated router/finder names) —
+    # e.g. "Address" and "Addresses" both resolving to "Addresses". A codegen-time (not
+    # loader) error, peer of ERR_PAYLOAD_NAME_COLLISION: refused rather than silently
+    # letting one entity's route win.
+    ERR_COLLECTION_NAME_COLLISION = "ERR_COLLECTION_NAME_COLLISION"
     ERR_OUTPUT_TAG_MISSING = "ERR_OUTPUT_TAG_MISSING"
     # SP-H Unit9 — @filterable: true on a field subtype with no filter-operator
     # band (e.g. field.object). Would silently generate an empty-ops filter.

{metaobjects-1.0.12 → metaobjects-1.0.13}/src/metaobjects/meta/persistence/source/meta_source.py

@@ -47,7 +47,17 @@ def _to_snake_case(s: str) -> str:
 
 
 def _pluralize(s: str) -> str:
-    """Trivial cross-port pluralization (matches TS ``pluralize``)."""
+    """FROZEN — the DEFAULT PHYSICAL name derivation only (step 4 below, reached
+    only when metadata declares no explicit physical name). Matches the TS
+    reference ``pluralizeTableNameLegacy`` (metadata/src/naming.ts) — NOT the TS
+    ``pluralize``, which now differs for an already-plural word, deliberately
+    with NO already-plural detection. An adopter's live database was created
+    with this rule; adding the already-plural check here would make a schema
+    migration propose a rename for every already-plural entity name on the next
+    run. The API-surface analog (``metaobjects.apidocs.naming.pluralize``) has
+    that fix — this one must not, and the two are intentionally separate,
+    independently-maintained implementations (never merge them into one call
+    site)."""
     if not s:
         return s
     lower = s.lower()
@@ -128,7 +138,8 @@ class MetaSource(MetaData):
             2. Legacy ``@table`` for non-table kind (pre-1.0 fallback).
             3. Source's bare structural ``name`` via snake_case
                (no pluralize — the source's name IS the logical name).
-            4. Owning entity's name via ``pluralize(snake_case())``.
+            4. Owning entity's name via the frozen legacy ``pluralize(snake_case())``
+               — see module-level ``_pluralize``'s docstring for why it is frozen.
 
         Callers needing the legacy raw ``@table`` slot only should use
         :meth:`table_name`; codegen / runtime should use ``physical_name``.

metaobjects-1.0.13/tests/codegen/test_collection_name_collision.py

@@ -0,0 +1,109 @@
+"""assert_no_collection_name_collisions — the single choke point every route/router
+generator path goes through (called once, in run_gen, over the full entity set
+BEFORE any generator runs). See collection_name_collision.py's module docstring.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from metaobjects import MetaDataLoader
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.shared.base_types import TYPE_OBJECT
+from metaobjects.codegen.collection_name_collision import (
+    ERR_COLLECTION_NAME_COLLISION,
+    assert_no_collection_name_collisions,
+)
+
+_NAMING_CONFORMANCE_FIXTURE = (
+    Path(__file__).parents[4] / "fixtures" / "naming-conformance" / "already-plural-pluralize.json"
+)
+
+
+def _entities(tmp_path: Path, *names: str) -> list:
+    children = [
+        {
+            "object.entity": {
+                "name": name,
+                "children": [
+                    {"source.rdb": {"@table": name.lower()}},
+                    {"field.long": {"name": "id"}},
+                    {"identity.primary": {"@fields": "id"}},
+                ],
+            }
+        }
+        for name in names
+    ]
+    meta_dir = tmp_path / "meta"
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    (meta_dir / "meta.json").write_text(
+        json.dumps({"metadata.root": {"package": "acme", "children": children}})
+    )
+    root = MetaDataLoader.from_directory(meta_dir).root
+    return [c for c in root.own_children() if c.type == TYPE_OBJECT and isinstance(c, MetaObject)]
+
+
+def _entity_and_value(tmp_path: Path, entity_name: str, value_name: str) -> list:
+    doc = {
+        "metadata.root": {
+            "package": "acme",
+            "children": [
+                {
+                    "object.entity": {
+                        "name": entity_name,
+                        "children": [
+                            {"source.rdb": {"@table": entity_name.lower()}},
+                            {"field.long": {"name": "id"}},
+                            {"identity.primary": {"@fields": "id"}},
+                        ],
+                    }
+                },
+                {
+                    "object.value": {
+                        "name": value_name,
+                        "children": [{"field.string": {"name": "text"}}],
+                    }
+                },
+            ],
+        }
+    }
+    meta_dir = tmp_path / "meta"
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    (meta_dir / "meta.json").write_text(json.dumps(doc))
+    root = MetaDataLoader.from_directory(meta_dir).root
+    return [c for c in root.own_children() if c.type == TYPE_OBJECT and isinstance(c, MetaObject)]
+
+
+def test_does_not_raise_for_distinct_plurals(tmp_path: Path) -> None:
+    assert_no_collection_name_collisions(_entities(tmp_path, "Post", "Author", "Category"))
+
+
+def test_raises_for_address_and_addresses(tmp_path: Path) -> None:
+    with pytest.raises(ValueError) as exc_info:
+        assert_no_collection_name_collisions(_entities(tmp_path, "Address", "Addresses"))
+    msg = str(exc_info.value)
+    assert ERR_COLLECTION_NAME_COLLISION in msg
+    assert "Address" in msg
+    assert "Addresses" in msg
+
+
+def test_raises_for_order_and_orders(tmp_path: Path) -> None:
+    with pytest.raises(ValueError):
+        assert_no_collection_name_collisions(_entities(tmp_path, "Order", "Orders"))
+
+
+def test_excludes_value_objects(tmp_path: Path) -> None:
+    # "Address" (entity) pluralizes to "Addresses"; an unrelated object.value named
+    # "Addresses" never gets a route, so it must not trip this.
+    assert_no_collection_name_collisions(_entity_and_value(tmp_path, "Address", "Addresses"))
+
+
+def test_naming_conformance_collision_cases_are_refused(tmp_path: Path) -> None:
+    cases = json.loads(_NAMING_CONFORMANCE_FIXTURE.read_text())["collisionCases"]
+    for i, case in enumerate(cases):
+        with pytest.raises(ValueError):
+            assert_no_collection_name_collisions(
+                _entities(tmp_path / str(i), case["entityA"], case["entityB"])
+            )

metaobjects-1.0.13/tests/codegen/test_route_path_naming.py

@@ -0,0 +1,149 @@
+"""The cross-port collection-URL spelling: the ENTITY NAME snake_cased, then pluralized.
+
+One rule in all five ports. The multi-word and consonant+y axes are also gated
+end-to-end by ``fixtures/api-contract-conformance/m2m/`` (the ``PostCategory``
+scenario). The ACRONYM case is not — no corpus entity carries one — so it is
+pinned here, against the same rule, in every port that owns a naming seam.
+
+``route_path`` deliberately does NOT reuse :func:`metaobjects.apidocs.naming.snake_case`:
+that one separates before every capital, which is right for a module name and
+would emit ``h_t_t_p_server`` in a URL.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from metaobjects.apidocs.naming import pluralize, reverse_finder_fn, route_path, snake_case
+
+_NAMING_CONFORMANCE_FIXTURE = (
+    Path(__file__).parents[4] / "fixtures" / "naming-conformance" / "already-plural-pluralize.json"
+)
+
+
+@pytest.mark.parametrize(
+    ("name", "expected"),
+    [
+        # Single regular word — every port's old rule already agreed here, which
+        # is exactly why four different spellings shipped green.
+        ("Author", "authors"),
+        ("Post", "posts"),
+        ("Tag", "tags"),
+        ("Person", "persons"),
+        ("Account", "accounts"),
+        ("Auth", "auths"),
+        # Multi-word: the capitals carry the word boundary, so lowercasing
+        # without separating used to yield "postcategorys".
+        ("PostCategory", "post_categories"),
+        ("OrderSummary", "order_summaries"),
+        # consonant + y -> ies; a sibilant takes -es.
+        ("Category", "categories"),
+        ("Address", "addresses"),
+        # Acronym: a run of capitals stays together until the final one that
+        # begins a word.
+        ("HTTPServer", "http_servers"),
+    ],
+)
+def test_route_path_is_entity_name_snake_cased_then_pluralized(name: str, expected: str) -> None:
+    assert route_path(name) == expected
+
+
+def test_route_path_does_not_reuse_the_module_name_snake_case() -> None:
+    """The two snake variants genuinely differ, so this is not a tautology."""
+    assert snake_case("HTTPServer") == "h_t_t_p_server"
+    assert route_path("HTTPServer") == "http_servers"
+
+
+@pytest.mark.parametrize(
+    ("word", "expected"),
+    [
+        ("post_category", "post_categories"),
+        ("address", "addresses"),
+        ("box", "boxes"),
+        ("buzz", "buzzes"),
+        ("match", "matches"),
+        ("dish", "dishes"),
+        # A VOWEL before the y takes a plain "s" — "days", never "daies".
+        ("day", "days"),
+        ("author", "authors"),
+    ],
+)
+def test_pluralize_contract(word: str, expected: str) -> None:
+    assert pluralize(word) == expected
+
+
+# ---- Already-plural detection --------------------------------
+#
+# An already-plural entity name used to double (program_purchase_stats ->
+# program_purchase_statses) in the REST collection segment and the reverse-finder
+# names. Mirrors the TS fix in metadata/src/naming.ts exactly (same four-letter
+# exclusion set before a final "s").
+
+@pytest.mark.parametrize(
+    "word",
+    ["stats", "settings", "details", "news", "analytics", "series", "photos"],
+)
+def test_pluralize_leaves_already_plural_words_unchanged(word: str) -> None:
+    assert pluralize(word) == word
+
+
+@pytest.mark.parametrize(
+    ("name", "expected"),
+    [
+        ("ProgramPurchaseStats", "program_purchase_stats"),
+        ("Settings", "settings"),
+    ],
+)
+def test_route_path_does_not_double_pluralize_an_already_plural_entity_name(
+    name: str, expected: str
+) -> None:
+    assert route_path(name) == expected
+
+
+@pytest.mark.parametrize(
+    ("word", "expected"),
+    [
+        ("status", "statuses"),
+        ("address", "addresses"),
+        ("bonus", "bonuses"),
+        ("alias", "aliases"),
+        ("gas", "gases"),
+        # Documented pre-existing imperfection, explicitly out of scope — not "analyses".
+        ("analysis", "analysises"),
+    ],
+)
+def test_pluralize_keeps_existing_behavior_for_s_u_i_a_plus_s_endings(
+    word: str, expected: str
+) -> None:
+    assert pluralize(word) == expected
+
+
+def test_pluralize_documented_known_miss_lens_reads_as_already_plural() -> None:
+    # Correct plural is "lenses"; this heuristic is not a dictionary. See
+    # pluralize's docstring.
+    assert pluralize("lens") == "lens"
+
+
+def test_reverse_finder_fn_does_not_double_pluralize_an_already_plural_source_entity() -> None:
+    assert reverse_finder_fn("ProgramPurchaseStats", "programId") == (
+        "find_program_purchase_stats_by_program"
+    )
+
+
+# ---------------------------------------------------------------------------
+# fixtures/naming-conformance/ — the shared cross-port data proving every
+# port's API-surface pluralizer agrees on the same inputs (the FROZEN legacy
+# half of the same fixture is checked in test_fr016_source_name_and_kind_aliases.py,
+# against meta_source._pluralize through a loaded entity). See that corpus's
+# README.
+# ---------------------------------------------------------------------------
+_naming_conformance_cases = json.loads(_NAMING_CONFORMANCE_FIXTURE.read_text())["cases"]
+
+
+@pytest.mark.parametrize(
+    "case", _naming_conformance_cases, ids=[c["name"] for c in _naming_conformance_cases]
+)
+def test_naming_conformance_api_plurals_match(case: dict) -> None:
+    assert pluralize(case["name"]) == case["apiPlural"]

{metaobjects-1.0.12 → metaobjects-1.0.13}/tests/codegen/test_runner.py

@@ -210,3 +210,24 @@ def test_the_no_manifest_refusal_leads_with_the_performable_remedy(tmp_path: Pat
     assert "--baseline=adopt" in msgs[0]
     # What it must no longer do: prescribe committing a file this project cannot produce.
     assert "Commit '.metaobjects/.gen-state/.hashes.json' and re-run" not in msgs[0]
+
+
+def test_run_gen_refuses_a_model_with_colliding_collection_names(tmp_path: Path) -> None:
+    """Integration-level: proves the collision gate is wired into the real entry
+    point (run_gen), not just callable as a standalone function. Address +
+    Addresses both pluralize to "Addresses" — reachable now that an already-
+    plural entity name is no longer double-pluralized."""
+    root = _load(tmp_path / "meta", {"metadata.root": {"package": "acme", "children": [
+        {"object.entity": {"name": "Address", "children": [
+            {"source.rdb": {"@table": "address"}},
+            {"field.long": {"name": "id"}},
+            {"identity.primary": {"@fields": "id"}},
+        ]}},
+        {"object.entity": {"name": "Addresses", "children": [
+            {"source.rdb": {"@table": "addresses"}},
+            {"field.long": {"name": "id"}},
+            {"identity.primary": {"@fields": "id"}},
+        ]}},
+    ]}})
+    with pytest.raises(ValueError):
+        run_gen(GenConfig(out_dir=str(tmp_path / "out")), root, generators=[entity_model()])

{metaobjects-1.0.12 → metaobjects-1.0.13}/tests/unit/test_fr016_source_name_and_kind_aliases.py

@@ -19,6 +19,8 @@ import os
 import tempfile
 from pathlib import Path
 
+import pytest
+
 from metaobjects import MetaDataLoader
 from metaobjects.core_types import core_provider
 from metaobjects.meta.persistence.source.meta_source import MetaSource
@@ -160,6 +162,37 @@ def test_physical_name_step4_owning_entity_pluralize_snake_case() -> None:
     assert _first_source(root).physical_name() == "authors"
 
 
+def test_physical_name_step4_frozen_legacy_rule_still_doubles_an_already_plural_owner_name() -> None:
+    """The default PHYSICAL table name derivation is FROZEN at the
+    pre-fix suffix-only rule, so an adopter's existing database never sees a
+    proposed rename for an already-plural entity name. Only the API-surface
+    ``metaobjects.apidocs.naming.pluralize`` gets the already-plural fix."""
+    _, _, root, _ = _load(_one_source("ProgramPurchaseStats", {}))
+    assert _first_source(root).physical_name() == "program_purchase_statses"
+
+
+# ---------------------------------------------------------------------------
+# fixtures/naming-conformance/ — the shared cross-port data proving every
+# port's FROZEN legacy pluralizer agrees on the same inputs (the API-surface
+# half of the same fixture is checked in test_route_path_naming.py, against
+# metaobjects.apidocs.naming.pluralize directly). See that corpus's README.
+# ---------------------------------------------------------------------------
+_NAMING_CONFORMANCE_FIXTURE = (
+    Path(__file__).parents[4] / "fixtures" / "naming-conformance" / "already-plural-pluralize.json"
+)
+_naming_conformance_cases = json.loads(_NAMING_CONFORMANCE_FIXTURE.read_text())["cases"]
+
+
+@pytest.mark.parametrize(
+    "case", _naming_conformance_cases, ids=[c["name"] for c in _naming_conformance_cases]
+)
+def test_naming_conformance_legacy_plurals_match(case: dict) -> None:
+    _, _, root, _ = _load(_one_source(case["name"], {}))
+    # Every fixture case is a single PascalCase word, so lowercasing is
+    # byte-equivalent to the snake_case step physical_name applies first.
+    assert _first_source(root).physical_name() == case["legacyPlural"].lower()
+
+
 # ---------------------------------------------------------------------------
 # Validation pass — kind mismatch, multiple aliases, empty string, legacy warn
 # ---------------------------------------------------------------------------

{metaobjects-1.0.12 → metaobjects-1.0.13}/uv.lock

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

metaobjects-1.0.12/tests/codegen/test_route_path_naming.py

@@ -1,67 +0,0 @@
-"""The cross-port collection-URL spelling: the ENTITY NAME snake_cased, then pluralized.
-
-One rule in all five ports. The multi-word and consonant+y axes are also gated
-end-to-end by ``fixtures/api-contract-conformance/m2m/`` (the ``PostCategory``
-scenario). The ACRONYM case is not — no corpus entity carries one — so it is
-pinned here, against the same rule, in every port that owns a naming seam.
-
-``route_path`` deliberately does NOT reuse :func:`metaobjects.apidocs.naming.snake_case`:
-that one separates before every capital, which is right for a module name and
-would emit ``h_t_t_p_server`` in a URL.
-"""
-from __future__ import annotations
-
-import pytest
-
-from metaobjects.apidocs.naming import pluralize, route_path, snake_case
-
-
-@pytest.mark.parametrize(
-    ("name", "expected"),
-    [
-        # Single regular word — every port's old rule already agreed here, which
-        # is exactly why four different spellings shipped green.
-        ("Author", "authors"),
-        ("Post", "posts"),
-        ("Tag", "tags"),
-        ("Person", "persons"),
-        ("Account", "accounts"),
-        ("Auth", "auths"),
-        # Multi-word: the capitals carry the word boundary, so lowercasing
-        # without separating used to yield "postcategorys".
-        ("PostCategory", "post_categories"),
-        ("OrderSummary", "order_summaries"),
-        # consonant + y -> ies; a sibilant takes -es.
-        ("Category", "categories"),
-        ("Address", "addresses"),
-        # Acronym: a run of capitals stays together until the final one that
-        # begins a word.
-        ("HTTPServer", "http_servers"),
-    ],
-)
-def test_route_path_is_entity_name_snake_cased_then_pluralized(name: str, expected: str) -> None:
-    assert route_path(name) == expected
-
-
-def test_route_path_does_not_reuse_the_module_name_snake_case() -> None:
-    """The two snake variants genuinely differ, so this is not a tautology."""
-    assert snake_case("HTTPServer") == "h_t_t_p_server"
-    assert route_path("HTTPServer") == "http_servers"
-
-
-@pytest.mark.parametrize(
-    ("word", "expected"),
-    [
-        ("post_category", "post_categories"),
-        ("address", "addresses"),
-        ("box", "boxes"),
-        ("buzz", "buzzes"),
-        ("match", "matches"),
-        ("dish", "dishes"),
-        # A VOWEL before the y takes a plain "s" — "days", never "daies".
-        ("day", "days"),
-        ("author", "authors"),
-    ],
-)
-def test_pluralize_contract(word: str, expected: str) -> None:
-    assert pluralize(word) == expected