@teamscale/javascript-instrumenter 0.0.1-alpha.20 → 0.0.1-beta.5

package/dist/src/instrumenter/TaskBuilder.js

@@ -1,20 +1,57 @@
-import { CollectorSpecifier, InstrumentationTask, OriginSourcePattern, SourceMapFileReference, TaskElement } from './Task';
-import { Contract, InvalidConfigurationException } from '@cqse/commons';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ensureExistingDirectory, expandToFileSet, isExistingDirectory, isExistingFile } from './FileSystem';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskBuilder = void 0;
+const Task_1 = require("./Task");
+const commons_1 = require("@cqse/commons");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FileSystem_1 = require("./FileSystem");
+/**
+ * Load a source map object from the given file (path).
+ * Exception if the specified file does not exist.
+ *
+ * @param sourceMapPath - The path to the source map file.
+ */
+function loadSourceMap(sourceMapPath) {
+    if (sourceMapPath) {
+        if (!fs.existsSync(sourceMapPath)) {
+            throw new commons_1.InvalidConfigurationException(`The specified source map file '${sourceMapPath}' was not found.`);
+        }
+        return new Task_1.SourceMapFileReference(sourceMapPath);
+    }
+    return undefined;
+}
 /**
  * A builder for an instrumentation task.
  */
-export class TaskBuilder {
+class TaskBuilder {
     constructor() {
         this.elements = [];
         this.collector = null;
     }
     /** Set the collector by extracting the information from a given string */
     setCollectorFromString(collectorSpecification) {
-        Contract.requireNonEmpty(collectorSpecification);
-        this.collector = new CollectorSpecifier(collectorSpecification);
+        commons_1.Contract.requireNonEmpty(collectorSpecification);
+        this.collector = new Task_1.CollectorSpecifier(collectorSpecification);
         return this;
     }
     /** Set the include pattern */
@@ -29,7 +66,7 @@ export class TaskBuilder {
     }
     /** Add a task element */
     addElement(fromFilePath, toFilePath, fromFileSourceMap) {
-        this.elements.push(new TaskElement(fromFilePath, toFilePath, fromFileSourceMap));
+        this.elements.push(new Task_1.TaskElement(fromFilePath, toFilePath, fromFileSourceMap));
         return this;
     }
     /**
@@ -47,74 +84,98 @@ export class TaskBuilder {
         this.setOriginSourceIncludePattern(config.include_origin);
         this.setOriginSourceExcludePattern(config.exclude_origin);
         // Handle an explicitly specified source map
-        let sourceMapInfo;
-        if (sourceMap) {
-            if (!fs.existsSync(sourceMap)) {
-                throw new InvalidConfigurationException(`The specified source map file '${sourceMap}' was not found.`);
-            }
-            sourceMapInfo = new SourceMapFileReference(sourceMap);
-        }
+        const sourceMapInfo = loadSourceMap(sourceMap);
         // Depending on whether or not an in place instrumentation is needed
         // the task has to be built differently and different invariants
         // have to be satisfied by the passed configuration.
         if (inPlace) {
             if (target) {
-                throw new InvalidConfigurationException('No target path must be specified in case an in-place instrumentation is enabled.');
+                throw new commons_1.InvalidConfigurationException('No target path must be specified in case an in-place instrumentation is enabled.');
             }
-            inputs
-                .map(input => expandToFileSet(input))
-                .reduce((prev, curr) => {
-                return curr.concat(prev);
-            }, [])
-                .forEach(filePath => this.addElement(filePath, filePath, sourceMapInfo));
+            this.addInPlaceTasksFromPattern(inputs, sourceMapInfo);
         }
         else if (!inPlace) {
             // A target directory must be specified
             if (!target) {
-                throw new InvalidConfigurationException('A target path must be specified using `--to`.');
+                throw new commons_1.InvalidConfigurationException('A target path must be specified using `--to`.');
             }
-            ensureExistingDirectory(target);
-            // Create task elements for all input specifiers
-            for (const input of inputs) {
-                if (isExistingFile(input)) {
-                    if (isExistingDirectory(target) || target.endsWith(path.sep)) {
-                        this.addElement(input, path.join(target, path.basename(input)), sourceMapInfo);
-                    }
-                    else {
-                        this.addElement(input, target, sourceMapInfo);
-                    }
+            this.addInstrumentationTasksFromPatternWithTarget(inputs, target, sourceMapInfo);
+        }
+        return this;
+    }
+    /**
+     * Adds instrumentation tasks based on a given pattern `inputs` describing the set of
+     * input files and produces the output files in the specified output folder `target.
+     *
+     * @param inputs - Glob pattern describing set of input files
+     * @param target - Target folder
+     * @param sourceMapInfo - Source map file for all the input files.
+     */
+    addInstrumentationTasksFromPatternWithTarget(inputs, target, sourceMapInfo) {
+        (0, FileSystem_1.ensureExistingDirectory)(target);
+        for (const input of inputs) {
+            if ((0, FileSystem_1.isExistingFile)(input)) {
+                if ((0, FileSystem_1.isExistingDirectory)(target) || target.endsWith(path.sep)) {
+                    this.addElement(input, path.join(target, path.basename(input)), sourceMapInfo);
                 }
-                else if (isExistingDirectory(input) || isPattern(input)) {
-                    const inputFiles = inputs
-                        .map(input => expandToFileSet(input))
-                        .reduce((prev, curr) => {
-                        return curr.concat(prev);
-                    }, []);
-                    if (isPattern(input)) {
-                        inputFiles.forEach(f => this.addElement(f, path.join(target, path.basename(f)), sourceMapInfo));
-                    }
-                    else {
-                        inputFiles.forEach(f => this.addElement(f, path.join(target, path.relative(input, path.basename(f))), sourceMapInfo));
-                    }
+                else {
+                    this.addElement(input, target, sourceMapInfo);
+                }
+            }
+            else if ((0, FileSystem_1.isExistingDirectory)(input) || isPattern(input)) {
+                const inputFiles = inputs.flatMap(input => (0, FileSystem_1.expandToFileSet)(input));
+                if (isPattern(input)) {
+                    inputFiles.forEach(f => this.addElement(f, path.join(target, path.basename(f)), sourceMapInfo));
                 }
                 else {
-                    throw new InvalidConfigurationException(`The specified input '${input}' was not found.`);
+                    inputFiles.forEach(f => this.addElement(f, path.join(target, path.relative(input, path.basename(f))), sourceMapInfo));
                 }
             }
+            else {
+                throw new commons_1.InvalidConfigurationException(`The specified input '${input}' was not found.`);
+            }
         }
-        return this;
+    }
+    /**
+     * Adds in-place instrumentation tasks for the set of files described
+     * by the `inputs` pattern.
+     *
+     * @param inputs - Glob pattern.
+     * @param sourceMapInfo - Source map for the files described by the pattern.
+     */
+    addInPlaceTasksFromPattern(inputs, sourceMapInfo) {
+        inputs
+            .map(input => expandAndCheck(input))
+            .reduce((prev, curr) => {
+            return curr.concat(prev);
+        }, [])
+            .forEach(filePath => this.addElement(filePath, filePath, sourceMapInfo));
     }
     /**
      * Build the instrumentation task.
      */
     build() {
-        const pattern = new OriginSourcePattern(this.originSourceIncludePattern, this.originSourceExcludePattern);
-        return new InstrumentationTask(Contract.requireDefined(this.collector), this.elements, pattern);
+        const pattern = new Task_1.OriginSourcePattern(this.originSourceIncludePattern, this.originSourceExcludePattern);
+        return new Task_1.InstrumentationTask(commons_1.Contract.requireDefined(this.collector), this.elements, pattern);
     }
 }
+exports.TaskBuilder = TaskBuilder;
 /**
  * Does the given string look like a RegExp or Glob pattern?
  */
 function isPattern(text) {
     return text.includes('*') || text.includes('+') || text.includes('?') || text.includes('|');
 }
+/**
+ * Expand the given Glob pattern and check whether or not files matched.
+ * Raises an exception is the result is empty.
+ *
+ * @param pattern - The Glob pattern used for matching.
+ */
+function expandAndCheck(pattern) {
+    const result = (0, FileSystem_1.expandToFileSet)(pattern);
+    if (result.length === 0) {
+        throw new commons_1.InvalidConfigurationException(`No files to instrument found. \n\tWorking directory: '${process.cwd()}'\n\tPattern: '${pattern}'`);
+    }
+    return result;
+}

package/dist/src/main.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
 export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/src/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":""}

package/dist/src/main.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
-import { App } from './App';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const App_1 = require("./App");
 // Run the instrumenter and print the results to the console.
-App.run()
+App_1.App.run()
     .then(result => {
     console.log('Instrumentation finished.');
     console.log(`\tInstrumented: ${result.translated}`);