@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/ruby/EvidenceRubyAdapter.js

@@ -1,19 +1,752 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvidenceRubyAdapter = void 0;
-const RubyAdapter_1 = require("./RubyAdapter");
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const typia_1 = __importDefault(require("typia"));
+const EvidenceDocumentation_1 = require("../../parsers/EvidenceDocumentation");
+const EvidenceInventory_1 = require("../../graph/EvidenceInventory");
+const EvidenceParser_1 = require("../../parsers/EvidenceParser");
+const EvidenceParserError_1 = require("../../parsers/EvidenceParserError");
+const EvidenceTagParser_1 = require("../../parsers/EvidenceTagParser");
+const EvidenceRubyFileScanner_1 = require("./EvidenceRubyFileScanner");
 /**
- * Extracts explicit Ruby declarations, reopenings, and bounded aliases from selected source.
+ * Extracts Ruby public declarations while merging reopened structural
+ * identities.
  *
- * The adapter reconciles classes, modules, methods, constants, and literal
- * attributes across the snapshot. RDoc line or embedded comments retain their
- * attachment. Instance members use their nominal owner directly, while singleton
- * members add a self segment, keeping equal method names on different sides distinct.
- *
- * Runtime load order, eval-generated declarations, mixins, refinements, and
- * inherited members are not executed or synthesized. Analysis retains failures
- * where these mechanisms prevent a trustworthy public population.
+ * File scans retain visibility and owner paths for classes, modules, and
+ * members. Materialization groups compatible declarations before attaching
+ * documentation, so reopened sites share semantic identity while keeping their
+ * physical origins and withdrawal causes. Unsupported analysis remains visible
+ * as incompleteness.
  */
-class EvidenceRubyAdapter extends RubyAdapter_1.RubyAdapter {
+class EvidenceRubyAdapter {
+    /**
+     * Artifact discriminator selecting Ruby source and named-file rules.
+     *
+     * Configuration uses this value independently of the filename's extension.
+     */
+    get type() {
+        return "ruby";
+    }
+    /**
+     * Builds a normalized Ruby inventory from an owned copy of the snapshot.
+     *
+     * Public identity groups are established before comment hosts are
+     * materialized. Source and scan diagnostics are retained, and parser cleanup
+     * runs on every exit.
+     */
+    async analyze(snapshot) {
+        const input = structuredClone((() => {
+            const _ip0 = input => "string" === typeof input["absolute"];
+            const _ip1 = input => "string" === typeof input["display"];
+            const _ip2 = input => "string" === typeof input["physicalPath"];
+            const _ip3 = input => "string" === typeof input["fingerprintPath"];
+            const _ip4 = input => "string" === typeof input["path"];
+            const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["absolute"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".absolute",
+                expected: "string",
+                value: input["absolute"]
+            }, _errorFactory);
+            const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["display"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".display",
+                expected: "string",
+                value: input["display"]
+            }, _errorFactory);
+            const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["physicalPath"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physicalPath",
+                expected: "string",
+                value: input["physicalPath"]
+            }, _errorFactory);
+            const _ap3 = (input, _path, _exceptionable = true) => "string" === typeof input["fingerprintPath"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".fingerprintPath",
+                expected: "string",
+                value: input["fingerprintPath"]
+            }, _errorFactory);
+            const _ap4 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".path",
+                expected: "string",
+                value: input["path"]
+            }, _errorFactory);
+            const _ae0 = "(\"case-mismatch\" | \"invalid-encoding\" | \"not-file\" | \"path-unreadable\" | \"root-unreadable\" | \"source-changed\" | \"symlink-cycle\")";
+            const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.root && null !== input.root || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".root",
+                expected: "IEvidenceSourceRoot",
+                value: input.root
+            }, _errorFactory)) && _ao1(input.root, _path + ".root", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".root",
+                expected: "IEvidenceSourceRoot",
+                value: input.root
+            }, _errorFactory)) && ((Array.isArray(input.files) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files",
+                expected: "Array<IEvidenceSourceFile>",
+                value: input.files
+            }, _errorFactory)) && input.files.every((elem, _index5) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files[" + _index5 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) && _ao2(elem, _path + ".files[" + _index5 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files[" + _index5 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files",
+                expected: "Array<IEvidenceSourceFile>",
+                value: input.files
+            }, _errorFactory)) && ((Array.isArray(input.dependencies) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies",
+                expected: "Array<IEvidenceSourceDependency>",
+                value: input.dependencies
+            }, _errorFactory)) && input.dependencies.every((elem, _index6) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index6 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) && _ao5(elem, _path + ".dependencies[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index6 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies",
+                expected: "Array<IEvidenceSourceDependency>",
+                value: input.dependencies
+            }, _errorFactory)) && ((Array.isArray(input.diagnostics) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceSourceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && input.diagnostics.every((elem, _index7) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index7 + "]",
+                expected: "IEvidenceSourceDiagnostic",
+                value: elem
+            }, _errorFactory)) && _ao6(elem, _path + ".diagnostics[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index7 + "]",
+                expected: "IEvidenceSourceDiagnostic",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceSourceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && ("boolean" === typeof input.complete || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".complete",
+                expected: "boolean",
+                value: input.complete
+            }, _errorFactory));
+            const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.declared || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declared",
+                expected: "string",
+                value: input.declared
+            }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.physical || "string" === typeof input.physical || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physical",
+                expected: "(string | undefined)",
+                value: input.physical
+            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
+            const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".id",
+                expected: "string",
+                value: input.id
+            }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && (undefined === input.fingerprintRoot || ("object" === typeof input.fingerprintRoot && null !== input.fingerprintRoot || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".fingerprintRoot",
+                expected: "(IEvidenceSourceFingerprintRoot | undefined)",
+                value: input.fingerprintRoot
+            }, _errorFactory)) && _ao3(input.fingerprintRoot, _path + ".fingerprintRoot", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".fingerprintRoot",
+                expected: "(IEvidenceSourceFingerprintRoot | undefined)",
+                value: input.fingerprintRoot
+            }, _errorFactory)) && ("string" === typeof input.content || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "string",
+                value: input.content
+            }, _errorFactory)) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".digest",
+                expected: "string",
+                value: input.digest
+            }, _errorFactory)) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory)) && input.addresses.every((elem, _index8) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index8 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) && _ao4(elem, _path + ".addresses[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index8 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory));
+            const _ao3 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable);
+            const _ao4 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.relative || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".relative",
+                expected: "string",
+                value: input.relative
+            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.selected || "boolean" === typeof input.selected || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".selected",
+                expected: "(boolean | undefined)",
+                value: input.selected
+            }, _errorFactory));
+            const _ao5 = (input, _path, _exceptionable = true) => _ap4(input, _path, true && _exceptionable) && ("boolean" === typeof input.recursive || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".recursive",
+                expected: "boolean",
+                value: input.recursive
+            }, _errorFactory));
+            const _ao6 = (input, _path, _exceptionable = true) => ("case-mismatch" === input.code || "invalid-encoding" === input.code || "not-file" === input.code || "path-unreadable" === input.code || "root-unreadable" === input.code || "source-changed" === input.code || "symlink-cycle" === input.code || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".code",
+                expected: _ae0,
+                value: input.code
+            }, _errorFactory)) && _ap4(input, _path, true && _exceptionable) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".message",
+                expected: "string",
+                value: input.message
+            }, _errorFactory));
+            const _io0 = input => "object" === typeof input.root && null !== input.root && _io1(input.root) && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && "boolean" === typeof input.complete;
+            const _io1 = input => "string" === typeof input.declared && _ip0(input) && (undefined === input.physical || "string" === typeof input.physical) && _ip1(input);
+            const _io2 = input => "string" === typeof input.id && _ip2(input) && _ip3(input) && (undefined === input.fingerprintRoot || "object" === typeof input.fingerprintRoot && null !== input.fingerprintRoot && _io3(input.fingerprintRoot)) && "string" === typeof input.content && "string" === typeof input.digest && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+            const _io3 = input => _ip2(input) && _ip3(input);
+            const _io4 = input => _ip0(input) && "string" === typeof input.relative && _ip1(input) && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io5 = input => _ip4(input) && "boolean" === typeof input.recursive;
+            const _io6 = input => ("case-mismatch" === input.code || "invalid-encoding" === input.code || "not-file" === input.code || "path-unreadable" === input.code || "root-unreadable" === input.code || "source-changed" === input.code || "symlink-cycle" === input.code) && _ip4(input) && "string" === typeof input.message;
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let _errorFactory;
+            return (input, errorFactory) => {
+                if (false === __is(input)) {
+                    _errorFactory = errorFactory;
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceSourceSnapshot",
+                        value: input
+                    }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceSourceSnapshot",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+        })()(snapshot));
+        const inventory = {
+            schemaVersion: 1,
+            sources: input.files,
+            annotationRanges: [],
+            units: [],
+            addresses: [],
+            hosts: [],
+            declarations: [],
+            reviews: [],
+            diagnostics: input.diagnostics.map((diagnostic) => ({
+                code: `source-${diagnostic.code}`,
+                severity: "error",
+                message: diagnostic.message,
+                repair: "Restore access to the selected Ruby source before evaluating coverage.",
+                location: { file: diagnostic.path },
+            })),
+            dependencies: input.dependencies,
+            complete: input.complete,
+        };
+        const parser = new EvidenceParser_1.EvidenceParser();
+        try {
+            const analyses = await Promise.all(input.files.map((source) => this.scan(parser, source)));
+            for (const analysis of analyses) {
+                inventory.diagnostics.push(...analysis.diagnostics);
+                inventory.complete &&= analysis.complete;
+            }
+            // Reopened declarations must agree on semantic ownership before their
+            // individual comment sites can contribute to the shared public identity.
+            const published = this.materializeUnits(inventory, analyses);
+            this.materializeDocumentation(inventory, analyses, published);
+            return new EvidenceInventory_1.EvidenceInventory([inventory]).snapshot();
+        }
+        finally {
+            await parser.close();
+        }
+    }
+    /**
+     * Copies one Ruby file's declaration and comment records out of its parse
+     * session.
+     *
+     * Syntax or acquisition failure yields an incomplete analysis with a concrete
+     * source diagnostic rather than a successful empty declaration list.
+     */
+    async scan(parser, source) {
+        const file = source.addresses[0]?.relative ?? source.physicalPath;
+        try {
+            return await parser.parse({ type: "ruby", file, content: source.content }, (session) => new EvidenceRubyFileScanner_1.EvidenceRubyFileScanner(session, source).scan());
+        }
+        catch (cause) {
+            const parserError = cause instanceof EvidenceParserError_1.EvidenceParserError ? cause : undefined;
+            return {
+                source,
+                declarations: [],
+                documentation: [],
+                diagnostics: [
+                    {
+                        code: `ruby-${parserError?.code ?? "parse-failed"}`,
+                        severity: "error",
+                        message: parserError?.message ??
+                            `Ruby parsing failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+                        repair: "Correct the source or add adapter support before evaluating coverage.",
+                        location: {
+                            file: source.physicalPath,
+                            ...(parserError?.range === undefined
+                                ? {}
+                                : { range: parserError.range }),
+                        },
+                    },
+                ],
+                complete: false,
+            };
+        }
+    }
+    /**
+     * Merges Ruby declaration groups and publishes their public owner hierarchy.
+     *
+     * Type groups are considered from outer to inner ownership before members,
+     * preventing a child of an unpublished owner from becoming a free-standing
+     * API.
+     */
+    materializeUnits(inventory, analyses) {
+        const declarationAnalysis = new Map();
+        const groups = new Map();
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                declarationAnalysis.set(declaration.id, analysis);
+                const id = this.unitId(declaration);
+                const group = groups.get(id) ?? [];
+                group.push(declaration);
+                groups.set(id, group);
+            }
+        const publicGroups = new Set();
+        const typeGroups = Array.from(groups.entries())
+            .filter(([, declarations]) => declarations[0]?.symbol === "type")
+            .sort(([, left], [, right]) => (left[0]?.identity?.length ?? 0) - (right[0]?.identity?.length ?? 0));
+        for (const [id, declarations] of typeGroups) {
+            this.checkGroup(inventory, declarations, declarationAnalysis);
+            if (declarations.some((declaration) => declaration.visibility !== "public"))
+                continue;
+            const owner = declarations[0]?.ownerIdentity;
+            if (owner !== undefined && owner.length !== 0) {
+                const parentId = this.typeId(owner);
+                if (!groups.has(parentId)) {
+                    const first = declarations[0];
+                    if (first !== undefined)
+                        this.problem(inventory, declarationAnalysis.get(first.id), first, "ruby-container-owner", `Ruby container '${first.identity.join("::")}' has no selected declared owner '${owner.join("::")}'.`, "Select the owner declaration or use a lexically nested class or module declaration.");
+                    continue;
+                }
+                if (!publicGroups.has(parentId))
+                    continue;
+            }
+            publicGroups.add(id);
+        }
+        for (const [id, declarations] of groups) {
+            if (declarations[0]?.symbol === "type")
+                continue;
+            this.checkGroup(inventory, declarations, declarationAnalysis);
+            const publicDeclarations = declarations.filter((declaration) => declaration.visibility === "public");
+            if (publicDeclarations.length === 0)
+                continue;
+            const owner = publicDeclarations[0]?.ownerIdentity;
+            if (owner !== undefined && owner.length !== 0) {
+                const parentId = this.typeId(owner);
+                if (!groups.has(parentId)) {
+                    const first = publicDeclarations[0];
+                    if (first !== undefined)
+                        this.problem(inventory, declarationAnalysis.get(first.id), first, "ruby-declaration-owner", `Ruby declaration '${first.identity.join("::")}' has no selected class or module owner '${owner.join("::")}'.`, "Select the owner declaration or move the declaration into a selected class or module body.");
+                    continue;
+                }
+                if (!publicGroups.has(parentId))
+                    continue;
+            }
+            if (declarations[0]?.form === "constant" &&
+                declarations.some((declaration) => declaration.visibility !== "public"))
+                continue;
+            publicGroups.add(id);
+        }
+        const published = new Map();
+        for (const [id, declarations] of groups)
+            if (publicGroups.has(id))
+                for (const declaration of declarations)
+                    if (declaration.visibility === "public")
+                        published.set(declaration.id, id);
+        const units = new Map();
+        for (const [id, declarations] of groups) {
+            if (!publicGroups.has(id))
+                continue;
+            const visible = declarations.filter((declaration) => declaration.visibility === "public");
+            const first = visible[0];
+            if (first === undefined)
+                continue;
+            const parentId = first.ownerIdentity === undefined || first.ownerIdentity.length === 0
+                ? undefined
+                : this.typeId(first.ownerIdentity);
+            const unit = {
+                id,
+                type: "ruby",
+                symbol: first.symbol,
+                identity: first.identity,
+                name: first.name,
+                sites: [],
+                withdrawals: [],
+                ...(parentId === undefined ? {} : { parentId }),
+            };
+            for (const declaration of visible)
+                this.addSite(unit, declaration.site);
+            units.set(id, unit);
+        }
+        inventory.units.push(...units.values());
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                const unitId = published.get(declaration.id);
+                if (unitId === undefined)
+                    continue;
+                for (const sourceAddress of analysis.source.addresses)
+                    inventory.addresses.push({
+                        file: sourceAddress.absolute,
+                        segments: declaration.address,
+                        unitId,
+                    });
+            }
+        this.checkAddressCollisions(inventory, analyses, published);
+        return published;
+    }
+    checkGroup(inventory, declarations, declarationAnalysis) {
+        const first = declarations[0];
+        if (first === undefined)
+            return;
+        const analysis = declarationAnalysis.get(first.id);
+        const visibility = new Set(declarations.map((declaration) => declaration.visibility));
+        if ((first.symbol === "type" || first.form === "constant") &&
+            visibility.size > 1)
+            this.problem(inventory, analysis, first, "ruby-constant-visibility", `Ruby constant '${first.identity.join("::")}' has conflicting selected visibility states.`, "Keep the declaration and its private_constant or public_constant transition in one unambiguous source order.");
+        if (first.symbol === "type") {
+            const kinds = new Set(declarations.map((declaration) => declaration.containerKind));
+            if (kinds.size > 1)
+                this.problem(inventory, analysis, first, "ruby-container-kind", `Ruby constant '${first.identity.join("::")}' is declared as both a class and a module.`, "Use one compatible container kind for every reopening.");
+            const superclasses = new Set(declarations.flatMap((declaration) => declaration.superclass === undefined ? [] : [declaration.superclass]));
+            if (superclasses.size > 1)
+                this.problem(inventory, analysis, first, "ruby-superclass-conflict", `Ruby class '${first.identity.join("::")}' names conflicting superclasses across reopenings.`, "Keep one explicit superclass and omit it from compatible reopenings.");
+            return;
+        }
+        if (first.form === "constant") {
+            if (declarations.filter((declaration) => declaration.definition).length > 1)
+                this.problem(inventory, analysis, first, "ruby-constant-redefinition", `Ruby constant '${first.identity.join("::")}' has more than one selected assignment.`, "Keep one assignment or add explicit runtime load-order analysis.");
+            return;
+        }
+        if (first.symbol === "function") {
+            if (declarations.filter((declaration) => declaration.definition).length > 1)
+                this.problem(inventory, analysis, first, "ruby-method-redefinition", `Ruby method '${first.identity.join(".")}' has competing selected definitions.`, "Keep one definition or add explicit runtime load-order analysis; Ruby methods are replaced rather than overloaded.");
+            return;
+        }
+        if (first.form === "attribute")
+            for (const mode of ["read", "write"])
+                if (declarations.filter((declaration) => declaration.attributeMode === mode).length > 1)
+                    this.problem(inventory, analysis, first, "ruby-attribute-redefinition", `Ruby attribute '${first.identity.join(".")}' declares its ${mode} access more than once.`, "Keep one literal declaration for each reader or writer capability.");
+    }
+    checkAddressCollisions(inventory, analyses, published) {
+        const owners = new Map();
+        const firstDeclarations = new Map();
+        const declarationAnalysis = new Map();
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                const unitId = published.get(declaration.id);
+                if (unitId === undefined)
+                    continue;
+                declarationAnalysis.set(declaration.id, analysis);
+                for (const sourceAddress of analysis.source.addresses) {
+                    const key = JSON.stringify([
+                        sourceAddress.absolute,
+                        declaration.address,
+                    ]);
+                    const values = owners.get(key) ?? new Set();
+                    values.add(unitId);
+                    owners.set(key, values);
+                    if (!firstDeclarations.has(key))
+                        firstDeclarations.set(key, declaration);
+                }
+            }
+        for (const [key, unitIds] of owners) {
+            if (unitIds.size < 2)
+                continue;
+            const first = firstDeclarations.get(key);
+            if (first === undefined)
+                continue;
+            this.problem(inventory, declarationAnalysis.get(first.id), first, "ruby-address-conflict", `Ruby public address '${first.address.join(".")}' identifies more than one declared contract.`, "Rename the colliding constant, method, or attribute, or add a distinct canonical address rule.");
+        }
+    }
+    materializeDocumentation(inventory, analyses, published) {
+        const units = new Map(inventory.units.map((unit) => [unit.id, unit]));
+        for (const analysis of analyses)
+            for (const documentation of analysis.documentation) {
+                const groups = this.attachmentGroups(documentation, published);
+                if (groups.size === 0 && !this.annotation(analysis, documentation))
+                    continue;
+                inventory.annotationRanges.push({
+                    file: analysis.source.physicalPath,
+                    range: documentation.range,
+                });
+                for (const [siteId, unitIds] of groups) {
+                    const parsed = this.parse(analysis.source, documentation, this.host(analysis.source, documentation, siteId, unitIds));
+                    for (const unitId of unitIds) {
+                        const unit = units.get(unitId);
+                        if (unit !== undefined)
+                            unit.withdrawals.push(...parsed.withdrawals);
+                    }
+                }
+            }
+        const hidden = new Set();
+        for (const unit of inventory.units)
+            if (this.withdrawn(unit.id, units, new Set()))
+                hidden.add(unit.id);
+        for (const analysis of analyses)
+            for (const documentation of analysis.documentation) {
+                const publishedGroups = this.attachmentGroups(documentation, published);
+                const groups = new Map();
+                for (const [siteId, unitIds] of publishedGroups) {
+                    const visible = unitIds.filter((unitId) => !hidden.has(unitId));
+                    if (visible.length !== 0)
+                        groups.set(siteId, visible);
+                }
+                if (groups.size === 0 &&
+                    publishedGroups.size !== 0 &&
+                    !this.claimAnnotation(analysis, documentation))
+                    continue;
+                if (groups.size === 0) {
+                    if (!this.annotation(analysis, documentation))
+                        continue;
+                    const host = this.host(analysis.source, documentation, undefined, []);
+                    inventory.hosts.push(host);
+                    const parsed = this.parse(analysis.source, documentation, host);
+                    inventory.declarations.push(...parsed.declarations);
+                    inventory.reviews.push(...parsed.reviews);
+                    inventory.diagnostics.push(...parsed.diagnostics);
+                    continue;
+                }
+                for (const [siteId, unitIds] of groups) {
+                    const host = this.host(analysis.source, documentation, siteId, unitIds);
+                    inventory.hosts.push(host);
+                    const parsed = this.parse(analysis.source, documentation, host);
+                    inventory.declarations.push(...parsed.declarations);
+                    inventory.reviews.push(...parsed.reviews);
+                    inventory.diagnostics.push(...parsed.diagnostics);
+                }
+            }
+        this.materializeUndocumentedHosts(inventory, analyses, published, hidden);
+    }
+    materializeUndocumentedHosts(inventory, analyses, published, hidden) {
+        for (const analysis of analyses) {
+            const documented = new Set(analysis.documentation.flatMap((documentation) => documentation.attachments.flatMap((attachment) => {
+                const unitId = published.get(attachment.declarationId);
+                return unitId !== undefined && !hidden.has(unitId)
+                    ? [attachment.siteId]
+                    : [];
+            })));
+            const sites = new Map();
+            for (const declaration of analysis.declarations) {
+                const unitId = published.get(declaration.id);
+                if (unitId === undefined ||
+                    hidden.has(unitId) ||
+                    documented.has(declaration.site.id))
+                    continue;
+                const declarations = sites.get(declaration.site.id) ?? [];
+                declarations.push(declaration);
+                sites.set(declaration.site.id, declarations);
+            }
+            for (const declarations of sites.values()) {
+                const first = declarations[0];
+                if (first === undefined)
+                    continue;
+                const unitIds = Array.from(new Set(declarations.flatMap((declaration) => {
+                    const unitId = published.get(declaration.id);
+                    return unitId === undefined ? [] : [unitId];
+                })));
+                inventory.hosts.push({
+                    id: `${first.site.id}:host`,
+                    file: analysis.source.physicalPath,
+                    range: first.site.range,
+                    origins: analysis.source.addresses.map((address) => address.absolute),
+                    siteId: first.site.id,
+                    unitIds,
+                    attachment: "attached",
+                });
+            }
+        }
+    }
+    attachmentGroups(documentation, published) {
+        const groups = new Map();
+        for (const attachment of documentation.attachments) {
+            const unitId = published.get(attachment.declarationId);
+            if (unitId === undefined)
+                continue;
+            const unitIds = groups.get(attachment.siteId) ?? [];
+            if (!unitIds.includes(unitId))
+                unitIds.push(unitId);
+            groups.set(attachment.siteId, unitIds);
+        }
+        return groups;
+    }
+    host(source, documentation, siteId, unitIds) {
+        const attached = siteId !== undefined && unitIds.length !== 0;
+        return {
+            id: `${documentation.id}:host:${siteId ?? "unsupported"}`,
+            file: source.physicalPath,
+            range: documentation.range,
+            origins: source.addresses.map((address) => address.absolute),
+            unitIds,
+            attachment: attached ? "attached" : "unsupported",
+            ...(attached ? { siteId } : {}),
+            ...(attached
+                ? {}
+                : {
+                    problem: "Move the annotation into an adjacent Ruby comment on a supported public class, module, method, constant, alias, or literal attribute declaration.",
+                }),
+        };
+    }
+    parse(source, documentation, host) {
+        const mapping = this.mapping(source, documentation);
+        return EvidenceTagParser_1.EvidenceTagParser.parse(source.content, host, {
+            ...mapping,
+            hostId: host.id,
+        });
+    }
+    annotation(analysis, documentation) {
+        return this.annotationPattern(this.mapping(analysis.source, documentation).text, true);
+    }
+    claimAnnotation(analysis, documentation) {
+        return this.annotationPattern(this.mapping(analysis.source, documentation).text, false);
+    }
+    annotationPattern(raw, withdrawal) {
+        return withdrawal
+            ? /(?:^|[\r\n])[ \t]*@(evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link|internal|hidden|ignore)\b/u.test(raw)
+            : /(?:^|[\r\n])[ \t]*@(evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link)\b/u.test(raw);
+    }
+    mapping(source, documentation) {
+        if (documentation.mapping !== undefined)
+            return structuredClone(documentation.mapping);
+        if (documentation.syntax === undefined)
+            throw new Error("Ruby documentation has no source mapping.");
+        return EvidenceDocumentation_1.EvidenceDocumentation.read(source.content, documentation.id, documentation.range, documentation.syntax);
+    }
+    addSite(unit, candidate) {
+        const site = unit.sites.find((entry) => entry.id === candidate.id);
+        if (site === undefined) {
+            unit.sites.push(structuredClone(candidate));
+            return;
+        }
+        for (const content of candidate.content)
+            if (!site.content.some((range) => range.start.offset === content.start.offset &&
+                range.end.offset === content.end.offset))
+                site.content.push(structuredClone(content));
+    }
+    withdrawn(id, units, visited) {
+        if (visited.has(id))
+            return false;
+        visited.add(id);
+        const unit = units.get(id);
+        if (unit === undefined)
+            return false;
+        if (unit.withdrawals.length !== 0)
+            return true;
+        return unit.parentId === undefined
+            ? false
+            : this.withdrawn(unit.parentId, units, visited);
+    }
+    unitId(declaration) {
+        if (declaration.symbol === "type")
+            return this.typeId(declaration.identity);
+        if (declaration.form === "constant")
+            return `ruby:property:constant:${JSON.stringify(declaration.identity)}`;
+        if (declaration.form === "attribute")
+            return `ruby:property:attribute:${declaration.side ?? "instance"}:${JSON.stringify(declaration.identity)}`;
+        return `ruby:function:${declaration.side ?? "instance"}:${JSON.stringify(declaration.identity)}`;
+    }
+    typeId(identity) {
+        return `ruby:type:container:${JSON.stringify(identity)}`;
+    }
+    problem(inventory, analysis, declaration, code, message, repair) {
+        inventory.complete = false;
+        inventory.diagnostics.push({
+            code,
+            severity: "error",
+            message,
+            repair,
+            location: {
+                file: analysis?.source?.physicalPath ?? declaration.site.file,
+                range: declaration.site.range,
+            },
+        });
+    }
 }
 exports.EvidenceRubyAdapter = EvidenceRubyAdapter;