();
124 | input.title = title;
125 | input.step = step;
126 | input.totalSteps = totalSteps;
127 | input.ignoreFocusOut = ignoreFocusOut ?? false;
128 | input.placeholder = placeholder;
129 | input.items = items;
130 | if (activeItem) {
131 | input.activeItems = [activeItem];
132 | }
133 | input.buttons = [
134 | ...(this.steps.length > 1 ? [QuickInputButtons.Back] : []),
135 | ...(buttons || []),
136 | ];
137 | disposables.push(
138 | input.onDidTriggerButton((item) => {
139 | if (item === QuickInputButtons.Back) {
140 | reject(InputFlowAction.back);
141 | } else {
142 | resolve((item as any));
143 | }
144 | }),
145 | input.onDidChangeSelection(items => resolve(items[0])),
146 | input.onDidHide(() => {
147 | (async () => {
148 | reject(shouldResume && await shouldResume()
149 | ? InputFlowAction.resume
150 | : InputFlowAction.cancel);
151 | })()
152 | .catch(reject);
153 | }),
154 | );
155 | if (this.current) {
156 | this.current.dispose();
157 | }
158 | this.current = input;
159 | this.current.show();
160 | });
161 | } finally {
162 | disposables.forEach(d => d.dispose());
163 | }
164 | }
165 |
166 | async showInputBox(
167 | { title, step, totalSteps, value, prompt, validate,
168 | buttons, ignoreFocusOut, placeholder, shouldResume }: P) {
169 | const disposables: Disposable[] = [];
170 | try {
171 | return await
172 | new Promise((resolve, reject) => {
173 | const input = window.createInputBox();
174 | input.title = title;
175 | input.step = step;
176 | input.totalSteps = totalSteps;
177 | input.value = value || "";
178 | input.prompt = prompt;
179 | input.ignoreFocusOut = ignoreFocusOut ?? false;
180 | input.placeholder = placeholder;
181 | input.buttons = [
182 | ...(this.steps.length > 1 ? [QuickInputButtons.Back] : []),
183 | ...(buttons || []),
184 | ];
185 | let validating = validate("");
186 | disposables.push(
187 | input.onDidTriggerButton((item) => {
188 | if (item === QuickInputButtons.Back) {
189 | reject(InputFlowAction.back);
190 | } else {
191 | resolve(item as any);
192 | }
193 | }),
194 | input.onDidAccept(async () => {
195 | const value = input.value;
196 | input.enabled = false;
197 | input.busy = true;
198 | if (!(await validate(value))) {
199 | resolve(value);
200 | }
201 | input.enabled = true;
202 | input.busy = false;
203 | }),
204 | input.onDidChangeValue(async (text) => {
205 | const current = validate(text);
206 | validating = current;
207 | const validationMessage = await current;
208 | if (current === validating) {
209 | input.validationMessage = validationMessage;
210 | }
211 | }),
212 | input.onDidHide(() => {
213 | (async () => {
214 | reject(shouldResume && await shouldResume()
215 | ? InputFlowAction.resume
216 | : InputFlowAction.cancel);
217 | })()
218 | .catch(reject);
219 | }),
220 | );
221 | if (this.current) {
222 | this.current.dispose();
223 | }
224 | this.current = input;
225 | this.current.show();
226 | });
227 | } finally {
228 | disposables.forEach(d => d.dispose());
229 | }
230 | }
231 | }
232 |
--------------------------------------------------------------------------------
/src/utils/terminal.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import { window } from "vscode";
3 |
4 | /**
5 | * Waits a user-defined delay before allowing the terminal to be used. This
6 | * might be useful for some activation scripts to load like virtualenvs etc.
7 | *
8 | * Note that this function must be awaited by the caller, otherwise the delay
9 | * will not be respected.
10 | *
11 | * This function does not have any reference to the actual terminal, it just
12 | * waits, and that's it.
13 | */
14 | export async function waitNewTerminalDelay() {
15 | const delay: number = await vscode.workspace
16 | .getConfiguration("manim-notebook").get("delayNewTerminal")!;
17 |
18 | if (delay > 600) {
19 | await window.withProgress({
20 | location: vscode.ProgressLocation.Notification,
21 | title: "Waiting a user-defined delay for the new terminal...",
22 | cancellable: false,
23 | }, async (progress, _token) => {
24 | progress.report({ increment: 0 });
25 |
26 | // split user-defined timeout into 500ms chunks and show progress
27 | const numChunks = Math.ceil(delay / 500);
28 | for (let i = 0; i < numChunks; i++) {
29 | await new Promise(resolve => setTimeout(resolve, 500));
30 | progress.report({ increment: 100 / numChunks });
31 | }
32 | });
33 | } else {
34 | await new Promise(resolve => setTimeout(resolve, delay));
35 | }
36 | }
37 |
38 | /**
39 | * Regular expression to match ANSI control sequences. Even though we might miss
40 | * some control sequences, this is good enough for our purposes as the relevant
41 | * ones are matched. From: https://stackoverflow.com/a/14693789/
42 | */
43 | const ANSI_CONTROL_SEQUENCE_REGEX = /(?:\x1B[@-Z\\-_]|[\x80-\x9A\x9C-\x9F]|(?:\x1B\[|\x9B)[0-?]*[ -/]*[@-~])/g;
44 |
45 | /**
46 | * Removes ANSI control codes from the given stream of strings and yields the
47 | * cleaned strings.
48 | *
49 | * @param stream The stream of strings to clean.
50 | * @returns An async iterable stream of strings without ANSI control codes.
51 | */
52 | export async function* withoutAnsiCodes(stream: AsyncIterable): AsyncIterable {
53 | for await (const data of stream) {
54 | yield stripAnsiCodes(data);
55 | }
56 | }
57 |
58 | export function stripAnsiCodes(data: string): string {
59 | return data.replace(ANSI_CONTROL_SEQUENCE_REGEX, "");
60 | }
61 |
62 | /**
63 | * Registers a callback to read the stdout from the terminal. The callback is
64 | * invoked whenever the given terminal emits output. The output is cleaned from
65 | * ANSI control codes by default.
66 | *
67 | * Note that you should execute the command in the terminal after registering
68 | * the callback, otherwise the callback might not be invoked.
69 | *
70 | * @param terminal The terminal to listen to.
71 | * @param callback The callback to invoke when output is emitted.
72 | * @param withoutAnsi Whether to clean the output from ANSI control codes.
73 | */
74 | export async function onTerminalOutput(
75 | terminal: vscode.Terminal, callback: (_data: string) => void, withoutAnsi = true) {
76 | window.onDidStartTerminalShellExecution(
77 | async (event: vscode.TerminalShellExecutionStartEvent) => {
78 | if (event.terminal !== terminal) {
79 | return;
80 | }
81 |
82 | let stream = event.execution.read();
83 | if (withoutAnsi) {
84 | stream = withoutAnsiCodes(stream);
85 | }
86 |
87 | for await (const data of stream) {
88 | callback(data);
89 | }
90 | });
91 | }
92 |
--------------------------------------------------------------------------------
/src/utils/testing.ts:
--------------------------------------------------------------------------------
1 | import * as path from "path";
2 | import { Terminal, TerminalShellExecution, window } from "vscode";
3 | import { stripAnsiCodes } from "./terminal";
4 |
5 | export function setupTestEnvironment() {
6 | const basePath = process.env.TEST_BASE_PATH;
7 | if (!basePath) {
8 | throw new Error("TEST_BASE_PATH not set, although in testing environment.");
9 | }
10 | const binFolderName = process.platform === "win32" ? "Scripts" : "bin";
11 | const binPath = path.join(basePath, "tmp", "manimVenv", binFolderName);
12 | injectPythonVenvIntoTerminals(binPath);
13 | injectPythonVenvIntoNodeExec(binPath);
14 | }
15 |
16 | /**
17 | * Injects the VSCode terminal such that every command sent to it is prefixed
18 | * with a given path.
19 | *
20 | * This is useful in a testing environment where we want to run commands in a
21 | * virtual Python environment without actually installing the Python extension
22 | * that would source the virtual environment for us.
23 | *
24 | * @param binPath The path to the bin folder of the virtual Python environment.
25 | * This path will be prefixed to every command sent to the terminal, e.g.
26 | * `manimgl --version` becomes
27 | * `/path/to/venv/bin/manimgl --version`.
28 | */
29 | function injectPythonVenvIntoTerminals(binPath: string) {
30 | const createTerminalOrig = window.createTerminal;
31 | window.createTerminal = (args: any): Terminal => {
32 | const terminal = createTerminalOrig(args);
33 |
34 | // Inject sendText()
35 | const sendTextOrig = terminal.sendText;
36 | terminal.sendText = (text: string, shouldExecute?: boolean): void => {
37 | if (isManimCommand(text)) {
38 | return sendTextOrig.call(terminal, text, shouldExecute);
39 | }
40 | return sendTextOrig.call(terminal, path.join(binPath, text), shouldExecute);
41 | };
42 |
43 | // Inject shellIntegration.executeCommand()
44 | window.onDidChangeTerminalShellIntegration((event) => {
45 | if (event.terminal !== terminal) {
46 | return;
47 | }
48 | const shellIntegration = event.shellIntegration;
49 | // only stub executeCommand(commandLine: string) method, not
50 | // the executeCommand(executable: string, args: string[]) method
51 | const executeCommandOrig = shellIntegration.executeCommand as
52 | (_commandLine: string) => TerminalShellExecution;
53 | shellIntegration.executeCommand = (commandLine: string): TerminalShellExecution => {
54 | if (isManimCommand(commandLine)) {
55 | return executeCommandOrig.call(shellIntegration, commandLine);
56 | }
57 | return executeCommandOrig.call(shellIntegration, path.join(binPath, commandLine));
58 | };
59 |
60 | // Overwrite the readonly shellIntegration property of the terminal
61 | Object.defineProperty(terminal, "shellIntegration", {
62 | value: shellIntegration,
63 | writable: false,
64 | });
65 | });
66 |
67 | return terminal;
68 | };
69 | }
70 |
71 | /**
72 | * Injects the Node.js child_process.exec() function such that every command
73 | * sent to it is prefixed with a given path.
74 | *
75 | * @param binPath The path to the bin folder of the virtual Python environment.
76 | * This path will be prefixed to every command sent to the terminal, e.g.
77 | * `manimgl --version` becomes `/path/to/venv/bin/manimgl --version`.
78 | */
79 | function injectPythonVenvIntoNodeExec(binPath: string) {
80 | const execOrig = require("child_process").exec;
81 |
82 | require("child_process").exec = (command: string, options: any, callback: any) => {
83 | return execOrig(path.join(binPath, command), options, callback);
84 | };
85 | }
86 |
87 | /**
88 | * Returns whether the given command is a Manim command used inside the Manim
89 | * interactive terminal (IPython shell).
90 | *
91 | * @param command The command to check.
92 | */
93 | function isManimCommand(command: string): boolean {
94 | if (command.length <= 3) {
95 | return false;
96 | }
97 | const manimCommands = ["checkpoint_paste", "reload", "exit", "clear"];
98 | command = command.trim();
99 | command = stripAnsiCodes(command);
100 | return manimCommands.some(manimCommand => command.includes(`${manimCommand}(`));
101 | }
102 |
--------------------------------------------------------------------------------
/src/utils/venv.ts:
--------------------------------------------------------------------------------
1 | import * as path from "path";
2 |
3 | /**
4 | * Regular expression to match Python executables on Windows and Unix-like
5 | * systems. Will detect "python", "python3", "python.exe", and "python3.exe".
6 | */
7 | const PYTHON_BINARY_REGEX = /python3?(\.exe)?$/;
8 |
9 | /**
10 | * Transforms a path pointing to either an environment folder or a
11 | * Python executable into a path pointing to the respective binary in that
12 | * environment.
13 | *
14 | * This is necessary since the Python extension may return the path to the
15 | * Python executable OR the path to the environment folder, depending on how
16 | * the venv was originally created. See:
17 | * https://github.com/microsoft/vscode-python/wiki/Python-Environment-APIs#extension-api-usage
18 | *
19 | * @param envPath The path to the Python environment or Python executable.
20 | * @param binary The binary to be called, e.g. "manimgl".
21 | * @returns The path to the binary inside the environment.
22 | */
23 | export function getBinaryPathInPythonEnv(envPath: string, binary: string): string {
24 | if (PYTHON_BINARY_REGEX.test(envPath)) {
25 | return envPath.replace(PYTHON_BINARY_REGEX, binary);
26 | }
27 |
28 | const binFolderName = process.platform === "win32" ? "Scripts" : "bin";
29 | return path.join(envPath, binFolderName, binary);
30 | }
31 |
--------------------------------------------------------------------------------
/src/walkthrough.ts:
--------------------------------------------------------------------------------
1 | import fs from "fs";
2 | import path from "path";
3 | import * as vscode from "vscode";
4 | import { commands, ExtensionContext, window, workspace } from "vscode";
5 | import { Logger } from "./logger";
6 |
7 | export function registerWalkthroughCommands(context: ExtensionContext) {
8 | const openSampleFileCommand = commands.registerCommand(
9 | "manim-notebook-walkthrough.openSample", async () => {
10 | Logger.info("💠 Command Open Sample File requested");
11 | await openSampleFile(context);
12 | });
13 |
14 | const showAllCommandsCommand = commands.registerCommand(
15 | "manim-notebook-walkthrough.showCommands", async () => {
16 | Logger.info("💠 Command Show All Commands requested");
17 | await showAllCommands();
18 | },
19 | );
20 |
21 | const showKeyboardShortcutsCommand = commands.registerCommand(
22 | "manim-notebook-walkthrough.showShortcuts", async () => {
23 | Logger.info("💠 Command Show Keyboard Shortcuts requested");
24 | await showKeyboardShortcuts();
25 | },
26 | );
27 |
28 | const showSettingsCommand = commands.registerCommand(
29 | "manim-notebook-walkthrough.showSettings", async () => {
30 | Logger.info("💠 Command Show Settings requested");
31 | await showSettings();
32 | },
33 | );
34 |
35 | const openWikiCommand = commands.registerCommand(
36 | "manim-notebook-walkthrough.openWiki", async () => {
37 | Logger.info("💠 Command Open Wiki requested");
38 | await openWiki();
39 | },
40 | );
41 |
42 | context.subscriptions.push(
43 | openSampleFileCommand,
44 | showAllCommandsCommand,
45 | showKeyboardShortcutsCommand,
46 | showSettingsCommand,
47 | openWikiCommand,
48 | );
49 | }
50 |
51 | /**
52 | * Opens a sample Manim file in a new editor that users can use to get started.
53 | *
54 | * @param context The extension context.
55 | */
56 | async function openSampleFile(context: ExtensionContext) {
57 | const sampleFilePath = path.join(context.extensionPath,
58 | "assets", "walkthrough", "sample_scene.py");
59 | const sampleFileContent = fs.readFileSync(sampleFilePath, "utf-8");
60 |
61 | const sampleFile = await workspace.openTextDocument({
62 | language: "python",
63 | content: sampleFileContent,
64 | });
65 |
66 | await window.showTextDocument(sampleFile);
67 | }
68 |
69 | /**
70 | * Opens the command palette with all the "Manim Notebook" commands.
71 | */
72 | async function showAllCommands() {
73 | await commands.executeCommand("workbench.action.quickOpen", ">Manim Notebook:");
74 | }
75 |
76 | /**
77 | * Opens the keyboard shortcuts page in the settings.
78 | */
79 | async function showKeyboardShortcuts() {
80 | await commands.executeCommand(
81 | "workbench.action.openGlobalKeybindings", "Manim Notebook");
82 | }
83 |
84 | /**
85 | * Opens the settings page for the extension.
86 | */
87 | async function showSettings() {
88 | await commands.executeCommand(
89 | "workbench.action.openSettings", "Manim Notebook");
90 | }
91 |
92 | /**
93 | * Opens the GitHub wiki page for the extension.
94 | */
95 | async function openWiki() {
96 | const wikiUrl = "https://github.com/Manim-Notebook/manim-notebook/wiki";
97 | await vscode.env.openExternal(vscode.Uri.parse(wikiUrl));
98 | }
99 |
--------------------------------------------------------------------------------
/tests/activation.test.ts:
--------------------------------------------------------------------------------
1 | import { commands, window } from "vscode";
2 |
3 | import { afterEach, before, describe, it } from "mocha";
4 | import * as sinon from "sinon";
5 | let expect: Chai.ExpectStatic;
6 |
7 | import { manimNotebookContext } from "../src/extension";
8 | import { Logger } from "../src/logger";
9 | import { applyWindowsPastePatch } from "../src/patches/applyPatches";
10 |
11 | import { onTerminalOutput } from "../src/utils/terminal";
12 |
13 | const MANIM_VERSION_STRING_REGEX = /v\d+\.\d+\.\d+/;
14 |
15 | before(async () => {
16 | // why this weird import syntax?
17 | // -> see https://github.com/microsoft/vscode/issues/130367
18 | const chai = await import("chai");
19 | expect = chai.expect;
20 | });
21 |
22 | describe("Manim Activation", function () {
23 | afterEach(() => {
24 | sinon.restore();
25 | });
26 |
27 | it("Reads `manimgl --version` from terminal", async () => {
28 | console.log("Creating terminal");
29 | const terminal = window.createTerminal("Dummy terminal");
30 | terminal.show();
31 |
32 | return new Promise((resolve) => {
33 | onTerminalOutput(terminal, (data) => {
34 | console.log(data);
35 | if (MANIM_VERSION_STRING_REGEX.test(data)) {
36 | resolve();
37 | }
38 | });
39 | terminal.sendText("manimgl --version");
40 | });
41 | });
42 |
43 | it("Redetects Manim version", async () => {
44 | // TODO: Test different Manim versions installed
45 | const spy = sinon.spy(window, "showInformationMessage");
46 | await commands.executeCommand("manim-notebook.redetectManimVersion");
47 | sinon.assert.called(spy);
48 | sinon.assert.calledWith(spy, sinon.match(MANIM_VERSION_STRING_REGEX));
49 | });
50 |
51 | it("Applies Windows paste patch", async function () {
52 | if (process.platform !== "win32") {
53 | this.skip();
54 | }
55 | expect(manimNotebookContext).to.not.be.undefined;
56 | this.timeout(5000);
57 |
58 | const spyInfo = sinon.spy(Logger, "info");
59 | const spyError = sinon.spy(Logger, "error");
60 |
61 | applyWindowsPastePatch(manimNotebookContext, "python.exe");
62 |
63 | await new Promise((resolve) => {
64 | const checkSpy = () => {
65 | sinon.assert.notCalled(spyError);
66 | if (spyInfo.calledWith("Windows paste patch successfully applied (in applyPatches.ts)")) {
67 | resolve();
68 | } else {
69 | // we use a polling mechanism here as the patch is run
70 | // in the background
71 | setTimeout(checkSpy, 300);
72 | }
73 | };
74 | checkSpy();
75 | });
76 | sinon.assert.notCalled(spyError);
77 | });
78 | });
79 |
--------------------------------------------------------------------------------
/tests/cellRanges.test.ts:
--------------------------------------------------------------------------------
1 | import { describe, it } from "mocha";
2 | import { Range, workspace } from "vscode";
3 | import { ManimCellRanges } from "../src/pythonParsing";
4 | import { uriInWorkspace } from "./utils/testRunner";
5 |
6 | describe("Manim Cell Ranges", function () {
7 | // in the expected ranges we only care about the start and end lines
8 | // line numbers are 0-based here
9 | const tests = [
10 | {
11 | filename: "detection_basic.py",
12 | expectedRanges: [[5, 7], [9, 10], [16, 18]],
13 | },
14 | {
15 | filename: "detection_class_definition.py",
16 | expectedRanges: [[9, 11], [13, 14]],
17 | },
18 | {
19 | filename: "detection_inside_construct.py",
20 | expectedRanges: [[5, 12], [14, 16]],
21 | },
22 | {
23 | filename: "detection_multiple_inheritance.py",
24 | expectedRanges: [[5, 7], [9, 21], [14, 21], [31, 33], [35, 36]],
25 | },
26 | {
27 | filename: "detection_multiple_methods.py",
28 | expectedRanges: [[5, 7], [9, 10]],
29 | },
30 | {
31 | filename: "detection_syntax.py",
32 | expectedRanges: [[5, 9], [11, 12], [14, 15], [17, 17], [19, 19],
33 | [25, 25], [31, 32], [33, 34], [35, 35], [36, 36]],
34 | },
35 | ];
36 |
37 | tests.forEach(function (test) {
38 | it(`Correctly assigns ranges for ${test.filename}`, async () => {
39 | const uri = uriInWorkspace(test.filename);
40 | const document = await workspace.openTextDocument(uri);
41 |
42 | const ranges: Range[] = ManimCellRanges.calculateRanges(document);
43 | const expectedRanges = test.expectedRanges;
44 |
45 | if (ranges.length !== expectedRanges.length) {
46 | throw new Error(`Expected ${expectedRanges.length} ranges, but got ${ranges.length}`);
47 | }
48 |
49 | for (let i = 0; i < ranges.length; i++) {
50 | const range = ranges[i];
51 | const expectedRange = expectedRanges[i];
52 |
53 | if (range.start.line !== expectedRange[0]) {
54 | throw new Error(`Start line does not match (${i}):`
55 | + ` expected: ${expectedRange[0]}, actual: ${range.start.line}`);
56 | }
57 | if (range.end.line !== expectedRange[1]) {
58 | throw new Error(`End line does not match (${i}):`
59 | + ` expected: ${expectedRange[1]}, actual: ${range.end.line}`);
60 | }
61 | }
62 | });
63 | });
64 | });
65 |
--------------------------------------------------------------------------------
/tests/fixtures/basic.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class MyFirstManimNotebook(Scene):
5 | def construct(self):
6 | ## Create a circle
7 | circle = Circle()
8 | circle.set_stroke(BLUE_E, width=4)
9 | self.play(ShowCreation(circle))
10 |
11 | ## Transform circle to square
12 | square = Square()
13 | self.play(ReplacementTransform(circle, square))
14 |
15 | ## Make it red & fly away
16 | self.play(
17 | square.animate.set_fill(RED_D, opacity=0.5),
18 | self.frame.animate.set_width(25),
19 | )
20 |
--------------------------------------------------------------------------------
/tests/fixtures/crazy.py:
--------------------------------------------------------------------------------
1 | class ManimScene:
2 | def setup(self):
3 | self.my_variable = 42
4 |
5 | def construct(self):
6 | a = 5
7 |
8 | class InnerClass:
9 | def __init__(self):
10 | self.a = 5
11 |
12 | def inner_function(self):
13 | ## A Manim Cell
14 | a = 6
15 | b = 3
16 |
17 | # comment
18 | print(a + b)
19 |
20 | def this_is():
21 | def very():
22 | ## A cell here ;)
23 | def nested():
24 | # print()
25 | # print()
26 | # print()
27 | def even_more():
28 | print("Hello world")
29 |
30 | return nested
31 |
32 | return very
33 |
34 | print(this_is())
35 |
36 | # some comments
37 |
38 | ## A Manim Cell
39 | a = 6
40 | b = 3
41 | c = 42
42 |
43 | def inline_function():
44 | a = 5
45 | b = 6
46 | c = 7
47 | return a + b + c
48 |
49 | d = 5
50 | e = 6
51 | f = 8
52 |
53 | ## Another Manim cell
54 | a = 6
55 | b = 3
56 |
57 | # Important
58 | c = 42
59 | d = 5
60 | e = 6
61 | f = 8
62 |
63 | ## Another one
64 | # Here
65 | def inside():
66 | ## nested cells are not supported
67 | a = 5
68 |
69 | def another_function(self):
70 | print("Hello world")
71 |
--------------------------------------------------------------------------------
/tests/fixtures/detection_basic.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class BasicNotebook(Scene):
5 | def construct(self):
6 | ## A Manim Cell
7 | print("With some code")
8 | print("With some more code")
9 |
10 | ## And another Manim Cell
11 | print("And even more code")
12 |
13 |
14 | class BasicNotebookWithType(Scene):
15 |
16 | def construct(self) -> None:
17 | ## Cell inside construct(self) marked with "None" type
18 | print("With some code None")
19 | print("With some more code None")
20 |
21 |
22 | class NoManimScene(Scene):
23 | def constructtttt(self):
24 | ## Should not be detected as Manim Cell
25 | print("Hi there")
26 |
27 |
28 | class WithoutAnyManimCells(Scene):
29 | def construct(self):
30 | print("We have no ManimCell in here")
31 | print("And therefore also no ManimCell is detected")
32 |
--------------------------------------------------------------------------------
/tests/fixtures/detection_class_definition.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class AnythingElse:
5 | pass
6 |
7 |
8 | class Inheritance(AnythingElse):
9 | def construct(self):
10 | ## A Manim Cell
11 | print("With some code")
12 | print("With some more code")
13 |
14 | ## And another Manim Cell
15 | print("And even more code")
16 |
17 |
18 | class InheritanceNothing(): # don't remove "()" here (!)
19 | def construct(self):
20 | ## Should not be detected as Manim Cell
21 | print("With some code")
22 | print("With some more code")
23 |
24 | ## Should neither be detected as Manim Cell
25 | print("And even more code")
26 |
27 |
28 | class InheritanceNothingWithoutParentheses:
29 | def construct(self):
30 | ## Should not be detected as Manim Cell
31 | print("With some code")
32 | print("With some more code")
33 |
34 | ## Should neither be detected as Manim Cell
35 | print("And even more code")
36 |
--------------------------------------------------------------------------------
/tests/fixtures/detection_inside_construct.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class SceneDetectionInsideConstruct(Scene):
5 | def construct(self):
6 | ## A Manim Cell
7 | def some_function():
8 | ## Not a Manim Cell, instead part of the outer one
9 | print("Not a Manim Cell")
10 |
11 | print("With some code")
12 | some_function()
13 | print("With some more code")
14 |
15 | ## And another Manim Cell
16 | print("And even more code")
17 | some_function()
18 |
--------------------------------------------------------------------------------
/tests/fixtures/detection_multiple_inheritance.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class BasicNotebook(Scene):
5 | def construct(self):
6 | ## A Manim Cell
7 | print("With some code")
8 | print("With some more code")
9 |
10 | ## And another Manim Cell
11 | print("And even more code")
12 |
13 | class AnInvalidManimScene(Scene):
14 | def construct(self):
15 | ## Not a Manim Cell, but still detected as one
16 | # We mark this as undefined behavior and Manim does not support
17 | # a scene inside another scene.
18 | # We still consider this as a Manim Cell since detecting this
19 | # case would be too cumbersome to be worth it to consider.
20 | # The user will find out in Manim itself that this is not
21 | # supported.
22 | print("Not a valid Manim Scene")
23 |
24 |
25 | class BaseClass(Scene):
26 | def setup(self):
27 | print("Setting up")
28 |
29 |
30 | class SubClass(BaseClass):
31 | def construct(self):
32 | ## A Manim Cell in a subclass
33 | print("Constructing")
34 | print("Hey there")
35 |
36 | ## Another Manim Cell in a subclass
37 | print("Constructing more")
38 |
--------------------------------------------------------------------------------
/tests/fixtures/detection_multiple_methods.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class MultipleMethods(Scene):
5 | def construct(self):
6 | ## A Manim Cell
7 | print("With some code")
8 | print("With some more code")
9 |
10 | ## And another Manim Cell
11 | print("And even more code")
12 |
13 | def another_construct(self):
14 | ## Should not be detected as Manim Cell
15 | print("Hi there from another construct method")
16 |
--------------------------------------------------------------------------------
/tests/fixtures/detection_syntax.py:
--------------------------------------------------------------------------------
1 | from manimlib import *
2 |
3 |
4 | class Syntax(Scene):
5 | def construct(self):
6 | ## A Manim Cell
7 | print("Hello, Manim!")
8 |
9 | # Not a Manim Cell, just a regular comment
10 | print("Not a Manim Cell")
11 |
12 | ### A Manim Cell
13 | print("Hello, Manim!")
14 |
15 | ########## # # # # A Manim Cell
16 | print("Hello, Manim!")
17 |
18 | ## A Manim Cell without any code
19 |
20 | ## Another empty Manim Cell
21 |
22 |
23 | class SyntaxNotAtStart(Scene):
24 | def construct(self):
25 | print("test")
26 | ## Empty Manim Cell, should start here, not at the line before
27 |
28 |
29 | class WithoutNewLine(Scene):
30 | def construct(self):
31 | print("test")
32 | ## First ManimCell
33 | print("yeah")
34 | ## Second ManimCell
35 | print("yeah2")
36 | ## Third ManimCell
37 | ## Fourth ManimCell
38 |
--------------------------------------------------------------------------------
/tests/fixtures/laggy.py:
--------------------------------------------------------------------------------
1 | # from https://github.com/Manim-Notebook/manim-notebook/issues/18#issuecomment-2431224967
2 | from manimlib import *
3 |
4 |
5 | class Laggy(Scene):
6 |
7 | def construct(self):
8 | ## Create some boxes
9 | grid = Square().get_grid(35, 35, buff=0)
10 | grid.set_height(5)
11 | grid.set_stroke(WHITE)
12 | self.play(ShowCreation(grid))
13 |
14 | ## Move the boxes
15 | position = ValueTracker(0)
16 | grid.add_updater(
17 | lambda m, position=position: m.move_to((position.get_value(), 0, 0))
18 | )
19 | self.play(position.animate.set_value(2), run_time=5)
20 |
21 | ## Move boxes back
22 | self.play(position.animate.set_value(0), run_time=5)
23 |
--------------------------------------------------------------------------------
/tests/main.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Main entry point for tests. Uses the @vscode/test-electron API to simplify
3 | * the process of downloading, unzipping, and launching VSCode with extension
4 | * test parameters.
5 | *
6 | * This is only used when you call "npm test" in the terminal and not when you
7 | * run the tests from the debug panel. For the latter, we have a custom
8 | * launch task in .vscode/launch.json.
9 | *
10 | * Adapted from the VSCode testing extension guide [1].
11 | * File on Github: [2].
12 | *
13 | * [1] https://code.visualstudio.com/api/working-with-extensions/testing-extension#advanced-setup-your-own-runner
14 | * [2] https://github.com/microsoft/vscode-extension-samples/blob/main/helloworld-test-sample/src/test/runTest.ts
15 | */
16 |
17 | import * as path from "path";
18 |
19 | import { runTests } from "@vscode/test-electron";
20 |
21 | /**
22 | * Main entry point for tests from the "npm test" script. This is not called
23 | * when you run the tests from the debug panel via the custom launch task in
24 | * .vscode/launch.json.
25 | */
26 | async function main() {
27 | try {
28 | // Folder containing the extension manifest package.json
29 | // Passed to `--extensionDevelopmentPath`
30 | const extensionDevelopmentPath = path.resolve(__dirname, "../../");
31 |
32 | // Path to the extension test script
33 | // Passed to --extensionTestsPath
34 | const extensionTestsPath = path.resolve(__dirname, "./utils/testRunner");
35 |
36 | // Download VS Code, unzip it and run the integration test
37 | await runTests({
38 | extensionDevelopmentPath,
39 | extensionTestsPath,
40 | launchArgs: [
41 | "tests/fixtures",
42 | "--disable-extensions",
43 | ],
44 | // handled in the testRunner
45 | extensionTestsEnv: {
46 | IS_CALLED_IN_NPM_SCRIPT: "true",
47 | EXTENSION_DEV_PATH: extensionDevelopmentPath,
48 | },
49 | });
50 | } catch {
51 | console.error("Failed to run tests");
52 | process.exit(1);
53 | }
54 | }
55 |
56 | main();
57 |
--------------------------------------------------------------------------------
/tests/preview.test.ts:
--------------------------------------------------------------------------------
1 | import { before, describe, it } from "mocha";
2 | import { commands, window } from "vscode";
3 | import { goToLine } from "./utils/editor";
4 | import { onAnyTerminalOutput } from "./utils/terminal";
5 | import { uriInWorkspace } from "./utils/testRunner";
6 | let expect: Chai.ExpectStatic;
7 |
8 | before(async () => {
9 | // why this weird import syntax?
10 | // -> see https://github.com/microsoft/vscode/issues/130367
11 | const chai = await import("chai");
12 | expect = chai.expect;
13 | });
14 |
15 | describe("Previewing", function () {
16 | it("Can preview the current Manim Cell", async () => {
17 | const editor = await window.showTextDocument(uriInWorkspace("basic.py"));
18 | goToLine(editor, 11);
19 | await commands.executeCommand("manim-notebook.previewManimCell");
20 |
21 | return new Promise((resolve) => {
22 | onAnyTerminalOutput(async (data, stopListening) => {
23 | if (data.includes("ReplacementTransformCircle")) {
24 | stopListening();
25 | await commands.executeCommand("manim-notebook.exitScene");
26 | setTimeout(resolve, 1500);
27 | }
28 | });
29 | });
30 | });
31 |
32 | it("Can preview laggy scene", async () => {
33 | const editor = await window.showTextDocument(uriInWorkspace("laggy.py"));
34 | const queue: { line: number; waitForStrings: string[]; resolve: () => void }[] = [];
35 | let wantToStopListening = false;
36 |
37 | onAnyTerminalOutput(async (data, stopListening) => {
38 | if (wantToStopListening) {
39 | stopListening();
40 | return;
41 | }
42 | if (queue.length === 0) {
43 | throw new Error("Listening to terminal output, but nothing in queue to check against");
44 | }
45 |
46 | const { waitForStrings } = queue[0];
47 | for (const str of waitForStrings) {
48 | if (data.includes(str)) {
49 | waitForStrings.removeByValue(str);
50 | }
51 | }
52 | if (waitForStrings.length === 0) {
53 | queue.shift()?.resolve();
54 | }
55 | });
56 |
57 | async function testPreviewAtLine(line: number, waitForStrings: string[]) {
58 | goToLine(editor, line);
59 | await commands.executeCommand("manim-notebook.previewManimCell");
60 | await new Promise((resolve) => {
61 | queue.push({ line, waitForStrings, resolve });
62 | });
63 | }
64 |
65 | await testPreviewAtLine(8, ["ShowCreationVGroup", "In [2]:"]);
66 | await testPreviewAtLine(14, ["_MethodAnimationValueTracker", "In [3]:"]);
67 | await testPreviewAtLine(21, ["_MethodAnimationValueTracker", "In [4]:"]);
68 | await testPreviewAtLine(14, ["_MethodAnimationValueTracker", "In [5]:"]);
69 |
70 | wantToStopListening = true; // cleanup for subsequent tests
71 | expect(queue.length).to.equal(0);
72 |
73 | await commands.executeCommand("manim-notebook.exitScene");
74 | await new Promise(resolve => setTimeout(resolve, 1000));
75 | });
76 | });
77 |
--------------------------------------------------------------------------------
/tests/scripts/setTestEntryPoint.js:
--------------------------------------------------------------------------------
1 | const fs = require("fs");
2 | const path = require("path");
3 |
4 | const packageJsonPath = path.resolve(__dirname, "../../package.json");
5 | const packageJson = require(packageJsonPath);
6 |
7 | function setTestEntryPointForTest() {
8 | packageJson.main = "./out-test/src/extension.js";
9 | fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
10 | }
11 |
12 | function resetEntryPoint() {
13 | packageJson.main = "./dist/extension.js";
14 | fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
15 | }
16 |
17 | if (process.argv[2] === "set") {
18 | setTestEntryPointForTest();
19 | } else if (process.argv[2] === "reset") {
20 | resetEntryPoint();
21 | }
22 |
--------------------------------------------------------------------------------
/tests/utils/editor.ts:
--------------------------------------------------------------------------------
1 | import { Selection, TextEditor } from "vscode";
2 |
3 | /**
4 | * Moves the cursor to the specified line number.
5 | *
6 | * @param editor The editor to move the cursor in.
7 | * @param lineNumber The line number to move the cursor to (1-indexed).
8 | *
9 | * Adapted from:
10 | * https://github.com/microsoft/vscode/issues/6695#issuecomment-221146568
11 | */
12 | export function goToLine(editor: TextEditor, lineNumber: number) {
13 | let range = editor.document.lineAt(lineNumber - 1).range;
14 | editor.selection = new Selection(range.start, range.end);
15 | editor.revealRange(range);
16 | }
17 |
--------------------------------------------------------------------------------
/tests/utils/installManim.ts:
--------------------------------------------------------------------------------
1 | import * as path from "path";
2 | import { ManimInstaller } from "./manimInstaller";
3 |
4 | async function setupManimInstallation() {
5 | const baseFolder = process.cwd();
6 | const tmpFolder = path.join(baseFolder, "tmp");
7 | console.log(`Temporary folder: ${tmpFolder}`);
8 |
9 | const installer = new ManimInstaller();
10 | await installer.setup(tmpFolder);
11 | await installer.download();
12 | await installer.install();
13 | await installer.installAdditionalDependencies();
14 | await installer.verifyInstallation();
15 |
16 | console.log("💫 If started via debug configuration,"
17 | + "go to the VSCode debug console to see the test output.");
18 | }
19 |
20 | (async () => {
21 | await setupManimInstallation();
22 | })();
23 |
--------------------------------------------------------------------------------
/tests/utils/manimCaller.ts:
--------------------------------------------------------------------------------
1 | import * as path from "path";
2 | import { window } from "vscode";
3 |
4 | export class ManimCaller {
5 | public venvPath: string = "";
6 |
7 | async callManim(args: string) {
8 | if (!this.venvPath) {
9 | throw new Error("Python virtual environment path not set (in ManimCaller).");
10 | }
11 |
12 | const terminal = await window.createTerminal("Manim");
13 | terminal.show();
14 |
15 | const activatePath = path.join(this.venvPath, "bin", "activate");
16 | console.log(`▶️ Calling Manimgl ${args}`);
17 | terminal.sendText(`. ${activatePath} && manimgl ${args}`);
18 | await new Promise(resolve => setTimeout(resolve, 5000));
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/tests/utils/manimInstaller.ts:
--------------------------------------------------------------------------------
1 | import { exec } from "child_process";
2 | import { existsSync, mkdirSync } from "fs";
3 | import * as path from "path";
4 |
5 | function run(cmd: string, ...args: any): Promise {
6 | const promise = new Promise((resolve, reject) => {
7 | console.log(`▶️ Running command: ${cmd}`);
8 | exec(cmd, ...args, (error: Error, stdout: string | Buffer, stderr: string | Buffer) => {
9 | let errorMessage = error?.message || stderr;
10 | if (errorMessage) {
11 | if (errorMessage.includes("ffmpeg")) {
12 | console.error("🔥 ffmpeg warning detected -> will be ignored:");
13 | console.error(errorMessage);
14 | } else if (errorMessage.includes("VK_ERROR_INCOMPATIBLE_DRIVER")) {
15 | // https://gitlab.freedesktop.org/mesa/mesa/-/issues/10293
16 | // MESA: error:
17 | // ZINK: vkCreateInstance failed (VK_ERROR_INCOMPATIBLE_DRIVER)
18 | console.error("🔥 ZINK: vkCreateInstance warning detected -> will be ignored:");
19 | console.error(errorMessage);
20 | } else {
21 | console.error("🔥 Error while running command");
22 | if (error) return reject(error);
23 | if (stderr) return reject(stderr);
24 | }
25 | }
26 | console.log(stdout);
27 | resolve(stdout);
28 | });
29 | });
30 | promise.catch((err) => {
31 | console.error("Caught error in promise");
32 | console.error(err);
33 | });
34 | return promise;
35 | }
36 |
37 | /**
38 | * Helper class to install Manim and set up the Python virtual environment.
39 | * We expect that the setup() method is the first one to be called.
40 | */
41 | export class ManimInstaller {
42 | /**
43 | * Path to the path where Manim will be installed to.
44 | */
45 | private manimPath: string = "";
46 |
47 | /**
48 | * Path to the virtual Python environment.
49 | */
50 | private venvPath: string = "";
51 |
52 | /**
53 | * Name of the Python binary.
54 | */
55 | private pythonBinary = process.platform === "win32" ? "python" : "python3";
56 |
57 | /**
58 | * Sets up the Manim installation path.
59 | *
60 | * @param tmpFolder The path for a temporary folder where we can install
61 | * Manim and the Python virtual environment to.
62 | */
63 | public async setup(tmpFolder: string) {
64 | console.log("🎈 SETTING UP MANIM INSTALLATION");
65 |
66 | // Manim installation path
67 | this.manimPath = path.join(tmpFolder, "manim");
68 | if (!existsSync(this.manimPath)) {
69 | mkdirSync(this.manimPath, { recursive: true });
70 | }
71 |
72 | console.log(`🍭 Manim installation path: ${this.manimPath}`);
73 |
74 | // Python virtual environment path
75 | this.venvPath = path.join(tmpFolder, "manimVenv");
76 | console.log(`🍭 Python virtual environment path: ${this.venvPath}`);
77 | await run(`${this.pythonBinary} -m venv ${this.venvPath}`);
78 | await this.runWithVenvBin(`${this.pythonBinary} --version`);
79 | await this.runWithVenvBin("pip config set global.disable-pip-version-check true");
80 | }
81 |
82 | /**
83 | * Checks if Manim is already downloaded (just a rudimentary check).
84 | */
85 | private async isAlreadyDownloaded() {
86 | const exists = existsSync(this.manimPath);
87 | if (!exists) {
88 | return false;
89 | }
90 | const files = await run(`ls -A ${this.manimPath}`);
91 | return files.length > 0;
92 | }
93 |
94 | /**
95 | * Downloads Manim from the official repository if not already done.
96 | */
97 | public async download() {
98 | if (await this.isAlreadyDownloaded()) {
99 | console.log("🎁 Manim already downloaded");
100 | return;
101 | }
102 |
103 | console.log("🎁 Downloading Manim... (this might take a while)");
104 | // 2>&1 redirects stderr to stdout since git writes to stderr for
105 | // diagnostic messages and we don't want to reject the promise in that case.
106 | await run(`git clone --depth 1 https://github.com/3b1b/manim.git ${this.manimPath} 2>&1`,
107 | { cwd: this.manimPath });
108 | }
109 |
110 | /**
111 | * Installs Manim as (editable) Python package.
112 | */
113 | public async install() {
114 | const pipList = await this.runWithVenvBin("pip list");
115 | if (pipList.toLowerCase().includes("manimgl")) {
116 | console.log("❇️ Manim already installed via pip");
117 | return;
118 | }
119 | console.log("❇️ Installing Manim...");
120 | await this.runWithVenvBin(`pip install -e ${this.manimPath}`);
121 | console.log("❇️ Manim successfully installed");
122 | }
123 |
124 | /**
125 | * Installs additional dependencies for Manim.
126 | */
127 | public async installAdditionalDependencies() {
128 | console.log("🔧 Installing additional dependencies...");
129 | await this.runWithVenvBin("pip install setuptools");
130 |
131 | const pythonVersion = await this.runWithVenvBin(`${this.pythonBinary} --version`);
132 | if (pythonVersion.includes("3.13")) {
133 | // https://github.com/jiaaro/pydub/issues/815
134 | await this.runWithVenvBin("pip install audioop-lts");
135 | }
136 |
137 | if (process.platform === "linux") {
138 | await this.runWithVenvBin("pip install PyOpenGL");
139 | }
140 |
141 | console.log("🔧 Additional dependencies successfully installed");
142 | }
143 |
144 | /**
145 | * Verifies the Manim installation.
146 | */
147 | public async verifyInstallation() {
148 | console.log("🔍 Verifying Manim installation");
149 | await this.runWithVenvBin("manimgl --version");
150 | }
151 |
152 | /**
153 | * Runs a command using the respective binary from the Python virtual
154 | * environment.
155 | *
156 | * @param binPath The path to the bin folder of the virtual Python
157 | * environment. This path will be prefixed to every command, e.g.
158 | * `manimgl --version` becomes
159 | * `/path/to/venv/bin/manimgl --version`.
160 | */
161 | private runWithVenvBin(cmd: string): Promise {
162 | if (!this.venvPath) {
163 | throw new Error("Python virtual environment not set up yet.");
164 | }
165 | const binFolderName = process.platform === "win32" ? "Scripts" : "bin";
166 | const binPath = path.join(this.venvPath, binFolderName);
167 | return run(path.join(binPath, cmd));
168 | }
169 | }
170 |
--------------------------------------------------------------------------------
/tests/utils/prototype.ts:
--------------------------------------------------------------------------------
1 | declare global {
2 | interface Array {
3 | removeByValue(_value: T): Array;
4 | }
5 | }
6 |
7 | /**
8 | * Removes the first occurrence of the specified value from the array.
9 | *
10 | * From https://stackoverflow.com/a/5767332/9655481
11 | *
12 | * @param value The value to remove.
13 | */
14 | Array.prototype.removeByValue = function (value: any) {
15 | for (var i = 0; i < this.length; i++) {
16 | if (this[i] === value) {
17 | this.splice(i, 1);
18 | i--;
19 | }
20 | }
21 | return this;
22 | };
23 |
--------------------------------------------------------------------------------
/tests/utils/terminal.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import { window } from "vscode";
3 | import { withoutAnsiCodes } from "../../src/utils/terminal";
4 |
5 | /**
6 | * Registers a callback to read the stdout from the terminal. The callback is
7 | * invoked whenever any terminal emits output. The output is cleaned from
8 | * ANSI control codes by default.
9 | *
10 | * This function should only be called once in every test it() block at the
11 | * beginning. Otherwise, subsequent calls might not yield the expected results.
12 | *
13 | * @param callback The callback to invoke when output is emitted.
14 | * @param shouldLog Whether to log the terminal output to the console.
15 | * @param withoutAnsi Whether to clean the output from ANSI control codes.
16 | */
17 | export function onAnyTerminalOutput(
18 | callback: (_data: string, _stopListening: CallableFunction) => void,
19 | shouldLog = true,
20 | withoutAnsi = true): void {
21 | const listener = window.onDidStartTerminalShellExecution(
22 | async (event: vscode.TerminalShellExecutionStartEvent) => {
23 | let stream = event.execution.read();
24 | if (withoutAnsi) {
25 | stream = withoutAnsiCodes(stream);
26 | }
27 |
28 | const stopListening = () => {
29 | shouldLog = false;
30 | listener.dispose();
31 | };
32 |
33 | for await (const data of stream) {
34 | if (shouldLog) {
35 | console.log(`Terminal output: ${data}`);
36 | }
37 | callback(data, stopListening);
38 | }
39 | });
40 | }
41 |
--------------------------------------------------------------------------------
/tests/utils/testRunner.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Test runner script that programmatically runs the test suite using Mocha.
3 | * Also see the Mocha API: https://mochajs.org/api/mocha
4 | *
5 | * Adapted from the VSCode testing extension guide [1].
6 | * File on Github: [2].
7 | *
8 | * [1] https://code.visualstudio.com/api/working-with-extensions/testing-extension#advanced-setup-your-own-runner
9 | * [2] https://github.com/microsoft/vscode-extension-samples/blob/main/helloworld-test-sample/src/test/suite/index.ts
10 | */
11 |
12 | // import as soon as possible
13 | import { activatedEmitter } from "../../src/extension";
14 |
15 | import * as assert from "assert";
16 | import { globSync } from "glob";
17 | import Mocha from "mocha";
18 | import * as path from "path";
19 | import "source-map-support/register";
20 | import "./prototype";
21 |
22 | import { Uri, extensions, window, workspace } from "vscode";
23 |
24 | const WORKSPACE_ROOT: string = workspace.workspaceFolders![0].uri.fsPath;
25 |
26 | /**
27 | * Returns a Uri object for a file path relative to the workspace root.
28 | */
29 | export function uriInWorkspace(pathRelativeToWorkspaceRoot: string): Uri {
30 | const fullPath = path.join(WORKSPACE_ROOT, pathRelativeToWorkspaceRoot);
31 | return Uri.file(fullPath);
32 | }
33 |
34 | /**
35 | * Runs the test suite.
36 | *
37 | * Note that this function is called from the launch.json test configuration
38 | * as well as when you execute "npm test" manually (in the latter case, from
39 | * the main() function in main.ts).
40 | */
41 | export function run(): Promise {
42 | const mocha = new Mocha({
43 | ui: "tdd",
44 | timeout: 45000,
45 | color: true,
46 | });
47 |
48 | console.log(`💠 workspaceRoot: ${WORKSPACE_ROOT}`);
49 | assert.ok(WORKSPACE_ROOT.endsWith("fixtures"));
50 | const files: string[] = globSync("**", { cwd: WORKSPACE_ROOT });
51 | console.log(`💠 files in root: ${files}`);
52 |
53 | return new Promise(async (resolve, reject) => {
54 | try {
55 | const testsRoot = path.resolve(__dirname, "..");
56 | console.log(`💠 testsRoot: ${testsRoot}`);
57 |
58 | const files: string[] = globSync("**/**.test.js",
59 | { cwd: testsRoot, ignore: ["**/node_modules/**"] });
60 | files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)));
61 |
62 | if (process.env.IS_CALLED_IN_NPM_SCRIPT !== "true") {
63 | console.log("💠 Tests requested via debug configuration");
64 | // respective env variables are set in launch.json
65 | } else {
66 | process.env.IS_TESTING = "true";
67 | process.env.TEST_BASE_PATH = process.env.EXTENSION_DEV_PATH;
68 | console.log("💠 Tests requested via npm script");
69 | }
70 |
71 | // open any python file to trigger extension activation
72 | await window.showTextDocument(uriInWorkspace("basic.py"));
73 |
74 | const extension = await extensions.getExtension("manim-notebook.manim-notebook");
75 | if (extension?.isActive) {
76 | console.log("💠 Extension is detected as *activated*");
77 | } else {
78 | console.log("💠 Waiting for extension activation...");
79 | await waitUntilExtensionActivated();
80 | console.log("💠 Extension activation detected in tests");
81 | }
82 |
83 | console.log("Running tests...");
84 | mocha.run((failures: any) => {
85 | if (failures > 0) {
86 | reject(new Error(`${failures} tests failed.`));
87 | } else {
88 | resolve();
89 | }
90 | });
91 | } catch (err) {
92 | console.error(err);
93 | reject(err);
94 | }
95 | });
96 | }
97 |
98 | /**
99 | * Waits until the Manim Notebook extension is activated.
100 | */
101 | async function waitUntilExtensionActivated(): Promise {
102 | await new Promise((resolve, reject) => {
103 | activatedEmitter.on("activated", () => resolve());
104 | setTimeout(() => {
105 | reject(new Error("Extension activation timeout"));
106 | }, 20000);
107 | });
108 | }
109 |
--------------------------------------------------------------------------------
4 |
5 |
6 | 
5 |
6 |