8918468448

Committed 02 May 2024 04:07AM UTC coverage: 75.329% (-0.9%) from 76.231%

Build # 8918468448

Build Type

push

github

Committed by

g-arjones

Commit Message

Implement setupRubyExtension command

Run Details

328 of 349 branches covered (93.98%)

Branch coverage included in aggregate %.

56 of 101 new or added lines in 3 files covered. (55.45%)

2 existing lines in 1 file now uncovered.

1791 of 2464 relevant lines covered (72.69%)

8.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.45

/src/commands.ts

import { basename, dirname, join as pathjoin } from "path";
import * as yaml from "js-yaml";
import { CancellationTokenSource, QuickPickOptions, Uri } from "vscode";
import { fs } from "./cmt/pr";
import * as autoproj from "./autoproj";
import * as tasks from "./tasks";
import * as wrappers from "./wrappers";
import * as path from "path";
import { ShimsWriter } from "./shimsWriter";

export class Commands {
    constructor(private readonly _workspaces: autoproj.Workspaces,
                private readonly _vscode: wrappers.VSCode) {
    }

    public async showWorkspacePicker(): Promise<autoproj.Workspace | undefined> {
        if (this._workspaces.workspaces.size === 0) {
            throw new Error("No Autoproj workspace found");
        }
        const choices: Array<{ label, description, ws }> = [];
        function addChoice(workspace: autoproj.Workspace) {
            const choice = {
                description: basename(dirname(workspace.root)),
                label: basename(workspace.root),
                ws: workspace,
            };
            choices.push(choice);
        }
        if (this._workspaces.workspaces.size === 1) {
            return this._workspaces.workspaces.values().next().value;
        }
        this._workspaces.forEachWorkspace((workspace: autoproj.Workspace) => {
            addChoice(workspace);
        });
        const options: QuickPickOptions = {
            placeHolder: "Select a workspace",
        };
        const ws = await this._vscode.showQuickPick(choices, options);
        if (ws) {
            return ws.ws;
        }
    }

    public async updatePackageInfo() {
        try {
            const ws = await this.showWorkspacePicker();
            if (ws) {
                const allTasks = await this._vscode.fetchTasks(tasks.WORKSPACE_TASK_FILTER);
                const updateEnvironmentTask = allTasks.find((task) =>
                    task.definition.mode === tasks.WorkspaceTaskMode.UpdateEnvironment &&
                    task.definition.workspace === ws.root);

                this._vscode.executeTask(updateEnvironmentTask!);
            }
        } catch (err) {
            this._vscode.showErrorMessage(err.message);
        }
    }

    public async packagePickerChoices(): Promise<Array<{ label, description, pkg }>> {
        const choices: Array<{ label, description, pkg }> = [];
        const fsPathsObj = {};
        const wsInfos: Array<[autoproj.Workspace, Promise<autoproj.WorkspaceInfo>]> = [];

        this._workspaces.forEachWorkspace((ws) => wsInfos.push([ws, ws.info()]));
        if (this._vscode.workspaceFolders) {
            for (const folder of this._vscode.workspaceFolders) {
                fsPathsObj[folder.uri.fsPath] = true;
            }
        }
        for (const [ws, wsInfoP] of wsInfos) {
            try {
                const wsInfo = await wsInfoP;
                const buildconfPath = pathjoin(ws.root, "autoproj");
                if (!fsPathsObj.hasOwnProperty(buildconfPath)) {
                    const name = `autoproj`;
                    choices.push({
                        description: `${ws.name} (buildconf)`,
                        label: name,
                        pkg: { name: `autoproj (${ws.name})`, srcdir: buildconfPath },
                    });
                }
                for (const pkgSet of wsInfo.packageSets) {
                    if (!fsPathsObj.hasOwnProperty(pkgSet[1].user_local_dir)) {
                        choices.push({
                            description: `${ws.name} (package set)`,
                            label: pkgSet[1].name,
                            pkg: { name: `${pkgSet[1].name} (package set)`, srcdir: pkgSet[1].user_local_dir },
                        });
                    }
                }
                for (const aPkg of wsInfo.packages) {
                    if (!fsPathsObj.hasOwnProperty(aPkg[1].srcdir)) {
                        choices.push({
                            description: ws.name,
                            label: aPkg[1].name,
                            pkg: aPkg[1],
                        });
                    }
                }
            } catch (err) {
                throw new Error(`Could not load installation manifest: ${err.message}`);
            }
        }
        choices.sort((a, b) =>
            a.pkg.name < b.pkg.name ? -1 : a.pkg.name > b.pkg.name ? 1 : 0);
        return choices;
    }

    public async addPackageToWorkspace() {
        const tokenSource = new CancellationTokenSource();
        const options: QuickPickOptions = {
            matchOnDescription: true,
            placeHolder: "Select a package to add to this workspace",
        };
        const choices = this.packagePickerChoices();
        choices.catch((err) => {
            this._vscode.showErrorMessage(err.message);
            tokenSource.cancel();
        });

        const selectedOption = await this._vscode.showQuickPick(choices, options, tokenSource.token);

        tokenSource.dispose();
        if (selectedOption) {
            const wsFolders = this._vscode.workspaceFolders;
            let folders = wsFolders?.map((folder) => { return { name: folder.name, uri: folder.uri }; }) || [];
            folders = folders.concat({
                name: selectedOption.pkg.name,
                uri: Uri.file(selectedOption.pkg.srcdir),
            });

            const buildconfPaths = [...this._workspaces.workspaces.values()]
                .map((folder) => path.join(folder.root, "autoproj"));
            const buildconfs = folders.filter((folder) => buildconfPaths.includes(folder.uri.fsPath));
            folders = folders.filter((folder) => !buildconfs.includes(folder));
            const pkgSets = folders.filter(
                (folder) => buildconfPaths.some((configPath) => folder.uri.fsPath.startsWith(configPath)));
            const pkgs = folders.filter((folder) => !pkgSets.includes(folder));

            [buildconfs, pkgSets, pkgs].forEach(group => {
                group.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
            });

            if (!this._vscode.updateWorkspaceFolders(0, wsFolders?.length || null, ...buildconfs, ...pkgSets, ...pkgs)) {
                this._vscode.showErrorMessage(`Could not add folder: ${selectedOption.pkg.srcdir}`);
            }
        }
    }

    private _assertSingleAutoprojWorkspace(what: string) {
        const workspaces = [...this._workspaces.workspaces.values()];
        if (workspaces.length == 0) {
            throw new Error(`Cannot setup ${what} for an empty workspace`);
        } else if (workspaces.length > 1) {
            throw new Error(`Cannot setup ${what} for multiple Autoproj workspaces`);
        }
    }

    public async setupPythonDefaultInterpreter() {
        try {
            this._assertSingleAutoprojWorkspace("Python default interpreter");
            const workspaces = [...this._workspaces.workspaces.values()];
            const pythonShimPath = path.join(workspaces[0].root, ShimsWriter.RELATIVE_SHIMS_PATH, "python");
            this._vscode.getConfiguration().update("python.defaultInterpreterPath", pythonShimPath);
        } catch (error) {
            await this._vscode.showErrorMessage(error.message);
        }
    }

    private async _writeWorkspaceGemfile(ws: autoproj.Workspace) {
        try {
            const overridesPath = path.join(ws.root, "autoproj", "overrides.d");
            const gemfileContents = [
                '# frozen_string_literal: true',
                '# AUTO GENERATED BY THE VSCODE AUTOPROJ EXTENSION',
                'source "https://rubygems.org"',
                '',
                'gem "ruby-lsp"',
                'gem "debug"',
                ''
            ].join("\n");

            await fs.mkdir_p(overridesPath);
            await fs.writeFile(path.join(overridesPath, "vscode-autoproj.gemfile"), gemfileContents);
        } catch (error) {
            throw new Error(`Could not create the extension's Gemfile in 'autoproj/overrides.d': ${error.message}`);
        }
    }

    private async _updateRubyLspConfiguration(ws: autoproj.Workspace) {
        try {
            const shimsPath = path.join(ws.root, ShimsWriter.RELATIVE_SHIMS_PATH);
            const env: any = yaml.load(await fs.readFile(path.join(ws.root, ".autoproj", "env.yml")));
            const wsGemfile = env["set"]["BUNDLE_GEMFILE"][0];

            this._vscode.getConfiguration("rubyLsp").update("rubyVersionManager.identifier", "custom");
            this._vscode.getConfiguration("rubyLsp").update("customRubyCommand", `PATH=${shimsPath}:$PATH`);
            this._vscode.getConfiguration("rubyLsp").update("bundleGemfile", wsGemfile);
        } catch (error) {
            throw new Error(`Unable to read the workspaces's environment: ${error.message}`);
        }
    }

    public async setupRubyExtension() {
        try {
            this._assertSingleAutoprojWorkspace("Ruby extension");

            const ws = [...this._workspaces.workspaces.values()][0];
            this._writeWorkspaceGemfile(ws);
            this._updateRubyLspConfiguration(ws);

            const message = [
                `A vscode-autoproj.gemfile was created in 'autoproj/overrides.d' on the ${ws.name} workspace. `,
                'To complete the Ruby integration, please run "autoproj osdeps" on your workspace and restart vscode.'
            ]

            this._vscode.showInformationMessage(message.join(""), { modal: true });
        } catch (error) {
            await this._vscode.showErrorMessage(error.message);
        }
    }

    public register() {
        this._vscode.registerAndSubscribeCommand("autoproj.addPackageToWorkspace", () => {
            this.addPackageToWorkspace();
        });
        this._vscode.registerAndSubscribeCommand("autoproj.updatePackageInfo", () => { this.updatePackageInfo(); });
        this._vscode.registerAndSubscribeCommand("autoproj.setupRubyExtension", () => {
            this.setupRubyExtension();
        });
        this._vscode.registerAndSubscribeCommand("autoproj.setupPythonDefaultInterpreter", () => {
            this.setupPythonDefaultInterpreter();
        });
    }
}

1	import { basename, dirname, join as pathjoin } from "path";	1✔
2	import * as yaml from "js-yaml";	1✔
3	import { CancellationTokenSource, QuickPickOptions, Uri } from "vscode";	1✔
4	import { fs } from "./cmt/pr";	1✔
5	import * as autoproj from "./autoproj";	1✔
6	import * as tasks from "./tasks";	1✔
7	import * as wrappers from "./wrappers";	1✔
8	import * as path from "path";	1✔
9	import { ShimsWriter } from "./shimsWriter";	1✔
10		1✔
11	export class Commands {	1✔
12	constructor(private readonly _workspaces: autoproj.Workspaces,	1✔
13	private readonly _vscode: wrappers.VSCode) {	20✔
14	}	20✔
15		1✔
16	public async showWorkspacePicker(): Promise<autoproj.Workspace \| undefined> {	1✔
17	if (this._workspaces.workspaces.size === 0) {	4✔
18	throw new Error("No Autoproj workspace found");	1✔
19	}	1✔
20	const choices: Array<{ label, description, ws }> = [];	3✔
21	function addChoice(workspace: autoproj.Workspace) {	3✔
22	const choice = {	4✔
23	description: basename(dirname(workspace.root)),	4✔
24	label: basename(workspace.root),	4✔
25	ws: workspace,	4✔
26	};	4✔
27	choices.push(choice);	4✔
28	}	4✔
29	if (this._workspaces.workspaces.size === 1) {	4✔
30	return this._workspaces.workspaces.values().next().value;	1✔
31	}	1✔
32	this._workspaces.forEachWorkspace((workspace: autoproj.Workspace) => {	2✔
33	addChoice(workspace);	4✔
34	});	2✔
35	const options: QuickPickOptions = {	2✔
36	placeHolder: "Select a workspace",	2✔
37	};	2✔
38	const ws = await this._vscode.showQuickPick(choices, options);	2✔
39	if (ws) {	4✔
40	return ws.ws;	1✔
41	}	1✔
42	}	4✔
43		1✔
44	public async updatePackageInfo() {	1✔
45	try {	4✔
46	const ws = await this.showWorkspacePicker();	4✔
47	if (ws) {	4✔
48	const allTasks = await this._vscode.fetchTasks(tasks.WORKSPACE_TASK_FILTER);	2✔
49	const updateEnvironmentTask = allTasks.find((task) =>	2✔
50	task.definition.mode === tasks.WorkspaceTaskMode.UpdateEnvironment &&	1✔
51	task.definition.workspace === ws.root);	2✔
52		2✔
53	this._vscode.executeTask(updateEnvironmentTask!);	2✔
54	}	2✔
55	} catch (err) {	4✔
56	this._vscode.showErrorMessage(err.message);	2✔
57	}	2✔
58	}	4✔
59		1✔
60	public async packagePickerChoices(): Promise<Array<{ label, description, pkg }>> {	1✔
61	const choices: Array<{ label, description, pkg }> = [];	3✔
62	const fsPathsObj = {};	3✔
63	const wsInfos: Array<[autoproj.Workspace, Promise<autoproj.WorkspaceInfo>]> = [];	3✔
64		3✔
65	this._workspaces.forEachWorkspace((ws) => wsInfos.push([ws, ws.info()]));	3✔
66	if (this._vscode.workspaceFolders) {	3✔
67	for (const folder of this._vscode.workspaceFolders) {	1✔
68	fsPathsObj[folder.uri.fsPath] = true;	3✔
69	}	3✔
70	}	1✔
71	for (const [ws, wsInfoP] of wsInfos) {	3✔
72	try {	3✔
73	const wsInfo = await wsInfoP;	3✔
74	const buildconfPath = pathjoin(ws.root, "autoproj");	2✔
75	if (!fsPathsObj.hasOwnProperty(buildconfPath)) {	3✔
76	const name = `autoproj`;	1✔
77	choices.push({	1✔
78	description: `${ws.name} (buildconf)`,	1✔
79	label: name,	1✔
80	pkg: { name: `autoproj (${ws.name})`, srcdir: buildconfPath },	1✔
81	});	1✔
82	}	1✔
83	for (const pkgSet of wsInfo.packageSets) {	2✔
84	if (!fsPathsObj.hasOwnProperty(pkgSet[1].user_local_dir)) {	2✔
85	choices.push({	1✔
86	description: `${ws.name} (package set)`,	1✔
87	label: pkgSet[1].name,	1✔
88	pkg: { name: `${pkgSet[1].name} (package set)`, srcdir: pkgSet[1].user_local_dir },	1✔
89	});	1✔
90	}	1✔
91	}	2✔
92	for (const aPkg of wsInfo.packages) {	3✔
93	if (!fsPathsObj.hasOwnProperty(aPkg[1].srcdir)) {	4✔
94	choices.push({	3✔
95	description: ws.name,	3✔
96	label: aPkg[1].name,	3✔
97	pkg: aPkg[1],	3✔
98	});	3✔
99	}	3✔
100	}	4✔
101	} catch (err) {	3✔
102	throw new Error(`Could not load installation manifest: ${err.message}`);	1✔
103	}	1✔
104	}	3✔
105	choices.sort((a, b) =>	2✔
106	a.pkg.name < b.pkg.name ? -1 : a.pkg.name > b.pkg.name ? 1 : 0);	2!
107	return choices;	2✔
108	}	2✔
109		1✔
110	public async addPackageToWorkspace() {	1✔
111	const tokenSource = new CancellationTokenSource();	4✔
112	const options: QuickPickOptions = {	4✔
113	matchOnDescription: true,	4✔
114	placeHolder: "Select a package to add to this workspace",	4✔
115	};	4✔
116	const choices = this.packagePickerChoices();	4✔
117	choices.catch((err) => {	4✔
118	this._vscode.showErrorMessage(err.message);	1✔
119	tokenSource.cancel();	1✔
120	});	4✔
121		4✔
122	const selectedOption = await this._vscode.showQuickPick(choices, options, tokenSource.token);	4✔
123		4✔
124	tokenSource.dispose();	4✔
125	if (selectedOption) {	4✔
126	const wsFolders = this._vscode.workspaceFolders;	2✔
127	let folders = wsFolders?.map((folder) => { return { name: folder.name, uri: folder.uri }; }) \|\| [];	2✔
128	folders = folders.concat({	2✔
129	name: selectedOption.pkg.name,	2✔
130	uri: Uri.file(selectedOption.pkg.srcdir),	2✔
131	});	2✔
132		2✔
133	const buildconfPaths = [...this._workspaces.workspaces.values()]	2✔
134	.map((folder) => path.join(folder.root, "autoproj"));	2✔
135	const buildconfs = folders.filter((folder) => buildconfPaths.includes(folder.uri.fsPath));	2✔
136	folders = folders.filter((folder) => !buildconfs.includes(folder));	2✔
137	const pkgSets = folders.filter(	2✔
138	(folder) => buildconfPaths.some((configPath) => folder.uri.fsPath.startsWith(configPath)));	2✔
139	const pkgs = folders.filter((folder) => !pkgSets.includes(folder));	2✔
140		2✔
141	[buildconfs, pkgSets, pkgs].forEach(group => {	2✔
142	group.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);	6!
143	});	2✔
144		2✔
145	if (!this._vscode.updateWorkspaceFolders(0, wsFolders?.length \|\| null, ...buildconfs, ...pkgSets, ...pkgs)) {	2✔
146	this._vscode.showErrorMessage(`Could not add folder: ${selectedOption.pkg.srcdir}`);	1✔
147	}	1✔
148	}	2✔
149	}	4✔
150		1✔
151	private _assertSingleAutoprojWorkspace(what: string) {	1✔
152	const workspaces = [...this._workspaces.workspaces.values()];	3✔
153	if (workspaces.length == 0) {	3✔
154	throw new Error(`Cannot setup ${what} for an empty workspace`);	1✔
155	} else if (workspaces.length > 1) {	3✔
156	throw new Error(`Cannot setup ${what} for multiple Autoproj workspaces`);	1✔
157	}	1✔
158	}	3✔
159		1✔
160	public async setupPythonDefaultInterpreter() {	1✔
161	try {	3✔
162	this._assertSingleAutoprojWorkspace("Python default interpreter");	3✔
163	const workspaces = [...this._workspaces.workspaces.values()];	3✔
164	const pythonShimPath = path.join(workspaces[0].root, ShimsWriter.RELATIVE_SHIMS_PATH, "python");	3✔
165	this._vscode.getConfiguration().update("python.defaultInterpreterPath", pythonShimPath);	3✔
166	} catch (error) {	3✔
167	await this._vscode.showErrorMessage(error.message);	2✔
168	}	2✔
169	}	3✔
170		1✔
171	private async _writeWorkspaceGemfile(ws: autoproj.Workspace) {	1✔
NEW 172	try {	×
NEW 173	const overridesPath = path.join(ws.root, "autoproj", "overrides.d");	×
NEW 174	const gemfileContents = [	×
NEW 175	'# frozen_string_literal: true',	×
NEW 176	'# AUTO GENERATED BY THE VSCODE AUTOPROJ EXTENSION',	×
NEW 177	'source "https://rubygems.org"',	×
NEW 178	'',	×
NEW 179	'gem "ruby-lsp"',	×
NEW 180	'gem "debug"',	×
NEW 181	''	×
NEW 182	].join("\n");	×
UNCOV 183		×
NEW 184	await fs.mkdir_p(overridesPath);	×
NEW 185	await fs.writeFile(path.join(overridesPath, "vscode-autoproj.gemfile"), gemfileContents);	×
NEW 186	} catch (error) {	×
NEW 187	throw new Error(`Could not create the extension's Gemfile in 'autoproj/overrides.d': ${error.message}`);	×
NEW 188	}	×
NEW 189	}	×
190		1✔
191	private async _updateRubyLspConfiguration(ws: autoproj.Workspace) {	1✔
NEW 192	try {	×
NEW 193	const shimsPath = path.join(ws.root, ShimsWriter.RELATIVE_SHIMS_PATH);	×
NEW 194	const env: any = yaml.load(await fs.readFile(path.join(ws.root, ".autoproj", "env.yml")));	×
NEW 195	const wsGemfile = env["set"]["BUNDLE_GEMFILE"][0];	×
NEW 196		×
NEW 197	this._vscode.getConfiguration("rubyLsp").update("rubyVersionManager.identifier", "custom");	×
NEW 198	this._vscode.getConfiguration("rubyLsp").update("customRubyCommand", `PATH=${shimsPath}:$PATH`);	×
NEW 199	this._vscode.getConfiguration("rubyLsp").update("bundleGemfile", wsGemfile);	×
NEW 200	} catch (error) {	×
NEW 201	throw new Error(`Unable to read the workspaces's environment: ${error.message}`);	×
NEW 202	}	×
NEW 203	}	×
204		1✔
205	public async setupRubyExtension() {	1✔
NEW 206	try {	×
NEW 207	this._assertSingleAutoprojWorkspace("Ruby extension");	×
NEW 208		×
NEW 209	const ws = [...this._workspaces.workspaces.values()][0];	×
NEW 210	this._writeWorkspaceGemfile(ws);	×
NEW 211	this._updateRubyLspConfiguration(ws);	×
NEW 212		×
NEW 213	const message = [	×
NEW 214	`A vscode-autoproj.gemfile was created in 'autoproj/overrides.d' on the ${ws.name} workspace. `,	×
NEW 215	'To complete the Ruby integration, please run "autoproj osdeps" on your workspace and restart vscode.'	×
NEW 216	]	×
NEW 217		×
NEW 218	this._vscode.showInformationMessage(message.join(""), { modal: true });	×
NEW 219	} catch (error) {	×
NEW 220	await this._vscode.showErrorMessage(error.message);	×
NEW 221	}	×
UNCOV 222	}	×
223		1✔
224	public register() {	1✔
225	this._vscode.registerAndSubscribeCommand("autoproj.addPackageToWorkspace", () => {	2✔
226	this.addPackageToWorkspace();	1✔
227	});	2✔
228	this._vscode.registerAndSubscribeCommand("autoproj.updatePackageInfo", () => { this.updatePackageInfo(); });	2✔
229	this._vscode.registerAndSubscribeCommand("autoproj.setupRubyExtension", () => {	2✔
230	this.setupRubyExtension();	1✔
231	});	2✔
232	this._vscode.registerAndSubscribeCommand("autoproj.setupPythonDefaultInterpreter", () => {	2✔
233	this.setupPythonDefaultInterpreter();	1✔
234	});	2✔
235	}	2✔
236	}	1✔

g-arjones / vscode-autoproj / 8918468448

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous