6819934160

Committed 10 Nov 2023 02:15AM UTC coverage: 87.225% (-0.03%) from 87.257%

Build # 6819934160

Build Type

Pull #1502

github

Committed by

web-flow

Commit Message

Merge 2cb6c9646 into 41b0600cb

Pull Request Pull Request #1502: feat: add support for JSON files in editors

Run Details

954 of 1189 branches covered (0.0%)

Branch coverage included in aggregate %.

10 of 12 new or added lines in 5 files covered. (83.33%)

5 existing lines in 3 files now uncovered.

3682 of 4126 relevant lines covered (89.24%)

32.11 hits per line

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

89.84

/src/renderer/remote-loader.ts

import semver from 'semver';

import { ELECTRON_ORG, ELECTRON_REPO } from './constants';
import { AppState } from './state';
import { disableDownload } from './utils/disable-download';
import { isKnownFile, isSupportedFile } from './utils/editor-utils';
import { getOctokit } from './utils/octokit';
import { getReleaseChannel } from './versions';
import {
  EditorId,
  EditorValues,
  ElectronReleaseChannel,
  GenericDialogType,
  InstallState,
  PACKAGE_NAME,
  VersionSource,
} from '../interfaces';

export class RemoteLoader {
  constructor(private readonly appState: AppState) {
    for (const name of [
      'fetchExampleAndLoad',
      'fetchGistAndLoad',
      'handleLoadingFailed',
      'handleLoadingSuccess',
      'loadFiddleFromElectronExample',
      'loadFiddleFromGist',
      'setElectronVersion',
      'verifyReleaseChannelEnabled',
      'verifyRemoteLoad',
    ] as const) {
      this[name] = this[name].bind(this);
    }
  }

  public async loadFiddleFromElectronExample(exampleInfo: {
    path: string;
    tag: string;
  }) {
    console.log(`Loading fiddle from Electron example`, exampleInfo);
    const { path, tag } = exampleInfo;
    const prettyName = path.replace('docs/fiddles/', '');
    const ok = await this.verifyRemoteLoad(
      `'${prettyName}' example from the Electron docs for version ${tag}`,
    );
    if (!ok) return;

    this.fetchExampleAndLoad(tag, path);
  }

  public async loadFiddleFromGist(gistInfo: { id: string }) {
    const { id } = gistInfo;
    const ok = await this.verifyRemoteLoad(`gist`);
    if (!ok) return;

    this.fetchGistAndLoad(id);
  }

  public async fetchExampleAndLoad(
    tag: string,
    path: string,
  ): Promise<boolean> {
    try {
      const octo = await getOctokit(this.appState);
      const folder = await octo.repos.getContents({
        owner: ELECTRON_REPO,
        repo: ELECTRON_ORG,
        ref: tag,
        path,
      });

      const index = tag.search(/\d/);
      const version = tag.substring(index);

      if (!semver.valid(version)) {
        throw new Error('Could not determine Electron version for example');
      }

      const ok = await this.setElectronVersion(version);
      if (!ok) return false;

      const values = await window.ElectronFiddle.getTemplate(
        this.appState.version,
      );
      if (!Array.isArray(folder.data)) {
        throw new Error(
          'The example Fiddle tried to launch is not a valid Electron example',
        );
      }

      const loaders: Array<Promise<void>> = [];

      for (const child of folder.data) {
        if (!child.download_url) {
          console.warn(`Could not find download_url for ${child.name}`);
          continue;
        }

        if (isSupportedFile(child.name)) {
          loaders.push(
            fetch(child.download_url)
              .then((r) => r.text())
              .then((t) => {
                values[child.name as EditorId] = t;
              }),
          );
        }
      }

      await Promise.all(loaders);

      return this.handleLoadingSuccess(values, '');
    } catch (error) {
      return this.handleLoadingFailed(error);
    }
  }

  /**
   * Load a fiddle
   */
  public async fetchGistAndLoad(gistId: string): Promise<boolean> {
    try {
      const octo = await getOctokit(this.appState);
      const gist = await octo.gists.get({ gist_id: gistId });
      const values: EditorValues = {};

      for (const [id, data] of Object.entries(gist.data.files)) {
        const content = data.truncated
          ? await fetch(data.raw_url).then((r) => r.text())
          : data.content;
        const isPackageJson = id === PACKAGE_NAME;
        if (isPackageJson) {
          const { dependencies, devDependencies } = JSON.parse(content);
          const deps: Record<string, string> = {
            ...dependencies,
            ...devDependencies,
          };

          // If the gist specifies an Electron version, we want to tell Fiddle to run
          // it with that version by default.
          const electronDeps = Object.keys(deps).filter((d) =>
            ['electron-nightly', 'electron'].includes(d),
          );
          for (const dep of electronDeps) {
            // Strip off semver range prefixes, e.g:
            // ^1.2.0 -> 1.2.0
            // ~2.3.4 -> 2.3.4
            const index = deps[dep].search(/\d/);
            const version = deps[dep].substring(index);

            if (
              !semver.valid(version) ||
              !(await window.ElectronFiddle.isReleasedMajor(
                semver.major(version),
              ))
            ) {
              await this.appState.showGenericDialog({
                label: `The Electron version (${version}) in this gist's package.json is invalid. Falling back to last used version.`,
                ok: 'Close',
                type: GenericDialogType.warning,
                wantsInput: false,
              });
            } else if (disableDownload(version)) {
              await this.appState.showGenericDialog({
                label: `This gist's Electron version (${version}) is not available on your current OS. Falling back to last used version.`,
                ok: 'Close',
                type: GenericDialogType.warning,
                wantsInput: false,
              });
            } else {
              this.setElectronVersion(version);
            }

            // We want to include all dependencies except Electron.
            delete deps[dep];
          }

          this.appState.modules = new Map(Object.entries(deps));
        }

        // JSON files are supported, but we don't want to add package.json
        // to the visible editor array.
        if (!isSupportedFile(id) && !isPackageJson) continue;

        if (isKnownFile(id) || (await this.confirmAddFile(id))) {
          values[id] = content;
        }
      }

      // If no files were populated into values, the Fiddle did not
      // contain any supported files. Throw an error to let the user know.
      if (Object.keys(values).length === 0) {
        throw new Error(
          'This Gist did not contain any supported files. Supported files must have one of the following extensions: .js, .css, or .html.',
        );
      }

      return this.handleLoadingSuccess(values, gistId);
    } catch (error) {
      return this.handleLoadingFailed(error);
    }
  }

  public async setElectronVersion(version: string): Promise<boolean> {
    if (!this.appState.hasVersion(version)) {
      const versionToDownload = {
        source: VersionSource.remote,
        state: InstallState.missing,
        version,
      };

      try {
        this.appState.addNewVersions([versionToDownload]);
        await this.appState.downloadVersion(versionToDownload);
      } catch {
        await this.appState.removeVersion(versionToDownload);
        this.handleLoadingFailed(
          new Error(`Failed to download Electron version ${version}`),
        );
        return false;
      }
    }

    // check if version is part of release channel
    const versionReleaseChannel: ElectronReleaseChannel =
      getReleaseChannel(version);

    if (!this.appState.channelsToShow.includes(versionReleaseChannel)) {
      const ok = await this.verifyReleaseChannelEnabled(versionReleaseChannel);
      if (!ok) return false;

      this.appState.channelsToShow.push(versionReleaseChannel);
    }

    this.appState.setVersion(version);
    return true;
  }

  public confirmAddFile = (filename: string): Promise<boolean> => {
    return this.appState.showConfirmDialog({
      cancel: 'Skip',
      label: `Do you want to add "${filename}"?`,
      ok: 'Add',
    });
  };

  /**
   * Verifies from the user that we should be loading this fiddle.
   *
   * @param {string} what What are we loading from (gist, example, etc.)
   */
  public verifyRemoteLoad(what: string): Promise<boolean> {
    return this.appState.showConfirmDialog({
      label: `Are you sure you want to load this ${what}? Only load and run it if you trust the source.`,
      ok: 'Load',
    });
  }

  public verifyReleaseChannelEnabled(channel: string): Promise<boolean> {
    return this.appState.showConfirmDialog({
      label: `You're loading an example with a version of Electron with an unincluded release
              channel (${channel}). Do you want to enable the release channel to load the
              version of Electron from the example?`,
      ok: 'Enable',
    });
  }

  /**
   * Loading a fiddle from GitHub succeeded, let's move on.
   *
   * @param {EditorValues} values
   * @param {string} gistId
   * @returns {Promise<boolean>}
   */
  private async handleLoadingSuccess(
    values: EditorValues,
    gistId: string,
  ): Promise<boolean> {
    await window.app.replaceFiddle(values, { gistId });
    return true;
  }

  /**
   * Loading a fiddle from GitHub failed - this method handles this case
   * gracefully.
   *
   * @param {Error} error
   * @returns {boolean}
   */
  private handleLoadingFailed(error: Error): false {
    const failedLabel = `Loading the fiddle failed: ${error.message}`;
    this.appState.showErrorDialog(
      this.appState.isOnline
        ? failedLabel
        : `Your computer seems to be offline. ${failedLabel}`,
    );

    console.warn(`Loading Fiddle failed`, error);
    return false;
  }
}

1	import semver from 'semver';	2✔
2
3	import { ELECTRON_ORG, ELECTRON_REPO } from './constants';	2✔
4	import { AppState } from './state';
5	import { disableDownload } from './utils/disable-download';	2✔
6	import { isKnownFile, isSupportedFile } from './utils/editor-utils';	2✔
7	import { getOctokit } from './utils/octokit';	2✔
8	import { getReleaseChannel } from './versions';	2✔
9	import {	2✔
10	EditorId,
11	EditorValues,
12	ElectronReleaseChannel,
13	GenericDialogType,
14	InstallState,
15	PACKAGE_NAME,
16	VersionSource,
17	} from '../interfaces';
18
19	export class RemoteLoader {	2✔
20	constructor(private readonly appState: AppState) {	50✔
21	for (const name of [	50✔
22	'fetchExampleAndLoad',
23	'fetchGistAndLoad',
24	'handleLoadingFailed',
25	'handleLoadingSuccess',
26	'loadFiddleFromElectronExample',
27	'loadFiddleFromGist',
28	'setElectronVersion',
29	'verifyReleaseChannelEnabled',
30	'verifyRemoteLoad',
31	] as const) {
32	this[name] = this[name].bind(this);	450✔
33	}
34	}
35
36	public async loadFiddleFromElectronExample(exampleInfo: {
37	path: string;
38	tag: string;
39	}) {
40	console.log(`Loading fiddle from Electron example`, exampleInfo);	2✔
41	const { path, tag } = exampleInfo;	2✔
42	const prettyName = path.replace('docs/fiddles/', '');	2✔
43	const ok = await this.verifyRemoteLoad(	2✔
44	`'${prettyName}' example from the Electron docs for version ${tag}`,
45	);
46	if (!ok) return;	2✔
47
48	this.fetchExampleAndLoad(tag, path);	1✔
49	}
50
51	public async loadFiddleFromGist(gistInfo: { id: string }) {
52	const { id } = gistInfo;	2✔
53	const ok = await this.verifyRemoteLoad(`gist`);	2✔
54	if (!ok) return;	2✔
55
56	this.fetchGistAndLoad(id);	1✔
57	}
58
59	public async fetchExampleAndLoad(
60	tag: string,
61	path: string,
62	): Promise<boolean> {
63	try {	3✔
64	const octo = await getOctokit(this.appState);	3✔
65	const folder = await octo.repos.getContents({	3✔
66	owner: ELECTRON_REPO,
67	repo: ELECTRON_ORG,
68	ref: tag,
69	path,
70	});
71
72	const index = tag.search(/\d/);	2✔
73	const version = tag.substring(index);	2✔
74
75	if (!semver.valid(version)) {	2!
76	throw new Error('Could not determine Electron version for example');	×
77	}
78
79	const ok = await this.setElectronVersion(version);	2✔
80	if (!ok) return false;	2!
81
82	const values = await window.ElectronFiddle.getTemplate(	2✔
83	this.appState.version,
84	);
85	if (!Array.isArray(folder.data)) {	2✔
86	throw new Error(	1✔
87	'The example Fiddle tried to launch is not a valid Electron example',
88	);
89	}
90
91	const loaders: Array<Promise<void>> = [];	1✔
92
93	for (const child of folder.data) {	1✔
94	if (!child.download_url) {	6!
95	console.warn(`Could not find download_url for ${child.name}`);	×
96	continue;	×
97	}
98
99	if (isSupportedFile(child.name)) {	6✔
100	loaders.push(	5✔
101	fetch(child.download_url)
102	.then((r) => r.text())	5✔
103	.then((t) => {
104	values[child.name as EditorId] = t;	5✔
105	}),
106	);
107	}
108	}
109
110	await Promise.all(loaders);	1✔
111
112	return this.handleLoadingSuccess(values, '');	1✔
113	} catch (error) {
114	return this.handleLoadingFailed(error);	2✔
115	}
116	}
117
118	/**
119	* Load a fiddle
120	*/
121	public async fetchGistAndLoad(gistId: string): Promise<boolean> {
122	try {	10✔
123	const octo = await getOctokit(this.appState);	10✔
124	const gist = await octo.gists.get({ gist_id: gistId });	10✔
125	const values: EditorValues = {};	9✔
126
127	for (const [id, data] of Object.entries(gist.data.files)) {	9✔
128	const content = data.truncated	49✔
129	? await fetch(data.raw_url).then((r) => r.text())	1✔
130	: data.content;
131	const isPackageJson = id === PACKAGE_NAME;	49✔
132	if (isPackageJson) {	49✔
133	const { dependencies, devDependencies } = JSON.parse(content);	4✔
134	const deps: Record<string, string> = {	4✔
135	...dependencies,
136	...devDependencies,
137	};
138
139	// If the gist specifies an Electron version, we want to tell Fiddle to run
140	// it with that version by default.
141	const electronDeps = Object.keys(deps).filter((d) =>	4✔
142	['electron-nightly', 'electron'].includes(d),	6✔
143	);
144	for (const dep of electronDeps) {	4✔
145	// Strip off semver range prefixes, e.g:
146	// ^1.2.0 -> 1.2.0
147	// ~2.3.4 -> 2.3.4
148	const index = deps[dep].search(/\d/);	4✔
149	const version = deps[dep].substring(index);	4✔
150
151	if (	4✔
152	!semver.valid(version) \|\|	8✔
153	!(await window.ElectronFiddle.isReleasedMajor(
154	semver.major(version),
155	))
156	) {
157	await this.appState.showGenericDialog({	3✔
158	label: `The Electron version (${version}) in this gist's package.json is invalid. Falling back to last used version.`,
159	ok: 'Close',
160	type: GenericDialogType.warning,
161	wantsInput: false,
162	});
163	} else if (disableDownload(version)) {	1!
164	await this.appState.showGenericDialog({	×
165	label: `This gist's Electron version (${version}) is not available on your current OS. Falling back to last used version.`,
166	ok: 'Close',
167	type: GenericDialogType.warning,
168	wantsInput: false,
169	});
170	} else {
171	this.setElectronVersion(version);	1✔
172	}
173
174	// We want to include all dependencies except Electron.
175	delete deps[dep];	4✔
176	}
177
178	this.appState.modules = new Map(Object.entries(deps));	4✔
179	}
180
181	// JSON files are supported, but we don't want to add package.json
182	// to the visible editor array.
183	if (!isSupportedFile(id) && !isPackageJson) continue;	49✔
184
185	if (isKnownFile(id) \|\| (await this.confirmAddFile(id))) {	47✔
186	values[id] = content;	43✔
187	}
188	}
189
190	// If no files were populated into values, the Fiddle did not
191	// contain any supported files. Throw an error to let the user know.
192	if (Object.keys(values).length === 0) {	9✔
193	throw new Error(	1✔
194	'This Gist did not contain any supported files. Supported files must have one of the following extensions: .js, .css, or .html.',
195	);
196	}
197
198	return this.handleLoadingSuccess(values, gistId);	8✔
199	} catch (error) {
200	return this.handleLoadingFailed(error);	2✔
201	}
202	}
203
204	public async setElectronVersion(version: string): Promise<boolean> {
205	if (!this.appState.hasVersion(version)) {	4✔
206	const versionToDownload = {	2✔
207	source: VersionSource.remote,
208	state: InstallState.missing,
209	version,
210	};
211
212	try {	2✔
213	this.appState.addNewVersions([versionToDownload]);	2✔
214	await this.appState.downloadVersion(versionToDownload);	2✔
215	} catch {
UNCOV 216	await this.appState.removeVersion(versionToDownload);	×
UNCOV 217	this.handleLoadingFailed(	×
218	new Error(`Failed to download Electron version ${version}`),
219	);
UNCOV 220	return false;	×
221	}
222	}
223
224	// check if version is part of release channel
225	const versionReleaseChannel: ElectronReleaseChannel =
226	getReleaseChannel(version);	4✔
227
228	if (!this.appState.channelsToShow.includes(versionReleaseChannel)) {	4✔
229	const ok = await this.verifyReleaseChannelEnabled(versionReleaseChannel);	1✔
230	if (!ok) return false;	1!
231
232	this.appState.channelsToShow.push(versionReleaseChannel);	1✔
233	}
234
235	this.appState.setVersion(version);	4✔
236	return true;	4✔
237	}
238
239	public confirmAddFile = (filename: string): Promise<boolean> => {	50✔
240	return this.appState.showConfirmDialog({	4✔
241	cancel: 'Skip',
242	label: `Do you want to add "${filename}"?`,
243	ok: 'Add',
244	});
245	};
246
247	/**
248	* Verifies from the user that we should be loading this fiddle.
249	*
250	* @param {string} what What are we loading from (gist, example, etc.)
251	*/
252	public verifyRemoteLoad(what: string): Promise<boolean> {
253	return this.appState.showConfirmDialog({	4✔
254	label: `Are you sure you want to load this ${what}? Only load and run it if you trust the source.`,
255	ok: 'Load',
256	});
257	}
258
259	public verifyReleaseChannelEnabled(channel: string): Promise<boolean> {
260	return this.appState.showConfirmDialog({	1✔
261	label: `You're loading an example with a version of Electron with an unincluded release
262	channel (${channel}). Do you want to enable the release channel to load the
263	version of Electron from the example?`,
264	ok: 'Enable',
265	});
266	}
267
268	/**
269	* Loading a fiddle from GitHub succeeded, let's move on.
270	*
271	* @param {EditorValues} values
272	* @param {string} gistId
273	* @returns {Promise<boolean>}
274	*/
275	private async handleLoadingSuccess(
276	values: EditorValues,
277	gistId: string,
278	): Promise<boolean> {
279	await window.app.replaceFiddle(values, { gistId });	9✔
280	return true;	9✔
281	}
282
283	/**
284	* Loading a fiddle from GitHub failed - this method handles this case
285	* gracefully.
286	*
287	* @param {Error} error
288	* @returns {boolean}
289	*/
290	private handleLoadingFailed(error: Error): false {
291	const failedLabel = `Loading the fiddle failed: ${error.message}`;	4✔
292	this.appState.showErrorDialog(	4✔
293	this.appState.isOnline
294	? failedLabel	4!
295	: `Your computer seems to be offline. ${failedLabel}`,
296	);
297
298	console.warn(`Loading Fiddle failed`, error);	4✔
299	return false;	4✔
300	}
301	}

electron / fiddle / 6819934160

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