@eagleoutice/flowr 2.1.9 → 2.1.11

package/documentation/print-query-wiki.js

@@ -25,6 +25,7 @@ const doc_cli_option_1 = require("./doc-util/doc-cli-option");
 const doc_issue_1 = require("./doc-util/doc-issue");
 const location_map_query_executor_1 = require("../queries/catalog/location-map-query/location-map-query-executor");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
+const config_query_executor_1 = require("../queries/catalog/config-query/config-query-executor");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -208,6 +209,18 @@ ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('config', {
+    name: 'Config Query',
+    type: 'active',
+    shortDescription: 'Returns the current configuration of flowR.',
+    functionName: config_query_executor_1.executeConfigQuery.name,
+    functionFile: '../queries/catalog/config-query/config-query-format.ts',
+    // eslint-disable-next-line @typescript-eslint/require-await -- no need for async here
+    buildExplanation: async () => {
+        return `
+This query provides access to the current configuration of the flowR instance. See the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface) wiki page for more information on what the configuration represents.`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('compound', {
     name: 'Compound Query',
     type: 'virtual',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.1.9",
+  "version": "2.1.11",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

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

@@ -0,0 +1,3 @@
+import type { ConfigQuery, ConfigQueryResult } from './config-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeConfigQuery(_: BasicQueryData, queries: readonly ConfigQuery[]): ConfigQueryResult;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeConfigQuery = executeConfigQuery;
+const log_1 = require("../../../util/log");
+const config_1 = require("../../../config");
+function executeConfigQuery(_, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Config query expects only up to one query, but got', queries.length);
+    }
+    return {
+        '.meta': {
+            /* there is no sense in measuring a get */
+            timing: 0
+        },
+        config: (0, config_1.getConfig)()
+    };
+}
+//# sourceMappingURL=config-query-executor.js.map

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

@@ -0,0 +1,16 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import { executeConfigQuery } from './config-query-executor';
+import { type OutputFormatter } from '../../../util/ansi';
+import Joi from 'joi';
+import type { FlowrConfigOptions } from '../../../config';
+export interface ConfigQuery extends BaseQueryFormat {
+    readonly type: 'config';
+}
+export interface ConfigQueryResult extends BaseQueryResult {
+    readonly config: FlowrConfigOptions;
+}
+export declare const ConfigQueryDefinition: {
+    readonly executor: typeof executeConfigQuery;
+    readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly schema: Joi.ObjectSchema<any>;
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigQueryDefinition = void 0;
+const config_query_executor_1 = require("./config-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const json_1 = require("../../../util/json");
+exports.ConfigQueryDefinition = {
+    executor: config_query_executor_1.executeConfigQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('config', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ Config:\n${JSON.stringify(out.config, json_1.jsonReplacer, 4)}`);
+        return true;
+    },
+    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.')
+};
+//# sourceMappingURL=config-query-format.js.map

package/queries/catalog/location-map-query/location-map-query-format.js

@@ -19,6 +19,6 @@ exports.LocationMapQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('location-map').required().description('The type of the query.'),
-    }).description('The id map query retrieves the location of every id in the ast.')
+    }).description('The location map query retrieves the location of every id in the ast.')
 };
 //# sourceMappingURL=location-map-query-format.js.map

package/queries/query.d.ts

@@ -14,7 +14,8 @@ import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
 import Joi from 'joi';
 import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
-export type Query = CallContextQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
+import type { ConfigQuery } from './catalog/config-query/config-query-format';
+export type Query = CallContextQuery | ConfigQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -33,6 +34,11 @@ export declare const SupportedQueries: {
         readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly config: {
+        readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
     readonly dataflow: {
         readonly executor: typeof import("./catalog/dataflow-query/dataflow-query-executor").executeDataflowQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{

package/queries/query.js

@@ -22,8 +22,10 @@ const cluster_query_format_1 = require("./catalog/cluster-query/cluster-query-fo
 const dependencies_query_format_1 = require("./catalog/dependencies-query/dependencies-query-format");
 const joi_1 = __importDefault(require("joi"));
 const location_map_query_format_1 = require("./catalog/location-map-query/location-map-query-format");
+const config_query_format_1 = require("./catalog/config-query/config-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
+    'config': config_query_format_1.ConfigQueryDefinition,
     'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
     'id-map': id_map_query_format_1.IdMapQueryDefinition,
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,

package/util/list-access.d.ts

@@ -0,0 +1,48 @@
+import type { REnvironmentInformation } from '../dataflow/environments/environment';
+import type { ContainerIndices, ContainerIndicesCollection } from '../dataflow/graph/vertex';
+import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
+ *
+ * @param accessedArg - The argument to resolve
+ * @param accessArg - The argument which is used to filter the indices
+ * @param environment - The environment in which {@link accessedArg} is resolved
+ * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
+ */
+export declare function resolveSingleIndex(accessedArg: {
+    lexeme: string;
+}, accessArg: {
+    lexeme: string;
+}, environment: REnvironmentInformation): ContainerIndicesCollection;
+/**
+ * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
+ *
+ * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @returns The filtered copy of {@link indicesCollection}
+ */
+export declare function filterIndices(indicesCollection: ContainerIndicesCollection, accessArg: {
+    lexeme: string;
+}): ContainerIndicesCollection;
+/**
+ * Constructs the definition of a nested access.
+ *
+ * Example:
+ * ```r
+ * person$credentials$username
+ * ```
+ * would result in a list with the index `credentials`, which has the subIndex `username`.
+ *
+ * @param accessedArg - The top level argument that is accessed
+ * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @returns The constructed nested access
+ */
+export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices): ContainerIndices[];
+/**
+ * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
+ *
+ * @param indicesCollection - Indices where to add the sub indices.
+ * @param leafSubIndices - Indices that are added to the leaf indices.
+ */
+export declare function addSubIndicesToLeafIndices(indicesCollection: ContainerIndices[], leafSubIndices: ContainerIndices[]): ContainerIndices[];

package/util/list-access.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSingleIndex = resolveSingleIndex;
+exports.filterIndices = filterIndices;
+exports.constructNestedAccess = constructNestedAccess;
+exports.addSubIndicesToLeafIndices = addSubIndicesToLeafIndices;
+const resolve_by_name_1 = require("../dataflow/environments/resolve-by-name");
+const vertex_1 = require("../dataflow/graph/vertex");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+/**
+ * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
+ *
+ * @param accessedArg - The argument to resolve
+ * @param accessArg - The argument which is used to filter the indices
+ * @param environment - The environment in which {@link accessedArg} is resolved
+ * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
+ */
+function resolveSingleIndex(accessedArg, accessArg, environment) {
+    const definitions = (0, resolve_by_name_1.resolveByName)(accessedArg.lexeme, environment);
+    const indicesCollection = definitions?.flatMap(def => def?.indicesCollection ?? []);
+    const accessedIndicesCollection = filterIndices(indicesCollection, accessArg);
+    return accessedIndicesCollection;
+}
+/**
+ * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
+ *
+ * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @returns The filtered copy of {@link indicesCollection}
+ */
+function filterIndices(indicesCollection, accessArg) {
+    let accessedIndicesCollection = undefined;
+    for (const indices of indicesCollection ?? []) {
+        const filteredIndices = indices.indices.filter(index => accessArg.lexeme === index.lexeme);
+        if (filteredIndices.length == 0) {
+            continue;
+        }
+        accessedIndicesCollection ??= [];
+        accessedIndicesCollection.push({
+            indices: filteredIndices,
+            isContainer: indices.isContainer
+        });
+    }
+    return accessedIndicesCollection;
+}
+/**
+ * Constructs the definition of a nested access.
+ *
+ * Example:
+ * ```r
+ * person$credentials$username
+ * ```
+ * would result in a list with the index `credentials`, which has the subIndex `username`.
+ *
+ * @param accessedArg - The top level argument that is accessed
+ * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @returns The constructed nested access
+ */
+function constructNestedAccess(accessedArg, leafIndices) {
+    const accessed = accessedArg.accessed;
+    const accesses = accessedArg.access.filter(arg => arg !== r_function_call_1.EmptyArgument).map(arg => arg);
+    const indices = [];
+    for (const access of accesses) {
+        const newIndices = {
+            indices: [
+                {
+                    lexeme: access.lexeme,
+                    nodeId: access.info.id,
+                    subIndices: [leafIndices],
+                }
+            ],
+            isContainer: false,
+        };
+        if (accessed.type === type_1.RType.Access) {
+            const nestedIndices = constructNestedAccess(accessed, newIndices);
+            indices.push(...nestedIndices);
+        }
+        else {
+            indices.push(newIndices);
+        }
+    }
+    return indices;
+}
+/**
+ * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
+ *
+ * @param indicesCollection - Indices where to add the sub indices.
+ * @param leafSubIndices - Indices that are added to the leaf indices.
+ */
+function addSubIndicesToLeafIndices(indicesCollection, leafSubIndices) {
+    const result = [];
+    for (const indices of indicesCollection) {
+        const newIndices = [];
+        for (const index of indices.indices) {
+            let newSubIndices = [];
+            if ((0, vertex_1.isParentContainerIndex)(index)) {
+                newSubIndices = addSubIndicesToLeafIndices(index.subIndices, leafSubIndices);
+            }
+            else {
+                newSubIndices = leafSubIndices;
+            }
+            newIndices.push({
+                ...index,
+                subIndices: newSubIndices,
+            });
+        }
+        result.push({
+            ...indices,
+            indices: newIndices,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=list-access.js.map

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.1.9';
+const version = '2.1.11';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }