@filipebraida/adonis-function-points 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -6,6 +6,135 @@ release moves the number for unchanged code, the rule set version moves with it
 otherwise the difference would measure the tool's change rather than the work, and
 that difference becomes an invoice.
 
+## 0.9.0
+
+**Rule set `afp@1.8.0`.** Two rules from a team's second review of their own count, one
+report fixed, and a rule about the library itself. A 0.8.0 baseline has to be recounted:
+the totals move 0, −3 and +1 FP — a writing transaction leaves EO for EI, two EIs gain an
+FTR — and the coverage line now means one thing in both reports.
+
+### Fixed
+
+- **The unresolved calls are listed, once each, and the inventory and the count show one
+  number.** The 0.8 CHANGELOG said `fp:inventory` listed them; it printed a total — and the
+  count printed a different total, because it summed each transaction's unresolved calls
+  (a body five routes reach counted five times) while the inventory added the route and
+  store problems. Now `inventory.unresolved` and `count.confidence.unresolved` are the same
+  list — one entry per site (`file:line expression — reason`, how many transactions reach
+  it), route and store problems included — and `unresolvedCalls` is its length in both.
+  `fp:inventory` prints every site, `fp:count` up to 25, `--json` / `--out` carry them. The
+  number changes without any code changing: it counts places to look at now, which is what
+  a person acts on.
+- **A method the model declares is application code.** `const items = await
+order.pendingItems().forUpdate()`, then `item.save()` in a loop: the rows come from a
+  method declared on the model class, and the chain was read as an access to the model at
+  its root — the write went to the wrong store, or was reported unreadable. The method's
+  return annotation (`typeof Item`), or its returns when every one is `Item.query()…`, names
+  the store; a builder chain after it hands the same rows on, an aggregate a number; the
+  chain is read from its innermost call outwards. On the reviewing team's application the
+  one writing transaction still counted as EO after 0.8 turns EI (7 → 4 FP).
+
+### New
+
+- **A listener written inline is a listener, and a string event is an event.**
+  `emitter.on('order:closed', async function ({ orderId }) { … })` binds a body to a
+  string, and the collector read only `emitter.on(EventClass, [ListenerClass])`: an
+  application that binds every listener this way had none followed, its jobs "reached by no
+  transaction", their writes nobody's FTR. The inline function or arrow is a handler located
+  by its line; the string is a binding key that `emitter.emit('…', payload)` / `emitSerial`
+  reach — the same decision as `Event.dispatch()`; a name built at runtime binds nothing;
+  `start/**` is scanned. Fixture `eventos_inline`: 27 FP where the previous rule set said 13.
+
+### The library itself
+
+- **The library names no application.** Its rules are found by recounting real
+  applications, and their names had leaked in: two heuristics keyed on one team's result
+  keys and one front-end's page layout, forty comments quoting somebody's routes and models,
+  a few shipped-doc lines. A heuristic keyed on one application's vocabulary is not a rule.
+  The result-key list keeps only framework and language conventions (one list page of one
+  application goes from 76 back to 83 DET, same FP); a module-scoped `pages/` directory is
+  read structurally; comments illustrate with the library's own domain; docs cite the
+  measurement, not the domain. `tests/unit/no_project_literals.spec.ts` holds the words that
+  belong to the validated applications — in the test, nowhere else — and fails when one
+  appears in `src`, `docs`, README or CHANGELOG.
+
+### Documented
+
+- counting-decisions §3 gains the model-method row of the bindings table; §9 gains "A
+  listener written inline is a listener; a string event is an event".
+- Fixtures: `escritas_indiretas` grows to 97 FP (a model's own query method);
+  `eventos_inline` (27 FP) is new.
+
+## 0.8.0
+
+**Rule set `afp@1.7.0`.** One rule, wide, found by a team reviewing a 0.6.0 count of
+their own application: six transactions that write were counted as EOs, with the
+coverage at 99.5% and three unresolved calls. The number was close and the count was
+wrong in nine places, and only the coverage line could have said so — it said 100%.
+Frozen in a fixture with a hand-written reference before the code, recounted on the
+three validated applications. A 0.7.0 baseline has to be recounted: the totals move −1,
+−8 and +2 FP; what moves is EO → EI (3 / 11 / 2 transactions), FTRs gained, and a
+coverage that now falls where the analysis does not know.
+
+### Fixed
+
+- **A write binds to what the variable IS, not to where it was born.** `document.save()`
+  was a write on `Document` only when the instance was born in the same body or arrived
+  as a parameter typed inline. The reviewed application's dominant shape — the
+  controller loads, the action alters — arrives it destructured from a **named**
+  interface (`handle({ document, name }: RenameDocumentInput)`), by `const { x } =
+input`, as a followed method's **declared return type** (`Promise<Session | null>`;
+  unannotated, its `return`s when every one is a store, one level of calls down), as a
+  conditional or a default whose branches are the same store (`id ? await X.find(id) :
+new X()`, `(await q.first()) ?? new X()`), as `auth.user` / `auth.getUserOrFail()` —
+  the model `config/auth.ts` names in its provider, read, never assumed — as a
+  **relation read off a loaded row** (`const pasta = documento.pasta`, which had been
+  billed to `Documento`), as a `for…of` or a callback parameter over rows or a relation,
+  as a `let x: Store` assigned later, as `Store[]` or `Store | null` parameters. Every
+  one is a reading of what the code declares; no type checker (the project resolves no
+  `#alias/…`, so `getType()` is `any`), and no guess. Counting-decisions §3.
+- **A write on a receiver nobody can type is an UNRESOLVED call**, reason "write on a
+  receiver whose type the analysis cannot read": `x.save()` / `x.delete()` with no
+  arguments, `x.merge(…).save()`, `x.related('…').create|sync|attach(…)`. It lowers
+  coverage and is listed by `fp:inventory`; the transaction stays what the readable
+  code says. A local a package built (`await PDFDocument.create()`, then `pdf.save()`)
+  is not a store and is not reported. This is the line between a count that errs and a
+  count that lies, and it did not exist.
+- **A service is what the container returns.** `const svc = await
+app.container.make(X)` binds `svc` to X as `new X()` already did, so `svc.method()` is
+  followed. On the reviewed application this shape carried the write of
+  the assignment route and 31 more sites.
+- A method chain on store rows handed to a delivery (`rows.map(f).join('\n')`) delivers
+  the rows, not one field.
+
+### New
+
+- **What the page shows is what leaves**, for a store handed to the page raw — no
+  transformer, no `.select()`. `inertia.render('livros/index', …)` opens
+  `inertia/pages/livros/index.tsx` (or `app/<module>/ui/pages/…`, or any `pages/` directory
+  — exactly one match, or nothing is read) and `view.render('catalogo')` opens
+  `resources/views/catalogo.edge`; the columns the page reads off the rows are the DETs
+  (`page:Livro.titulo`), one child component deep, through tsconfig `paths`, subpath
+  imports and relative paths. Where it cannot read — a second level of components, a
+  spread, a function receiving the rows, a package's `<DataTable data={…} />`, two files
+  answering to one name, one prop carrying several stores, members that are not columns
+  — the store leaves whole and the count says why, by transaction. Measured on the three
+  applications: **0 FP moved** (one of them: three pages read, 22 stores reported; the other two
+  hand every raw store through a transformer). Fixture `inertia_pages` (25 FP): the DETs
+  change, the points do not.
+
+### Documented
+
+- counting-decisions §3 gains "A write is attributed to what the variable IS", with the
+  eleven bindings as a table; the fixture `escritas_indiretas` (87 FP; `afp@1.6.0` said
+  57 with full coverage — five EIs sold as EOs, two ILFs mistaken for EIFs, one ILF lost)
+  carries one transaction per shape, plus the unreadable receiver and the package object.
+- counting-decisions §6 gains "What the page shows" — the reader, its reach, and the
+  measured zero.
+- The three boundary questions the review left open — technical logs, a mirror of another
+  system's table, a requirement's data — are declarations (`boundary.infrastructure`,
+  `boundary.externallyMaintained`), not rules; plan 0.8 §C records them.
+
 ## 0.7.0
 
 **Rule set `afp@1.6.0`.** Three rules move the number for unchanged code, every one
@@ -32,10 +161,10 @@ and most of that is new elementary processes the count had never seen.
   attribute; a yes/no, a formatted value, a framework service's answer and an Inertia
   lazy prop are one value. Without a delivery point the output falls back to the
   stores read, as before. On the applications: a home page at 1 DET became 10; a
-  petitions list at 8 DET became 60 — its nested transformers, which the unresolved
+  list page at 8 DET became 60 — its nested transformers, which the unresolved
   variant had hidden; every listing page stopped counting its filters twice.
 - **A function of the same file is followed** (`local-function`), and so is
-  `rows.map(paraLinha)`. Not only DETs: the stores those helpers read are FTRs now, and
+  `rows.map(toRow)`. Not only DETs: the stores those helpers read are FTRs now, and
   two `POST`s that wrote through a local helper moved from EO to EI. Models and modules
   imported **inside** a body (`const { default: X } = await import('#…')`) bind like a
   static import — an importer that wrote four tables this way had touched nothing.
@@ -113,7 +242,7 @@ of it is EOs losing DETs they never showed and one data function that was four.
   benchmark depends on it); a child hanging off two parents stays apart and the report
   says why. Cascade delete was measured and rejected as the signal: on one application
   11 of 13 cascades pointed at the tenant table. On the three applications the rule
-  folds four stores in all — the `Inpi*` mirror of an external registry becomes **one**
+  folds four stores in all — the four-table mirror of an external registry becomes **one**
   EIF with 4 RET, which is what the CPM says.
 - **A data function is identified by its table**, as counting-decisions §5 always said.
   Keyed by the class, renaming a model billed as a deletion plus an addition.

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.6.0
+Ruleset: afp@1.8.0
 
 type      n     FP
 ILF       2     14

package/build/commands/main.js

@@ -14,27 +14,27 @@
 const commands = [
 	{
 		commandName: "fp:inventory",
-		importer: () => import("../fp_inventory-DIjKIC9t.js")
+		importer: () => import("../fp_inventory-B4Pv8Thz.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-BpU61waG.js")
+		importer: () => import("../fp_metrics-DoS5riGr.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-arGLnVlY.js")
+		importer: () => import("../fp_count-Bjviq8dz.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-aNFApwiT.js")
+		importer: () => import("../fp_explain-CrFcMeXU.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-DBBvzq5x.js")
+		importer: () => import("../fp_diff-BSK1kKLQ.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-3TxGdS1b.js")
+		importer: () => import("../fp_calibrate-DJspMFHc.js")
 	}
 ];
 let cache = null;

package/build/{fp_calibrate-3TxGdS1b.js → fp_calibrate-DJspMFHc.js}

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-Dm7cWGa-.js";
+import { s as printResult, t as runCalibrate } from "./runners-BuZNr-FE.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_calibrate.ts

package/build/{fp_count-arGLnVlY.js → fp_count-Bjviq8dz.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-Dm7cWGa-.js";
+import { n as runCount, s as printResult } from "./runners-BuZNr-FE.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_count.ts

package/build/{fp_diff-DBBvzq5x.js → fp_diff-BSK1kKLQ.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-Dm7cWGa-.js";
+import { r as runDiff, s as printResult } from "./runners-BuZNr-FE.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_diff.ts

package/build/{fp_explain-aNFApwiT.js → fp_explain-CrFcMeXU.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-Dm7cWGa-.js";
+import { i as runExplain, s as printResult } from "./runners-BuZNr-FE.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_explain.ts

package/build/{fp_inventory-DIjKIC9t.js → fp_inventory-B4Pv8Thz.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-Dm7cWGa-.js";
+import { a as runInventory, s as printResult } from "./runners-BuZNr-FE.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_inventory.ts

package/build/{fp_metrics-BpU61waG.js → fp_metrics-DoS5riGr.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-Dm7cWGa-.js";
+import { o as runMetrics, s as printResult } from "./runners-BuZNr-FE.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_metrics.ts

package/build/index.js

@@ -1,6 +1,6 @@
 import { configure } from "./configure.js";
 import { a as AEP_FACTORS, c as IncomparableSourcesError, f as defineConfig, i as measureStructure, l as SISP_FACTORS, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
 import "./src/types.js";
-import { n as ignoreCalls, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-DaU4uAqT.js";
-import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-DO2301fV.js";
+import { n as ignoreCalls, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CneCj3sT.js";
+import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-DqPrDZfD.js";
 export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, DEFAULT_TECHNICAL_PATTERNS, FACTOR_PRESETS, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, SISP_FACTORS, analyze, calibrate, configure, defineConfig, diffCounts, ignoreCalls, measureConformance, measureStructure, parseSamples };