feat(lax-source): provide replacement options (#1625)

* feat: provide replacement options

* refactor: rename apply replacements for clarity

Author: EagleoutIce

src/config.ts

@@ -42,7 +42,54 @@ export enum DropPathsOption {
 	Once = 'once',
 	/** try to drop every folder of the path */
 	All = 'all'
-};
+}
+
+export interface FlowrLaxSourcingOptions extends MergeableRecord {
+	/**
+	 * search for filenames matching in the lowercase
+	 */
+	readonly ignoreCapitalization:  boolean
+	/**
+	 * try to infer the working directory from the main or any script to analyze.
+	 */
+	readonly inferWorkingDirectory: InferWorkingDirectory
+	/**
+	 * Additionally search in these paths
+	 */
+	readonly searchPath:            readonly string[]
+	/**
+	 * Allow to drop the first or all parts of the sourced path,
+	 * if it is relative.
+	 */
+	readonly dropPaths:             DropPathsOption
+	/**
+	 * How often the same file can be sourced within a single run?
+	 * Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.
+	 */
+	readonly repeatedSourceLimit?:  number
+	/**
+	 * sometimes files may have a different name in the source call	(e.g., due to later replacements),
+	 * with this setting you can provide a list of replacements to apply for each sourced file.
+	 * Every replacement consists of a record that maps a regex to a replacement string.
+	 *
+	 * @example
+	 * ```ts
+	 * [
+	 *      { }, // no replacement -> still try the original name/path
+	 *      { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
+	 *      { '\s' : '_' }, // replace all spaces with underscores
+	 *      { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
+	 * ]
+	 * ```
+	 *
+	 * Given a `source("foo bar.R")` this configuration will search for (in this order):
+	 * - `foo bar.R` (original name)
+	 * - `main.R` (replaced with main.R)
+	 * - `foo_bar.R` (replaced spaces)
+	 * - `foo-bar.R` (replaced spaces and oo)
+	 */
+	readonly applyReplacements?:    Record<string, string>[]
+}
 
 export interface FlowrConfigOptions extends MergeableRecord {
 	/**
@@ -97,30 +144,7 @@ export interface FlowrConfigOptions extends MergeableRecord {
 		 * based on the configurations you give it.
 		 * This option is only in effect if {@link ignoreSourceCalls} is set to false.
 		 */
-		readonly resolveSource?: {
-			/**
-			 * search for filenames matching in the lowercase
-			 */
-			readonly ignoreCapitalization:  boolean
-			/**
-			 * try to infer the working directory from the main or any script to analyze.
-			 */
-			readonly inferWorkingDirectory: InferWorkingDirectory
-			/**
-			 * Additionally search in these paths
-			 */
-			readonly searchPath:            readonly string[]
-			/**
-			 * Allow to drop the first or all parts of the sourced path,
-			 * if it is relative.
-			 */
-			readonly dropPaths:             DropPathsOption
-			/**
-			 * How often the same file can be sourced within a single run?
-			 * Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.
-			 */
-			readonly repeatedSourceLimit?:  number
-		},
+		readonly resolveSource?: FlowrLaxSourcingOptions,
 		/**
 		 * The configuration for flowR's slicer
 		 */
@@ -146,7 +170,7 @@ export interface TreeSitterEngineConfig extends MergeableRecord {
 	/**
 	 * Whether to use the lax parser for parsing R code (allowing for syntax errors). If this is undefined, the strict parser will be used.
 	 */
-	readonly lax?:				            boolean
+	readonly lax?:                boolean
 }
 
 export interface RShellEngineConfig extends MergeableRecord {
@@ -231,7 +255,8 @@ export const flowrConfigFileSchema = Joi.object({
 			ignoreCapitalization:  Joi.boolean().description('Search for filenames matching in the lowercase.'),
 			inferWorkingDirectory: Joi.string().valid(...Object.values(InferWorkingDirectory)).description('Try to infer the working directory from the main or any script to analyze.'),
 			searchPath:            Joi.array().items(Joi.string()).description('Additionally search in these paths.'),
-			repeatedSourceLimit:   Joi.number().optional().description('How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.')
+			repeatedSourceLimit:   Joi.number().optional().description('How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.'),
+			applyReplacements:     Joi.array().items(Joi.object()).description('Provide name replacements for loaded files')
 		}).optional().description('If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if `ignoreSourceCalls` is set to false.'),
 		slicer: Joi.object({
 			threshold: Joi.number().optional().description('The maximum number of iterations to perform on a single function call during slicing.')

src/dataflow/internal/process/functions/call/built-in/built-in-source.ts

@@ -22,7 +22,7 @@ import { dataflowLogger } from '../../../../../logger';
 import { RType } from '../../../../../../r-bridge/lang-4.x/ast/model/type';
 import { overwriteEnvironment } from '../../../../../environments/overwrite';
 import type { NoInfo } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
-import { expensiveTrace, log } from '../../../../../../util/log';
+import { expensiveTrace, log, LogLevel } from '../../../../../../util/log';
 import fs from 'fs';
 import { normalize, normalizeTreeSitter } from '../../../../../../r-bridge/lang-4.x/ast/parser/json/parser';
 import { RShellExecutor } from '../../../../../../r-bridge/shell-executor';
@@ -66,6 +66,16 @@ function returnPlatformPath(p: string): string {
 	return p.replaceAll(AnyPathSeparator, path.sep);
 }
 
+function applyReplacements(path: string, replacements: readonly Record<string, string>[]): string[] {
+	const results = [];
+	for(const replacement of replacements) {
+		const newPath = Object.entries(replacement).reduce((acc, [key, value]) => acc.replace(new RegExp(key, 'g'), value), path);
+		results.push(newPath);
+	}
+
+	return results;
+}
+
 /**
  * Tries to find sourced by a source request and returns the first path that exists
  * @param seed - the path originally requested in the `source` call
@@ -80,7 +90,7 @@ export function findSource(seed: string, data: { referenceChain: readonly RParse
 		...(inferWdFromScript(config?.inferWorkingDirectory ?? InferWorkingDirectory.No, data.referenceChain))
 	];
 
-	const tryPaths = [seed];
+	let tryPaths = [seed];
 	switch(config?.dropPaths ?? DropPathsOption.No) {
 		case DropPathsOption.Once: {
 			const first = platformBasename(seed);
@@ -103,6 +113,12 @@ export function findSource(seed: string, data: { referenceChain: readonly RParse
 			break;
 	}
 
+	if(config?.applyReplacements) {
+		const r = config.applyReplacements;
+		tryPaths = tryPaths.flatMap(t => applyReplacements(t, r));
+	}
+
+
 	const found: string[] = [];
 	for(const explore of [undefined, ...explorePaths]) {
 		for(const tryPath of tryPaths) {
@@ -115,7 +131,9 @@ export function findSource(seed: string, data: { referenceChain: readonly RParse
 			}
 		}
 	}
-	log.info(`Found sourced file ${JSON.stringify(seed)} at ${JSON.stringify(found)}`);
+	if(log.settings.minLevel >= LogLevel.Info) {
+		log.info(`Found sourced file ${JSON.stringify(seed)} at ${JSON.stringify(found)}`);
+	}
 	return found;
 }
 

test/functionality/slicing/configuration/source-finding.test.ts

@@ -20,7 +20,8 @@ describe('source finding', () => {
 		[`a${path.sep}b.txt`]:                         'f <- function() { function() 3 }',
 		'c.txt':                                       'f <- function() { x <<- 3 }',
 		[`x${path.sep}y${path.sep}z${path.sep}b.txt`]: 'x <- 3',
-		[`x${path.sep}y${path.sep}b.txt`]:             'x <- 3'
+		[`x${path.sep}y${path.sep}b.txt`]:             'x <- 3',
+		'with-spaces.txt':                             'x <- 3',
 	};
 	beforeAll(() => {
 		setSourceProvider(requestProviderFromText(sources));
@@ -31,7 +32,11 @@ describe('source finding', () => {
 					dropPaths:             DropPathsOption.All,
 					ignoreCapitalization:  true,
 					inferWorkingDirectory: InferWorkingDirectory.ActiveScript,
-					searchPath:            []
+					searchPath:            [],
+					applyReplacements:     [
+						{ },
+						{ ' ': '-' }
+					]
 				}
 			}
 		});
@@ -53,4 +58,5 @@ describe('source finding', () => {
 	assertSourceFound('b.txt', [`a${path.sep}b.txt`], [{ request: 'file', content: `a${path.sep}x.txt` }]);
 	assertSourceFound('b.txt', [`x${path.sep}y${path.sep}z${path.sep}b.txt`], [{ request: 'file', content: `x${path.sep}y${path.sep}z${path.sep}g.txt` }]);
 	assertSourceFound(`..${path.sep}b.txt`, [`x${path.sep}y${path.sep}b.txt`], [{ request: 'file', content: `x${path.sep}y${path.sep}z${path.sep}g.txt` }]);
+	assertSourceFound('with spaces.txt', ['with-spaces.txt']); // space replacements
 });