Merge pull request 'fix(places): phase-grouped tables, plain-English measures, styled links' (#118) from fix/place-page-presentation into fix/place-title-brand-doubling

Reviewed-on: #118

backend/app.py

@@ -1212,15 +1212,10 @@ async def get_place(request: Request, kind: str, slug: str,
         if wanted and "phase" in rows.columns:
             rows = rows[rows["phase"].fillna("").str.lower().isin(wanted)]
 
-    # The metric the page shows, and averages.
+    # The metric the page ranks on, which is also the one it averages.
     metric = "attainment_8_score" if phase == "secondary" else "rwm_expected_pct"
-
+    if metric in rows.columns:
-    # Alphabetical, not by score. A place page is read by someone looking for
+        rows = rows.sort_values(metric, ascending=False, na_position="last")
-    # a school they can name, and scanning for it is what the order should
-    # serve. /rankings is where the league-table ordering lives, and it keeps
-    # sorting by metric.
-    if "school_name" in rows.columns:
-        rows = rows.sort_values("school_name", key=lambda c: c.str.lower())
 
     averages = {
         m: (None if m not in rows.columns or rows[m].dropna().empty
@@ -1237,13 +1232,6 @@ async def get_place(request: Request, kind: str, slug: str,
         "place": {"kind": place.kind, "slug": place.slug, "name": place.name,
                   "count": len(place.urns),
                   "parent_authority": place.parent_authority,
-                  # Every authority the place meaningfully sits in. SW19 is
-                  # mostly Merton but partly Wandsworth; naming one asserts
-                  # something false.
-                  "authorities": [
-                      {"name": name, "slug": _slugify(name), "count": n}
-                      for name, n in place.authorities
-                  ],
                   # Only phases that clear the threshold, so the page links
                   # variants that exist rather than 404s.
                   "phases": [ph for ph in ("primary", "secondary")

backend/places.py

@@ -30,12 +30,6 @@ class Place:
     name: str
     urns: tuple[int, ...]
     parent_authority: str | None    # authority NAME, for the 301 target
-    # Every authority the place meaningfully sits in, largest first. A quarter
-    # of outcodes and a third of towns straddle a boundary — SW19 is mostly
-    # Merton but partly Wandsworth — so naming only one asserts something
-    # false. parent_authority stays single because a redirect needs one
-    # target; this is what the page shows.
-    authorities: tuple[tuple[str, int], ...] = ()
     # URNs per phase, so the per-phase threshold can be applied without
     # re-querying. A place with 30 primaries and 2 secondaries publishes a
     # primary variant and no secondary one.
@@ -59,151 +53,57 @@ def _publishable_urns(df) -> set[int]:
     return set(df.loc[df[cols].notna().any(axis=1), "urn"].astype(int))
 
 
-# The measure a phase page is built around. A page with no results in this
-# column has nothing a list of school names does not already give.
-_PHASE_METRIC = {
-    "primary": "rwm_expected_pct",
-    "secondary": "attainment_8_score",
-}
-
-
 def _phase_urns(group, publishable: set[int]) -> dict[str, tuple[int, ...]]:
-    """URNs per phase, counting only schools with a result for that phase.
+    """URNs per phase. All-through schools count toward both, matching the
-
+    PHASE_GROUPS mapping the search filters already use."""
-    Not merely "publishable". A school with an Ofsted grade and no results is
-    worth a page of its own and belongs in the place list, but it cannot
-    populate a phase page's results column — and the threshold is there to ask
-    whether that column will have anything in it.
-
-    Counting publishable schools instead let /schools/kent/primary publish
-    with none of its five rows carrying a result, and left 44 phase pages
-    majority-blank. It is the same rule as "no page without a local average",
-    which was never extended per phase.
-
-    All-through schools count toward both phases, matching the PHASE_GROUPS
-    mapping the search filters already use.
-    """
     from backend.app import PHASE_GROUPS
 
     if "phase" not in group.columns:
         return {}
     lowered = group["phase"].fillna("").str.lower()
-
     out: dict[str, tuple[int, ...]] = {}
     for phase in ("primary", "secondary"):
         wanted = PHASE_GROUPS.get(phase, set())
         subset = group[lowered.isin(wanted)]
-
-        # The page lists every school of the phase; the threshold counts only
-        # those carrying a result, so a mostly-empty table never publishes.
-        metric = _PHASE_METRIC[phase]
-        with_result = (
-            {int(u) for u in subset.loc[subset[metric].notna(), "urn"]}
-            if metric in subset.columns else set()
-        )
-        if len(with_result & publishable) < MIN_SCHOOLS:
-            continue
-
         urns = tuple(sorted({int(u) for u in subset["urn"]} & publishable))
         if urns:
             out[phase] = urns
     return out
 
 
-# A place is described by an authority when it holds at least a tenth of the
+def _parent_authority(group) -> str | None:
-# schools, and at least two. GIAS carries occasional postcode errors — EN6
+    """The most common authority in a group — the useful 301 target.
-# lists two Shropshire schools among fourteen in Hertfordshire — and a bare
-# "any authority present" rule would print those as though they were real.
-# There is deliberately no cap on how many are named. An earlier cut stopped
-# at three, which silently dropped the fourth in exactly the case where the
-# information matters most — a genuinely fragmented place. The share rule is
-# the only limit, and it already bounds the list at ten.
-_AUTHORITY_MIN_SHARE = 0.10
-_AUTHORITY_MIN_SCHOOLS = 2
 
-
+    A town spanning several authorities has no single parent, so the mode is
-def _authorities(group) -> tuple[tuple[str, int], ...]:
+    the honest answer rather than an arbitrary first row.
-    """Authorities this place meaningfully sits in, largest first."""
-    from backend.app import EXCLUDED_FILTER_VALUES
-
-    if "local_authority" not in group.columns:
-        return ()
-    counts = group["local_authority"].dropna().value_counts()
-    total = int(counts.sum())
-    if not total:
-        return ()
-
-    kept = [
-        (str(name), int(n)) for name, n in counts.items()
-        if str(name) not in EXCLUDED_FILTER_VALUES
-        and n >= _AUTHORITY_MIN_SCHOOLS
-        and n / total >= _AUTHORITY_MIN_SHARE
-    ]
-    # A place too small or too fragmented for the share rule still names its
-    # largest authority, or the page would say nothing about where it is.
-    if not kept:
-        for name, n in counts.items():
-            if str(name) not in EXCLUDED_FILTER_VALUES:
-                return ((str(name), int(n)),)
-        return ()
-    return tuple(kept)
-
-
-def _parent_authority(authorities: tuple[tuple[str, int], ...]) -> str | None:
-    """The 301 target: the largest authority a place sits in.
-
-    Derived from `authorities` rather than computed separately. The first cut
-    used `mode()` here while `authorities` used `value_counts()`, and on an
-    exact tie pandas does not guarantee the two pick the same name — so the
-    redirect could have pointed somewhere other than the authority the page
-    named first. One computation, one answer.
-
-    Deriving it also inherits the sentinel filter, so a place can no longer
-    redirect to /schools/authority/does-not-apply.
     """
-    return authorities[0][0] if authorities else None
+    if "local_authority" not in group.columns:
+        return None
+    top = group["local_authority"].dropna()
+    return str(top.mode().iloc[0]) if not top.empty else None
 
 
 def _group(df, column: str, kind: str, publishable: set[int]) -> dict[str, Place]:
-    """One Place per distinct SLUG in `column` that clears the threshold.
+    """One Place per distinct value of `column` that clears the threshold."""
-
-    Grouped by slug, not by raw value, because GIAS spells the same place
-    several ways and they all resolve to one URL. Five town slugs come from
-    more than one spelling: "London" (1,819 schools) and "LONDON" (12) both
-    slugify to `london`; Weston-super-Mare is split 14/19 across two
-    spellings; Newcastle-under-Lyme across three.
-
-    Grouping by raw value meant the later group simply overwrote the earlier
-    one in this dict — so /schools/london could have shown twelve schools
-    instead of 1,819, silently and depending on row order.
-
-    The display name is the most common spelling, which is the one a reader
-    expects to see.
-    """
     from backend.app import _slugify
 
     if column not in df.columns:
         return {}
 
-    working = df.assign(_slug=df[column].map(
-        lambda v: _slugify(str(v).strip()) if isinstance(v, str) and v.strip() else None))
-    working = working[working["_slug"].notna() & (working["_slug"] != "")]
-
     out: dict[str, Place] = {}
-    for slug, group in working.groupby("_slug"):
+    for name, group in df.groupby(column, dropna=True):
-        slug = str(slug)
+        name = str(name).strip()
+        if not name:
+            continue
         urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
         if len(urns) < MIN_SCHOOLS:
             continue
-        spellings = group[column].dropna().value_counts()
+        slug = _slugify(name)
-        if spellings.empty:
+        if not slug:
             continue
-        name = str(spellings.index[0]).strip()
-        authorities = () if kind == "authority" else _authorities(group)
         place = Place(
             kind=kind, slug=slug, name=name, urns=urns,
-            parent_authority=_parent_authority(authorities),
+            parent_authority=_parent_authority(group) if kind == "town" else None,
-            authorities=authorities,
             phase_urns=_phase_urns(group, publishable),
         )
         out[place.key] = place
@@ -236,10 +136,8 @@ def _outcode_places(df, publishable: set[int]) -> dict[str, Place]:
         urns = tuple(sorted({int(u) for u in group["urn"]} & publishable))
         if len(urns) < MIN_SCHOOLS:
             continue
-        authorities = _authorities(group)
         place = Place(kind="outcode", slug=str(oc).lower(), name=str(oc),
-                      urns=urns, parent_authority=_parent_authority(authorities),
+                      urns=urns, parent_authority=_parent_authority(group),
-                      authorities=authorities,
                       phase_urns=_phase_urns(group, publishable))
         out[place.key] = place
     return out
@@ -281,10 +179,8 @@ def _locality_places(df, publishable: set[int],
                 "threshold of %d - not published",
                 slug, ", ".join(outcodes), len(urns), MIN_SCHOOLS)
             continue
-        authorities = _authorities(group)
         place = Place(kind="locality", slug=slug, name=name, urns=urns,
-                      parent_authority=_parent_authority(authorities),
+                      parent_authority=_parent_authority(group),
-                      authorities=authorities,
                       phase_urns=_phase_urns(group, publishable))
         out[place.key] = place
     return out

backend/tests/test_places.py

@@ -229,163 +229,3 @@ def test_no_curated_locality_names_a_london_borough():
         f"these are boroughs, not districts: {sorted(named)} - they already "
         "have an authority page covering every school"
     )
-
-
-def test_a_place_names_every_authority_it_straddles():
-    """SW19 is mostly Merton but partly Wandsworth.
-
-    A quarter of viable outcodes and a third of viable towns cross an
-    authority boundary, so naming only the largest asserts something false.
-    """
-    rows = (_town(26, "London", "Merton", start=300000)
-            + _town(7, "London", "Wandsworth", start=400000))
-    for r in rows:
-        r["postcode"] = "SW19 1AA"
-    reg = build_place_registry(_df(rows))
-
-    names = [n for n, _ in reg["outcode:sw19"].authorities]
-    assert names == ["Merton", "Wandsworth"]          # largest first
-    assert dict(reg["outcode:sw19"].authorities)["Wandsworth"] == 7
-
-
-def test_the_redirect_target_stays_a_single_authority():
-    # parent_authority and authorities do different jobs: a 301 needs one
-    # target, the page needs the truth.
-    rows = (_town(26, "London", "Merton", start=300000)
-            + _town(7, "London", "Wandsworth", start=400000))
-    for r in rows:
-        r["postcode"] = "SW19 1AA"
-    reg = build_place_registry(_df(rows))
-    assert reg["outcode:sw19"].parent_authority == "Merton"
-
-
-def test_a_stray_authority_below_the_share_threshold_is_not_named():
-    # GIAS carries postcode errors — EN6 lists two Shropshire schools among
-    # fourteen in Hertfordshire. Printing those as though real would be worse
-    # than omitting them.
-    rows = (_town(30, "Barnet", "Hertfordshire", start=300000)
-            + _town(1, "Barnet", "Shropshire", start=400000))
-    for r in rows:
-        r["postcode"] = "EN6 1AA"
-    reg = build_place_registry(_df(rows))
-    assert [n for n, _ in reg["outcode:en6"].authorities] == ["Hertfordshire"]
-
-
-def test_a_sentinel_authority_is_never_named():
-    rows = (_town(20, "London", "Merton", start=300000)
-            + _town(6, "London", "Does not apply", start=400000))
-    for r in rows:
-        r["postcode"] = "SW19 1AA"
-    reg = build_place_registry(_df(rows))
-    assert [n for n, _ in reg["outcode:sw19"].authorities] == ["Merton"]
-
-
-def test_a_place_always_names_at_least_one_authority():
-    # Even when every authority is below the share threshold, the page has to
-    # say where the place is.
-    rows = []
-    for i, la in enumerate(["A", "B", "C", "D", "E", "F", "G"]):
-        rows += _town(1, "Fragmented", la, start=300000 + i * 100)
-    reg = build_place_registry(_df(rows))
-    place = reg.get("town:fragmented")
-    assert place is not None
-    assert len(place.authorities) == 1
-
-
-def test_every_qualifying_authority_is_named_with_no_cap():
-    """An earlier cut stopped at three, dropping the fourth silently.
-
-    That truncation bit exactly where the information matters most — a
-    genuinely fragmented place — and nothing recorded it.
-    """
-    rows = []
-    for i, la in enumerate(["Hackney", "Lambeth", "Westminster", "Lewisham"]):
-        rows += _town(3, "Fourway", la, start=300000 + i * 100)
-    reg = build_place_registry(_df(rows))
-    assert len(reg["town:fourway"].authorities) == 4
-
-
-def test_the_redirect_target_is_the_authority_named_first():
-    """They were computed separately — mode() against value_counts() — and on
-    an exact tie pandas does not guarantee the two agree."""
-    rows = (_town(26, "London", "Merton", start=300000)
-            + _town(7, "London", "Wandsworth", start=400000))
-    for r in rows:
-        r["postcode"] = "SW19 1AA"
-    place = build_place_registry(_df(rows))["outcode:sw19"]
-    assert place.parent_authority == place.authorities[0][0]
-
-
-def test_a_place_never_redirects_to_a_sentinel_authority():
-    # Deriving the parent from `authorities` inherits its sentinel filter.
-    rows = (_town(6, "Someplace", "Does not apply", start=300000)
-            + _town(5, "Someplace", "Essex", start=400000))
-    reg = build_place_registry(_df(rows))
-    assert reg["town:someplace"].parent_authority == "Essex"
-
-
-def test_spellings_of_one_place_are_merged_not_overwritten():
-    """GIAS spells the same place several ways, and they share a URL.
-
-    "London" (1,819 schools) and "LONDON" (12) both slugify to `london`.
-    Grouping by raw value let the later group overwrite the earlier one, so
-    the page could have shown twelve schools instead of 1,819 — silently, and
-    depending on row order.
-    """
-    rows = (_town(6, "Weston-super-Mare", "North Somerset", start=300000)
-            + _town(5, "Weston-Super-Mare", "North Somerset", start=400000))
-    reg = build_place_registry(_df(rows))
-    assert len(reg["town:weston-super-mare"].urns) == 11
-
-
-def test_the_merged_place_takes_its_most_common_spelling():
-    rows = (_town(9, "Newcastle-under-Lyme", "Staffordshire", start=300000)
-            + _town(5, "NEWCASTLE-UNDER-LYME", "Staffordshire", start=400000))
-    reg = build_place_registry(_df(rows))
-    assert reg["town:newcastle-under-lyme"].name == "Newcastle-under-Lyme"
-
-
-def test_a_phase_page_needs_results_not_merely_publishable_schools():
-    """/schools/kent/primary published with none of its five rows scored.
-
-    The threshold counted schools that were publishable — a result OR an
-    Ofsted grade — while the page exists for its results column. Forty-four
-    phase pages were majority-blank; one had no results at all.
-    """
-    rows = _town(MIN_SCHOOLS, "Kent", "Kent")
-    for r in rows:
-        r["rwm_expected_pct"] = np.nan     # Ofsted only, no results
-    reg = build_place_registry(_df(rows))
-
-    assert "town:kent" in reg               # the place still publishes
-    assert not reg["town:kent"].publishes_phase("primary")
-
-
-def test_a_phase_page_publishes_once_enough_schools_carry_a_result():
-    rows = _town(MIN_SCHOOLS, "Beccles", "Suffolk")
-    reg = build_place_registry(_df(rows))
-    assert reg["town:beccles"].publishes_phase("primary")
-
-
-def test_a_publishing_phase_page_still_lists_its_unscored_schools():
-    """The threshold gates whether the page exists; it does not filter rows.
-
-    A parent looking up a school by name has to find it whether or not it
-    published results.
-    """
-    scored = _town(MIN_SCHOOLS, "Beccles", "Suffolk", start=300000)
-    unscored = _town(2, "Beccles", "Suffolk", start=400000)
-    for r in unscored:
-        r["rwm_expected_pct"] = np.nan
-    reg = build_place_registry(_df(scored + unscored))
-
-    place = reg["town:beccles"]
-    assert place.publishes_phase("primary")
-    assert len(place.phase_urns["primary"]) == MIN_SCHOOLS + 2
-
-
-def test_the_secondary_threshold_counts_its_own_metric():
-    # A town full of scored primaries must not thereby publish a secondary page.
-    rows = _town(MIN_SCHOOLS, "Brentwood", "Essex")
-    reg = build_place_registry(_df(rows))
-    assert not reg["town:brentwood"].publishes_phase("secondary")

backend/tests/test_places_api.py

@@ -45,30 +45,10 @@ def test_registry_carries_a_count_per_place(client):
     assert town["count"] == 6
 
 
-def test_place_detail_returns_its_schools_alphabetically(client):
+def test_place_detail_returns_its_schools_ranked(client):
-    """A place page is read by someone looking for a school they can name.
-
-    Scanning for it is what the order should serve, so the list is A-Z.
-    /api/rankings is where the league-table ordering lives.
-    """
     body = client.get("/api/places/town/brentwood").json()
     assert body["place"]["name"] == "Brentwood"
-    names = [s["school_name"] for s in body["schools"]]
+    scores = [s["rwm_expected_pct"] for s in body["schools"]]
-    assert names == sorted(names, key=str.lower)
-
-
-def test_place_ordering_ignores_case(client):
-    body = client.get("/api/places/town/brentwood").json()
-    names = [s["school_name"] for s in body["schools"]]
-    # A capitalised name must not sort ahead of every lowercase one.
-    assert names == sorted(names, key=str.lower)
-
-
-def test_the_rankings_endpoint_still_ranks_by_metric(client):
-    # Alphabetical is a place-page decision, not a site-wide one.
-    body = client.get("/api/rankings?metric=rwm_expected_pct&phase=primary").json()
-    scores = [r["rwm_expected_pct"] for r in body.get("rankings", [])
-              if r.get("rwm_expected_pct") is not None]
     assert scores == sorted(scores, reverse=True)
 
 

e2e/tests/journeys.spec.ts

@@ -1649,29 +1649,13 @@ const CANONICAL_ROUTES: Array<[string, string]> = [
   ['/admissions', 'https://www.schoolcompare.co.uk/admissions'],
 ];
 
-/**
- * Next normalises canonical URLs against `trailingSlash: false`, so the root
- * ships as `https://www.schoolcompare.co.uk` with no slash while every other
- * route keeps its path. Both forms address the same document, and which one
- * Next emits is its business, not something worth pinning a test to.
- *
- * The first cut hardcoded the slash and failed only on the homepage — the
- * same gap as the doubled brand: it asserted the metadata object rather than
- * what the page actually renders.
- */
-function sameUrl(a: string | null, b: string): boolean {
-  const strip = (u: string) => u.replace(/\/+$/, '');
-  return strip(a ?? '') === strip(b);
-}
-
 for (const [path, expected] of CANONICAL_ROUTES) {
   test(`${path} declares exactly one canonical, on the www host`, async ({ page }) => {
     await page.goto(path);
     const hrefs = await page.locator('link[rel="canonical"]').evaluateAll(
       (els) => els.map((e) => e.getAttribute('href')));
     expect(hrefs, `${path} should declare one canonical`).toHaveLength(1);
-    expect(sameUrl(hrefs[0], expected),
+    expect(hrefs[0]).toBe(expected);
-      `${path} canonical was ${hrefs[0]}, expected ${expected}`).toBe(true);
   });
 }
 
@@ -1679,8 +1663,7 @@ test('a filtered homepage still canonicalises to the bare root', async ({ page }
   await page.goto('/?search=primary&phase=primary&sort=name&page=2');
   const href = await page.locator('link[rel="canonical"]').first()
     .getAttribute('href');
-  expect(sameUrl(href, 'https://www.schoolcompare.co.uk/'),
+  expect(href).toBe('https://www.schoolcompare.co.uk/');
-    `filtered homepage canonical was ${href}`).toBe(true);
 });
 
 test('a school page canonicalises to its own slug on the www host', async ({ page }) => {
@@ -1731,33 +1714,10 @@ test('staging answers noindex, and stays crawlable so the noindex is seen', asyn
   // The other half, and the reason this is one test rather than two: a
   // Disallow would stop Google fetching the page at all, so it would never
   // see the noindex above. The two only work together.
-  //
-  // Scoped to the `*` group. The first cut matched `Disallow: /` anywhere in
-  // the file and tripped over the AI-crawler groups Cloudflare injects —
-  // ClaudeBot, GPTBot, Amazonbot and friends all carry a blanket disallow,
-  // deliberately, and none of them is Googlebot.
   const robots = await (await page.request.get('/robots.txt')).text();
-  expect(blocksEverything(robots, '*'),
+  expect(robots).not.toMatch(/^\s*Disallow:\s*\/\s*$/mi);
-    'the * group must not disallow the whole site, or the noindex is never seen')
-    .toBe(false);
 });
 
-/** True when `agent`'s group in a robots.txt disallows the entire site. */
-function blocksEverything(robots: string, agent: string): boolean {
-  let current: string | null = null;
-  let blocked = false;
-  for (const raw of robots.split('\n')) {
-    const line = raw.split('#')[0].trim();
-    if (!line) continue;
-    const [key, ...rest] = line.split(':');
-    const value = rest.join(':').trim();
-    const k = key.trim().toLowerCase();
-    if (k === 'user-agent') current = value;
-    else if (current === agent && k === 'disallow' && value === '/') blocked = true;
-  }
-  return blocked;
-}
-
 test('a school page on staging is noindexed too, not just the homepage', async ({ page }) => {
   const list = await page.request.get('/api/schools?search=primary&per_page=1');
   const [first] = (await list.json()).schools ?? [];
@@ -1925,57 +1885,3 @@ test('no page title repeats the brand', async ({ page }) => {
     expect(brands, `${path} repeats the brand: ${title}`).toBeLessThanOrEqual(1);
   }
 });
-
-test('a place straddling a boundary names every authority it sits in', async ({ page }) => {
-  // A quarter of outcodes and a third of towns cross an authority boundary —
-  // SW19 is mostly Merton but partly Wandsworth. Naming only the largest
-  // asserts something false about the place.
-  const { places } = await (await page.request.get('/api/places')).json();
-  const outcode = places.find((p: { kind: string }) => p.kind === 'outcode');
-  expect(outcode).toBeTruthy();
-
-  // Find any place the registry reports as straddling.
-  let straddling: { kind: string; slug: string } | null = null;
-  for (const p of places.filter((p: { kind: string }) => p.kind === 'outcode').slice(0, 40)) {
-    const d = await (await page.request.get(`/api/places/outcode/${p.slug}`)).json();
-    if ((d.place.authorities ?? []).length > 1) { straddling = p; break; }
-  }
-  test.skip(!straddling, 'no straddling outcode found in the sample');
-
-  const detail = await (await page.request.get(
-    `/api/places/outcode/${straddling!.slug}`)).json();
-  await page.goto(`/schools/near/${straddling!.slug}`);
-
-  for (const a of detail.place.authorities) {
-    await expect(page.locator(`a[href="/schools/authority/${a.slug}"]`).first())
-      .toBeVisible();
-  }
-});
-
-test('a place page lists its schools alphabetically', async ({ page }) => {
-  // Someone on a place page is usually looking for a school they can name,
-  // so the order should serve scanning for it. /rankings is where the
-  // league-table ordering lives.
-  const { places } = await (await page.request.get('/api/places')).json();
-  const town = places.find((p: { kind: string; count: number }) =>
-    p.kind === 'town' && p.count >= 5);
-  expect(town).toBeTruthy();
-
-  await page.goto(`/schools/${town.slug}`);
-  const names = await page.locator('a[href^="/school/"]').allTextContents();
-  expect(names.length).toBeGreaterThan(1);
-
-  const sorted = [...names].sort((a, b) =>
-    a.toLowerCase().localeCompare(b.toLowerCase()));
-  expect(names).toEqual(sorted);
-});
-
-test('the rankings page still orders by score, not name', async ({ page }) => {
-  // Alphabetical is a place-page decision, not a site-wide one.
-  const res = await page.request.get('/api/rankings?metric=rwm_expected_pct&phase=primary');
-  expect(res.ok()).toBeTruthy();
-  const scores = ((await res.json()).rankings ?? [])
-    .map((r: { rwm_expected_pct: number | null }) => r.rwm_expected_pct)
-    .filter((v: number | null) => v != null);
-  expect(scores).toEqual([...scores].sort((a: number, b: number) => b - a));
-});

nextjs-app/__tests__/components/PlaceView.test.tsx

@@ -168,111 +168,3 @@ describe('PlaceView presentation', () => {
       .not.toBeInTheDocument();
   });
 });
-
-describe('PlaceView table alignment', () => {
-  const aligned: PlaceDetail = {
-    place: { kind: 'town', slug: 'brentwood', name: 'Brentwood', count: 2,
-             parent_authority: 'Essex', phases: ['primary'] },
-    schools: [
-      { urn: 1, school_name: 'Alpha Primary', phase: 'Primary',
-        rwm_expected_pct: 82, attainment_8_score: null } as never,
-    ],
-    averages: { rwm_expected_pct: 63, attainment_8_score: null },
-  };
-
-  it('aligns the measure heading and its values with the same class', () => {
-    // They were aligned by two different selectors whose specificity did not
-    // match: `.table th:last-child` (0,2,1) won and went right, while `.num`
-    // (0,1,0) lost to `.table td` (0,1,1) and stayed left. Sharing one class
-    // is what makes them impossible to drift apart.
-    const { container } = render(<PlaceView detail={aligned} englandAverage={61}
-      neighbours={[]} />);
-    const th = container.querySelectorAll('th')[1];
-    const td = container.querySelectorAll('tbody td')[1];
-    expect(th.className).toBeTruthy();
-    expect(td.className).toBe(th.className);
-  });
-
-  it('leaves the school-name column unclassed so it takes the spare width', () => {
-    const { container } = render(<PlaceView detail={aligned} englandAverage={61}
-      neighbours={[]} />);
-    expect(container.querySelectorAll('th')[0].className).toBe('');
-  });
-});
-
-describe('PlaceView authorities', () => {
-  const straddling: PlaceDetail = {
-    place: { kind: 'outcode', slug: 'sw19', name: 'SW19', count: 33,
-             parent_authority: 'Merton', phases: ['primary'],
-             authorities: [
-               { name: 'Merton', slug: 'merton', count: 26 },
-               { name: 'Wandsworth', slug: 'wandsworth', count: 7 },
-             ] },
-    schools: [
-      { urn: 1, school_name: 'Alpha Primary', phase: 'Primary',
-        rwm_expected_pct: 82, attainment_8_score: null } as never,
-    ],
-    averages: { rwm_expected_pct: 63, attainment_8_score: null },
-  };
-
-  it('names every authority the place straddles, not just the largest', () => {
-    // SW19 is mostly Merton but partly Wandsworth. Naming one asserts
-    // something false about a quarter of outcodes.
-    render(<PlaceView detail={straddling} englandAverage={61} neighbours={[]} />);
-    expect(screen.getByRole('link', { name: 'Merton' }))
-      .toHaveAttribute('href', '/schools/authority/merton');
-    expect(screen.getByRole('link', { name: 'Wandsworth' }))
-      .toHaveAttribute('href', '/schools/authority/wandsworth');
-  });
-
-  it('joins them readably rather than as a bare list', () => {
-    // Asserted on the summary line's whole text: a loose /and/ matcher also
-    // hits "Wandsworth".
-    const { container } = render(<PlaceView detail={straddling}
-      englandAverage={61} neighbours={[]} />);
-    const summary = container.querySelector('header p');
-    expect(summary?.textContent).toContain('Merton and Wandsworth');
-  });
-
-  it('falls back to the single parent when the field is absent', () => {
-    // A cached API response predating the authorities field must not blank
-    // the line entirely.
-    const legacy = { ...straddling,
-      place: { ...straddling.place, authorities: undefined } };
-    render(<PlaceView detail={legacy} englandAverage={61} neighbours={[]} />);
-    expect(screen.getByRole('link', { name: 'Merton' })).toBeInTheDocument();
-  });
-});
-
-describe('PlaceView list ordering', () => {
-  const detail3: PlaceDetail = {
-    place: { kind: 'town', slug: 'brentwood', name: 'Brentwood', count: 2,
-             parent_authority: 'Essex', phases: ['primary'] },
-    schools: [
-      { urn: 1, school_name: 'Alpha Primary', phase: 'Primary',
-        rwm_expected_pct: 40, attainment_8_score: null } as never,
-      { urn: 2, school_name: 'Beta Primary', phase: 'Primary',
-        rwm_expected_pct: 90, attainment_8_score: null } as never,
-    ],
-    averages: { rwm_expected_pct: 65, attainment_8_score: null },
-  };
-
-  it('renders schools in the order the API sent them, not by score', () => {
-    // The API sorts alphabetically now; the component must not re-sort.
-    render(<PlaceView detail={detail3} englandAverage={61} neighbours={[]} />);
-    const links = screen.getAllByRole('link', { name: /Primary$/ });
-    expect(links.map((l) => l.textContent))
-      .toEqual(['Alpha Primary', 'Beta Primary']);
-  });
-
-  it('declares the list as ascending rather than implying a ranking', () => {
-    // An ItemList carrying `position` reads as a ranking unless it says
-    // otherwise, and the table is A-Z.
-    const { container } = render(<PlaceView detail={detail3} englandAverage={61}
-      neighbours={[]} />);
-    const ld = JSON.parse(
-      container.querySelector('script[type="application/ld+json"]')!.textContent!);
-    const list = ld['@graph'].find((n: { '@type': string }) => n['@type'] === 'ItemList');
-    expect(list.itemListOrder).toBe('https://schema.org/ItemListOrderAscending');
-  });
-});

nextjs-app/app/schools/[place]/[phase]/page.tsx

@@ -37,12 +37,10 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
   const word = phase === 'secondary' ? 'Secondary' : 'Primary';
   const { name } = detail.place;
   return {
-    // Not "Ranked": the table is alphabetical, so the word would be a claim
+    title: { absolute: `${word} Schools in ${name} — Ranked | schoolcompare` },
-    // the page does not keep.
-    title: { absolute: `${word} Schools in ${name} | schoolcompare` },
     description:
-      `Every ${phase} school in ${name}, with results, Ofsted grades and the local `
+      `Every ${phase} school in ${name} ranked by results, with Ofsted grades and `
-      + `average against England.`,
+      + `the local average against England.`,
     alternates: { canonical: absoluteUrl(`/schools/${slug}/${phase}`) },
   };
 }

nextjs-app/app/schools/[place]/page.tsx

@@ -58,8 +58,8 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
     // place title read '... | schoolcompare | schoolcompare'.
     title: { absolute: `Schools in ${name} — Compare ${count} Schools | schoolcompare` },
     description:
-      `Every school in ${name}, with SATs and GCSE results, Ofsted grades, the local `
+      `Every school in ${name} ranked by SATs and GCSE results, with Ofsted grades, `
-      + `average against England, and how close you had to live to get a place.`,
+      + `the local average against England, and how close you had to live to get a place.`,
     alternates: { canonical: absoluteUrl(`/schools/${slug}`) },
   };
 }

nextjs-app/app/schools/authority/[la]/page.tsx

@@ -45,8 +45,8 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
   return {
     title: { absolute: `Schools in ${name} — Local Authority | schoolcompare` },
     description:
-      `All ${count} schools in the ${name} local authority, with SATs and GCSE results, `
+      `All ${count} schools in the ${name} local authority, ranked by SATs and GCSE `
-      + `Ofsted grades and the authority average against England.`,
+      + `results, with Ofsted grades and the authority average against England.`,
     alternates: { canonical: absoluteUrl(`/schools/authority/${la}`) },
   };
 }

nextjs-app/app/schools/near/[outcode]/page.tsx

@@ -40,8 +40,8 @@ export async function generateMetadata({ params }: Props): Promise<Metadata> {
   return {
     title: { absolute: `Schools near ${name} | schoolcompare` },
     description:
-      `${count} schools in the ${name} postcode district, with results, Ofsted grades `
+      `${count} schools in the ${name} postcode district, ranked by results, with `
-      + `and how close you had to live to get a place.`,
+      + `Ofsted grades and how close you had to live to get a place.`,
     alternates: { canonical: absoluteUrl(`/schools/near/${outcode}`) },
   };
 }

nextjs-app/components/places/PlaceView.module.css

@@ -144,24 +144,10 @@
   border-bottom: none;
 }
 
-/*
+.table th:last-child,
- * Header and value share one class and one rule, so they cannot drift apart.
+.num {
- *
- * The first cut aligned them with two different selectors: `.table th:last-child`
- * at (0,2,1) beat the element rule and went right, while `.num` at (0,1,0) lost
- * to `.table td` at (0,1,1) and stayed left. The heading and its numbers sat on
- * opposite edges of the column.
- *
- * width:1% with nowrap makes the measure column hug its content so the school
- * name takes the remaining width — without it the two columns split evenly and
- * the gap between heading and value reads as misalignment on a wide screen.
- */
-.table th.num,
-.table td.num {
   text-align: right;
   font-variant-numeric: tabular-nums;
-  width: 1%;
-  white-space: nowrap;
 }
 
 /* The measure is spelled out; the tooltip carries the definition. */

nextjs-app/components/places/PlaceView.tsx

@@ -71,9 +71,7 @@ function SchoolTable({ schools, phase }: { schools: School[]; phase: PhaseKey })
         <thead>
           <tr>
             <th scope="col">School</th>
-            {/* Same class as the value cell below: one rule aligns both, so
+            <th scope="col">
-                they cannot drift apart. */}
-            <th scope="col" className={styles.num}>
               <abbr className={styles.metricHead} title={metric.hint}>
                 {metric.heading}
               </abbr>
@@ -106,13 +104,6 @@ function SchoolTable({ schools, phase }: { schools: School[]; phase: PhaseKey })
 
 export function PlaceView({ detail, phase, englandAverage, neighbours }: Props) {
   const { place, schools, averages } = detail;
-  // Fall back to the single parent when the API predates the authorities
-  // field, so a stale cache never blanks the line entirely.
-  const authorities = place.authorities?.length
-    ? place.authorities
-    : place.parent_authority
-      ? [{ name: place.parent_authority, slug: authoritySlug(place.parent_authority), count: 0 }]
-      : [];
   const local = averages[METRICS[phase ?? 'primary'].key];
   const phaseWord = phase === 'secondary' ? 'Secondary schools'
     : phase === 'primary' ? 'Primary schools' : 'Schools';
@@ -142,10 +133,6 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
         '@type': 'ItemList',
         name: `${phaseWord} in ${place.name}`,
         numberOfItems: schools.length,
-        // Alphabetical, and said so. Without this an ItemList carrying
-        // `position` reads as a ranking, which would be a claim the page
-        // stopped making when the table became A-Z.
-        itemListOrder: 'https://schema.org/ItemListOrderAscending',
         itemListElement: schools.slice(0, 20).map((s, i) => ({
           '@type': 'ListItem',
           position: i + 1,
@@ -174,20 +161,13 @@ export function PlaceView({ detail, phase, englandAverage, neighbours }: Props)
         <h1>{phaseWord} in {place.name}</h1>
         <p className={styles.summary}>
           {place.count} schools
-          {authorities.length > 0 && (
+          {place.parent_authority && (
             <>
               {' · '}
-              {/* Every authority, not just the largest. A quarter of outcodes
+              <Link href={`/schools/authority/${authoritySlug(place.parent_authority)}`}
-                  and a third of towns cross a boundary: SW19 is mostly Merton
+                className={styles.inlineLink}>
-                  but partly Wandsworth, and naming one asserts otherwise. */}
+                {place.parent_authority}
-              {authorities.map((a, i) => (
+              </Link>
-                <span key={a.slug}>
-                  {i > 0 && (i === authorities.length - 1 ? ' and ' : ', ')}
-                  <Link href={`/schools/authority/${a.slug}`} className={styles.inlineLink}>
-                    {a.name}
-                  </Link>
-                </span>
-              ))}
             </>
           )}
         </p>

nextjs-app/lib/places.ts

@@ -18,19 +18,8 @@ export interface PlaceSummary {
   phases?: string[];
 }
 
-export interface PlaceAuthority {
-  name: string;
-  slug: string;
-  count: number;
-}
-
 export interface PlaceDetail {
-  place: PlaceSummary & {
+  place: PlaceSummary & { parent_authority: string | null };
-    parent_authority: string | null;
-    /** Every authority the place meaningfully sits in, largest first. SW19 is
-     *  mostly Merton but partly Wandsworth. */
-    authorities?: PlaceAuthority[];
-  };
   schools: School[];
   averages: {
     rwm_expected_pct: number | null;