Журнал изменений

Stage 1 of docs/COMMENTS-REDESIGN-2026.md closes here. The comment table now has exactly one owner: the three global helpers that shared it are gone, the last consumer reaching it through an assembled table name is closed, and a guard test asserts the boundary for the whole stage rather than for one batch.

Core changes:

1. Counter and resolver absorbed (core/classes/comment.php):

2. numcom() becomes the private updateTargetCount()

   • three unreachable branches dropped: account/members, gallery, multimedia
   • their points slots 3, 17 and 29 leave the code; the users.points CSV keeps

all 45 positions, because the list is indexed positionally

• getCommentMode() becomes the public getTargetMode()

• both index one MODULES map holding the target table and the points slot of the eight modules that render comments

  • the counter map and the supported-module list stop being two lists
• getStatusCount() added for the admin sidebar
• The HTML monolith is deleted (core/system.php, core/user.php):

• ashowcom() removed; its frontend half is getCommentList() in core/user.php, directly above setComShow(), which is where the design puts the rendering

• the seven defined('ADMIN_FILE') branches are deleted rather than moved

  • core/user.php is required only under MODULE_FILE, so they were unreachable
• core/system.php shrinks from 5944 to 5689 lines
• The last direct consumer is closed (core/admin.php):
• the waiting-content chip reads getStatusCount(CommentStatus::Pending)

• getAdminCountRow() takes an optional precomputed count and skips its own query when it is given; the other fifteen sidebar rows are unchanged

• the dead table, where and rate keys leave the comment entry of getProfileModules(), which is the shape that hid two consumers from earlier sweeps

• Stage guard (tests/Unit/CommentIsolationTest.php):
• no production file but the class names the comment table

• the files that build a table name from a variable are a closed list, and neither getProfileModules() nor getAdminCountRow() can be handed comments

• the retired globals are defined nowhere and named nowhere

• the module map keeps its eight modules and their slots; the points CSV keeps its length

Benefits:

• one reader and one writer for the comment table, so a counter can no longer drift from the rows it counts

• the resolver that authorizes a target and the counter that follows a write sit behind the same private boundary, so the trust boundary stage 0 closed cannot be reopened from inside the project

• the render is 135 lines of markup assembly with no SQL and no dead branches

Technical notes:

• no table or column changes

• behaviour and markup preserved: 80 URLs per round compared against the pre-move tree, 80/80 identical descending, and the moderator branch the guest probe cannot reach proven by source equivalence

• measured on the live table: no stored row carries a module outside the map, so the dropped counter branches were unreachable in data as well as in code

• breaking change for third-party code: ashowcom(), numcom() and getCommentMode() no longer exist; no wrapper and no alias is provided

Stage 1, batch 5 of docs/COMMENTS-REDESIGN-2026.md. The profile feed, the profile hub and the eight module delete handlers stop reaching the comment table themselves, which leaves one runtime consumer outside the class and removes the last statement that pasted an id list into IN (...).

Core changes:

1. Target deletion and the profile count (core/classes/comment.php):

2. deleteTarget() removes the comments of target rows a module admin has just deleted

   • one placeholder per id, so a bulk selection reaches the statement as

bound values and the single case needs no second method

• no counter is moved: a target that is gone has no row left to hold

one, which is what the eight handlers did before the move

• getUserCount() answers the published comment count of one account, the number the profile hub shows beside its other module counters

• Profile reads (core/user.php, modules/account/index.php):

• getProfileLastView() drops the comment branch of its UNION and fills the comment tab from getUserList()

• the profile hub drops the same branch and takes its count from getUserCount(), keeping the rating and favourites values it wrote before

• the unreachable "no parts" guard of the feed moved to the query itself, so a comment-only feed still renders and the empty case is unchanged

• Module delete handlers (eight admin modules):

• faq, files, links, media, news, pages, shop and voting call deleteTarget() and hold no comment statement any more

• Bulk id list (modules/shop/admin/index.php):

• productops() builds $keys/$pars the way the news and pages handlers already did

  • all six IN (...) clauses bind, closing the interpolation the plan

lists as an acceptance criterion of this stage

1. Parity probe and guard (tests/):

2. contract_probe.php gains three modes: the pre-move feed function beside the migrated one, deleteTarget() driven inside a rolled-back transaction, and the hub values of both versions

3. CommentTargetTest.php asserts the migrated call sites and the measured behaviour, and pins the comment entry out of both UNION branches

Benefits:

• every runtime comment read and write goes through one class, except the admin sidebar chip recorded as open in the plan

• a target delete can no longer reach past the module it names
• the shop handler stops assembling SQL from a joined id list

Technical notes:

• no table or column changes; no behaviour change intended, and none measured

• the feed renders byte for byte against the UNION it replaces: 10 accounts, six with comments, one without, plus a missing, a zero and a negative id

• deleteTarget() measured on all eight modules, on a bulk selection, on a target id shared by five modules, and against crafted id lists and a crafted module name, all inside a transaction that is rolled back

• the eight routes exercised over real HTTP with a signed-in administrator: each removed only its own module's rows, a wrong token removed none, a repeated delete was a no-op, every per-module total returned to the value it started from

• core/admin.php:319 still counts pending comments through getAdminCountRow(), which assembles the table name from a variable; it is left for a batch that owns the admin sidebar

Stage 1, batch 4 of docs/COMMENTS-REDESIGN-2026.md. The admin comment module no longer touches the comment table: every read and write it performed now goes through the Comment class, which leaves the class as the only place that knows how a comment is stored, permitted and counted.

Core changes:

1. Moderation write methods (core/classes/comment.php):

2. deleteComment() removes one comment and takes the target counter and the author points back when the removed row was published

   • the module and the target come from the stored row, never from the

request, so the stage 0 trust boundary holds for deletion too

• updateBody() stores the body a moderator typed, verbatim

  • the moderation form is not the author edit path and applies neither

checkEditRules() nor filterHtml() nor the edit window

• setStatus() takes the read-then-compare guard the moderation module always had

  • a comment already carrying the wanted status is answered as done

without writing, so a repeated click cannot count its target twice

• the frontend path inherits the guard and loses a double count it

never intended; the rendered fragment is unchanged

1. Moderation module (admin/modules/comments.php):

2. the module selector reads getModuleList(), the list and its count read getAdminList(), the edit form reads getComment()

3. the four write handlers call setStatus(), deleteComment() and updateBody(); no handler takes $db any more

4. the pager renders through getTplPagerView() from the total the list itself counted, replacing getTplPager() and its separate COUNT

   • the $where/$wcnt pair is gone, and with it the second, differently

spelled description of one list

• the rewritten list loop drops its snake_case names per .rules/global.md
• Trust boundary guard (tests/Unit/CommentTrustBoundaryTest.php):

• deleteComment() joined the methods asserted to read module and target from the stored row

• the numcom() assertion follows the $cid the new status guard needs

Benefits:

• the moderation list can no longer count one thing and show another
• a repeated approve or delete leaves counters and points untouched

• the admin panel gains prepared statements everywhere it had them by hand, and loses one hand-built subquery

Technical notes:

• no table or column changes; the current sort is untouched

• three measured behaviour changes, each a consequence of the move: an out-of-range page now clamps instead of answering "no information", &num=0 no longer builds "LIMIT -25, 25", and delete() redirects by the tab the request came from instead of by the deleted row's status

• parity measured over real HTTP with a signed-in administrator: 42 URLs in two rounds, 39 byte-identical in the module content region, the three others being the page clamp above; 16 write scenarios left identical rows, bodies, target counters, points and row count

Stage 1 batch 3 of docs/COMMENTS-REDESIGN-2026.md: adding, editing and moderating a comment no longer happen in the request handlers. The subsystem owns the rules, the permissions and the state changes, and the handlers read the request and render the answer, which is what lets stage 2 make the write transactional in one place instead of at three call sites.

Core changes:

1. Comment write path (core/classes/comment.php):

2. addComment(), updateComment() and setStatus() carry the frontend writes

   • the target mode, the author, the address and the moderation state are

resolved from the server context, never taken from the request

• checkAddRules() answers the single message the submit path shows,

checkEditRules() the list the edit path shows; both are merged into
checkRules() in stage 2, not here

• getLinkFlag(), getLastTime() and getLastId() carry the auto-link rule,

the flood window and the anchor id of a fresh row

• CommentStatus names the value written to the status column; the acomm

comparisons stay bare because CommentMode belongs to stage 2

• the counters still run through the global numcom(), and the target still resolves through the global getCommentMode(), as the batch table requires; batch 6 absorbs both

• Request handlers (core/user.php, core/system.php):

• addComment() shrank from 48 lines to 16, updateComment() from 43 to 22 and updateCommentStatus() from 15 to 7

• none of the three holds comment SQL any more; the alerts, the ajax textarea, filterContent(), ashowcom() and addAdminMail() stay with the handler

• Write parity checks (tests/):

• CommentWriteTest drives the class against the live rows of the installation inside a transaction that is always rolled back

  • all eight modules store the row they resolved, increment their own target

counter and award their own points slot

• an anonymous comment lands pending and moves neither
• every refusal answers the message the submit path answered
• the author edits inside the window and is refused after it; a visitor

edits and moderates nothing

• CommentTrustBoundaryTest follows the code it guards: the stage 0 contract is now read off the class, and the handlers are asserted to carry neither a request module nor comment SQL

Benefits:

• one description of what may be written, shared by the three routes
• the counter and the points slot of every module are measured, not assumed
• the write path is ready for the transaction and the reqkey of stage 2

Technical notes:

• no schema and no markup change; behaviour is preserved down to the falsy body test that keeps a body of "0" from being saved, and to the edit length rule that still measures the last word in bytes

• the six POSTs that reach the three routes answer byte for byte the same as before the move, with the comment count and the target counter unchanged

• comment-baseline verify stays OK on all eight modules
• the moderator paths need a browser session and are not covered by this batch

Stage 1 batch 2 of docs/COMMENTS-REDESIGN-2026.md: the render function no longer queries the comment table itself. It asks the subsystem for one page and assembles markup, which is what lets the later stages change storage and sorting in one place instead of at every call site.

Core changes:

1. Comment list rendering (core/system.php):

2. ashowcom() reads through $com->getList() instead of its own SQL

   • the count query, the page query and the author group join are gone
   • pagination, the visibility scope and the running comment number now come

from the class, so a count can no longer disagree with the page it counts

• the unreachable ADMIN_FILE read branch left with the read it built; the

admin render branches stay until the function itself is removed

• local names follow the naming rules of .rules/global.md

  • the running number $a became $numb, the checkbox flag $b became $mark

Benefits:

• 253 lines down to 186, and no direct comment SQL left in the render path
• one description of what a viewer may see, shared by the count and the page
• a broken comments.num setting falls back to 15 instead of dividing by zero

Technical notes:

• no schema, template or markup change; the rendered output is byte for byte the same

• verified against the pre-move file over 26 URLs in both sort directions: first, middle, last, out-of-range and zero pages, a target with no comments, a target spilling one row onto a second page, one holding exactly the page size, garbage and negative page parameters, and a missing target id

• comment-baseline verify stays OK on all eight modules

• the signed-in and moderator views need a browser session and are not covered by this batch