Remove process and factory

Author: paulacamargo25

package-lock.json

@@ -49,8 +49,8 @@
         "category": "Debugpy",
         "command": "debugpy.viewOutput",
         "icon": {
-            "dark": "resources/dark/repl.svg",
-            "light": "resources/light/repl.svg"
+          "dark": "resources/dark/repl.svg",
+          "light": "resources/light/repl.svg"
         },
         "title": "%debugpy.command.viewOutput.title%"
       }
@@ -474,8 +474,6 @@
     "jsonc-parser": "^3.2.0",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
-    "rxjs": "^6.5.4",
-    "rxjs-compat": "^6.5.4",
     "vscode-debugadapter": "^1.51.0",
     "vscode-debugprotocol": "^1.51.0",
     "vscode-languageclient": "^8.0.2"

package.json

@@ -4,41 +4,37 @@
 'use strict';
 
 import { Logging } from '../utils/localize';
-import { IProcessLogger, SpawnOptions } from './types';
+import { SpawnOptions } from './types';
 import { escapeRegExp } from 'lodash';
 import { traceLog } from '../log/logging';
 import { getWorkspaceFolders } from '../vscodeapi';
 import { getOSType, getUserHomeDir, OSType } from '../platform';
 import { replaceAll, toCommandArgumentForPythonExt, trimQuotes } from '../stringUtils';
 
-export class ProcessLogger implements IProcessLogger {
-    constructor() {}
+export function logProcess(fileOrCommand: string, args?: string[], options?: SpawnOptions) {
+    let command = args
+        ? [fileOrCommand, ...args].map((e) => toCommandArgumentForPythonExt(trimQuotes(e))).join(' ')
+        : fileOrCommand;
+    const info = [`> ${getDisplayCommands(command)}`];
+    if (options && options.cwd) {
+        info.push(`${Logging.currentWorkingDirectory} ${getDisplayCommands(options.cwd as string)}`);
+    }
 
-    public logProcess(fileOrCommand: string, args?: string[], options?: SpawnOptions) {
-        let command = args
-            ? [fileOrCommand, ...args].map((e) => toCommandArgumentForPythonExt(trimQuotes(e))).join(' ')
-            : fileOrCommand;
-        const info = [`> ${this.getDisplayCommands(command)}`];
-        if (options && options.cwd) {
-            info.push(`${Logging.currentWorkingDirectory} ${this.getDisplayCommands(options.cwd as string)}`);
-        }
+    info.forEach((line) => {
+        traceLog(line);
+    });
+}
 
-        info.forEach((line) => {
-            traceLog(line);
-        });
+function getDisplayCommands(command: string): string {
+    const workspaceFolders = getWorkspaceFolders();
+    if (workspaceFolders && workspaceFolders.length === 1) {
+        command = replaceMatchesWithCharacter(command, workspaceFolders[0].uri.fsPath, '.');
     }
-
-    private getDisplayCommands(command: string): string {
-        const workspaceFolders = getWorkspaceFolders();
-        if (workspaceFolders && workspaceFolders.length === 1) {
-            command = replaceMatchesWithCharacter(command, workspaceFolders[0].uri.fsPath, '.');
-        }
-        const home = getUserHomeDir();
-        if (home) {
-            command = replaceMatchesWithCharacter(command, home, '~');
-        }
-        return command;
+    const home = getUserHomeDir();
+    if (home) {
+        command = replaceMatchesWithCharacter(command, home, '~');
     }
+    return command;
 }
 
 /**

src/extension/common/process/logger.ts

@@ -1,17 +1,15 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { exec, execSync, spawn } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import { Readable } from 'stream';
-import { Observable } from 'rxjs/Observable';
 import { IDisposable } from '../types';
 import { createDeferred } from '../utils/async';
 import { EnvironmentVariables } from '../variables/types';
 import { DEFAULT_ENCODING } from './constants';
-import { ExecutionResult, ObservableExecutionResult, Output, ShellOptions, SpawnOptions, StdErrError } from './types';
+import { ExecutionResult, ShellOptions, SpawnOptions, StdErrError } from './types';
 import { noop } from '../utils/misc';
 import { decodeBuffer } from './decoder';
-import { traceVerbose } from '../log/logging';
 
 function getDefaultOptions<T extends ShellOptions | SpawnOptions>(options: T, defaultEnv?: EnvironmentVariables): T {
     const defaultOptions = { ...options };
@@ -45,42 +43,6 @@ function getDefaultOptions<T extends ShellOptions | SpawnOptions>(options: T, de
     return defaultOptions;
 }
 
-export function shellExec(
-    command: string,
-    options: ShellOptions = {},
-    defaultEnv?: EnvironmentVariables,
-    disposables?: Set<IDisposable>,
-): Promise<ExecutionResult<string>> {
-    const shellOptions = getDefaultOptions(options, defaultEnv);
-    traceVerbose(`Shell Exec: ${command} with options: ${JSON.stringify(shellOptions, null, 4)}`);
-    return new Promise((resolve, reject) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const callback = (e: any, stdout: any, stderr: any) => {
-            if (e && e !== null) {
-                reject(e);
-            } else if (shellOptions.throwOnStdErr && stderr && stderr.length) {
-                reject(new Error(stderr));
-            } else {
-                stdout = filterOutputUsingCondaRunMarkers(stdout);
-                // Make sure stderr is undefined if we actually had none. This is checked
-                // elsewhere because that's how exec behaves.
-                resolve({ stderr: stderr && stderr.length > 0 ? stderr : undefined, stdout });
-            }
-        };
-        const proc = exec(command, shellOptions, callback); // NOSONAR
-        const disposable: IDisposable = {
-            dispose: () => {
-                if (!proc.killed) {
-                    proc.kill();
-                }
-            },
-        };
-        if (disposables) {
-            disposables.add(disposable);
-        }
-    });
-}
-
 export function plainExec(
     file: string,
     args: string[],
@@ -162,96 +124,6 @@ function filterOutputUsingCondaRunMarkers(stdout: string) {
     return filteredOut !== undefined ? filteredOut : stdout;
 }
 
-function removeCondaRunMarkers(out: string) {
-    out = out.replace('>>>PYTHON-EXEC-OUTPUT\r\n', '').replace('>>>PYTHON-EXEC-OUTPUT\n', '');
-    return out.replace('<<<PYTHON-EXEC-OUTPUT\r\n', '').replace('<<<PYTHON-EXEC-OUTPUT\n', '');
-}
-
-export function execObservable(
-    file: string,
-    args: string[],
-    options: SpawnOptions = {},
-    defaultEnv?: EnvironmentVariables,
-    disposables?: Set<IDisposable>,
-): ObservableExecutionResult<string> {
-    const spawnOptions = getDefaultOptions(options, defaultEnv);
-    const encoding = spawnOptions.encoding ? spawnOptions.encoding : 'utf8';
-    const proc = spawn(file, args, spawnOptions);
-    let procExited = false;
-    const disposable: IDisposable = {
-        dispose() {
-            if (proc && !proc.killed && !procExited) {
-                killPid(proc.pid!);
-            }
-            if (proc) {
-                proc.unref();
-            }
-        },
-    };
-    disposables?.add(disposable);
-
-    const output = new Observable<Output<string>>((subscriber) => {
-        const internalDisposables: IDisposable[] = [];
-
-        // eslint-disable-next-line @typescript-eslint/ban-types
-        const on = (ee: Readable | null, name: string, fn: Function) => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            ee?.on(name, fn as any);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            internalDisposables.push({ dispose: () => ee?.removeListener(name, fn as any) as any });
-        };
-
-        if (options.token) {
-            internalDisposables.push(
-                options.token.onCancellationRequested(() => {
-                    if (!procExited && !proc.killed) {
-                        proc.kill();
-                        procExited = true;
-                    }
-                }),
-            );
-        }
-
-        const sendOutput = (source: 'stdout' | 'stderr', data: Buffer) => {
-            let out = decodeBuffer([data], encoding);
-            if (source === 'stderr' && options.throwOnStdErr) {
-                subscriber.error(new StdErrError(out));
-            } else {
-                // Because all of output is not retrieved at once, filtering out the
-                // actual output using markers is not possible. Hence simply remove
-                // the markers and return original output.
-                out = removeCondaRunMarkers(out);
-                subscriber.next({ source, out });
-            }
-        };
-
-        on(proc.stdout, 'data', (data: Buffer) => sendOutput('stdout', data));
-        on(proc.stderr, 'data', (data: Buffer) => sendOutput('stderr', data));
-
-        proc.once('close', () => {
-            procExited = true;
-            subscriber.complete();
-            internalDisposables.forEach((d) => d.dispose());
-        });
-        proc.once('exit', () => {
-            procExited = true;
-            subscriber.complete();
-            internalDisposables.forEach((d) => d.dispose());
-        });
-        proc.once('error', (ex) => {
-            procExited = true;
-            subscriber.error(ex);
-            internalDisposables.forEach((d) => d.dispose());
-        });
-    });
-
-    return {
-        proc,
-        out: output,
-        dispose: disposable.dispose,
-    };
-}
-
 export function killPid(pid: number): void {
     try {
         if (process.platform === 'win32') {