@groma/scanner-go 0.1.3 → 0.2.1

package/package.json

@@ -1,23 +1,30 @@
 {
   "name": "@groma/scanner-go",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Go project evidence through Go language tooling.",
   "private": false,
   "type": "module",
   "license": "MIT",
   "os": [
+    "win32",
     "linux",
-    "darwin",
-    "win32"
+    "darwin"
   ],
   "cpu": [
-    "arm64",
-    "x64"
+    "x64",
+    "arm64"
   ],
   "groma": {
     "scanner": {
       "id": "go",
       "entry": "./src/index.js",
+      "include": [
+        "**/*.go",
+        "**/go.mod"
+      ],
+      "exclude": [
+        "vendor/"
+      ],
       "discovery": {
         "technologies": [
           "go"
@@ -35,14 +42,14 @@
           }
         ],
         "compatibility": {
-          "groma": ">=0.3.0"
+          "groma": ">=0.5.0"
         }
       }
     }
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/MrLesk/Groma.md.git"
+    "url": "https://github.com/MrLesk/groma.md.git"
   },
   "publishConfig": {
     "access": "public"

package/src/index.js

@@ -1,42 +1,12 @@
 // @bun
 // plugins/scanners/go/src/index.ts
-import path5 from "path";
-
-// plugins/scanners/projects.ts
-import { execFile } from "child_process";
-import { existsSync } from "fs";
-import path from "path";
-import { promisify } from "util";
-var execute = promisify(execFile);
-var excluded = new Set([
-  ".git",
-  "node_modules",
-  "vendor",
-  "target",
-  "dist",
-  "build",
-  "bin",
-  "obj",
-  ".gradle",
-  ".angular",
-  "coverage",
-  "generated",
-  "groma",
-  ".groma"
-]);
-async function repositoryFiles(root, matches) {
-  const { stdout } = await execute("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { maxBuffer: 64 * 1024 * 1024 });
-  return [...new Set(stdout.split("\x00").filter((file) => file && matches(file) && existsSync(path.join(root, file))))].sort();
-}
-function projectFiles(root, matches) {
-  return repositoryFiles(root, (file) => matches(file) && !file.split("/").some((part) => excluded.has(part)));
-}
+import path4 from "path";
 
 // plugins/scanners/project-scanner.ts
-import path3 from "path";
+import path2 from "path";
 
 // plugins/scanners/observations.ts
-import path2 from "path";
+import path from "path";
 
 // packages/scanner/src/values.ts
 function object(value, label) {
@@ -154,13 +124,13 @@ function compare(...values) {
 }
 function uniqueBy(values, key, label) {
   const seen = new Set;
-  for (const value of values) {
-    const id = key(value);
+  const keyed = values.map((value) => ({ id: key(value), value }));
+  for (const { id } of keyed) {
     if (seen.has(id))
       throw new Error(`duplicate ${label}: ${id}`);
     seen.add(id);
   }
-  return [...values].sort((left, right) => key(left).localeCompare(key(right)));
+  return keyed.sort((left, right) => left.id.localeCompare(right.id)).map((entry) => entry.value);
 }
 function createScanObservation(input) {
   const roots = validateRoots(input.roots);
@@ -171,9 +141,7 @@ function createScanObservation(input) {
     symbols: [...new Map(file.symbols.map((symbol) => [
       compare(symbol.id, symbol.kind),
       symbol
-    ])).values()].sort((left, right) => {
-      return compare(left.id, left.kind).localeCompare(compare(right.id, right.kind));
-    })
+    ]))].sort(([left], [right]) => left.localeCompare(right)).map(([, symbol]) => symbol)
   })), (file) => file.file, "file path");
   const filePaths = new Set(files.map((file) => file.file));
   for (const file of files) {
@@ -184,24 +152,46 @@ function createScanObservation(input) {
         throw new Error(`file references unknown root: ${root}`);
     }
   }
-  for (const diagnostic of input.diagnostics)
-    diagnosticLocation(diagnostic);
   return {
     schemaVersion: 1,
     scanner: input.scanner,
     roots,
     files,
     ...sourceUnits(input.sourceUnits, filePaths),
+    ...entryPoints(input.entryPoints, filePaths),
     ...operationEvidence(input, filePaths),
     ...httpEvidence(input.httpEndpoints, input.httpRequests, input.operations && new Set(input.operations.map((operation) => operation.id))),
-    diagnostics: [...new Map(input.diagnostics.map((diagnostic) => [
-      diagnosticKey(diagnostic),
-      diagnostic
-    ])).values()].sort((left, right) => {
-      return diagnosticKey(left).localeCompare(diagnosticKey(right));
-    })
+    diagnostics: normalizeScanDiagnostics(input.diagnostics)
   };
 }
+function normalizeScanDiagnostics(diagnostics) {
+  for (const diagnostic of diagnostics)
+    diagnosticLocation(diagnostic);
+  return [...new Map(diagnostics.map((diagnostic) => [diagnosticKey(diagnostic), diagnostic]))].sort(([left], [right]) => left.localeCompare(right)).map(([, diagnostic]) => diagnostic);
+}
+function entryPoints(input, paths) {
+  if (input === undefined)
+    return {};
+  const entries = array(input, "entryPoints").map((value) => {
+    const entry = object(value, "entry point");
+    const files = [...new Set(array(entry.files, "entry point.files").map((file) => string(file, "entry point.file")))].sort();
+    for (const file of files) {
+      if (!paths.has(file))
+        throw new Error(`entry point references unknown file: ${file}`);
+    }
+    const file = string(entry.file, "entry point.file");
+    if (!files.includes(file))
+      throw new Error(`entry point must include its own source file: ${file}`);
+    return {
+      file,
+      declaration: string(entry.declaration, "entry point.declaration"),
+      name: string(entry.name, "entry point.name"),
+      files
+    };
+  });
+  const key = (entry) => compare(entry.file, entry.declaration, entry.name, ...entry.files);
+  return { entryPoints: [...new Map(entries.map((entry) => [key(entry), entry])).values()].sort((a, b) => key(a).localeCompare(key(b))) };
+}
 function sourceUnits(input, paths) {
   if (input === undefined)
     return {};
@@ -264,6 +254,7 @@ function parseScanObservation(source) {
     ...parseOperations(value),
     httpEndpoints: value.httpEndpoints,
     httpRequests: value.httpRequests,
+    entryPoints: value.entryPoints,
     ...sourceUnits(value.sourceUnits, new Set(array(value.files, "files").map((entry) => string(object(entry, "file").file, "file.file")))),
     roots: array(value.roots, "roots").map((entry) => {
       const root = object(entry, "root");
@@ -376,10 +367,14 @@ function operationTokens(operation) {
   const endLine = Number(operation.endLine);
   if (endLine < startLine)
     throw new Error("operation.endLine must be at or after startLine");
+  const tokens = array(operation.tokens, "operation.tokens");
+  tokens.forEach((token) => {
+    string(token, "operation.token");
+  });
   return {
     startLine,
     endLine,
-    tokens: array(operation.tokens, "operation.tokens").map((token) => string(token, "operation.token"))
+    tokens
   };
 }
 function validateOperationTokens(operation) {
@@ -410,7 +405,7 @@ function sourcePosition(position) {
 
 // plugins/scanners/observations.ts
 function relocateObservation(observation, directory) {
-  const file = (value) => path2.posix.normalize(path2.posix.join(directory, value));
+  const file = (value) => path.posix.normalize(path.posix.join(directory, value));
   return {
     ...observation,
     roots: observation.roots.map((root) => ({ ...root, ...root.file ? { file: file(root.file) } : {} })),
@@ -418,11 +413,20 @@ function relocateObservation(observation, directory) {
     ...observation.sourceUnits === undefined ? {} : {
       sourceUnits: observation.sourceUnits.map((unit) => ({ primary: file(unit.primary), files: unit.files.map(file) }))
     },
+    ...observation.entryPoints === undefined ? {} : {
+      entryPoints: observation.entryPoints.map((entry) => ({
+        ...entry,
+        file: file(entry.file),
+        declaration: file(entry.declaration),
+        files: entry.files.map(file)
+      }))
+    },
     operations: observation.operations?.map((operation) => ({ ...operation, file: file(operation.file) })),
     invocations: observation.invocations?.map((call) => ({
       ...call,
       ...call.binding ? { binding: { ...call.binding, file: file(call.binding.file) } } : {}
     })),
+    httpEndpoints: observation.httpEndpoints?.map((endpoint) => endpoint.order === undefined ? endpoint : { ...endpoint, order: { ...endpoint.order, application: file(endpoint.order.application) } }),
     diagnostics: observation.diagnostics.map((item) => ({ ...item, ...item.file ? { file: file(item.file) } : {} }))
   };
 }
@@ -435,6 +439,7 @@ function combineObservations(parts) {
   const invocations = [];
   const diagnostics = [];
   const sourceUnits = [];
+  const entryPoints = [];
   const httpEndpoints = [];
   const httpRequests = [];
   for (const { key, observation } of parts) {
@@ -452,6 +457,7 @@ function combineObservations(parts) {
     httpRequests.push(...(observation.httpRequests ?? []).map((request) => ({ ...request, operation: id(request.operation) })));
     diagnostics.push(...observation.diagnostics);
     sourceUnits.push(...observation.sourceUnits ?? []);
+    entryPoints.push(...observation.entryPoints ?? []);
   }
   return createScanObservation({
     scanner: parts[0].observation.scanner,
@@ -461,29 +467,36 @@ function combineObservations(parts) {
     invocations,
     diagnostics,
     ...parts.some((part) => part.observation.sourceUnits !== undefined) ? { sourceUnits } : {},
+    ...parts.some((part) => part.observation.entryPoints !== undefined) ? { entryPoints } : {},
     ...parts.some((part) => part.observation.httpEndpoints !== undefined) ? { httpEndpoints } : {},
     ...parts.some((part) => part.observation.httpRequests !== undefined) ? { httpRequests } : {}
   });
 }
 
 // plugins/scanners/project-scanner.ts
+function within(root, project, files) {
+  const key = path2.relative(root, project).split(path2.sep).join("/");
+  if (key === "")
+    return { key, files: [...files] };
+  return { key, files: files.flatMap((file) => file.startsWith(`${key}/`) ? [file.slice(key.length + 1)] : []) };
+}
 function projectScanner(scanner, select) {
   return {
     ...scanner,
-    checkReadiness: async (root, settings = {}) => {
-      const projects = await select(root, settings);
+    checkReadiness: async (root, settings, files) => {
+      const projects = await select(root, settings, files);
       if (!projects.length)
         throw new Error(`${scanner.id}: No supported project declaration was found.`);
       for (const project of projects)
-        await scanner.checkReadiness?.(project, settings);
+        await scanner.checkReadiness?.(project, settings, within(root, project, files).files);
     },
-    scan: async (root, settings = {}) => {
+    scan: async (root, settings, files) => {
       const parts = [];
-      for (const project of await select(root, settings)) {
-        const observation = await scanner.scan(project, settings);
-        const key = path3.relative(root, project).split(path3.sep).join("/");
+      for (const project of await select(root, settings, files)) {
+        const local = within(root, project, files);
+        const observation = await scanner.scan(project, settings, local.files);
         if (observation)
-          parts.push({ key, observation: relocateObservation(observation, key) });
+          parts.push({ key: local.key, observation: relocateObservation(observation, local.key) });
       }
       return combineObservations(parts);
     }
@@ -491,14 +504,42 @@ function projectScanner(scanner, select) {
 }
 
 // plugins/scanners/go/src/adapter.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile } from "child_process";
 import { access, realpath } from "fs/promises";
-import path4 from "path";
 import { fileURLToPath } from "url";
+
+// plugins/scanners/go/src/sources.ts
+import path3 from "path";
+function ignoredByGo(file) {
+  return file.endsWith("_test.go") || file.split("/").some((part) => part === "testdata" || part.startsWith(".") || part.startsWith("_"));
+}
+function goFiles(files) {
+  const read = files.filter((file) => !ignoredByGo(file));
+  return {
+    modules: read.filter((file) => path3.posix.basename(file) === "go.mod").map((file) => path3.posix.dirname(file)),
+    sources: read.filter((file) => file.endsWith(".go"))
+  };
+}
+function moduleOf(file, modules) {
+  return modules.filter((module) => module === "." || file.startsWith(`${module}/`)).sort((left, right) => right.length - left.length)[0];
+}
+function goModules(files) {
+  return goFiles(files).modules;
+}
+function goSources(candidates) {
+  const { modules, sources } = goFiles(candidates);
+  return sources.filter((file) => moduleOf(file, modules) !== undefined);
+}
+function moduleSources(files) {
+  const { modules, sources } = goFiles(files);
+  return sources.filter((file) => moduleOf(file, modules) === ".");
+}
+
+// plugins/scanners/go/src/adapter.ts
 var packagedWorker = fileURLToPath(new URL(`../dist/${process.platform}-${process.arch}/worker${process.platform === "win32" ? ".exe" : ""}`, import.meta.url));
 function run(command, args, root, { env = process.env, input } = {}) {
   return new Promise((resolve, reject) => {
-    const child = execFile2(command, args, {
+    const child = execFile(command, args, {
       cwd: root,
       env,
       encoding: "utf8",
@@ -524,41 +565,35 @@ async function workerPath(options) {
   }
   return worker;
 }
-async function checkGoReadiness(repositoryRoot, options = {}) {
-  const root = await realpath(repositoryRoot);
+async function checkGoReadiness(moduleRoot, options = {}) {
+  const root = await realpath(moduleRoot);
   const worker = await workerPath(options);
-  await access(path4.join(root, "go.mod"));
   return { root, worker };
 }
 async function readGoCodeStructure(repositoryRoot, references, options = {}) {
   const worker = await workerPath(options);
   return JSON.parse(await run(worker, ["outline", repositoryRoot], repositoryRoot, { input: JSON.stringify(references) }));
 }
-async function scanGoSource(repositoryRoot, options = {}) {
-  const { root, worker } = await checkGoReadiness(repositoryRoot, options);
+async function scanGoSource(moduleRoot, options, files) {
+  const { root, worker } = await checkGoReadiness(moduleRoot, options);
   try {
-    return parseScanObservation(await run(worker, [root], root));
+    return parseScanObservation(await run(worker, [root], root, { input: JSON.stringify(moduleSources(files)) }));
   } catch (error) {
     throw new Error(`GO_SOURCE_INVALID: No observation was produced. Check Go source syntax and module declarations. ${error}`);
   }
 }
 
 // plugins/scanners/go/src/index.ts
-async function goSources(root) {
-  const modules = (await projectFiles(root, (file) => path5.posix.basename(file) === "go.mod")).map((file) => path5.posix.dirname(file));
-  return projectFiles(root, (file) => file.endsWith(".go") && !file.endsWith("_test.go") && !file.split("/").some((part) => part === "testdata" || part.startsWith(".")) && modules.some((module) => module === "." || file.startsWith(`${module}/`)));
-}
 var scanner = {
   id: "go",
-  watch: { include: ["**/*.go", "**/go.mod", "**/go.sum", "**/go.work"], exclude: [] },
-  listSourceFiles: goSources,
+  listSourceFiles: async (_root, _settings, candidates) => goSources(candidates),
   checkReadiness: async (root) => {
     await checkGoReadiness(root);
   },
   readCodeStructure: readGoCodeStructure,
   scan: scanGoSource
 };
-var src_default = projectScanner(scanner, async (root) => (await projectFiles(root, (file) => path5.posix.basename(file) === "go.mod")).map((file) => path5.dirname(path5.join(root, file))));
+var src_default = projectScanner(scanner, async (root, _settings, files) => goModules(files).map((module) => path4.join(root, module)));
 export {
   src_default as default
 };