sigmap 6.10.9 → 6.10.10

package/src/discovery/r-manifest.js

@@ -0,0 +1,176 @@
+'use strict';
+
+/**
+ * Parsers for R package manifest files (DESCRIPTION + NAMESPACE).
+ *
+ * Zero-dependency, regex/line-based. Both readers are safe on missing files
+ * (return null) and on malformed input (return whatever could be parsed).
+ *
+ * Exports:
+ *   readDescription(cwd) → { package, version, imports[], depends[], suggests[], linkingTo[] } | null
+ *   readNamespace(cwd)   → { exports: Set, exportPatterns: RegExp[], s3methods: [{generic,class}], importFrom: Map<pkg, Set<name>> } | null
+ *   collectLocalDefs(rFiles) → Map<defName, absPath>
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+/**
+ * Parse a DESCRIPTION file (Debian control format).
+ *
+ * Continuation lines start with whitespace and are appended to the previous
+ * field. Comma-separated dependency lists are split and version constraints
+ * `pkg (>= 1.0.0)` are stripped to just `pkg`.
+ *
+ * @param {string} cwd - project root containing DESCRIPTION
+ * @returns {object|null}
+ */
+function readDescription(cwd) {
+  const p = path.join(cwd, 'DESCRIPTION');
+  if (!fs.existsSync(p)) return null;
+  let raw;
+  try { raw = fs.readFileSync(p, 'utf8'); } catch (_) { return null; }
+
+  const fields = {};
+  let currentKey = null;
+  for (const rawLine of raw.split('\n')) {
+    if (/^\s/.test(rawLine) && currentKey) {
+      // Continuation: append (with a space) to the current field.
+      fields[currentKey] += ' ' + rawLine.trim();
+      continue;
+    }
+    const m = rawLine.match(/^([A-Za-z][\w.]*)\s*:\s*(.*)$/);
+    if (m) {
+      currentKey = m[1];
+      fields[currentKey] = m[2].trim();
+    } else {
+      currentKey = null;
+    }
+  }
+
+  return {
+    package:   fields.Package   || null,
+    version:   fields.Version   || null,
+    imports:   splitDeps(fields.Imports),
+    depends:   splitDeps(fields.Depends),
+    suggests:  splitDeps(fields.Suggests),
+    linkingTo: splitDeps(fields.LinkingTo),
+  };
+}
+
+/**
+ * Split a DESCRIPTION dep list like
+ *   "dplyr (>= 1.0.0), ggplot2, R (>= 4.0)"
+ * into a clean array of package names, dropping `R` itself.
+ */
+function splitDeps(value) {
+  if (!value) return [];
+  return value.split(',')
+    .map((s) => s.trim().replace(/\s*\([^)]*\)\s*$/, '').trim())
+    .filter((s) => s && s !== 'R');
+}
+
+/**
+ * Parse a NAMESPACE file.
+ *
+ * Recognised directives (R writes NAMESPACE in Lisp-y notation):
+ *   export(name) / export("name")
+ *   exportPattern("^foo")
+ *   exportMethods(generic1, generic2)
+ *   S3method(generic, class)
+ *   importFrom(pkg, name1, name2, ...)
+ *   import(pkg)
+ *   useDynLib(pkg)            — ignored (compiled code)
+ *
+ * @param {string} cwd
+ * @returns {object|null}
+ */
+function readNamespace(cwd) {
+  const p = path.join(cwd, 'NAMESPACE');
+  if (!fs.existsSync(p)) return null;
+  let raw;
+  try { raw = fs.readFileSync(p, 'utf8'); } catch (_) { return null; }
+
+  // Strip comments.
+  const text = raw.replace(/#.*$/gm, '');
+
+  const exports = new Set();
+  const exportPatterns = [];
+  const s3methods = [];
+  const importFrom = new Map();
+
+  for (const m of text.matchAll(/\bexport\s*\(\s*([^)]+)\)/g)) {
+    for (const name of splitArgs(m[1])) {
+      const clean = stripQuotes(name);
+      if (clean) exports.add(clean);
+    }
+  }
+  for (const m of text.matchAll(/\bexportMethods\s*\(\s*([^)]+)\)/g)) {
+    for (const name of splitArgs(m[1])) {
+      const clean = stripQuotes(name);
+      if (clean) exports.add(clean);
+    }
+  }
+  for (const m of text.matchAll(/\bexportPattern\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+    try { exportPatterns.push(new RegExp(m[1])); } catch (_) {}
+  }
+  for (const m of text.matchAll(/\bS3method\s*\(\s*([\w.]+)\s*,\s*([\w.]+)\s*\)/g)) {
+    s3methods.push({ generic: m[1], class: m[2] });
+    // The generic itself is implicitly exported for the registered class.
+    exports.add(m[1]);
+  }
+  for (const m of text.matchAll(/\bimportFrom\s*\(\s*([\w.]+)\s*,\s*([^)]+)\)/g)) {
+    const pkg = m[1];
+    if (!importFrom.has(pkg)) importFrom.set(pkg, new Set());
+    for (const name of splitArgs(m[2])) {
+      const clean = stripQuotes(name);
+      if (clean) importFrom.get(pkg).add(clean);
+    }
+  }
+
+  return { exports, exportPatterns, s3methods, importFrom };
+}
+
+function splitArgs(raw) {
+  return raw.split(',').map((s) => s.trim()).filter(Boolean);
+}
+
+function stripQuotes(s) {
+  return s.replace(/^["']|["']$/g, '').trim();
+}
+
+/**
+ * Build a Map<symbolName, absFilePath> from the top-level definitions in a
+ * set of R files. Used by the graph builder to resolve `localPkg::fn` to a
+ * concrete file. Reads each file once and runs a single regex.
+ *
+ * @param {string[]} rFiles - absolute paths to .R/.r files
+ * @returns {Map<string, string>}
+ */
+function collectLocalDefs(rFiles) {
+  const defs = new Map();
+  // Matches `name <- function(`, `name <- R6Class(`, `name <- new_class(`,
+  // `setGeneric("name"`, `setClass("name"`. First-write-wins.
+  const reAssign = /^(?:[ \t]*)([\w.]+)\s*(?:<<-|<-|=)\s*(?:(?:R6::)?R6Class|(?:S7::)?new_class|function)\b/gm;
+  const reS4Generic = /^[ \t]*setGeneric\s*\(\s*["']([\w.]+)["']/gm;
+  const reS4Class   = /^[ \t]*setClass\s*\(\s*["']([\w.]+)["']/gm;
+  for (const filePath of rFiles) {
+    let content;
+    try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+    const stripped = content.replace(/#.*$/gm, '');
+    let m;
+    while ((m = reAssign.exec(stripped)) !== null) {
+      if (m[1].startsWith('.')) continue;
+      if (!defs.has(m[1])) defs.set(m[1], filePath);
+    }
+    while ((m = reS4Generic.exec(stripped)) !== null) {
+      if (!defs.has(m[1])) defs.set(m[1], filePath);
+    }
+    while ((m = reS4Class.exec(stripped)) !== null) {
+      if (!defs.has(m[1])) defs.set(m[1], filePath);
+    }
+  }
+  return defs;
+}
+
+module.exports = { readDescription, readNamespace, collectLocalDefs };

package/src/extractors/deps.js

@@ -60,6 +60,35 @@ function extractTSDeps(src) {
   return [...deps].slice(0, 5);
 }
 
+// R base packages — present in every install, not informative as deps.
+const R_BASE_PKGS = new Set([
+  'base', 'stats', 'utils', 'graphics', 'grDevices', 'methods', 'datasets',
+  'parallel', 'splines', 'stats4', 'tools', 'tcltk', 'grid', 'compiler',
+]);
+
+/**
+ * Extract project-level import dependencies from R source.
+ * Captures `library(pkg)`, `require(pkg)`, `requireNamespace("pkg")`, and
+ * `pkg::fn` references, skipping base packages.
+ * @param {string} src
+ * @returns {string[]}
+ */
+function extractRDeps(src) {
+  const deps = new Set();
+  // Strip line comments so commented-out library() calls don't match.
+  const stripped = (src || '').replace(/#.*$/gm, '');
+  for (const m of stripped.matchAll(/\b(?:library|require)\s*\(\s*["']?([\w.]+)["']?\s*\)/g)) {
+    if (m[1] && !R_BASE_PKGS.has(m[1])) deps.add(m[1]);
+  }
+  for (const m of stripped.matchAll(/\brequireNamespace\s*\(\s*["']([\w.]+)["']/g)) {
+    if (m[1] && !R_BASE_PKGS.has(m[1])) deps.add(m[1]);
+  }
+  for (const m of stripped.matchAll(/\b([A-Za-z][\w.]*)::[A-Za-z]/g)) {
+    if (m[1] && !R_BASE_PKGS.has(m[1])) deps.add(m[1]);
+  }
+  return [...deps].slice(0, 5);
+}
+
 /**
  * Build reverse dependency map from forward map.
  * @param {Map<string, string[]>} forwardMap
@@ -78,4 +107,4 @@ function buildReverseDepMap(forwardMap) {
   return reverse;
 }
 
-module.exports = { extractPythonDeps, extractTSDeps, buildReverseDepMap };
+module.exports = { extractPythonDeps, extractTSDeps, extractRDeps, buildReverseDepMap };

package/src/extractors/r.js

@@ -2,6 +2,18 @@
 
 /**
  * Extract signatures from R source code.
+ *
+ * Recognised constructs:
+ *   - Function definitions: `name <- function(args)`, `name = function(args)`,
+ *     `name <<- function(args)`
+ *   - S4: setClass / setGeneric / setMethod
+ *   - R6: `Name <- R6Class("Name", public = list(method = function(...)))`
+ *   - S7: `Name <- new_class("Name", ...)` and `method(generic, Name) <- function(...)`
+ *   - roxygen2 docstring hint (first non-tag `#'` line) appended as `  # hint`
+ *
+ * The extractor stays regex-only and zero-dependency. Output uses two-space
+ * indentation for class members (matching python/typescript/scala fixtures).
+ *
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -9,58 +21,202 @@ function extract(src) {
   if (!src || typeof src !== 'string') return [];
   const sigs = [];
 
-  // Strip line comments. R uses # comments. Roxygen2 (#') comments are
-  // stripped along with regular ones; Phase 2 may parse them.
+  // Collect roxygen2 hints from the original source (before stripping `#`).
+  const docHints = collectRoxygenHints(src);
+
+  // Strip line comments for the rest of the parsing. R uses `#` comments and
+  // roxygen2 `#'` is consumed alongside them — its content already lives in
+  // docHints.
   const stripped = src.replace(/#.*$/gm, '');
 
-  // Function definitions:
-  //   name <- function(args) { ... }
-  //   name = function(args) { ... }
-  //   name <<- function(args) { ... }
-  // Args may span multiple lines and contain default values, so we need to
-  // match a balanced parenthesis group rather than a single line.
-  const funcRe = /^(?:[ \t]*)([\w.]+)\s*(?:<<-|<-|=)\s*function\s*\(/gm;
+  // Track byte ranges already accounted for by R6 / setClass blocks so the
+  // top-level function regex doesn't re-emit their methods as bare functions.
+  const consumedRanges = [];
+
+  // ── R6 classes ────────────────────────────────────────────────────────────
+  //   ClassName <- R6Class("ClassName", public = list(method = function(...)))
+  //   ClassName <- R6::R6Class(...)
+  const r6Re = /([\w.]+)\s*(?:<<-|<-|=)\s*(?:R6::)?R6Class\s*\(/g;
   let m;
-  while ((m = funcRe.exec(stripped)) !== null) {
+  while ((m = r6Re.exec(stripped)) !== null && sigs.length < 30) {
+    const name = m[1];
+    if (name.startsWith('.')) continue;
+    const openIdx = r6Re.lastIndex - 1;
+    const body = readBalancedParens(stripped, openIdx);
+    if (body === null) continue;
+    const closeIdx = openIdx + body.length + 1;
+    const classNameLit = readFirstStringArg(body) || name;
+    sigs.push(`${name} <- R6Class("${classNameLit}")` + applyHint(docHints, name));
+    for (const memberSig of extractListMethods(body, 8)) {
+      sigs.push('  ' + memberSig);
+      if (sigs.length >= 30) break;
+    }
+    consumedRanges.push([m.index, closeIdx]);
+    r6Re.lastIndex = closeIdx;
+  }
+
+  // ── S7 classes ────────────────────────────────────────────────────────────
+  //   ClassName <- new_class("ClassName", properties = list(...))
+  const s7Classes = new Set();
+  const s7Re = /([\w.]+)\s*(?:<<-|<-|=)\s*(?:S7::)?new_class\s*\(/g;
+  while ((m = s7Re.exec(stripped)) !== null && sigs.length < 30) {
+    const name = m[1];
+    if (name.startsWith('.')) continue;
+    const openIdx = s7Re.lastIndex - 1;
+    const body = readBalancedParens(stripped, openIdx);
+    if (body === null) continue;
+    const closeIdx = openIdx + body.length + 1;
+    const classNameLit = readFirstStringArg(body) || name;
+    s7Classes.add(classNameLit);
+    s7Classes.add(name);
+    sigs.push(`${name} <- new_class("${classNameLit}")` + applyHint(docHints, name));
+    consumedRanges.push([m.index, closeIdx]);
+    s7Re.lastIndex = closeIdx;
+  }
+
+  // S7 method dispatch: `method(generic, ClassName) <- function(args)`
+  const s7MethodRe = /^[ \t]*method\s*\(\s*([\w.]+)\s*,\s*([\w.]+)\s*\)\s*(?:<<-|<-|=)\s*function\s*\(/gm;
+  while ((m = s7MethodRe.exec(stripped)) !== null && sigs.length < 30) {
+    if (!s7Classes.has(m[2])) continue;
+    const argsStart = s7MethodRe.lastIndex - 1;
+    const args = readBalancedParens(stripped, argsStart);
+    if (args === null) continue;
+    sigs.push(`  method(${m[1]}, ${m[2]}) <- function(${normalizeParams(args)})`);
+  }
+
+  // ── Top-level function definitions ────────────────────────────────────────
+  //   name <- function(args), name = function(args), name <<- function(args)
+  // Skip matches whose position falls inside an R6/S7 class body — those have
+  // already been emitted as indented members.
+  const funcRe = /^(?:[ \t]*)([\w.]+)\s*(?:<<-|<-|=)\s*function\s*\(/gm;
+  while ((m = funcRe.exec(stripped)) !== null && sigs.length < 30) {
     const name = m[1];
-    if (name.startsWith('.')) continue; // private convention
-    const argsStart = funcRe.lastIndex;
-    const args = readBalancedParens(stripped, argsStart - 1);
+    if (name.startsWith('.')) continue;
+    if (inAnyRange(m.index, consumedRanges)) continue;
+    const argsStart = funcRe.lastIndex - 1;
+    const args = readBalancedParens(stripped, argsStart);
     if (args === null) continue;
-    sigs.push(`${name} <- function(${normalizeParams(args)})`);
+    sigs.push(`${name} <- function(${normalizeParams(args)})` + applyHint(docHints, name));
   }
 
-  // S4 setMethod / setGeneric:
-  //   setGeneric("name", function(args) standardGeneric("name"))
-  //   setMethod("name", "ClassName", function(args) { ... })
+  // ── S4 ────────────────────────────────────────────────────────────────────
   for (const sm of stripped.matchAll(/^[ \t]*setGeneric\s*\(\s*["']([\w.]+)["']/gm)) {
+    if (sigs.length >= 30) break;
     sigs.push(`setGeneric("${sm[1]}")`);
   }
   for (const sm of stripped.matchAll(/^[ \t]*setMethod\s*\(\s*["']([\w.]+)["']\s*,\s*["']([\w.]+)["']/gm)) {
+    if (sigs.length >= 30) break;
     sigs.push(`setMethod("${sm[1]}", "${sm[2]}")`);
   }
-
-  // S4 class definitions:
-  //   setClass("Name", representation(...), ...)
   for (const sm of stripped.matchAll(/^[ \t]*setClass\s*\(\s*["']([\w.]+)["']/gm)) {
+    if (sigs.length >= 30) break;
     sigs.push(`setClass("${sm[1]}")`);
   }
 
   return sigs.slice(0, 30);
 }
 
+/**
+ * Collect roxygen2 docstring hints from the original (uncommented) source.
+ * Returns Map<symbolName, hint> where hint is the first @title line, else
+ * @description, else the first non-tag content line. Trimmed to 60 chars,
+ * trailing punctuation removed.
+ */
+function collectRoxygenHints(src) {
+  const hints = new Map();
+  const lines = src.split('\n');
+  let block = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*#'/.test(line)) {
+      block.push(line.replace(/^\s*#'\s?/, ''));
+      continue;
+    }
+    if (block.length > 0) {
+      const m = line.match(/^[ \t]*([\w.]+)\s*(?:<<-|<-|=)\s*(?:R6::)?R6Class\b/)
+             || line.match(/^[ \t]*([\w.]+)\s*(?:<<-|<-|=)\s*(?:S7::)?new_class\b/)
+             || line.match(/^[ \t]*([\w.]+)\s*(?:<<-|<-|=)\s*function\b/);
+      if (m) {
+        const name = m[1];
+        let hint = pickRoxygenLine(block, '@title')
+                || pickRoxygenLine(block, '@description')
+                || pickRoxygenLine(block, null);
+        if (hint) {
+          hint = hint.replace(/\s+/g, ' ').trim().slice(0, 60).replace(/[.,;:!?]+$/, '').trim();
+          if (hint) hints.set(name, hint);
+        }
+      }
+      block = [];
+    }
+  }
+  return hints;
+}
+
+function pickRoxygenLine(block, tag) {
+  for (const raw of block) {
+    const b = raw.trim();
+    if (!b) continue;
+    if (tag) {
+      if (b.startsWith(tag)) {
+        const rest = b.slice(tag.length).trim();
+        if (rest) return rest;
+      }
+    } else if (!b.startsWith('@')) {
+      return b;
+    }
+  }
+  return null;
+}
+
+function applyHint(hints, name) {
+  const h = hints.get(name);
+  return h ? `  # ${h}` : '';
+}
+
+/**
+ * Extract method-like entries from the body of an R6/S7 list(...) argument.
+ * Matches `name = function(args)` at any indentation. Caps at `cap` entries.
+ */
+function extractListMethods(body, cap) {
+  const out = [];
+  const re = /(?:^|[\n,])\s*([\w.]+)\s*=\s*function\s*\(/g;
+  let m;
+  while ((m = re.exec(body)) !== null && out.length < cap) {
+    const name = m[1];
+    if (name.startsWith('.')) continue;
+    const argsStart = re.lastIndex - 1;
+    const args = readBalancedParens(body, argsStart);
+    if (args === null) continue;
+    out.push(`${name} <- function(${normalizeParams(args)})`);
+  }
+  return out;
+}
+
+function inAnyRange(pos, ranges) {
+  for (const [s, e] of ranges) {
+    if (pos >= s && pos < e) return true;
+  }
+  return false;
+}
+
+/** Extract the first quoted string from a comma-separated argument body. */
+function readFirstStringArg(body) {
+  const m = body.match(/^\s*["']([\w.]+)["']/);
+  return m ? m[1] : null;
+}
+
 /**
  * Read a parenthesis-balanced substring starting at the position of the
  * opening '(' character, returning the inner content (without the outer
  * parens). Returns null if no matching close paren is found within `cap`
  * characters, which guards against runaway scans on malformed input.
  */
-function readBalancedParens(src, openIdx, cap = 4096) {
+function readBalancedParens(src, openIdx, cap = 16384) {
   if (src[openIdx] !== '(') return null;
   let depth = 1;
   let i = openIdx + 1;
   const end = Math.min(src.length, openIdx + cap);
-  let inString = null; // null | '"' | "'"
+  let inString = null;
   while (i < end) {
     const ch = src[i];
     if (inString) {
@@ -82,36 +238,17 @@ function readBalancedParens(src, openIdx, cap = 4096) {
 
 /**
  * Compress whitespace inside a parameter list, collapse multi-line default
- * expressions onto a single line, and trim. The goal is one-line readable
- * signatures, not a faithful AST.
- *
- * String literals are protected so that commas/equals inside default values
- * like sep = "," don't get respaced.
+ * expressions onto a single line, and trim. String literals are protected so
+ * that commas/equals inside default values like `sep = ","` don't get respaced.
  */
 function normalizeParams(raw) {
-  const tokens = [];
-  let buf = '';
+  let out = '';
   let inString = null;
   for (let i = 0; i < raw.length; i++) {
     const ch = raw[i];
-    if (inString) {
-      buf += ch;
-      if (ch === '\\' && i + 1 < raw.length) { buf += raw[i + 1]; i++; continue; }
-      if (ch === inString) inString = null;
-      continue;
-    }
-    if (ch === '"' || ch === "'") { inString = ch; buf += ch; continue; }
-    buf += ch;
-  }
-  // Now buf === raw with strings preserved character-for-character.
-  // Walk again: collapse non-string runs of whitespace, normalize ', ' and ' = '.
-  let out = '';
-  inString = null;
-  for (let i = 0; i < buf.length; i++) {
-    const ch = buf[i];
     if (inString) {
       out += ch;
-      if (ch === '\\' && i + 1 < buf.length) { out += buf[i + 1]; i++; continue; }
+      if (ch === '\\' && i + 1 < raw.length) { out += raw[i + 1]; i++; continue; }
       if (ch === inString) inString = null;
       continue;
     }