@suss/packs 0.26.0 → 0.28.0

package/dist/rails.js

@@ -1,35 +1,177 @@
 // ../framework/rails/dist/index.js
-import path from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { z } from "zod";
-import { underscoreConstantPath } from "@suss/adapter-ruby";
+import { underscoreConstantPath as underscoreConstantPath2 } from "@suss/adapter-ruby";
 import fs from "fs";
+import path from "path";
 import {
   bodyStatements,
   field,
-  hashKeySymbolName,
   parseRubySync,
+  underscoreConstantPath
+} from "@suss/adapter-ruby";
+import fs2 from "fs";
+import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
+import {
+  bodyStatements as bodyStatements2,
+  field as field2,
+  hashKeySymbolName,
+  nestedStatements,
+  parseRubySync as parseRubySync2,
   stringValueOf,
   symbolValue
 } from "@suss/adapter-ruby";
-function readSimpleArgs(call) {
-  const argumentList = field(call, "arguments");
+var ENGINE_BASE_NAMES = /* @__PURE__ */ new Set(["Rails::Engine", "::Rails::Engine"]);
+var CONSTANT_TYPES = /* @__PURE__ */ new Set(["constant", "scope_resolution"]);
+function readEngines(roots, acronyms = []) {
+  const engines = [];
+  for (const root of roots) {
+    const routesFile = engineRoutesFile(root);
+    for (const file of engineFilesUnder(root)) {
+      const source = fs.readFileSync(file, "utf8");
+      const rootNode = parseRubySync(source).rootNode;
+      for (const found of engineClassesIn(rootNode, acronyms)) {
+        engines.push({ ...found, routesFile });
+      }
+    }
+  }
+  return engines;
+}
+function engineSourceFiles(root) {
+  const routesFile = engineRoutesFile(root);
+  return [
+    ...engineFilesUnder(root),
+    ...routesFile === null ? [] : [routesFile]
+  ];
+}
+function engineRoutesFile(root) {
+  const routesFile = path.join(root, "config", "routes.rb");
+  return fs.existsSync(routesFile) ? routesFile : null;
+}
+function engineFilesUnder(root) {
+  const directory = path.join(root, "lib");
+  if (!fs.existsSync(directory)) {
+    return [];
+  }
+  return rubyFilesUnder(directory).filter(
+    (file) => fs.readFileSync(file, "utf8").includes("Rails::Engine")
+  );
+}
+function expandPathPattern(pattern) {
+  const segments = pattern.split(path.sep).filter((s) => s !== "");
+  const start = path.isAbsolute(pattern) ? path.sep : ".";
+  let candidates = [start];
+  for (const segment of segments) {
+    if (!segment.includes("*")) {
+      candidates = candidates.map((base) => path.join(base, segment));
+      continue;
+    }
+    const matcher = new RegExp(
+      `^${segment.split("*").map(escapeRegExp).join(".*")}$`
+    );
+    candidates = candidates.flatMap(
+      (base) => fs.existsSync(base) ? fs.readdirSync(base).filter((name) => matcher.test(name)).sort().map((name) => path.join(base, name)) : []
+    );
+  }
+  return candidates.filter((candidate) => fs.existsSync(candidate));
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rubyFilesUnder(directory) {
+  return fs.readdirSync(directory, { withFileTypes: true, recursive: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".rb")).map((entry) => path.join(entry.parentPath, entry.name)).sort();
+}
+function engineClassesIn(node, acronyms, enclosing = []) {
+  const found = [];
+  for (const child of node.namedChildren) {
+    if (child === null) {
+      continue;
+    }
+    if (child.type === "class" && extendsEngine(child)) {
+      const name = definedName(child);
+      if (name !== void 0) {
+        found.push({
+          qualifiedName: [...enclosing, name].join("::"),
+          modulePrefix: isolatedNamespaceOf(child, acronyms)
+        });
+      }
+      continue;
+    }
+    const nested = child.type === "module" || child.type === "class" ? [...enclosing, definedName(child) ?? ""] : enclosing;
+    found.push(...engineClassesIn(child, acronyms, nested));
+  }
+  return found;
+}
+function definedName(definition) {
+  return field(definition, "name")?.text.replace(/^::/, "");
+}
+function extendsEngine(classNode) {
+  const superclass = field(classNode, "superclass");
+  const base = superclass?.namedChildren.find(
+    (child) => child !== null && CONSTANT_TYPES.has(child.type)
+  );
+  return base !== void 0 && base !== null && ENGINE_BASE_NAMES.has(base.text);
+}
+function isolatedNamespaceOf(classNode, acronyms) {
+  const body = field(classNode, "body");
+  if (body === null) {
+    return "";
+  }
+  for (const statement of bodyStatements(body)) {
+    if (statement.type !== "call" || field(statement, "method")?.text !== "isolate_namespace") {
+      continue;
+    }
+    const arguments_ = field(statement, "arguments");
+    const argument = arguments_ === null ? void 0 : bodyStatements(arguments_)[0];
+    if (argument !== void 0 && CONSTANT_TYPES.has(argument.type)) {
+      return underscoreConstantPath(argument.text.replace(/^::/, ""), acronyms);
+    }
+  }
+  return "";
+}
+var ACRONYM_CALL = /\.acronym\s*\(?\s*(["'])([A-Za-z\d]+)\1/g;
+function readAcronyms(configDirectory) {
+  const found = /* @__PURE__ */ new Set();
+  for (const file of inflectionFiles(configDirectory)) {
+    const source = fs2.readFileSync(file, "utf8");
+    for (const match of source.matchAll(ACRONYM_CALL)) {
+      found.add(match[2] ?? "");
+    }
+  }
+  found.delete("");
+  return [...found].sort();
+}
+function inflectionFiles(configDirectory) {
+  const directory = path2.join(configDirectory, "config", "initializers");
+  if (!fs2.existsSync(directory)) {
+    return [];
+  }
+  return fs2.readdirSync(directory, { withFileTypes: true, recursive: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".rb")).map((entry) => path2.join(entry.parentPath, entry.name)).filter(
+    (file) => fs2.readFileSync(file, "utf8").match(ACRONYM_CALL) !== null
+  ).sort();
+}
+function readSimpleArgs(call, defaults = {}) {
+  const argumentList = field2(call, "arguments");
   const positional = [];
-  const keyword = {};
+  const keyword = { ...defaults };
   let hashRocketPair = null;
   if (argumentList === null) {
     return { positional, keyword, hashRocketPair };
   }
-  for (const child of bodyStatements(argumentList)) {
+  for (const child of bodyStatements2(argumentList)) {
     if (child.type !== "pair") {
       positional.push(child);
       continue;
     }
-    const keyNode = field(child, "key");
-    const valueNode = field(child, "value");
+    const keyNode = field2(child, "key");
+    const valueNode = field2(child, "value");
     if (keyNode === null || valueNode === null) {
       continue;
     }
-    const symbolKey = hashKeySymbolName(keyNode);
+    const symbolKey = hashKeySymbolName(keyNode) ?? symbolValue(keyNode);
     if (symbolKey !== null) {
       keyword[symbolKey] = valueNode;
     } else {
@@ -38,11 +180,14 @@ function readSimpleArgs(call) {
   }
   return { positional, keyword, hashRocketPair };
 }
-function wordValue(node) {
+function textValue(node, ctx) {
+  return stringValueOf(node, void 0, ctx.bindings);
+}
+function wordValue(node, ctx) {
   if (node === void 0) {
     return null;
   }
-  return symbolValue(node) ?? stringValueOf(node);
+  return symbolValue(node) ?? textValue(node, ctx);
 }
 function splitControllerAction(text) {
   const index = text.indexOf("#");
@@ -51,15 +196,15 @@ function splitControllerAction(text) {
   }
   return { controllerKey: text.slice(0, index), action: text.slice(index + 1) };
 }
-function readRouteTarget(args) {
-  const toText = args.keyword.to ? stringValueOf(args.keyword.to) : null;
+function readRouteTarget(args, ctx) {
+  const toText = args.keyword.to ? textValue(args.keyword.to, ctx) : null;
   if (toText !== null) {
     const target = splitControllerAction(toText);
     return target === null ? null : { ...target, path: null };
   }
   if (args.hashRocketPair !== null) {
-    const pathText = stringValueOf(args.hashRocketPair.key);
-    const actionText = stringValueOf(args.hashRocketPair.value);
+    const pathText = textValue(args.hashRocketPair.key, ctx);
+    const actionText = textValue(args.hashRocketPair.value, ctx);
     const target = actionText !== null ? splitControllerAction(actionText) : null;
     return target !== null && pathText !== null ? { ...target, path: pathText } : null;
   }
@@ -70,7 +215,7 @@ function readSymbolList(node) {
     return null;
   }
   if (node.type === "array") {
-    return bodyStatements(node).map((child) => symbolValue(child)).filter((name) => name !== null);
+    return bodyStatements2(node).map((child) => symbolValue(child)).filter((name) => name !== null);
   }
   const single = symbolValue(node);
   return single === null ? null : [single];
@@ -96,10 +241,10 @@ function pluralize(word) {
   if (/[^aeiou]y$/.test(word)) {
     return `${word.slice(0, -1)}ies`;
   }
-  if (/(s|x|z|ch|sh)$/.test(word)) {
+  if (/(ss|us|is|x|z|ch|sh)$/.test(word)) {
     return `${word}es`;
   }
-  return `${word}s`;
+  return /s$/.test(word) ? word : `${word}s`;
 }
 function singularize(word) {
   if (/ies$/.test(word)) {
@@ -111,27 +256,79 @@ function singularize(word) {
   return /s$/.test(word) ? word.slice(0, -1) : word;
 }
 var RouteAccumulator = class {
+  /** `drawDirectory` is where `draw(:name)` finds `name.rb`. */
+  constructor(drawDirectory) {
+    this.drawDirectory = drawDirectory;
+  }
+  drawDirectory;
   byKey = /* @__PURE__ */ new Map();
-  unread = /* @__PURE__ */ new Set();
+  unread = /* @__PURE__ */ new Map();
+  /** Per file, each gem block call whose body was walked as though the call changed nothing about it. */
+  walkedBlocks = /* @__PURE__ */ new Map();
+  missingDrawn = [];
+  /** The block each `concern :name do ... end` declared, for `concerns` to replay. */
+  concerns = /* @__PURE__ */ new Map();
+  /** Files `draw(:name)` has already read, so a file drawing itself stops. */
+  drawn = /* @__PURE__ */ new Set();
+  /** Every engine a `mount` may refer to, by the class name it is written with. */
+  engines = /* @__PURE__ */ new Map();
+  /** Engines whose route set is being walked, so an engine that mounts itself stops. */
+  mounting = /* @__PURE__ */ new Set();
+  /** The file whose statements are being walked, as a gap writes it. */
+  file = "";
+  /** The first route written for an action wins, the way Rails matches the first route it declared. */
   add(controllerKey, action, route) {
-    this.byKey.set(`${controllerKey}#${action}`, route);
+    const key = `${controllerKey}#${action}`;
+    if (!this.byKey.has(key)) {
+      this.byKey.set(key, route);
+    }
   }
   recordUnread(callName) {
-    this.unread.add(callName);
+    addUnderFile(this.unread, this.file, callName);
+  }
+  recordWalkedBlock(callName) {
+    addUnderFile(this.walkedBlocks, this.file, callName);
+  }
+  recordMissingDrawn(name) {
+    this.missingDrawn.push({ file: this.file, name });
   }
   routeFor(controllerKey, action) {
     return this.byKey.get(`${controllerKey}#${action}`) ?? null;
   }
-  gapsAgainst(displayPath) {
-    if (this.unread.size === 0) {
-      return [];
+  /** Runs `walk` with gaps attributed to `file`, then goes back to the file being walked before. */
+  inFile(file, walk) {
+    const previous = this.file;
+    this.file = file;
+    walk();
+    this.file = previous;
+  }
+  gaps() {
+    const gaps = [];
+    for (const [file, unread] of this.unread) {
+      const names = [...unread].sort().join(", ");
+      gaps.push(
+        `${file} also declares ${names}, which this pack does not read; whatever those declarations route is missing from what suss reports`
+      );
     }
-    const names = [...this.unread].sort().join(", ");
-    return [
-      `${displayPath} also declares ${names}, which this pack does not read; whatever those declarations route is missing from what suss reports`
-    ];
+    for (const [file, walked] of this.walkedBlocks) {
+      const names = [...walked].sort().join(", ");
+      gaps.push(
+        `${file} wraps routes in ${names}, which this pack does not know; it read the routes inside as though the wrapper changed nothing about their path or controller`
+      );
+    }
+    for (const { file, name } of this.missingDrawn) {
+      gaps.push(
+        `${file} draws ${name}, but there is no ${name}.rb under ${path3.basename(this.drawDirectory)}/ beside it to read; whatever that file routes is missing from what suss reports`
+      );
+    }
+    return gaps;
   }
 };
+function addUnderFile(byFile, file, name) {
+  const names = byFile.get(file) ?? /* @__PURE__ */ new Set();
+  names.add(name);
+  byFile.set(file, names);
+}
 function joinKey(prefix, segment) {
   return prefix === "" ? segment : `${prefix}/${segment}`;
 }
@@ -141,15 +338,20 @@ function joinPath(prefix, segment) {
   return trimmed === "" ? base || "/" : `${base}/${trimmed}`;
 }
 function handleResourceCall(call, ctx, out, plural) {
-  const args = readSimpleArgs(call);
+  const args = readSimpleArgs(call, ctx.defaults);
   const symbol = args.positional[0] ? symbolValue(args.positional[0]) : null;
   if (symbol === null) {
     return;
   }
-  const controllerSegment = wordValue(args.keyword.controller) ?? (plural ? symbol : pluralize(symbol));
-  const controllerKey = joinKey(ctx.modulePrefix, controllerSegment);
+  const controllerSegment = wordValue(args.keyword.controller, ctx) ?? (plural ? symbol : pluralize(symbol));
+  const moduleName = wordValue(args.keyword.module, ctx);
+  const modulePrefix = moduleName === null ? ctx.modulePrefix : joinKey(ctx.modulePrefix, moduleName);
+  const controllerKey = joinKey(modulePrefix, controllerSegment);
   const prefixBase = ctx.resource !== void 0 ? ctx.resource.nestedBase : ctx.pathPrefix;
-  const base = joinPath(prefixBase, wordValue(args.keyword.path) ?? symbol);
+  const base = joinPath(
+    prefixBase,
+    wordValue(args.keyword.path, ctx) ?? symbol
+  );
   const only = readSymbolList(args.keyword.only);
   const except = readSymbolList(args.keyword.except);
   const table = plural ? RESTFUL_ROUTES_PLURAL : RESTFUL_ROUTES_SINGULAR;
@@ -162,11 +364,6 @@ function handleResourceCall(call, ctx, out, plural) {
     }
     out.add(controllerKey, action, routeAt(base));
   }
-  const block = field(call, "block");
-  const body = block !== null ? field(block, "body") : null;
-  if (body === null) {
-    return;
-  }
   const nestedBase = plural ? `${base}/:${singularize(symbol)}_id` : base;
   const nested = {
     controllerKey,
@@ -175,14 +372,20 @@ function handleResourceCall(call, ctx, out, plural) {
     nestedBase,
     ambientBase: nestedBase
   };
-  walkBody(body, { ...ctx, resource: nested }, out);
+  const inside = { ...ctx, modulePrefix, resource: nested };
+  applyConcerns(readSymbolList(args.keyword.concerns) ?? [], inside, out);
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  if (body !== null) {
+    walkBody(body, inside, out);
+  }
 }
 function handleOnBlock(call, ctx, out, isMember) {
   if (ctx.resource === void 0) {
     return;
   }
-  const block = field(call, "block");
-  const body = block !== null ? field(block, "body") : null;
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
   if (body === null) {
     return;
   }
@@ -199,35 +402,36 @@ function baseForOn(resource, on) {
   return resource.ambientBase;
 }
 function handleVerb(call, ctx, out, method) {
-  const args = readSimpleArgs(call);
-  const target = readRouteTarget(args);
+  const args = readSimpleArgs(call, ctx.defaults);
+  const on = wordValue(args.keyword.on, ctx);
+  const base = ctx.resource === void 0 ? ctx.pathPrefix : baseForOn(ctx.resource, on);
+  const target = readRouteTarget(args, ctx);
   if (target !== null) {
-    const literalPath = args.positional[0] ? stringValueOf(args.positional[0]) : null;
-    const path2 = target.path ?? literalPath;
-    if (path2 !== null) {
+    const literalPath = args.positional[0] ? textValue(args.positional[0], ctx) : null;
+    const path5 = target.path ?? literalPath;
+    if (path5 !== null) {
       out.add(joinKey(ctx.modulePrefix, target.controllerKey), target.action, {
         method,
-        path: joinPath(ctx.pathPrefix, path2)
+        path: joinPath(base, path5)
       });
     }
     return;
   }
-  if (ctx.resource === void 0) {
+  const segment = args.positional[0] ? wordValue(args.positional[0], ctx) : null;
+  if (segment === null) {
     return;
   }
-  const symbol = args.positional[0] ? symbolValue(args.positional[0]) : null;
-  if (symbol === null) {
+  const action = wordValue(args.keyword.action, ctx) ?? segment;
+  const controller = wordValue(args.keyword.controller, ctx);
+  const controllerKey = controller !== null ? joinKey(ctx.modulePrefix, controller) : ctx.resource?.controllerKey;
+  if (controllerKey === void 0) {
     return;
   }
-  const base = baseForOn(ctx.resource, wordValue(args.keyword.on));
-  out.add(ctx.resource.controllerKey, symbol, {
-    method,
-    path: `${base}/${symbol}`
-  });
+  out.add(controllerKey, action, { method, path: joinPath(base, segment) });
 }
 function handleRoot(call, ctx, out) {
-  const args = readSimpleArgs(call);
-  const target = readRouteTarget(args) ?? (args.positional[0] ? splitControllerAction(stringValueOf(args.positional[0]) ?? "") : null);
+  const args = readSimpleArgs(call, ctx.defaults);
+  const target = readRouteTarget(args, ctx) ?? (args.positional[0] ? splitControllerAction(textValue(args.positional[0], ctx) ?? "") : null);
   if (target !== null) {
     out.add(joinKey(ctx.modulePrefix, target.controllerKey), target.action, {
       method: "GET",
@@ -236,40 +440,146 @@ function handleRoot(call, ctx, out) {
   }
 }
 function handleNamespace(call, ctx, out) {
-  const args = readSimpleArgs(call);
+  const args = readSimpleArgs(call, ctx.defaults);
   const symbol = args.positional[0] ? symbolValue(args.positional[0]) : null;
-  const block = field(call, "block");
-  const body = block !== null ? field(block, "body") : null;
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
   if (symbol === null || body === null) {
     return;
   }
-  walkBody(
-    body,
-    {
-      pathPrefix: joinPath(ctx.pathPrefix, symbol),
-      modulePrefix: joinKey(ctx.modulePrefix, symbol)
-    },
-    out
-  );
+  walkBody(body, enterScope(ctx, symbol, symbol), out);
+}
+function enterScope(ctx, pathSegment, moduleName) {
+  const base = ctx.resource?.nestedBase ?? ctx.pathPrefix;
+  const { resource: _left, ...kept } = ctx;
+  return {
+    ...kept,
+    pathPrefix: pathSegment !== null ? joinPath(base, pathSegment) : base,
+    modulePrefix: moduleName !== null ? joinKey(ctx.modulePrefix, moduleName) : ctx.modulePrefix
+  };
 }
 function handleScope(call, ctx, out) {
-  const args = readSimpleArgs(call);
-  const moduleName = wordValue(args.keyword.module);
-  const pathSegment = wordValue(args.keyword.path) ?? (args.positional[0] ? wordValue(args.positional[0]) : null);
-  const block = field(call, "block");
-  const body = block !== null ? field(block, "body") : null;
+  const args = readSimpleArgs(call, ctx.defaults);
+  const moduleName = wordValue(args.keyword.module, ctx);
+  const pathSegment = wordValue(args.keyword.path, ctx) ?? (args.positional[0] ? wordValue(args.positional[0], ctx) : null);
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
   if (body === null) {
     return;
   }
-  walkBody(
-    body,
-    {
-      pathPrefix: pathSegment !== null ? joinPath(ctx.pathPrefix, pathSegment) : ctx.pathPrefix,
-      modulePrefix: moduleName !== null ? joinKey(ctx.modulePrefix, moduleName) : ctx.modulePrefix
-    },
-    out
+  walkBody(body, enterScope(ctx, pathSegment, moduleName), out);
+}
+var LITERAL_LIST_TYPES = /* @__PURE__ */ new Set(["array", "string_array", "symbol_array"]);
+var LOOP_METHODS = /* @__PURE__ */ new Set(["each", "each_with_index"]);
+function replayLiteralLoop(call, ctx, out) {
+  const receiver = field2(call, "receiver");
+  const method = field2(call, "method")?.text;
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  const parameters = block !== null ? field2(block, "parameters") : null;
+  if (receiver === null || !LITERAL_LIST_TYPES.has(receiver.type) || method === void 0 || !LOOP_METHODS.has(method) || body === null || parameters === null) {
+    return;
+  }
+  const [element, index] = bodyStatements2(parameters).map((p) => p.text);
+  if (element === void 0) {
+    return;
+  }
+  const elements = bodyStatements2(receiver).map(
+    (node) => listElementWord(node, ctx)
+  );
+  elements.forEach((word, position) => {
+    if (word === null) {
+      return;
+    }
+    const bindings = new Map(ctx.bindings ?? []);
+    bindings.set(element, word);
+    if (index !== void 0) {
+      bindings.set(index, String(position));
+    }
+    walkBody(body, { ...ctx, bindings }, out);
+  });
+}
+function listElementWord(node, ctx) {
+  if (node.type === "bare_symbol") {
+    return node.text;
+  }
+  return wordValue(node, ctx);
+}
+function walkBlockInPlace(call, ctx, out) {
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  if (body !== null) {
+    walkBody(body, ctx, out);
+  }
+}
+function handleWithOptions(call, ctx, out) {
+  const args = readSimpleArgs(call, ctx.defaults);
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  if (body === null) {
+    return;
+  }
+  walkBody(body, { ...ctx, defaults: args.keyword }, out);
+}
+function handleConcern(call, ctx, out) {
+  const args = readSimpleArgs(call, ctx.defaults);
+  const name = args.positional[0] ? symbolValue(args.positional[0]) : null;
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  if (name !== null && body !== null) {
+    out.concerns.set(name, body);
+  }
+}
+function applyConcerns(names, ctx, out) {
+  for (const name of names) {
+    const body = out.concerns.get(name);
+    if (body !== void 0) {
+      walkBody(body, ctx, out);
+    }
+  }
+}
+function handleConcerns(call, ctx, out) {
+  const args = readSimpleArgs(call, ctx.defaults);
+  const names = args.positional.map((node) => symbolValue(node)).filter((name) => name !== null);
+  applyConcerns(names, ctx, out);
+}
+function methodsOfVia(node) {
+  const names = readSymbolList(node) ?? [];
+  if (names.includes("all")) {
+    return ["*"];
+  }
+  return names.map((name) => name.toUpperCase());
+}
+function handleMatch(call, ctx, out) {
+  const via = readSimpleArgs(call, ctx.defaults).keyword.via;
+  for (const method of methodsOfVia(via)) {
+    handleVerb(call, ctx, out, method);
+  }
+}
+function drawDirectoryOf(routesFile) {
+  return path3.join(
+    path3.dirname(routesFile),
+    path3.basename(routesFile, path3.extname(routesFile))
   );
 }
+function handleDraw(call, ctx, out) {
+  const args = readSimpleArgs(call, ctx.defaults);
+  const name = args.positional[0] ? wordValue(args.positional[0], ctx) : null;
+  if (name === null) {
+    return;
+  }
+  const file = path3.join(out.drawDirectory, `${name}.rb`);
+  if (out.drawn.has(file)) {
+    return;
+  }
+  out.drawn.add(file);
+  if (!fs3.existsSync(file)) {
+    out.recordMissingDrawn(name);
+    return;
+  }
+  const tree = parseRubySync2(fs3.readFileSync(file, "utf8"));
+  walkBody(tree.rootNode, ctx, out);
+}
 var HANDLERS = {
   resources: (call, ctx, out) => handleResourceCall(call, ctx, out, true),
   resource: (call, ctx, out) => handleResourceCall(call, ctx, out, false),
@@ -282,59 +592,182 @@ var HANDLERS = {
   post: (call, ctx, out) => handleVerb(call, ctx, out, "POST"),
   patch: (call, ctx, out) => handleVerb(call, ctx, out, "PATCH"),
   put: (call, ctx, out) => handleVerb(call, ctx, out, "PUT"),
-  delete: (call, ctx, out) => handleVerb(call, ctx, out, "DELETE")
+  delete: (call, ctx, out) => handleVerb(call, ctx, out, "DELETE"),
+  match: handleMatch,
+  draw: handleDraw,
+  constraints: walkBlockInPlace,
+  with_options: handleWithOptions,
+  concern: handleConcern,
+  concerns: handleConcerns,
+  mount: handleMount
 };
+function handleMount(call, ctx, out) {
+  const args = readSimpleArgs(call, ctx.defaults);
+  const target = args.positional[0] ?? args.hashRocketPair?.key;
+  const at = args.keyword.at ?? args.hashRocketPair?.value;
+  const name = target?.text.replace(/^::/, "");
+  const engine = name === void 0 ? void 0 : out.engines.get(name);
+  const mountPath = at === void 0 ? null : textValue(at, ctx);
+  if (name === void 0 || engine === void 0 || mountPath === null || out.mounting.has(name)) {
+    out.recordUnread("mount");
+    return;
+  }
+  if (engine.body === null) {
+    return;
+  }
+  out.mounting.add(name);
+  out.inFile(engine.displayPath, () => {
+    walkBody(
+      engine.body,
+      {
+        pathPrefix: joinPath(ctx.pathPrefix, mountPath),
+        modulePrefix: engine.modulePrefix,
+        defaults: {}
+      },
+      out
+    );
+  });
+  out.mounting.delete(name);
+}
 function walkBody(body, ctx, out) {
-  for (const statement of bodyStatements(body)) {
-    if (statement.type !== "call" || field(statement, "receiver") !== null) {
+  walkStatements(bodyStatements2(body), ctx, out);
+}
+function walkStatements(statements, ctx, out) {
+  for (const statement of statements) {
+    if (statement.type !== "call") {
+      walkStatements(nestedStatements(statement), ctx, out);
+      continue;
+    }
+    if (field2(statement, "receiver") !== null) {
+      replayLiteralLoop(statement, ctx, out);
       continue;
     }
-    const name = field(statement, "method")?.text;
+    const name = field2(statement, "method")?.text;
     if (name === void 0) {
       continue;
     }
     const handler = HANDLERS[name];
-    if (handler === void 0) {
-      out.recordUnread(name);
+    if (handler !== void 0) {
+      handler(statement, ctx, out);
+      continue;
+    }
+    if (blockWrittenInRoutesGrammar(statement)) {
+      out.recordWalkedBlock(name);
+      walkBlockInPlace(statement, ctx, out);
       continue;
     }
-    handler(statement, ctx, out);
+    out.recordUnread(name);
   }
 }
-function drawBlockBody(root) {
-  for (const statement of bodyStatements(root)) {
-    if (statement.type !== "call") {
-      continue;
+function blockWrittenInRoutesGrammar(call) {
+  const block = field2(call, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  if (body === null) {
+    return false;
+  }
+  return bodyStatements2(body).some(
+    (statement) => statement.type === "call" && field2(statement, "receiver") === null && Object.hasOwn(HANDLERS, field2(statement, "method")?.text ?? "")
+  );
+}
+var DECLARATION_ORDER = {
+  prepend: 0,
+  draw: 1,
+  append: 2
+};
+function isDeclarationKind(name) {
+  return name in DECLARATION_ORDER;
+}
+function routeDeclarations(root, displayPath) {
+  const found = [];
+  const visit = (node) => {
+    const declaration = asRouteDeclaration(node, displayPath);
+    if (declaration !== null) {
+      found.push(declaration);
+      return;
     }
-    const block = field(statement, "block");
-    const body = block !== null ? field(block, "body") : null;
-    if (body !== null) {
-      return body;
+    for (const child of node.namedChildren) {
+      if (child !== null) {
+        visit(child);
+      }
     }
+  };
+  visit(root);
+  return found;
+}
+function asRouteDeclaration(node, displayPath) {
+  if (node.type !== "call") {
+    return null;
   }
-  return null;
+  const kind = field2(node, "method")?.text;
+  const receiver = field2(node, "receiver");
+  const block = field2(node, "block");
+  const body = block !== null ? field2(block, "body") : null;
+  if (kind === void 0 || !isDeclarationKind(kind) || receiver === null || receiver.type !== "call" || field2(receiver, "method")?.text !== "routes" || body === null) {
+    return null;
+  }
+  const owner = field2(receiver, "receiver");
+  if (owner === null) {
+    return null;
+  }
+  return { owner: owner.text.replace(/^::/, ""), kind, body, displayPath };
+}
+function isApplication(owner) {
+  return owner === "Rails.application" || /(^|::)Application$/.test(owner);
 }
-function readRoutesFile(absRoutesPath, displayPath) {
-  if (!fs.existsSync(absRoutesPath)) {
+function parseDeclarations(source) {
+  if (!fs3.existsSync(source.file)) {
+    return [];
+  }
+  const tree = parseRubySync2(fs3.readFileSync(source.file, "utf8"));
+  return routeDeclarations(tree.rootNode, source.displayPath);
+}
+function readRoutes(input) {
+  if (!fs3.existsSync(input.routesFile.file)) {
     return {
       routeFor: () => null,
       fileFound: false,
       gaps: [
-        `${displayPath} does not exist, so this run assumes each action's path and method from Rails' RESTful naming convention instead of reading it from routing`
+        `${input.routesFile.displayPath} does not exist, so this run assumes each action's path and method from Rails' RESTful naming convention instead of reading it from routing`
       ]
     };
   }
-  const source = fs.readFileSync(absRoutesPath, "utf8");
-  const tree = parseRubySync(source);
-  const out = new RouteAccumulator();
-  const body = drawBlockBody(tree.rootNode);
-  if (body !== null) {
-    walkBody(body, { pathPrefix: "", modulePrefix: "" }, out);
+  const out = new RouteAccumulator(drawDirectoryOf(input.routesFile.file));
+  const engineDeclarations = input.engines.flatMap(
+    (engine) => engine.routesFile === null ? [] : parseDeclarations({
+      file: engine.routesFile,
+      displayPath: engine.displayPath
+    })
+  );
+  for (const engine of input.engines) {
+    out.engines.set(engine.qualifiedName, {
+      modulePrefix: engine.modulePrefix,
+      body: engineDeclarations.find(
+        (declaration) => declaration.owner === engine.qualifiedName
+      )?.body ?? null,
+      displayPath: engine.displayPath
+    });
+  }
+  const applicationDeclarations = [
+    ...parseDeclarations(input.routesFile),
+    ...input.routesFiles.flatMap(parseDeclarations),
+    ...engineDeclarations
+  ].filter((declaration) => isApplication(declaration.owner));
+  const ordered = applicationDeclarations.map((declaration, position) => ({ declaration, position })).sort(
+    (a, b) => DECLARATION_ORDER[a.declaration.kind] - DECLARATION_ORDER[b.declaration.kind] || a.position - b.position
+  );
+  for (const { declaration } of ordered) {
+    out.inFile(declaration.displayPath, () => {
+      walkBody(
+        declaration.body,
+        { pathPrefix: "", modulePrefix: "", defaults: {} },
+        out
+      );
+    });
   }
   return {
     routeFor: (controllerKey, action) => out.routeFor(controllerKey, action),
     fileFound: true,
-    gaps: out.gapsAgainst(displayPath)
+    gaps: out.gaps()
   };
 }
 var RACK_STATUS_CODE_NAMES = {
@@ -424,7 +857,21 @@ var optionsSchema = z.object({
    */
   inheritedMethodNames: z.array(z.string()).optional(),
   /** Where this project's routes live, relative to `configDirectory` when there is one. Every Rails app scaffolds this at `config/routes.rb`. */
-  routesFile: z.string().optional()
+  routesFile: z.string().optional(),
+  /**
+   * Directories the project keeps its own engines under, each one the
+   * root a `Rails::Engine` subclass has its `lib/` and `config/routes.rb`
+   * in. A `*` in a segment matches any one directory, so `plugins/*`
+   * covers every plugin. Relative to `configDirectory`.
+   */
+  engineRoots: z.array(z.string()).optional(),
+  /**
+   * Files beyond the routes file that add routes through a
+   * `Rails.application.routes.draw`, `.append` or `.prepend` block,
+   * a plugin's `plugin.rb` being the usual one. Same `*` rule as
+   * `engineRoots`. Relative to `configDirectory`.
+   */
+  routesFiles: z.array(z.string()).optional()
 }).strict();
 var RAILS_ROOT_CLASS_NAMES = [
   "ActionController::Base",
@@ -479,9 +926,9 @@ var RAILS_CONTROLLER_METHODS = [
   "controller_name",
   "controller_path"
 ];
-function controllerKeyFromQualified(qualifiedName) {
+function controllerKeyFromQualified(qualifiedName, acronyms) {
   const withoutSuffix = qualifiedName.endsWith("Controller") ? qualifiedName.slice(0, -"Controller".length) : qualifiedName;
-  return underscoreConstantPath(withoutSuffix);
+  return underscoreConstantPath2(withoutSuffix, acronyms);
 }
 function conventionalRoute(controllerKey, actionName) {
   const template = RESTFUL_ACTIONS[actionName];
@@ -495,10 +942,10 @@ function conventionalRoute(controllerKey, actionName) {
   };
 }
 function resolveAgainst(configDirectory, value) {
-  if (configDirectory === void 0 || path.isAbsolute(value)) {
+  if (configDirectory === void 0 || path4.isAbsolute(value)) {
     return value;
   }
-  return path.resolve(configDirectory, value);
+  return path4.resolve(configDirectory, value);
 }
 function railsFramework(options = {}) {
   const root = resolveAgainst(options.configDirectory, options.root ?? "app");
@@ -506,12 +953,27 @@ function railsFramework(options = {}) {
     options.configDirectory,
     options.routesFile ?? "config/routes.rb"
   );
+  const displayPathOf = (file) => options.configDirectory === void 0 ? file : path4.relative(options.configDirectory, file);
+  const engineRoots = () => expandPatterns(options.configDirectory, options.engineRoots);
+  const extraRoutesFiles = () => expandPatterns(options.configDirectory, options.routesFiles);
+  const acronyms = options.configDirectory === void 0 ? [] : readAcronyms(options.configDirectory);
+  const routesInput = () => ({
+    routesFile: {
+      file: routesFile,
+      displayPath: options.routesFile ?? "config/routes.rb"
+    },
+    engines: readEngines(engineRoots(), acronyms).map((engine) => ({
+      ...engine,
+      displayPath: engine.routesFile === null ? engine.qualifiedName : displayPathOf(engine.routesFile)
+    })),
+    routesFiles: extraRoutesFiles().map((file) => ({
+      file,
+      displayPath: displayPathOf(file)
+    }))
+  });
   let table;
   const routeTable = () => {
-    table ??= readRoutesFile(
-      routesFile,
-      options.routesFile ?? "config/routes.rb"
-    );
+    table ??= readRoutes(routesInput());
     return table;
   };
   const pattern = {
@@ -522,6 +984,7 @@ function railsFramework(options = {}) {
     ],
     root,
     pathConvention: "railsUnderscore",
+    acronyms,
     ancestryRootClassNames: [...RAILS_ROOT_CLASS_NAMES],
     defaultStatusCode: 200,
     responseStatusCalls: RESPONSE_STATUS_CALLS,
@@ -533,7 +996,7 @@ function railsFramework(options = {}) {
     routesFile,
     filters: CONTROLLER_FILTERS,
     routeFor: (controllerQualifiedName, actionName) => {
-      const key = controllerKeyFromQualified(controllerQualifiedName);
+      const key = controllerKeyFromQualified(controllerQualifiedName, acronyms);
       const found = routeTable();
       return found.fileFound ? found.routeFor(key, actionName) : conventionalRoute(key, actionName);
     },
@@ -543,21 +1006,50 @@ function railsFramework(options = {}) {
     name: "rails",
     protocol: "http",
     discovery: [pattern],
-    // The routes file decides every action's method and path but is
-    // never walked, so the cache key has to read it here.
-    discoveryInputs: () => [routesFile]
+    // Every file routing or naming is read from decides an action's
+    // binding without being walked, so the cache key has to read them
+    // here. This runs before the grammar loads, so nothing parses Ruby.
+    discoveryInputs: () => [
+      routesFile,
+      ...drawableRoutesFiles(routesFile),
+      ...engineRoots().flatMap(engineSourceFiles),
+      ...extraRoutesFiles(),
+      ...options.configDirectory === void 0 ? [] : inflectionFiles(options.configDirectory)
+    ]
   };
 }
+function expandPatterns(configDirectory, patterns) {
+  return (patterns ?? []).flatMap(
+    (pattern) => expandPathPattern(resolveAgainst(configDirectory, pattern))
+  );
+}
+function drawableRoutesFiles(routesFile) {
+  const directory = drawDirectoryOf(routesFile);
+  if (!fs4.existsSync(directory)) {
+    return [];
+  }
+  return fs4.readdirSync(directory).filter((name) => name.endsWith(".rb")).sort().map((name) => path4.join(directory, name));
+}
 var declares = {
   kind: "framework",
   package: "@suss/framework-rails",
-  dependencies: [{ ecosystem: "rubygems", name: "rails" }],
+  // An app that depends on the Rails gems one at a time has railties in
+  // its Gemfile and no rails.
+  dependencies: [
+    { ecosystem: "rubygems", name: "rails" },
+    { ecosystem: "rubygems", name: "railties" }
+  ],
   reads: "Rails controller actions (Ruby), bound to the method and path `config/routes.rb` gives each one; an action the routes file does not reach is discovered with no boundary.",
   configuration: {
     file: "suss.rails.json",
-    example: { root: "app", routesFile: "config/routes.rb" },
+    example: {
+      root: "app",
+      routesFile: "config/routes.rb",
+      engineRoots: ["engines/*"],
+      routesFiles: ["plugins/*/plugin.rb"]
+    },
     required: false,
-    why: "the app directory a controller is defined under and the routes file suss reads each action's method and path from. rails new scaffolds both at these paths."
+    why: "the app directory a controller is defined under and the routes file suss reads each action's method and path from; rails new scaffolds both at these paths. engineRoots lists where the project keeps engines it mounts, and routesFiles any other file that adds routes, when it has either."
   }
 };
 var index_default = railsFramework;