@eagleoutice/flowr 2.4.6 → 2.4.8

package/queries/catalog/config-query/config-query-format.d.ts

@@ -3,15 +3,22 @@ import { executeConfigQuery } from './config-query-executor';
 import { type OutputFormatter } from '../../../util/text/ansi';
 import Joi from 'joi';
 import type { FlowrConfigOptions } from '../../../config';
+import type { DeepPartial } from 'ts-essentials';
 export interface ConfigQuery extends BaseQueryFormat {
     readonly type: 'config';
+    readonly update?: DeepPartial<FlowrConfigOptions>;
 }
 export interface ConfigQueryResult extends BaseQueryResult {
     readonly config: FlowrConfigOptions;
 }
+declare function configReplCompleter(partialLine: readonly string[], config: FlowrConfigOptions): string[];
+declare function configQueryLineParser(line: readonly string[], _config: FlowrConfigOptions): [ConfigQuery];
 export declare const ConfigQueryDefinition: {
     readonly executor: typeof executeConfigQuery;
     readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly completer: typeof configReplCompleter;
+    readonly fromLine: typeof configQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };
+export {};

package/queries/catalog/config-query/config-query-format.js

@@ -9,6 +9,74 @@ const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const json_1 = require("../../../util/json");
+function configReplCompleter(partialLine, config) {
+    if (partialLine.length === 0) {
+        // update specific fields
+        return ['+'];
+    }
+    else if (partialLine.length === 1 && partialLine[0].startsWith('+')) {
+        const path = partialLine[0].slice(1).split('.').filter(p => p.length > 0);
+        const fullPath = path.slice();
+        const lastPath = partialLine[0].endsWith('.') ? '' : path.pop() ?? '';
+        if (lastPath.endsWith('=')) {
+            return [];
+        }
+        const subConfig = path.reduce((obj, key) => (obj && obj[key] !== undefined && typeof obj[key] === 'object') ? obj[key] : obj, config);
+        if (subConfig && !(subConfig[lastPath] !== undefined && typeof subConfig[lastPath] !== 'object')) {
+            const have = Object.keys(subConfig)
+                .filter(k => k.startsWith(lastPath) && k !== lastPath)
+                .map(k => `${partialLine[0].slice(0, 1)}${[...path, k].join('.')}`);
+            if (have.length > 0) {
+                return have;
+            }
+            else if (lastPath.length > 0) {
+                return [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}.`];
+            }
+        }
+        return [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}=`];
+    }
+    return [];
+}
+function configQueryLineParser(line, _config) {
+    if (line.length > 0 && line[0].startsWith('+')) {
+        const [pathPart, ...valueParts] = line[0].slice(1).split('=');
+        // build the update object
+        const path = pathPart.split('.').filter(p => p.length > 0);
+        if (path.length === 0 || valueParts.length !== 1) {
+            console.error('Invalid config update syntax, must be of the form +path.to.field=value');
+        }
+        else {
+            const update = {};
+            const value = valueParts[0];
+            let current = update;
+            for (let i = 0; i < path.length; i++) {
+                const key = path[i];
+                if (i === path.length - 1) {
+                    // last part, set the value
+                    // try to parse as JSON first
+                    try {
+                        current[key] = JSON.parse(value);
+                    }
+                    catch {
+                        // fallback to string
+                        current[key] = value;
+                    }
+                }
+                else {
+                    current[key] = {};
+                    current = current[key];
+                }
+            }
+            return [{
+                    type: 'config',
+                    update
+                }];
+        }
+    }
+    return [{
+            type: 'config'
+        }];
+}
 exports.ConfigQueryDefinition = {
     executor: config_query_executor_1.executeConfigQuery,
     asciiSummarizer: (formatter, _processed, queryResults, result) => {
@@ -17,9 +85,12 @@ exports.ConfigQueryDefinition = {
         result.push(`   ╰ Config:\n${JSON.stringify(out.config, json_1.jsonReplacer, 4)}`);
         return true;
     },
+    completer: configReplCompleter,
+    fromLine: configQueryLineParser,
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('config').required().description('The type of the query.'),
-    }).description('The config query retrieves the current configuration of the flowR instance.'),
+        update: joi_1.default.object().optional().description('An optional partial configuration to update the current configuration with before returning it. Only the provided fields will be updated, all other fields will remain unchanged.')
+    }).description('The config query retrieves the current configuration of the flowR instance and optionally also updates it.'),
     flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=config-query-format.js.map

package/queries/catalog/dependencies-query/dependencies-query-executor.js

@@ -6,29 +6,11 @@ const dependencies_query_format_1 = require("./dependencies-query-format");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const log_1 = require("../../../util/log");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const objects_1 = require("../../../util/objects");
-const library_functions_1 = require("./function-info/library-functions");
-const source_functions_1 = require("./function-info/source-functions");
-const read_functions_1 = require("./function-info/read-functions");
-const write_functions_1 = require("./function-info/write-functions");
 const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
 const assert_1 = require("../../../util/assert");
-function collectNamespaceAccesses(data, libraries) {
-    /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
-    (0, visitor_1.visitAst)(data.ast.ast, n => {
-        if (n.type === type_1.RType.Symbol && n.namespace) {
-            /* we should improve the identification of ':::' */
-            libraries.push({
-                nodeId: n.info.id,
-                functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
-                libraryName: n.namespace,
-            });
-        }
-    });
-}
 function executeDependenciesQuery(data, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Dependencies query expects only up to one query, but got ', queries.length, 'only using the first query');
@@ -36,64 +18,28 @@ function executeDependenciesQuery(data, queries) {
     const now = Date.now();
     const [query] = queries;
     const ignoreDefault = query.ignoreDefaultFunctions ?? false;
-    const libraryFunctions = getFunctionsToCheck(query.libraryFunctions, ignoreDefault, library_functions_1.LibraryFunctions);
-    const sourceFunctions = getFunctionsToCheck(query.sourceFunctions, ignoreDefault, source_functions_1.SourceFunctions);
-    const readFunctions = getFunctionsToCheck(query.readFunctions, ignoreDefault, read_functions_1.ReadFunctions);
-    const writeFunctions = getFunctionsToCheck(query.writeFunctions, ignoreDefault, write_functions_1.WriteFunctions);
-    const numberOfFunctions = libraryFunctions.length + sourceFunctions.length + readFunctions.length + writeFunctions.length;
-    const results = numberOfFunctions === 0 ? { kinds: {}, '.meta': { timing: 0 } } : (0, query_1.executeQueriesOfSameType)(data, [
-        makeCallContextQuery(libraryFunctions, 'library'),
-        makeCallContextQuery(sourceFunctions, 'source'),
-        makeCallContextQuery(readFunctions, 'read'),
-        makeCallContextQuery(writeFunctions, 'write')
-    ].flat());
-    function getLexeme(argument, id) {
-        if ((argument && argument !== dependencies_query_format_1.Unknown) || !id) {
-            return undefined;
-        }
-        let get = data.ast.idMap.get(id);
-        if (get?.type === type_1.RType.Argument) {
-            get = get.value;
-        }
-        return get?.info.fullLexeme ?? get?.lexeme;
-    }
-    const libraries = getResults(data, results, 'library', libraryFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        lexemeOfArgument: getLexeme(value, argId),
-        libraryName: value ?? dependencies_query_format_1.Unknown,
-        linkedIds: linkedIds?.length ? linkedIds : undefined
+    const functions = new Map(Object.entries(dependencies_query_format_1.DefaultDependencyCategories).map(([c, v]) => {
+        return [c, getFunctionsToCheck(query[`${c}Functions`], c, query.enabledCategories, ignoreDefault, v.functions)];
     }));
-    if (!ignoreDefault) {
-        collectNamespaceAccesses(data, libraries);
+    if (query.additionalCategories !== undefined) {
+        for (const [category, value] of Object.entries(query.additionalCategories)) {
+            // custom categories only use the "functions" collection and do not allow specifying additional functions in the object itself, so we "undefined" a lot here
+            functions.set(category, getFunctionsToCheck(undefined, category, undefined, false, value.functions));
+        }
     }
-    const sourcedFiles = getResults(data, results, 'source', sourceFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        file: value ?? dependencies_query_format_1.Unknown,
-        lexemeOfArgument: getLexeme(value, argId),
-        linkedIds: linkedIds?.length ? linkedIds : undefined
-    }));
-    const readData = getResults(data, results, 'read', readFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        source: value ?? dependencies_query_format_1.Unknown,
-        lexemeOfArgument: getLexeme(value, argId),
-        linkedIds: linkedIds?.length ? linkedIds : undefined
-    }));
-    const writtenData = getResults(data, results, 'write', writeFunctions, (id, vertex, argId, value, linkedIds) => ({
-        nodeId: id,
-        functionName: vertex.name,
-        // write functions that don't have argIndex are assumed to write to stdout
-        destination: value ?? 'stdout',
-        lexemeOfArgument: getLexeme(value, argId),
-        linkedIds: linkedIds?.length ? linkedIds : undefined
+    const queryResults = functions.values().toArray().flat().length === 0 ? { kinds: {}, '.meta': { timing: 0 } } :
+        (0, query_1.executeQueriesOfSameType)(data, functions.entries().map(([c, f]) => makeCallContextQuery(f, c)).toArray().flat());
+    const results = Object.fromEntries(functions.entries().map(([c, f]) => {
+        const results = getResults(queries, data, queryResults, c, f);
+        // only default categories allow additional analyses, so we null coalese here!
+        dependencies_query_format_1.DefaultDependencyCategories[c]?.additionalAnalysis?.(data, ignoreDefault, f, queryResults, results);
+        return [c, results];
     }));
     return {
         '.meta': {
             timing: Date.now() - now
         },
-        libraries, sourcedFiles, readData, writtenData
+        ...results
     };
 }
 function makeCallContextQuery(functions, kind) {
@@ -116,19 +62,28 @@ function dropInfoOnLinkedIds(linkedIds) {
 }
 const readOnlyModes = new Set(['r', 'rt', 'rb']);
 const writeOnlyModes = new Set(['w', 'wt', 'wb', 'a', 'at', 'ab']);
-function getResults(data, results, kind, functions, makeInfo) {
+function getResults(queries, data, results, kind, functions) {
+    const defaultValue = (0, dependencies_query_format_1.getAllCategories)(queries)[kind].defaultValue;
+    const functionMap = new Map(functions.map(f => [f.name, f]));
     const kindEntries = Object.entries(results?.kinds[kind]?.subkinds ?? {});
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
         const vertex = data.dataflow.graph.getVertex(id);
-        const info = functions.find(f => f.name === name);
+        const info = functionMap.get(name);
         const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
         const linkedArgs = collectValuesFromLinks(args, data, linkedIds);
+        const linked = dropInfoOnLinkedIds(linkedIds);
         const foundValues = linkedArgs ?? args;
         if (!foundValues) {
             if (info.ignoreIf === 'arg-missing') {
                 return [];
             }
-            const record = (0, objects_1.compactRecord)(makeInfo(id, vertex, undefined, undefined, dropInfoOnLinkedIds(linkedIds)));
+            const record = (0, objects_1.compactRecord)({
+                nodeId: id,
+                functionName: vertex.name,
+                lexemeOfArgument: undefined,
+                linkedIds: linked?.length ? linked : undefined,
+                value: defaultValue
+            });
             return record ? [record] : [];
         }
         else if (info.ignoreIf === 'mode-only-read' || info.ignoreIf === 'mode-only-write') {
@@ -136,7 +91,7 @@ function getResults(data, results, kind, functions, makeInfo) {
             const margs = info.additionalArgs?.mode;
             (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
             const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue);
-            const modeValues = [...modeArgs?.values() ?? []].flatMap(v => [...v]) ?? [];
+            const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
             if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
                 // all modes are read-only, so we can ignore this
                 return [];
@@ -149,7 +104,13 @@ function getResults(data, results, kind, functions, makeInfo) {
         const results = [];
         for (const [arg, values] of foundValues.entries()) {
             for (const value of values) {
-                const result = (0, objects_1.compactRecord)(makeInfo(id, vertex, arg, value, dropInfoOnLinkedIds(linkedIds)));
+                const result = (0, objects_1.compactRecord)({
+                    nodeId: id,
+                    functionName: vertex.name,
+                    lexemeOfArgument: getLexeme(value, arg),
+                    linkedIds: linked?.length ? linked : undefined,
+                    value: value ?? defaultValue
+                });
                 if (result) {
                     results.push(result);
                 }
@@ -157,6 +118,16 @@ function getResults(data, results, kind, functions, makeInfo) {
         }
         return results;
     })) ?? [];
+    function getLexeme(argument, id) {
+        if ((argument && argument !== dependencies_query_format_1.Unknown) || !id) {
+            return undefined;
+        }
+        let get = data.ast.idMap.get(id);
+        if (get?.type === type_1.RType.Argument) {
+            get = get.value;
+        }
+        return get?.info.fullLexeme ?? get?.lexeme;
+    }
 }
 function collectValuesFromLinks(args, data, linkedIds) {
     if (!linkedIds || linkedIds.length === 0) {
@@ -192,7 +163,11 @@ function collectValuesFromLinks(args, data, linkedIds) {
     }
     return map.size ? map : undefined;
 }
-function getFunctionsToCheck(customFunctions, ignoreDefaultFunctions, defaultFunctions) {
+function getFunctionsToCheck(customFunctions, functionFlag, enabled, ignoreDefaultFunctions, defaultFunctions) {
+    // "If unset or empty, all function types are searched for."
+    if (enabled?.length && enabled.indexOf(functionFlag) < 0) {
+        return [];
+    }
     let functions = ignoreDefaultFunctions ? [] : [...defaultFunctions];
     if (customFunctions) {
         functions = functions.concat(customFunctions);

package/queries/catalog/dependencies-query/dependencies-query-format.d.ts

@@ -1,42 +1,66 @@
-import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { BaseQueryFormat, BaseQueryResult, BasicQueryData } from '../../base-query-format';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import Joi from 'joi';
 import { executeDependenciesQuery } from './dependencies-query-executor';
 import type { FunctionInfo } from './function-info/function-info';
+import type { CallContextQueryResult } from '../call-context-query/call-context-query-format';
 export declare const Unknown = "unknown";
-export interface DependenciesQuery extends BaseQueryFormat {
+export interface DependencyCategorySettings {
+    queryDisplayName?: string;
+    functions: FunctionInfo[];
+    defaultValue?: string;
+    additionalAnalysis?: (data: BasicQueryData, ignoreDefault: boolean, functions: FunctionInfo[], queryResults: CallContextQueryResult, result: DependencyInfo[]) => void;
+}
+export declare const DefaultDependencyCategories: {
+    readonly library: {
+        readonly queryDisplayName: "Libraries";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "unknown";
+        readonly additionalAnalysis: (data: BasicQueryData, ignoreDefault: boolean, _functions: FunctionInfo[], _queryResults: CallContextQueryResult, result: DependencyInfo[]) => void;
+    };
+    readonly source: {
+        readonly queryDisplayName: "Sourced Files";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "unknown";
+    };
+    readonly read: {
+        readonly queryDisplayName: "Read Data";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "unknown";
+    };
+    readonly write: {
+        readonly queryDisplayName: "Written Data";
+        readonly functions: FunctionInfo[];
+        readonly defaultValue: "stdout";
+    };
+    readonly visualize: {
+        readonly queryDisplayName: "Visualizations";
+        readonly functions: FunctionInfo[];
+    };
+};
+export type DefaultDependencyCategoryName = keyof typeof DefaultDependencyCategories;
+export type DependencyCategoryName = DefaultDependencyCategoryName | string;
+export interface DependenciesQuery extends BaseQueryFormat, Partial<Record<`${DefaultDependencyCategoryName}Functions`, FunctionInfo[]>> {
     readonly type: 'dependencies';
+    readonly enabledCategories?: DependencyCategoryName[];
     readonly ignoreDefaultFunctions?: boolean;
-    readonly libraryFunctions?: FunctionInfo[];
-    readonly sourceFunctions?: FunctionInfo[];
-    readonly readFunctions?: FunctionInfo[];
-    readonly writeFunctions?: FunctionInfo[];
-}
-export interface DependenciesQueryResult extends BaseQueryResult {
-    libraries: LibraryInfo[];
-    sourcedFiles: SourceInfo[];
-    readData: ReadInfo[];
-    writtenData: WriteInfo[];
+    readonly additionalCategories?: Record<string, Omit<DependencyCategorySettings, 'additionalAnalysis'>>;
 }
+export type DependenciesQueryResult = BaseQueryResult & {
+    [C in DefaultDependencyCategoryName]: DependencyInfo[];
+} & {
+    [S in string]?: DependencyInfo[];
+};
 export interface DependencyInfo extends Record<string, unknown> {
     nodeId: NodeId;
     functionName: string;
     linkedIds?: readonly NodeId[];
     /** the lexeme is presented whenever the specific info is of {@link Unknown} */
     lexemeOfArgument?: string;
+    /** The library name, file, source, destination etc. being sourced, read from, or written to. */
+    value?: string;
 }
-export type LibraryInfo = (DependencyInfo & {
-    libraryName: 'unknown' | string;
-});
-export type SourceInfo = (DependencyInfo & {
-    file: string;
-});
-export type ReadInfo = (DependencyInfo & {
-    source: string;
-});
-export type WriteInfo = (DependencyInfo & {
-    destination: 'stdout' | string;
-});
+export declare function getAllCategories(queries: readonly DependenciesQuery[]): Record<DependencyCategoryName, DependencyCategorySettings>;
 export declare const DependenciesQueryDefinition: {
     readonly executor: typeof executeDependenciesQuery;
     readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
@@ -92,7 +116,7 @@ export declare const DependenciesQueryDefinition: {
             readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
         };
         readonly dependencies: readonly ["normalize"];
-    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    }>>, queryResults: BaseQueryResult, result: string[], queries: readonly import("../../query").Query[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
-    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly import("../../query").Query[]) => NodeId[];
 };

package/queries/catalog/dependencies-query/dependencies-query-format.js

@@ -3,13 +3,62 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DependenciesQueryDefinition = exports.Unknown = void 0;
+exports.DependenciesQueryDefinition = exports.DefaultDependencyCategories = exports.Unknown = void 0;
+exports.getAllCategories = getAllCategories;
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const dependencies_query_executor_1 = require("./dependencies-query-executor");
+const library_functions_1 = require("./function-info/library-functions");
+const source_functions_1 = require("./function-info/source-functions");
+const read_functions_1 = require("./function-info/read-functions");
+const write_functions_1 = require("./function-info/write-functions");
+const visualize_functions_1 = require("./function-info/visualize-functions");
+const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 exports.Unknown = 'unknown';
-function printResultSection(title, infos, result, sectionSpecifics) {
+exports.DefaultDependencyCategories = {
+    'library': {
+        queryDisplayName: 'Libraries',
+        functions: library_functions_1.LibraryFunctions,
+        defaultValue: exports.Unknown,
+        /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
+        additionalAnalysis: (data, ignoreDefault, _functions, _queryResults, result) => {
+            if (!ignoreDefault) {
+                (0, visitor_1.visitAst)(data.ast.ast, n => {
+                    if (n.type === type_1.RType.Symbol && n.namespace) {
+                        /* we should improve the identification of ':::' */
+                        result.push({
+                            nodeId: n.info.id,
+                            functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
+                            value: n.namespace,
+                        });
+                    }
+                });
+            }
+        }
+    },
+    'source': {
+        queryDisplayName: 'Sourced Files',
+        functions: source_functions_1.SourceFunctions,
+        defaultValue: exports.Unknown
+    },
+    'read': {
+        queryDisplayName: 'Read Data',
+        functions: read_functions_1.ReadFunctions,
+        defaultValue: exports.Unknown
+    },
+    'write': {
+        queryDisplayName: 'Written Data',
+        functions: write_functions_1.WriteFunctions,
+        defaultValue: 'stdout'
+    },
+    'visualize': {
+        queryDisplayName: 'Visualizations',
+        functions: visualize_functions_1.VisualizeFunctions
+    }
+};
+function printResultSection(title, infos, result) {
     if (infos.length <= 0) {
         return;
     }
@@ -26,9 +75,18 @@ function printResultSection(title, infos, result, sectionSpecifics) {
     }, new Map());
     for (const [functionName, infos] of grouped) {
         result.push(`       ╰ \`${functionName}\``);
-        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}, ${sectionSpecifics(i)}`).join('\n'));
+        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}${i.value !== undefined ? `, \`${i.value}\`` : ''}`).join('\n'));
     }
 }
+function getAllCategories(queries) {
+    let categories = exports.DefaultDependencyCategories;
+    for (const query of queries) {
+        if (query.additionalCategories) {
+            categories = { ...categories, ...query.additionalCategories };
+        }
+    }
+    return categories;
+}
 const functionInfoSchema = joi_1.default.array().items(joi_1.default.object({
     name: joi_1.default.string().required().description('The name of the library function.'),
     package: joi_1.default.string().optional().description('The package name of the library function'),
@@ -37,31 +95,28 @@ const functionInfoSchema = joi_1.default.array().items(joi_1.default.object({
 })).optional();
 exports.DependenciesQueryDefinition = {
     executor: dependencies_query_executor_1.executeDependenciesQuery,
-    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+    asciiSummarizer: (formatter, _processed, queryResults, result, queries) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('dependencies', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        printResultSection('Libraries', out.libraries, result, l => `\`${l.libraryName}\``);
-        printResultSection('Sourced Files', out.sourcedFiles, result, s => `\`${s.file}\``);
-        printResultSection('Read Data', out.readData, result, r => `\`${r.source}\``);
-        printResultSection('Written Data', out.writtenData, result, w => `\`${w.destination}\``);
+        for (const [category, value] of Object.entries(getAllCategories(queries))) {
+            printResultSection(value.queryDisplayName ?? category, out[category] ?? [], result);
+        }
         return true;
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('dependencies').required().description('The type of the query.'),
-        ignoreDefaultFunctions: joi_1.default.boolean().optional().description('Should the set of functions that are detected by default be ignored/skipped?'),
-        libraryFunctions: functionInfoSchema.description('The set of library functions to search for.'),
-        sourceFunctions: functionInfoSchema.description('The set of source functions to search for.'),
-        readFunctions: functionInfoSchema.description('The set of data reading functions to search for.'),
-        writeFunctions: functionInfoSchema.description('The set of data writing functions to search for.'),
+        ignoreDefaultFunctions: joi_1.default.boolean().optional().description('Should the set of functions that are detected by default be ignored/skipped? Defaults to false.'),
+        ...Object.fromEntries(Object.keys(exports.DefaultDependencyCategories).map(c => [`${c}Functions`, functionInfoSchema.description(`The set of ${c} functions to search for.`)])),
+        enabledCategories: joi_1.default.array().optional().items(joi_1.default.string().valid(...Object.keys(exports.DefaultDependencyCategories))).description('A set of flags that determines what types of dependencies are searched for. If unset or empty, all dependency types are searched for.'),
+        additionalCategories: joi_1.default.object().allow(joi_1.default.object({
+            queryDisplayName: joi_1.default.string().description('The display name in the query result.'),
+            functions: functionInfoSchema.description('The functions that this additional category should search for.'),
+            defaultValue: joi_1.default.string().description('The default value to return when there is no value to gather from the function information.').optional()
+        })).description('A set of additional, user-supplied dependency categories, whose results will be included in the query return value.').optional()
     }).description('The dependencies query retrieves and returns the set of all dependencies in the dataflow graph, which includes libraries, sourced files, read data, and written data.'),
-    flattenInvolvedNodes: (queryResults) => {
+    flattenInvolvedNodes: (queryResults, query) => {
         const out = queryResults;
-        return [
-            ...out.libraries.map(library => library.nodeId),
-            ...out.sourcedFiles.map(sourced => sourced.nodeId),
-            ...out.readData.map(read => read.nodeId),
-            ...out.writtenData.map(write => write.nodeId)
-        ];
+        return Object.keys(getAllCategories(query)).flatMap(c => out[c] ?? []).map(o => o.nodeId);
     }
 };
 //# sourceMappingURL=dependencies-query-format.js.map

package/queries/catalog/dependencies-query/function-info/function-info.d.ts

@@ -1,4 +1,4 @@
-import type { LinkTo } from '../../call-context-query/call-context-query-format';
+import type { CallNameTypes, LinkTo } from '../../call-context-query/call-context-query-format';
 /** when to read the argument value from a linked function */
 export declare enum DependencyInfoLinkConstraint {
     Always = "always",
@@ -8,7 +8,7 @@ export declare enum DependencyInfoLinkConstraint {
  * A dependency link may have attached information. If you pass it, we try to resolve the argument value from the linked function
  * if the `when` constraint is met.
  */
-export type DependencyInfoLink = LinkTo<RegExp | string, Omit<FunctionInfo, 'name' | 'linkTo' | 'package'> & {
+export type DependencyInfoLink = LinkTo<CallNameTypes, Omit<FunctionInfo, 'name' | 'linkTo' | 'package'> & {
     when: DependencyInfoLinkConstraint;
 } | undefined>;
 export type DependencyInfoLinkAttachedInfo = DependencyInfoLink['attachLinkInfo'];

package/queries/catalog/dependencies-query/function-info/visualize-functions.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionInfo } from './function-info';
+export declare const VisualizeFunctions: FunctionInfo[];

package/queries/catalog/dependencies-query/function-info/visualize-functions.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualizeFunctions = void 0;
+const default_builtin_config_1 = require("../../../../dataflow/environments/default-builtin-config");
+const LinkToPlotCreation = [
+    { type: 'link-to-last-call', callName: default_builtin_config_1.PlotCreate }
+];
+exports.VisualizeFunctions = 
+// plot creation
+default_builtin_config_1.GgPlotCreate.map(f => ({ package: 'ggplot2', name: f })).concat(default_builtin_config_1.TinyPlotCrate.map(f => ({ package: 'tinyplot', name: f })), default_builtin_config_1.GraphicsPlotCreate.map(f => ({ name: f })), 
+// plot modification
+default_builtin_config_1.GgPlotImplicitAddons.concat(default_builtin_config_1.GgPlotAddons).map(f => ({ package: 'ggplot2', name: f, linkTo: LinkToPlotCreation })), default_builtin_config_1.TinyPlotAddons.map(f => ({ package: 'tinyplot', name: f, linkTo: LinkToPlotCreation })), default_builtin_config_1.GraphicsPlotAddons.map(f => ({ name: f, linkTo: LinkToPlotCreation })));
+//# sourceMappingURL=visualize-functions.js.map

package/queries/catalog/happens-before-query/happens-before-query-executor.js

@@ -9,7 +9,7 @@ const parse_1 = require("../../../slicing/criterion/parse");
 function executeHappensBefore({ ast }, queries) {
     const start = Date.now();
     const results = {};
-    const cfg = (0, extract_cfg_1.extractSimpleCfg)(ast);
+    const cfg = (0, extract_cfg_1.extractCfgQuick)(ast);
     for (const query of queries) {
         const { a, b } = query;
         const fingerprint = `${a}<${b}`;

package/queries/catalog/linter-query/linter-query-format.js

@@ -33,6 +33,10 @@ exports.LinterQueryDefinition = {
 function addLintingRuleResult(ruleName, results, result) {
     const rule = linter_rules_1.LintingRules[ruleName];
     result.push(`   ╰ **${rule.info.name}** (${ruleName}):`);
+    if ((0, linter_format_1.isLintingResultsError)(results)) {
+        result.push(`       ╰ Error during execution of Rule: ${results.error}`);
+        return;
+    }
     for (const certainty of [linter_format_1.LintingResultCertainty.Certain, linter_format_1.LintingResultCertainty.Uncertain]) {
         const certaintyResults = results.results.filter(r => r.certainty === certainty);
         if (certaintyResults.length) {

package/queries/query-print.d.ts

@@ -1,8 +1,8 @@
 import type { OutputFormatter } from '../util/text/ansi';
-import type { QueryResults, SupportedQueryTypes } from './query';
+import type { Queries, QueryResults, SupportedQueryTypes } from './query';
 import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 export declare function asciiCallContext(formatter: OutputFormatter, results: QueryResults<'call-context'>['call-context'], processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string;
 export declare function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly NodeId[]): string;
-export declare function asciiSummaryOfQueryResult<S extends SupportedQueryTypes>(formatter: OutputFormatter, totalInMs: number, results: Awaited<QueryResults<S>>, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string;
+export declare function asciiSummaryOfQueryResult<S extends SupportedQueryTypes>(formatter: OutputFormatter, totalInMs: number, results: Awaited<QueryResults<S>>, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queries: Queries<S>): string;

package/queries/query-print.js

@@ -69,14 +69,15 @@ function summarizeIdsIfTooLong(formatter, ids) {
     }
     return formatter === ansi_1.markdownFormatter ? (0, html_hover_over_1.textWithTooltip)(acc, JSON.stringify(ids)) : acc;
 }
-function asciiSummaryOfQueryResult(formatter, totalInMs, results, processed) {
+function asciiSummaryOfQueryResult(formatter, totalInMs, results, processed, queries) {
     const result = [];
     for (const [query, queryResults] of Object.entries(results)) {
         if (query === '.meta') {
             continue;
         }
         const queryType = query_1.SupportedQueries[query];
-        if (queryType.asciiSummarizer(formatter, processed, queryResults, result)) {
+        const relevantQueries = queries.filter(q => q.type === query);
+        if (queryType.asciiSummarizer(formatter, processed, queryResults, result, relevantQueries)) {
             continue;
         }
         result.push(`Query: ${(0, ansi_1.bold)(query, formatter)}`);