@eagleoutice/flowr 2.5.0 → 2.6.1

package/project/flowr-analyzer.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzer = void 0;
+const query_1 = require("../queries/query");
+const flowr_search_executor_1 = require("../search/flowr-search-executor");
+const cfg_kind_1 = require("./cfg-kind");
+const shell_1 = require("../r-bridge/shell");
+const assert_1 = require("../util/assert");
+/**
+ * Central class for conducting analyses with FlowR.
+ * Use the {@link FlowrAnalyzerBuilder} to create a new instance.
+ *
+ * If you want the original pattern of creating a pipeline and running all steps, you can still do this with {@link FlowrAnalyzer#runFull}.
+ *
+ * To inspect the context of the analyzer, use {@link FlowrAnalyzer#inspectContext} (if you are a plugin and need to modify it, use {@link FlowrAnalyzer#context} instead).
+ */
+class FlowrAnalyzer {
+    flowrConfig;
+    /** The parser and engine backend */
+    parser;
+    /** The cache used for storing analysis results */
+    cache;
+    ctx;
+    /**
+     * Create a new analyzer instance.
+     * **Prefer the use of the {@link FlowrAnalyzerBuilder} instead of calling this constructor directly.**
+     *
+     * @param config - The FlowR config to use for the analyses
+     * @param parser - The parser to use for parsing the given request.
+     * @param ctx    - The context to use for the analyses.
+     * @param cache  - The caching layer to use for storing analysis results.
+     */
+    constructor(config, parser, ctx, cache) {
+        this.flowrConfig = config;
+        this.parser = parser;
+        this.ctx = ctx;
+        this.cache = cache;
+    }
+    context() {
+        return this.ctx;
+    }
+    async parserInformation() {
+        return this.parser.name === 'r-shell' ?
+            { name: 'r-shell', rVersion: await this.parser.rVersion() }
+            : { name: 'tree-sitter' };
+    }
+    async sendCommandWithOutput(command, addonConfig) {
+        (0, assert_1.guard)(this.parser instanceof shell_1.RShell, 'sendCommandWithOutput can only be used with RShell parsers!');
+        return this.parser.sendCommandWithOutput(command, addonConfig);
+    }
+    inspectContext() {
+        return this.ctx.inspect();
+    }
+    reset() {
+        this.ctx.reset();
+        this.cache.reset();
+    }
+    async parse(force) {
+        return this.cache.parse(force);
+    }
+    async normalize(force) {
+        return this.cache.normalize(force);
+    }
+    async dataflow(force) {
+        return this.cache.dataflow(force);
+    }
+    async runFull(force) {
+        await this.dataflow(force);
+        return;
+    }
+    async controlflow(simplifications, kind, force) {
+        return this.cache.controlflow(force, kind ?? cfg_kind_1.CfgKind.NoDataflow, simplifications);
+    }
+    async query(query) {
+        return (0, query_1.executeQueries)({ analyzer: this }, query);
+    }
+    async runSearch(search) {
+        return (0, flowr_search_executor_1.runSearch)(search, this);
+    }
+    /**
+     * Close the parser if it was created by this builder. This is only required if you rely on an RShell/remote engine.
+     */
+    close() {
+        return this.parser?.close();
+    }
+}
+exports.FlowrAnalyzer = FlowrAnalyzer;
+//# sourceMappingURL=flowr-analyzer.js.map

package/project/plugins/file-plugins/flowr-analyzer-description-file-plugin.d.ts

@@ -0,0 +1,17 @@
+import { FlowrAnalyzerFilePlugin } from './flowr-analyzer-file-plugin';
+import { SemVer } from 'semver';
+import type { PathLike } from 'fs';
+import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
+import { FlowrDescriptionFile } from './flowr-description-file';
+import type { FlowrFileProvider } from '../../context/flowr-file';
+export declare const descriptionFileLog: import("tslog").Logger<import("tslog").ILogObj>;
+/**
+ * This plugin provides support for R `DESCRIPTION` files.
+ */
+export declare class FlowrAnalyzerDescriptionFilePlugin extends FlowrAnalyzerFilePlugin {
+    readonly name = "flowr-analyzer-description-file-plugin";
+    readonly description = "This plugin provides support for DESCRIPTION files and extracts their content into key-value(s) pairs.";
+    readonly version: SemVer;
+    applies(file: PathLike): boolean;
+    process(_ctx: FlowrAnalyzerContext, file: FlowrFileProvider<string>): FlowrDescriptionFile;
+}

package/project/plugins/file-plugins/flowr-analyzer-description-file-plugin.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerDescriptionFilePlugin = exports.descriptionFileLog = void 0;
+const flowr_analyzer_file_plugin_1 = require("./flowr-analyzer-file-plugin");
+const semver_1 = require("semver");
+const log_1 = require("../../../util/log");
+const flowr_description_file_1 = require("./flowr-description-file");
+const flowr_file_1 = require("../../context/flowr-file");
+exports.descriptionFileLog = log_1.log.getSubLogger({ name: 'flowr-analyzer-loading-order-description-file-plugin' });
+/**
+ * This plugin provides support for R `DESCRIPTION` files.
+ */
+class FlowrAnalyzerDescriptionFilePlugin extends flowr_analyzer_file_plugin_1.FlowrAnalyzerFilePlugin {
+    name = 'flowr-analyzer-description-file-plugin';
+    description = 'This plugin provides support for DESCRIPTION files and extracts their content into key-value(s) pairs.';
+    version = new semver_1.SemVer('0.1.0');
+    applies(file) {
+        return /^(DESCRIPTION|DESCRIPTION\.txt)$/i.test(file.toString().split(/[/\\]/).pop() ?? '');
+    }
+    process(_ctx, file) {
+        const f = flowr_description_file_1.FlowrDescriptionFile.from(file, flowr_file_1.SpecialFileRole.Description);
+        // already load it here
+        f.content();
+        return f;
+    }
+}
+exports.FlowrAnalyzerDescriptionFilePlugin = FlowrAnalyzerDescriptionFilePlugin;
+//# sourceMappingURL=flowr-analyzer-description-file-plugin.js.map

package/project/plugins/file-plugins/flowr-analyzer-file-plugin.d.ts

@@ -0,0 +1,21 @@
+import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
+import type { PathLike } from 'fs';
+import type { FlowrFileProvider } from '../../context/flowr-file';
+/**
+ * This is the base class for all plugins that load and possibly transform files when they are loaded.
+ * Different from other plugins, these plugins trigger for each file that is loaded (if they {@link applies} to the file).
+ * See the {@link FlowrAnalyzerFilesContext.addFile} for more information on how files are loaded and managed.
+ *
+ * It is upt to the construction to ensure that no two file plugins {@link applies} to the same file, otherwise, the loading order
+ * of these plugins will determine which plugin gets to process the file.
+ *
+ * See {@link DefaultFlowrAnalyzerFilePlugin} for the no-op default implementation.
+ */
+export declare abstract class FlowrAnalyzerFilePlugin extends FlowrAnalyzerPlugin<FlowrFileProvider<string>, FlowrFileProvider> {
+    readonly type = PluginType.FileLoad;
+    /**
+     * Determine whether this plugin applies to the given file.
+     */
+    abstract applies(file: PathLike): boolean;
+    static defaultPlugin(): FlowrAnalyzerFilePlugin;
+}

package/project/plugins/file-plugins/flowr-analyzer-file-plugin.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerFilePlugin = void 0;
+const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const semver_1 = require("semver");
+/**
+ * This is the base class for all plugins that load and possibly transform files when they are loaded.
+ * Different from other plugins, these plugins trigger for each file that is loaded (if they {@link applies} to the file).
+ * See the {@link FlowrAnalyzerFilesContext.addFile} for more information on how files are loaded and managed.
+ *
+ * It is upt to the construction to ensure that no two file plugins {@link applies} to the same file, otherwise, the loading order
+ * of these plugins will determine which plugin gets to process the file.
+ *
+ * See {@link DefaultFlowrAnalyzerFilePlugin} for the no-op default implementation.
+ */
+class FlowrAnalyzerFilePlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugin {
+    type = flowr_analyzer_plugin_1.PluginType.FileLoad;
+    static defaultPlugin() {
+        return new DefaultFlowrAnalyzerFilePlugin();
+    }
+}
+exports.FlowrAnalyzerFilePlugin = FlowrAnalyzerFilePlugin;
+class DefaultFlowrAnalyzerFilePlugin extends FlowrAnalyzerFilePlugin {
+    name = 'default-file-plugin';
+    description = 'This is the default file plugin that does nothing.';
+    version = new semver_1.SemVer('0.0.0');
+    applies() {
+        return true;
+    }
+    process(_context, args) {
+        return args;
+    }
+}
+//# sourceMappingURL=flowr-analyzer-file-plugin.js.map

package/project/plugins/file-plugins/flowr-description-file.d.ts

@@ -0,0 +1,24 @@
+import type { FlowrFileProvider, SpecialFileRole } from '../../context/flowr-file';
+import { FlowrFile } from '../../context/flowr-file';
+export type DCF = Map<string, string[]>;
+/**
+ * This decorates a text file and provides access to its content as a DCF (Debian Control File)-like structure.
+ */
+export declare class FlowrDescriptionFile extends FlowrFile<DCF> {
+    private readonly wrapped;
+    /**
+     * Prefer the static {@link FlowrDescriptionFile.from} method to create instances of this class as it will not re-create if already a description file
+     * and handle role assignments.
+     */
+    constructor(file: FlowrFileProvider<string>);
+    /**
+     * Loads and parses the content of the wrapped file as a DCF structure.
+     *
+     * @see {@link parseDCF} for details on the parsing logic.
+     */
+    protected loadContent(): DCF;
+    /**
+     * Description file lifter, this does not re-create if already a description file
+     */
+    static from(file: FlowrFileProvider<string> | FlowrDescriptionFile, role?: SpecialFileRole): FlowrDescriptionFile;
+}

package/project/plugins/file-plugins/flowr-description-file.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrDescriptionFile = void 0;
+const flowr_file_1 = require("../../context/flowr-file");
+const files_1 = require("../../../util/files");
+/**
+ * This decorates a text file and provides access to its content as a DCF (Debian Control File)-like structure.
+ */
+class FlowrDescriptionFile extends flowr_file_1.FlowrFile {
+    wrapped;
+    /**
+     * Prefer the static {@link FlowrDescriptionFile.from} method to create instances of this class as it will not re-create if already a description file
+     * and handle role assignments.
+     */
+    constructor(file) {
+        super(file.path(), file.role);
+        this.wrapped = file;
+    }
+    /**
+     * Loads and parses the content of the wrapped file as a DCF structure.
+     *
+     * @see {@link parseDCF} for details on the parsing logic.
+     */
+    loadContent() {
+        return (0, files_1.parseDCF)(this.wrapped);
+    }
+    /**
+     * Description file lifter, this does not re-create if already a description file
+     */
+    static from(file, role) {
+        if (role) {
+            file.assignRole(role);
+        }
+        return file instanceof FlowrDescriptionFile ? file : new FlowrDescriptionFile(file);
+    }
+}
+exports.FlowrDescriptionFile = FlowrDescriptionFile;
+//# sourceMappingURL=flowr-description-file.js.map

package/project/plugins/flowr-analyzer-plugin.d.ts

@@ -0,0 +1,90 @@
+import type { SemVer } from 'semver';
+import type { AsyncOrSync } from 'ts-essentials';
+import type { FlowrAnalyzerContext } from '../context/flowr-analyzer-context';
+/**
+ * Based on *when* and *what-for* the plugin is applied during the analysis,
+ * plugins are categorized into different types.
+ *
+ * Consult this diagram for an overview of orders and (implicit or explicit) dependencies:
+ *
+ * ```text
+ * ┌───────────┐   ┌───────────────────┐   ┌─────────────┐   ┌───────────────┐   ┌───────┐
+ * │           │   │                   │   │             │   │               │   │       │
+ * │ *Builder* ├──▶│ Project Discovery ├──▶│ File Loader ├──▶│ Dependencies  ├──▶│ *DFA* │
+ * │           │   │  (if necessary)   │   │             │   │   (static)    │   │       │
+ * └───────────┘   └───────────────────┘   └──────┬──────┘   └───────────────┘   └───────┘
+ *                                                │                                  ▲
+ *                                                │          ┌───────────────┐       │
+ *                                                │          │               │       │
+ *                                                └─────────▶│ Loading Order ├───────┘
+ *                                                           │               │
+ *                                                           └───────────────┘
+ *```
+ *
+ */
+export declare enum PluginType {
+    /**
+     * Plugins that are applied right after the builder has been created and before any analysis is done.
+     * @see {@link FlowrAnalyzerPackageVersionsPlugin} - for the base class to implement such a plugin.
+     */
+    DependencyIdentification = "package-versions",
+    /**
+     * Plugins that are used to determine the order in which files are loaded and analyzed.
+     * @see {@link FlowrAnalyzerLoadingOrderPlugin} - for the base class to implement such a plugin.
+     */
+    LoadingOrder = "loading-order",
+    /**
+     * Plugins that are applied to discover the project structure, files, and folders to analyze.
+     * @see {@link FlowrAnalyzerProjectDiscoveryPlugin} - for the base class to implement such a plugin.
+     */
+    ProjectDiscovery = "project-discovery",
+    /**
+     * Plugins that are applied to load and parse files.
+     * @see {@link FlowrAnalyzerFilePlugin} - for the base class to implement such a plugin.
+     */
+    FileLoad = "file-load"
+}
+/**
+ * This is the main interface that every plugin to be used with the {@link FlowrAnalyzer} must comply with.
+ *
+ * One of the most important decisions for the generics is also the {@link PluginType}, as this determines
+ * at which stage of the analysis the plugin is applied and what it is expected to do.
+ * Do yourself a favor and do not implement a corresponding class yourself but use the classes referenced alongside
+ * the {@link PluginType} values, as these already provide the correct generic restrictions, additional capabilities, and the `type` property.
+ */
+export interface FlowrAnalyzerPluginInterface<In = unknown, Out = In> {
+    /** A unique, human-readable name of the plugin. */
+    readonly name: string;
+    /** A short description of what the plugin does. */
+    readonly description: string;
+    /** The version of the plugin, ideally following [semver](https://semver.org/). */
+    readonly version: SemVer;
+    /** The type of the plugin, determining when and for what purpose it is applied during the analysis. */
+    readonly type: PluginType;
+    /**
+     * The main implementation of the plugin, receiving the current analysis context and the input arguments,
+     * The plugin is (based on the restrictions of its {@link PluginType}) allowed to modify the context.
+     */
+    processor(analyzer: FlowrAnalyzerContext, args: In): Out;
+}
+/**
+ * The base class every plugin to be used with the {@link FlowrAnalyzer} must extend.
+ * **Please do not create plugins directly based on this class, but use the classes referenced alongside the {@link PluginType} values!**
+ * For example, if you want to create a plugin that determines the loading order of files, extend {@link FlowrAnalyzerLoadingOrderPlugin} instead.
+ * These classes also provide sensible overrides of {@link FlowrAnalyzerPlugin.defaultPlugin} to be used when no plugin of this type is registered or triggered.
+ */
+export declare abstract class FlowrAnalyzerPlugin<In = unknown, Out extends AsyncOrSync<unknown> = In> implements FlowrAnalyzerPluginInterface<In, Out> {
+    abstract readonly name: string;
+    abstract readonly description: string;
+    abstract readonly version: SemVer;
+    abstract readonly type: PluginType;
+    /**
+     * Returns a default/dummy implementation to be used when no plugin of this type is registered or triggered.
+     */
+    static defaultPlugin(): FlowrAnalyzerPlugin<unknown, unknown>;
+    /**
+     * Run the plugin with the given context and arguments.
+     */
+    processor(context: FlowrAnalyzerContext, args: In): Out;
+    protected abstract process(analyzer: FlowrAnalyzerContext, args: In): Out;
+}

package/project/plugins/flowr-analyzer-plugin.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPlugin = exports.PluginType = void 0;
+const log_1 = require("../../util/log");
+/**
+ * Based on *when* and *what-for* the plugin is applied during the analysis,
+ * plugins are categorized into different types.
+ *
+ * Consult this diagram for an overview of orders and (implicit or explicit) dependencies:
+ *
+ * ```text
+ * ┌───────────┐   ┌───────────────────┐   ┌─────────────┐   ┌───────────────┐   ┌───────┐
+ * │           │   │                   │   │             │   │               │   │       │
+ * │ *Builder* ├──▶│ Project Discovery ├──▶│ File Loader ├──▶│ Dependencies  ├──▶│ *DFA* │
+ * │           │   │  (if necessary)   │   │             │   │   (static)    │   │       │
+ * └───────────┘   └───────────────────┘   └──────┬──────┘   └───────────────┘   └───────┘
+ *                                                │                                  ▲
+ *                                                │          ┌───────────────┐       │
+ *                                                │          │               │       │
+ *                                                └─────────▶│ Loading Order ├───────┘
+ *                                                           │               │
+ *                                                           └───────────────┘
+ *```
+ *
+ */
+var PluginType;
+(function (PluginType) {
+    /**
+     * Plugins that are applied right after the builder has been created and before any analysis is done.
+     * @see {@link FlowrAnalyzerPackageVersionsPlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["DependencyIdentification"] = "package-versions";
+    /**
+     * Plugins that are used to determine the order in which files are loaded and analyzed.
+     * @see {@link FlowrAnalyzerLoadingOrderPlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["LoadingOrder"] = "loading-order";
+    /**
+     * Plugins that are applied to discover the project structure, files, and folders to analyze.
+     * @see {@link FlowrAnalyzerProjectDiscoveryPlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["ProjectDiscovery"] = "project-discovery";
+    /**
+     * Plugins that are applied to load and parse files.
+     * @see {@link FlowrAnalyzerFilePlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["FileLoad"] = "file-load";
+})(PluginType || (exports.PluginType = PluginType = {}));
+const generalPluginLog = log_1.log.getSubLogger({ name: 'plugins' });
+/**
+ * The base class every plugin to be used with the {@link FlowrAnalyzer} must extend.
+ * **Please do not create plugins directly based on this class, but use the classes referenced alongside the {@link PluginType} values!**
+ * For example, if you want to create a plugin that determines the loading order of files, extend {@link FlowrAnalyzerLoadingOrderPlugin} instead.
+ * These classes also provide sensible overrides of {@link FlowrAnalyzerPlugin.defaultPlugin} to be used when no plugin of this type is registered or triggered.
+ */
+class FlowrAnalyzerPlugin {
+    /**
+     * Returns a default/dummy implementation to be used when no plugin of this type is registered or triggered.
+     */
+    static defaultPlugin() {
+        throw new Error('This is to be implemented by every Plugin Layer');
+    }
+    /**
+     * Run the plugin with the given context and arguments.
+     */
+    processor(context, args) {
+        const now = Date.now();
+        try {
+            const result = this.process(context, args);
+            const duration = Date.now() - now;
+            (0, log_1.expensiveTrace)(generalPluginLog, () => `Plugin ${this.name} (v${this.version.format()}, ${this.type}) executed in ${duration}ms.`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - now;
+            generalPluginLog.error(`Plugin ${this.name} (v${this.version.format()}, {this.type}) failed after ${duration}ms. Error: ${error.message}`);
+            throw error;
+        }
+    }
+}
+exports.FlowrAnalyzerPlugin = FlowrAnalyzerPlugin;
+//# sourceMappingURL=flowr-analyzer-plugin.js.map

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin.d.ts

@@ -0,0 +1,14 @@
+import { SemVer } from 'semver';
+import { FlowrAnalyzerLoadingOrderPlugin } from './flowr-analyzer-loading-order-plugin';
+import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
+/**
+ * This plugin extracts loading order information from R `DESCRIPTION` files.
+ * It looks at the `Collate` field to determine the order in which files should be loaded.
+ * If no `Collate` field is present, it does nothing.
+ */
+export declare class FlowrAnalyzerLoadingOrderDescriptionFilePlugin extends FlowrAnalyzerLoadingOrderPlugin {
+    readonly name = "flowr-analyzer-package-version-description-file-plugin";
+    readonly description = "This plugin determines loading order based on the Collate field in DESCRIPTION files.";
+    readonly version: SemVer;
+    process(ctx: FlowrAnalyzerContext): void;
+}

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerLoadingOrderDescriptionFilePlugin = void 0;
+const flowr_analyzer_description_file_plugin_1 = require("../file-plugins/flowr-analyzer-description-file-plugin");
+const semver_1 = require("semver");
+const flowr_analyzer_loading_order_plugin_1 = require("./flowr-analyzer-loading-order-plugin");
+const flowr_file_1 = require("../../context/flowr-file");
+/**
+ * This plugin extracts loading order information from R `DESCRIPTION` files.
+ * It looks at the `Collate` field to determine the order in which files should be loaded.
+ * If no `Collate` field is present, it does nothing.
+ */
+class FlowrAnalyzerLoadingOrderDescriptionFilePlugin extends flowr_analyzer_loading_order_plugin_1.FlowrAnalyzerLoadingOrderPlugin {
+    name = 'flowr-analyzer-package-version-description-file-plugin';
+    description = 'This plugin determines loading order based on the Collate field in DESCRIPTION files.';
+    version = new semver_1.SemVer('0.1.0');
+    process(ctx) {
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        if (descFiles.length !== 1) {
+            flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
+            return;
+        }
+        /** this will do the caching etc. for me */
+        const deps = descFiles[0].content();
+        if (deps.has('Collate')) {
+            const collate = deps.get('Collate') ?? [];
+            /* we probably have to do some more guesswork here */
+            const unordered = ctx.files.loadingOrder.getUnorderedRequests();
+            // sort them by their path index in the Collate field
+            const sorted = unordered.slice().sort((a, b) => {
+                const aPath = a.request === 'file' ? a.content : undefined;
+                const bPath = b.request === 'file' ? b.content : undefined;
+                const aIndex = aPath ? collate.findIndex(c => aPath.endsWith(c.trim())) : -1;
+                const bIndex = bPath ? collate.findIndex(c => bPath.endsWith(c.trim())) : -1;
+                if (aIndex === -1 && bIndex === -1) {
+                    return 0; // both not found, keep original order
+                }
+                else if (aIndex === -1) {
+                    return 1; // a not found, b found -> a after b
+                }
+                else if (bIndex === -1) {
+                    return -1; // b not found, a found -> a before b
+                }
+                else {
+                    return aIndex - bIndex; // both found, sort by index
+                }
+            });
+            ctx.files.loadingOrder.addGuess(sorted, true);
+        }
+        else {
+            flowr_analyzer_description_file_plugin_1.descriptionFileLog.info(`No Collate field in DESCRIPTION file ${descFiles[0].path().toString()}`);
+        }
+    }
+}
+exports.FlowrAnalyzerLoadingOrderDescriptionFilePlugin = FlowrAnalyzerLoadingOrderDescriptionFilePlugin;
+//# sourceMappingURL=flowr-analyzer-loading-order-description-file-plugin.js.map

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-plugin.d.ts

@@ -0,0 +1,13 @@
+import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
+/**
+ * This is the base class for all plugins that determine the loading order of files in a project.
+ * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project and determine their loading order.
+ * See {@link DefaultFlowrAnalyzerLoadingOrderPlugin} for the dummy default implementation.
+ *
+ * In general, these plugins only trigger for a full project analysis after all files have been discovered and loaded.
+ * Otherwise, they may trigger multiple times (if for some reason, discovery reveals new files during the analysis).
+ */
+export declare abstract class FlowrAnalyzerLoadingOrderPlugin extends FlowrAnalyzerPlugin<undefined, void> {
+    readonly type = PluginType.LoadingOrder;
+    static defaultPlugin(): FlowrAnalyzerLoadingOrderPlugin;
+}

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerLoadingOrderPlugin = void 0;
+const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const semver_1 = require("semver");
+/**
+ * This is the base class for all plugins that determine the loading order of files in a project.
+ * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project and determine their loading order.
+ * See {@link DefaultFlowrAnalyzerLoadingOrderPlugin} for the dummy default implementation.
+ *
+ * In general, these plugins only trigger for a full project analysis after all files have been discovered and loaded.
+ * Otherwise, they may trigger multiple times (if for some reason, discovery reveals new files during the analysis).
+ */
+class FlowrAnalyzerLoadingOrderPlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugin {
+    type = flowr_analyzer_plugin_1.PluginType.LoadingOrder;
+    static defaultPlugin() {
+        return new DefaultFlowrAnalyzerLoadingOrderPlugin();
+    }
+}
+exports.FlowrAnalyzerLoadingOrderPlugin = FlowrAnalyzerLoadingOrderPlugin;
+/**
+ * This is the default dummy implementation of the {@link FlowrAnalyzerLoadingOrderPlugin}.
+ * It does nothing and relies on the chronological order of file discovery.
+ */
+class DefaultFlowrAnalyzerLoadingOrderPlugin extends FlowrAnalyzerLoadingOrderPlugin {
+    name = 'default-loading-order-plugin';
+    description = 'This is the default loading order plugin that does nothing.';
+    version = new semver_1.SemVer('0.0.0');
+    process() {
+        /* we always *have* to have a loading order, this plugin does not have to guess to rely on chronological order */
+    }
+}
+//# sourceMappingURL=flowr-analyzer-loading-order-plugin.js.map

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-description-file-plugin.d.ts

@@ -0,0 +1,14 @@
+import { FlowrAnalyzerPackageVersionsPlugin } from './flowr-analyzer-package-versions-plugin';
+import { SemVer } from 'semver';
+import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
+/**
+ * This plugin extracts package versions from R `DESCRIPTION` files.
+ * It looks at the `Depends` and `Imports` fields to find package names and their version constraints.
+ */
+export declare class FlowrAnalyzerPackageVersionsDescriptionFilePlugin extends FlowrAnalyzerPackageVersionsPlugin {
+    readonly name = "flowr-analyzer-package-version-description-file-plugin";
+    readonly description = "This plugin does...";
+    readonly version: SemVer;
+    process(ctx: FlowrAnalyzerContext): void;
+    private retrieveVersionsFromField;
+}

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-description-file-plugin.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPackageVersionsDescriptionFilePlugin = void 0;
+const flowr_analyzer_package_versions_plugin_1 = require("./flowr-analyzer-package-versions-plugin");
+const flowr_analyzer_description_file_plugin_1 = require("../file-plugins/flowr-analyzer-description-file-plugin");
+const semver_1 = require("semver");
+const package_1 = require("./package");
+const flowr_file_1 = require("../../context/flowr-file");
+const VersionRegex = /^([a-zA-Z0-9.]+)(?:\s*\(([><=~!]+)\s*([\d.]+)\))?$/;
+/**
+ * This plugin extracts package versions from R `DESCRIPTION` files.
+ * It looks at the `Depends` and `Imports` fields to find package names and their version constraints.
+ */
+class FlowrAnalyzerPackageVersionsDescriptionFilePlugin extends flowr_analyzer_package_versions_plugin_1.FlowrAnalyzerPackageVersionsPlugin {
+    name = 'flowr-analyzer-package-version-description-file-plugin';
+    description = 'This plugin does...';
+    version = new semver_1.SemVer('0.1.0');
+    process(ctx) {
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        if (descFiles.length !== 1) {
+            flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
+            return;
+        }
+        /** this will do the caching etc. for me */
+        const deps = descFiles[0].content();
+        this.retrieveVersionsFromField(ctx, deps, 'Depends', 'r');
+        this.retrieveVersionsFromField(ctx, deps, 'Imports', 'package');
+    }
+    retrieveVersionsFromField(ctx, file, field, type) {
+        for (const entry of file.get(field) ?? []) {
+            const match = VersionRegex.exec(entry);
+            if (match) {
+                const [, name, operator, version] = match;
+                const range = package_1.Package.parsePackageVersionRange(operator, version);
+                ctx.deps.addDependency(new package_1.Package(name, type, undefined, range));
+            }
+        }
+    }
+}
+exports.FlowrAnalyzerPackageVersionsDescriptionFilePlugin = FlowrAnalyzerPackageVersionsDescriptionFilePlugin;
+//# sourceMappingURL=flowr-analyzer-package-versions-description-file-plugin.js.map

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-plugin.d.ts

@@ -0,0 +1,10 @@
+import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
+/**
+ * This is the base class for all plugins that identify package and dependency versions used in the project.
+ * These plugins interplay with the {@link FlowrAnalyzerDependenciesContext} to gather information about the packages used in the project.
+ * See {@link DefaultFlowrAnalyzerPackageVersionsPlugin} for the no-op default implementation.
+ */
+export declare abstract class FlowrAnalyzerPackageVersionsPlugin extends FlowrAnalyzerPlugin<undefined, void> {
+    readonly type = PluginType.DependencyIdentification;
+    static defaultPlugin(): FlowrAnalyzerPackageVersionsPlugin;
+}

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-plugin.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPackageVersionsPlugin = void 0;
+const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const semver_1 = require("semver");
+/**
+ * This is the base class for all plugins that identify package and dependency versions used in the project.
+ * These plugins interplay with the {@link FlowrAnalyzerDependenciesContext} to gather information about the packages used in the project.
+ * See {@link DefaultFlowrAnalyzerPackageVersionsPlugin} for the no-op default implementation.
+ */
+class FlowrAnalyzerPackageVersionsPlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugin {
+    type = flowr_analyzer_plugin_1.PluginType.DependencyIdentification;
+    static defaultPlugin() {
+        return new DefaultFlowrAnalyzerPackageVersionsPlugin();
+    }
+}
+exports.FlowrAnalyzerPackageVersionsPlugin = FlowrAnalyzerPackageVersionsPlugin;
+/**
+ * This is the default no-op implementation of the {@link FlowrAnalyzerPackageVersionsPlugin}.
+ */
+class DefaultFlowrAnalyzerPackageVersionsPlugin extends FlowrAnalyzerPackageVersionsPlugin {
+    name = 'default-package-versions-plugin';
+    description = 'This is the default package versions plugin that does nothing.';
+    version = new semver_1.SemVer('0.0.0');
+    process() {
+        /* we do not need package versions for the analysis to do things! */
+    }
+}
+//# sourceMappingURL=flowr-analyzer-package-versions-plugin.js.map