2508370952

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/electron/fiddle/commit/<a class=hub.com/electron/fiddle/commit/<a class="double-link" href="https://git"><a class=hub.com/electron/fiddle/commit/<a class="double-link" href="https://git"><a class=hub.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf484a4e6f2">e23267b70<a href="https://github.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf484a4e6f2">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/electron/fiddle/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/electron/fiddle/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf484a4e6f2&quot;&gt;e23267b70&lt;/a&gt;&lt;a href=&quot;https://github.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf484a4e6f2&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf4&lt;/a&gt;84a4e6f2">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/electron/fiddle/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/electron/fiddle/commit/<a class="double-link" href="https://github.com/electron/fiddle/commit/29460ee08d1858669fff6e011d52fa5f075c1758">29460ee08</a><a href="https://github.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf484a4e6f2">&amp;quot;&amp;gt;29460ee08&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;29460ee08&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/electron/fiddle/commit/e23267b70625457eb8ab286d74cb9cf484a4e&lt;/a&gt;6f2&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/electron/fiddle/commit/<a class="double-link" href="https://github.com/electron/fiddle/commit/6f3824c19">6f3824c19">6f3824c19</a>

Pull Request Pull Request #1105: Test make

Run Details

1088 of 1240 branches covered (87.74%)

Branch coverage included in aggregate %.

2484 of 2484 new or added lines in 86 files covered. (100.0%)

3342 of 3522 relevant lines covered (94.89%)

116.39 hits per line

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

84.17

/src/renderer/remote-loader.ts

import {
  EditorValues,
  ElectronReleaseChannel,
  PACKAGE_NAME,
  VersionSource,
  VersionState,
} from '../interfaces';
import { getOctokit } from '../utils/octokit';
import { ELECTRON_ORG, ELECTRON_REPO } from './constants';
import { getTemplate } from './content';
import { AppState } from './state';
import { getReleaseChannel } from './versions';
import { isKnownFile, isSupportedFile } from '../utils/editor-utils';

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

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

    this.fetchExampleAndLoad(ref, path);
  }

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

    this.fetchGistAndLoad(id);
  }

  public async fetchExampleAndLoad(
    ref: 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,
        path,
      });

      const ok = await this.setElectronVersionWithRef(ref);
      if (!ok) return false;

      const values = await 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] = 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)) {
        if (id === PACKAGE_NAME) {
          const { dependencies } = JSON.parse(data.content);
          this.appState.modules = new Map(Object.entries(dependencies));
        }
        if (!isSupportedFile(id)) {
          continue;
        }
        if (isKnownFile(id) || (await this.confirmAddFile(id))) {
          values[id] = data.content;
        }
      }

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

  public async setElectronVersionWithRef(ref: string): Promise<boolean> {
    const version = await this.getPackageVersionFromRef(ref);

    if (!this.appState.hasVersion(version)) {
      const versionToDownload = {
        source: VersionSource.remote,
        state: VersionState.unknown,
        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 async getPackageVersionFromRef(ref: string): Promise<string> {
    const octo = await getOctokit(this.appState);
    const { data: packageJsonData } = await octo.repos.getContents({
      owner: ELECTRON_ORG,
      repo: ELECTRON_REPO,
      ref,
      path: PACKAGE_NAME,
    });

    if (!Array.isArray(packageJsonData) && !!packageJsonData.content) {
      const packageJsonString = Buffer.from(
        packageJsonData.content,
        'base64',
      ).toString('utf8');
      const { version } = JSON.parse(packageJsonString);
      return version;
    } else {
      console.error(
        `getPackageVersionFromRef: Received unexpected response from GitHub, could not parse version`,
        {
          packageJsonData,
        },
      );

      return '0.0.0';
    }
  }

  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 {boolean}
   */
  private async handleLoadingSuccess(
    values: EditorValues,
    gistId: string,
  ): Promise<boolean> {
    await window.ElectronFiddle.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 {	2✔
2	EditorValues,
3	ElectronReleaseChannel,
4	PACKAGE_NAME,
5	VersionSource,
6	VersionState,
7	} from '../interfaces';
8	import { getOctokit } from '../utils/octokit';	2✔
9	import { ELECTRON_ORG, ELECTRON_REPO } from './constants';	2✔
10	import { getTemplate } from './content';	2✔
11	import { AppState } from './state';
12	import { getReleaseChannel } from './versions';	2✔
13	import { isKnownFile, isSupportedFile } from '../utils/editor-utils';	2✔
14
15	export class RemoteLoader {	2✔
16	constructor(private readonly appState: AppState) {	42✔
17	for (const name of [	42✔
18	'fetchExampleAndLoad',
19	'fetchGistAndLoad',
20	'getPackageVersionFromRef',
21	'handleLoadingFailed',
22	'handleLoadingSuccess',
23	'loadFiddleFromElectronExample',
24	'loadFiddleFromGist',
25	'setElectronVersionWithRef',
26	'verifyReleaseChannelEnabled',
27	'verifyRemoteLoad',
28	]) {
29	this[name] = this[name].bind(this);	420✔
30	}
31	}
32
33	public async loadFiddleFromElectronExample(
34	_: any,
35	exampleInfo: { path: string; ref: string },
36	) {
37	console.log(`Loading fiddle from Electron example`, _, exampleInfo);	2✔
38	const { path, ref } = exampleInfo;	2✔
39	const prettyName = path.replace('docs/fiddles/', '');	2✔
40	const ok = await this.verifyRemoteLoad(	2✔
41	`'${prettyName}' example from the Electron docs for version ${ref}`,
42	);
43	if (!ok) return;	2✔
44
45	this.fetchExampleAndLoad(ref, path);	1✔
46	}
47
48	public async loadFiddleFromGist(_: any, gistInfo: { id: string }) {
49	const { id } = gistInfo;	2✔
50	const ok = await this.verifyRemoteLoad(`gist`);	2✔
51	if (!ok) return;	2✔
52
53	this.fetchGistAndLoad(id);	1✔
54	}
55
56	public async fetchExampleAndLoad(
57	ref: string,
58	path: string,
59	): Promise<boolean> {
60	try {	3✔
61	const octo = await getOctokit(this.appState);	3✔
62
63	const folder = await octo.repos.getContents({	3✔
64	owner: ELECTRON_REPO,
65	repo: ELECTRON_ORG,
66	ref,
67	path,
68	});
69
70	const ok = await this.setElectronVersionWithRef(ref);	2✔
71	if (!ok) return false;	2!
72
73	const values = await getTemplate(this.appState.version);	2✔
74	if (!Array.isArray(folder.data)) {	2✔
75	throw new Error(	1✔
76	'The example Fiddle tried to launch is not a valid Electron example',
77	);
78	}
79
80	const loaders: Array<Promise<void>> = [];	1✔
81
82	for (const child of folder.data) {	1✔
83	if (!child.download_url) {	6!
84	console.warn(`Could not find download_url for ${child.name}`);	×
85	continue;	×
86	}
87
88	if (isSupportedFile(child.name)) {	6✔
89	loaders.push(	5✔
90	fetch(child.download_url)
91	.then((r) => r.text())	5✔
92	.then((t) => {
93	values[child.name] = t;	5✔
94	}),
95	);
96	}
97	}
98
99	await Promise.all(loaders);	1✔
100
101	return this.handleLoadingSuccess(values, '');	1✔
102	} catch (error) {
103	return this.handleLoadingFailed(error);	2✔
104	}
105	}
106
107	/**
108	* Load a fiddle
109	*/
110	public async fetchGistAndLoad(gistId: string): Promise<boolean> {
111	try {	3✔
112	const octo = await getOctokit(this.appState);	3✔
113	const gist = await octo.gists.get({ gist_id: gistId });	3✔
114	const values: EditorValues = {};	2✔
115
116	for (const [id, data] of Object.entries(gist.data.files)) {	2✔
117	if (id === PACKAGE_NAME) {	11!
118	const { dependencies } = JSON.parse(data.content);	×
119	this.appState.modules = new Map(Object.entries(dependencies));	×
120	}
121	if (!isSupportedFile(id)) {	11!
122	continue;	×
123	}
124	if (isKnownFile(id) \|\| (await this.confirmAddFile(id))) {	11!
125	values[id] = data.content;	11✔
126	}
127	}
128
129	return this.handleLoadingSuccess(values, gistId);	2✔
130	} catch (error) {
131	return this.handleLoadingFailed(error);	1✔
132	}
133	}
134
135	public async setElectronVersionWithRef(ref: string): Promise<boolean> {
136	const version = await this.getPackageVersionFromRef(ref);	3✔
137
138	if (!this.appState.hasVersion(version)) {	3✔
139	const versionToDownload = {	1✔
140	source: VersionSource.remote,
141	state: VersionState.unknown,
142	version,
143	};
144
145	try {	1✔
146	this.appState.addNewVersions([versionToDownload]);	1✔
147	await this.appState.downloadVersion(versionToDownload);	1✔
148	} catch {
149	await this.appState.removeVersion(versionToDownload);	×
150	this.handleLoadingFailed(	×
151	new Error(`Failed to download Electron version ${version}`),
152	);
153	return false;	×
154	}
155	}
156
157	// check if version is part of release channel
158	const versionReleaseChannel: ElectronReleaseChannel = getReleaseChannel(	3✔
159	version,
160	);
161
162	if (!this.appState.channelsToShow.includes(versionReleaseChannel)) {	3✔
163	const ok = await this.verifyReleaseChannelEnabled(versionReleaseChannel);	1✔
164	if (!ok) return false;	1!
165
166	this.appState.channelsToShow.push(versionReleaseChannel);	1✔
167	}
168
169	this.appState.setVersion(version);	3✔
170	return true;	3✔
171	}
172
173	public async getPackageVersionFromRef(ref: string): Promise<string> {
174	const octo = await getOctokit(this.appState);	1✔
175	const { data: packageJsonData } = await octo.repos.getContents({	1✔
176	owner: ELECTRON_ORG,
177	repo: ELECTRON_REPO,
178	ref,
179	path: PACKAGE_NAME,
180	});
181
182	if (!Array.isArray(packageJsonData) && !!packageJsonData.content) {	1!
183	const packageJsonString = Buffer.from(	1✔
184	packageJsonData.content,
185	'base64',
186	).toString('utf8');
187	const { version } = JSON.parse(packageJsonString);	1✔
188	return version;	1✔
189	} else {
190	console.error(	×
191	`getPackageVersionFromRef: Received unexpected response from GitHub, could not parse version`,
192	{
193	packageJsonData,
194	},
195	);
196
197	return '0.0.0';	×
198	}
199	}
200
201	public confirmAddFile = (filename: string): Promise<boolean> => {	42✔
202	return this.appState.showConfirmDialog({	×
203	cancel: 'Skip',
204	label: `Do you want to add "${filename}"?`,
205	ok: 'Add',
206	});
207	};
208
209	/**
210	* Verifies from the user that we should be loading this fiddle.
211	*
212	* @param {string} what What are we loading from (gist, example, etc.)
213	*/
214	public verifyRemoteLoad(what: string): Promise<boolean> {
215	return this.appState.showConfirmDialog({	4✔
216	label: `Are you sure you want to load this ${what}? Only load and run it if you trust the source.`,
217	ok: 'Load',
218	});
219	}
220
221	public verifyReleaseChannelEnabled(channel: string): Promise<boolean> {
222	return this.appState.showConfirmDialog({	1✔
223	label: `You're loading an example with a version of Electron with an unincluded release
224	channel (${channel}). Do you want to enable the release channel to load the
225	version of Electron from the example?`,
226	ok: 'Enable',
227	});
228	}
229
230	/**
231	* Loading a fiddle from GitHub succeeded, let's move on.
232	*
233	* @param {EditorValues} values
234	* @param {string} gistId
235	* @returns {boolean}
236	*/
237	private async handleLoadingSuccess(
238	values: EditorValues,
239	gistId: string,
240	): Promise<boolean> {
241	await window.ElectronFiddle.app.replaceFiddle(values, { gistId });	3✔
242	return true;	3✔
243	}
244
245	/**
246	* Loading a fiddle from GitHub failed - this method handles this case
247	* gracefully.
248	*
249	* @param {Error} error
250	* @returns {boolean}
251	*/
252	private handleLoadingFailed(error: Error): false {
253	const failedLabel = `Loading the fiddle failed: ${error.message}`;	3✔
254	this.appState.showErrorDialog(	3✔
255	this.appState.isOnline
256	? failedLabel	3!
257	: `Your computer seems to be offline. ${failedLabel}`,
258	);
259
260	console.warn(`Loading Fiddle failed`, error);	3✔
261	return false;	3✔
262	}
263	}

electron / fiddle / 2508370952

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