jeans/arduino-ide
1
0
Fork 0
mirror of https://github.com/arduino/arduino-ide.git synced 2025-11-08 09:58:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

build: use a local npm registry for app packaging

Browse Source 
Signed-off-by: Akos Kitta <a.kitta@arduino.cc>
This commit is contained in:
Akos Kitta
2022-12-08 16:37:12 +01:00
committed by Akos Kitta
parent 908ec4c544
commit 1d342cdbd0
12 changed files with 4021 additions and 2287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintrc.js
View File

@@ -15,7 +15,6 @@ module.exports = {
'.browser_modules/*',
'docs/*',
'scripts/*',
'electron/*',
'electron-app/*',
'plugins/*',
'arduino-ide-extension/src/node/cli-protocol',

2
arduino-ide-extension/src/browser/dialogs/cloud-share-sketch-dialog.tsx
View File

@@ -2,7 +2,7 @@ import * as React from '@theia/core/shared/react';
import { inject, injectable } from '@theia/core/shared/inversify';
import { Widget } from '@theia/core/shared/@phosphor/widgets';
import { Message } from '@theia/core/shared/@phosphor/messaging';
import { clipboard } from 'electron';
import { clipboard } from '@theia/core/electron-shared/@electron/remote';
import { ReactWidget, DialogProps } from '@theia/core/lib/browser';
import { AbstractDialog } from '../theia/dialogs/dialogs';
import { CreateApi } from '../create/create-api';

2
arduino-ide-extension/src/browser/widgets/cloud-sketchbook/cloud-sketchbook-tree-widget.tsx
View File

@@ -9,7 +9,7 @@ import { CloudUserCommands } from '../../auth/cloud-user-commands';
import { NodeProps } from '@theia/core/lib/browser/tree/tree-widget';
import { TreeNode } from '@theia/core/lib/browser/tree';
import { CompositeTreeNode } from '@theia/core/lib/browser';
import { shell } from 'electron';
import { shell } from '@theia/core/electron-shared/@electron/remote';
import { SketchbookTreeWidget } from '../sketchbook/sketchbook-tree-widget';
import { nls } from '@theia/core/lib/common';

17
electron/.gitignore vendored
View File

@@ -1,22 +1,15 @@
# The working-copy folder we use to package the application.
working-copy/
# Ignore all Theia generated things.
*.log
src-gen/
node_modules/
build/yarn.lock
webpack.config.js
lib/
# The electron-builder output.
dist/
# `dotenv` can provide dynamic input for the elecrton-builder. e.g.: commitish for the build.
electron-builder.env
# The generated `package.json` under the `build` folder.
# The generated `package.json` and lock file under the `build` folder.
build/package.json
build/yarn.lock
# Resources the packager copies from dev to prod
build/resources/preload.html
# For the private npm package registry
packager/npm-registry/storage

1
electron/build/template-package.json
View File

@@ -21,7 +21,6 @@
"build": "yarn download:plugins && theia build --mode production && yarn patch",
"rebuild": "yarn theia rebuild:electron",
"package": "cross-env DEBUG=* && electron-builder --publish=never",
"package:publish": "cross-env DEBUG=* && electron-builder --publish=always",
"download:plugins": "theia download:plugins",
"patch": "ncp ./patch/backend/main.js ./src-gen/backend/main.js"
},

464
electron/packager/index.js
View File

@@ -1,9 +1,31 @@
//@ts-check
(async () => {
const toDispose = [];
const disposeAll = () => {
let disposable = toDispose.pop();
while (disposable) {
try {
disposable();
} catch (err) {
console.error(err);
}
disposable = toDispose.pop();
}
};
process.on('uncaughtException', (error) => {
disposeAll();
throw error;
});
process.on('unhandledRejection', (reason) => {
disposeAll();
throw reason;
});
const fs = require('fs');
const join = require('path').join;
const shell = require('shelljs');
const { echo, cp, mkdir, mv, rm } = shell;
shell.config.fatal = true;
const glob = require('glob');
const isCI = require('is-ci');
// Note, this will crash on PI if the available memory is less than desired heap size.
@@ -21,175 +43,124 @@
echo(`📦 Building ${isRelease ? 'release ' : ''}version '${version}'...`);
const workingCopy = 'working-copy';
const repoRoot = join(__dirname, '..', '..');
/**
* Relative path from the `__dirname` to the root where the `arduino-ide-extension` and the `electron-app` folders are.
* This could come handy when moving the location of the `electron/packager`.
* Extensions are expected to be folders directly available from the repository root.
*/
const rootPath = join('..', '..');
// This is a HACK! We rename the root `node_modules` to something else. Otherwise, due to the hoisting,
// multiple Theia extensions will be picked up.
if (fs.existsSync(path(rootPath, 'node_modules'))) {
// We either do this or change the project structure.
echo(
"🔧 >>> [Hack] Renaming the root 'node_modules' folder to '.node_modules'..."
);
mv('-f', path(rootPath, 'node_modules'), path(rootPath, '.node_modules'));
echo(
"👌 <<< [Hack] Renamed the root 'node_modules' folder to '.node_modules'."
);
}
try {
//---------------------------+
// Clean the previous state. |
//---------------------------+
// rm -rf ../working-copy
rm('-rf', path('..', workingCopy));
// Clean up the `./electron/build` folder.
const resourcesToKeep = [
'patch',
'resources',
'scripts',
'template-package.json'
];
fs.readdirSync(path('..', 'build'))
.filter((filename) => resourcesToKeep.indexOf(filename) === -1)
.forEach((filename) => rm('-rf', path('..', 'build', filename)));
// Clean up the `./electron/build/resources` folder with Git.
// To avoid file duplication between bundled app and dev mode, some files are copied from `./electron-app` to `./electron/build` folder.
const foldersToSyncFromDev = ['resources'];
foldersToSyncFromDev.forEach((filename) =>
shell.exec(`git -C ${path('..', 'build', filename)} clean -ffxdq`, {
async: false,
})
);
const extensions = require('./extensions.json');
echo(
`Building the application with the following extensions:\n${extensions
.map((ext) => ` - ${ext}`)
.join(',\n')}`
);
const allDependencies = [...extensions, 'electron-app'];
//----------------------------------------------------------------------------------------------+
// Copy the following items into the `working-copy` folder. Make sure to reuse the `yarn.lock`. |
//----------------------------------------------------------------------------------------------+
mkdir('-p', path('..', workingCopy));
for (const filename of [
...allDependencies,
'yarn.lock',
'package.json',
'lerna.json',
'i18n',
]) {
cp('-rf', path(rootPath, filename), path('..', workingCopy));
try {
//---------------------------+
// Clean the previous state. |
//---------------------------+
// Clean up the `./electron/build` folder.
const resourcesToKeep = [
'patch',
'resources',
'scripts',
'template-package.json',
];
fs.readdirSync(join(repoRoot, 'electron', 'build'))
.filter((filename) => resourcesToKeep.indexOf(filename) === -1)
.forEach((filename) =>
rm('-rf', join(repoRoot, 'electron', 'build', filename))
);
// Clean up the `./electron/build/resources` folder with Git.
// To avoid file duplication between bundled app and dev mode, some files are copied from `./electron-app` to `./electron/build` folder.
const foldersToSyncFromDev = ['resources'];
foldersToSyncFromDev.forEach((filename) =>
shell.exec(
`git -C ${join(repoRoot, 'electron', 'build', filename)} clean -ffxdq`,
{
async: false,
}
)
);
//---------------------------------------------------------------------------------------------+
// Copy the patched `index.js` for the frontend, the Theia preload, etc. from `./electron-app` |
//---------------------------------------------------------------------------------------------+
//----------------------------------------------------+
// Copy the Theia preload, etc. from `./electron-app` |
//----------------------------------------------------+
for (const filename of foldersToSyncFromDev) {
cp(
'-rf',
path('..', workingCopy, 'electron-app', filename),
path('..', 'build')
join(repoRoot, 'electron-app', filename),
join(repoRoot, 'electron', 'build')
);
}
//----------------------------------------------+
// Sanity check: all versions must be the same. |
//----------------------------------------------+
verifyVersions(allDependencies);
verifyVersions(extensions);
//----------------------------------------------------------------------+
// Use the nightly patch version if not a release but requires publish. |
//----------------------------------------------------------------------+
if (!isRelease) {
for (const dependency of allDependencies) {
const pkg = require(`../working-copy/${dependency}/package.json`);
pkg.version = version;
for (const dependency in pkg.dependencies) {
if (allDependencies.indexOf(dependency) !== -1) {
pkg.dependencies[dependency] = version;
}
}
fs.writeFileSync(
path('..', workingCopy, dependency, 'package.json'),
JSON.stringify(pkg, null, 2)
);
}
}
verifyVersions(allDependencies);
//---------------------------------------------------------------------------------------------------+
// Save some time: no need to build the projects that are not needed in final app. Currently unused. |
//---------------------------------------------------------------------------------------------------+
//@ts-ignore
const rootPackageJson = require('../working-copy/package.json');
const workspaces = rootPackageJson.workspaces;
// We cannot remove the `electron-app`. Otherwise, there is not way to collect the unused dependencies.
const dependenciesToRemove = [];
for (const dependencyToRemove of dependenciesToRemove) {
const index = workspaces.indexOf(dependencyToRemove);
if (index !== -1) {
workspaces.splice(index, 1);
}
}
rootPackageJson.workspaces = workspaces;
fs.writeFileSync(
path('..', workingCopy, 'package.json'),
JSON.stringify(rootPackageJson, null, 2)
);
//-------------------------------------------------------------------------------------------------+
// Rebuild the extension with the copied `yarn.lock`. It is a must to use the same Theia versions. |
//-------------------------------------------------------------------------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', workingCopy)}`,
`Building the ${productName} application`
);
//-------------------------------------------------------------------------------------------------------------------------+
// Test the application. With this approach, we cannot publish test results to GH Actions but save 6-10 minutes per builds |
//-------------------------------------------------------------------------------------------------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', workingCopy)} test`,
`Testing the ${productName} application`
);
//-------------------------------------------------------------------------------------------------------------+
// Change the regular NPM dependencies to `local-paths`, so that we can build them without any NPM registries. |
//-------------------------------------------------------------------------------------------------------------+
//-------------------------------+
// Build and test the extensions |
//-------------------------------+
for (const extension of extensions) {
if (extension !== 'arduino-ide-extension') {
// Do not unlink self.
// @ts-ignore
rootPackageJson = require(`../working-copy/${extension}/package.json`);
// @ts-ignore
rootPackageJson.dependencies['arduino-ide-extension'] =
'file:../arduino-ide-extension';
fs.writeFileSync(
path('..', workingCopy, extension, 'package.json'),
JSON.stringify(rootPackageJson, null, 2)
exec(
`yarn --network-timeout 1000000 --cwd ${join(repoRoot, extension)}`,
`Building and testing ${extension}`
);
}
//------------------------+
// Publish the extensions |
//------------------------+
const npmrc = join(repoRoot, '.npmrc');
const storage = join(__dirname, 'npm-registry', 'storage');
rm('-rf', npmrc);
rm('-rf', storage);
// To avoid interactive npm login on the CI when publishing to the private registry.
// The actual token is fake and does not matter as the publishing is `$anonymous` anyway.
fs.writeFileSync(npmrc, '//localhost:4873/:_authToken=placeholder\n', {
encoding: 'utf8',
});
toDispose.push(() => rm('-rf', storage));
toDispose.push(() => rm('-rf', npmrc));
const npmProxyProcess = await startNpmRegistry(
join(__dirname, 'npm-registry', 'config.yml')
);
toDispose.push(() => {
if (!npmProxyProcess.killed) {
npmProxyProcess.kill();
}
});
for (const extension of extensions) {
const packageJsonPath = join(repoRoot, extension, 'package.json');
const versionToRestore = readJson(packageJsonPath).version;
exec(
`yarn --network-timeout 1000000 --cwd ${join(
repoRoot,
extension
)} publish --ignore-scripts --new-version ${version} --no-git-tag-version --registry http://localhost:4873`,
`Publishing ${extension}@${version} to the private npm registry`
);
// Publishing will change the version number, this should be reverted up after the build.
// A git checkout or reset could be easier, but this is safer to avoid wiping uncommitted dev state.
toDispose.push(() => {
const json = readJson(packageJsonPath);
json.version = versionToRestore;
writeJson(packageJsonPath, json);
});
}
//------------------------------------------------------------------------------------+
// Merge the `working-copy/package.json` with `electron/build/template-package.json`. |
//------------------------------------------------------------------------------------+
// @ts-ignore
const appPackageJson = require('../working-copy/electron-app/package.json');
//-----------------------------------------------------------------------------------------------------------+
// Merge the `./package.json` and `./electron-app/package.json` with `electron/build/template-package.json`. |
//-----------------------------------------------------------------------------------------------------------+
const rootPackageJson = readJson(join(repoRoot, 'package.json'));
const appPackageJson = readJson(
join(repoRoot, 'electron-app', 'package.json')
);
const dependencies = {};
for (const extension of extensions) {
dependencies[extension] = `file:../working-copy/${extension}`;
dependencies[extension] = version;
}
// @ts-ignore
appPackageJson.dependencies = {
...appPackageJson.dependencies,
...dependencies,
@@ -199,80 +170,115 @@
...template.devDependencies,
};
// Deep-merging the Theia application configuration.
// @ts-ignore
const theia = merge(appPackageJson.theia || {}, template.theia || {});
const content = {
...appPackageJson,
...template,
theia,
// @ts-ignore
dependencies: appPackageJson.dependencies,
devDependencies: appPackageJson.devDependencies,
// VS Code extensions and the plugins folder is defined in the top level `package.json`. The template picks them up.
// VS Code extensions and the plugins folder is defined in the root `package.json`. The template picks them up.
theiaPluginsDir: rootPackageJson.theiaPluginsDir,
theiaPlugins: rootPackageJson.theiaPlugins,
};
fs.writeFileSync(
path('..', 'build', 'package.json'),
JSON.stringify(
writeJson(
join(repoRoot, 'electron', 'build', 'package.json'),
merge(content, template, {
arrayMerge: (_, sourceArray) => sourceArray,
}),
null,
2
)
})
);
echo(`📜 Effective 'package.json' for the ${productName} application is:
echo(`📜 Effective 'package.json' for the ${productName} application:
-----------------------
${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
${fs
.readFileSync(join(repoRoot, 'electron', 'build', 'package.json'))
.toString()}
-----------------------
`);
// Make sure the original `yarn.lock` file is used from the electron application.
if (fs.existsSync(path('..', 'build', 'yarn.lock'))) {
echo(`${path('..', 'build', 'yarn.lock')} must not exist.`);
if (fs.existsSync(join(repoRoot, 'electron', 'build', 'yarn.lock'))) {
echo(
`${join(repoRoot, 'electron', 'build', 'yarn.lock')} must not exist.`
);
shell.exit(1);
}
cp('-rf', path(rootPath, 'yarn.lock'), path('..', 'build'));
if (!fs.existsSync(path('..', 'build', 'yarn.lock'))) {
echo(`${path('..', 'build', 'yarn.lock')} does not exist.`);
cp('-rf', join(repoRoot, 'yarn.lock'), join(repoRoot, 'electron', 'build'));
if (!fs.existsSync(join(repoRoot, 'electron', 'build', 'yarn.lock'))) {
echo(
`${join(repoRoot, 'electron', 'build', 'yarn.lock')} does not exist.`
);
shell.exit(1);
}
// This is a HACK! We rename the root `node_modules` to something else. Otherwise, due to the hoisting,
// multiple Theia extensions will be picked up.
if (fs.existsSync(join(repoRoot, 'node_modules'))) {
// We either do this or change the project structure.
echo(
"🔧 >>> [Hack] Renaming the root 'node_modules' folder to '.node_modules'..."
);
mv('-f', join(repoRoot, 'node_modules'), join(repoRoot, '.node_modules'));
echo(
"👌 <<< [Hack] Renamed the root 'node_modules' folder to '.node_modules'."
);
}
toDispose.push(() => {
if (fs.existsSync(join(repoRoot, '.node_modules'))) {
echo(
"🔧 >>> [Restore] Renaming the root '.node_modules' folder to 'node_modules'..."
);
mv(
'-f',
join(repoRoot, '.node_modules'),
join(repoRoot, 'node_modules')
);
echo(
"👌 >>> [Restore] Renamed the root '.node_modules' folder to 'node_modules'."
);
}
});
//-------------------------------------------------------------------------------------------+
// Install all private and public dependencies for the electron application and build Theia. |
//-------------------------------------------------------------------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')}`,
`yarn --network-timeout 1000000 --cwd ${join(
repoRoot,
'electron',
'build'
)} --registry http://localhost:4873`,
'Installing dependencies'
);
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')} build`,
`yarn --cwd ${join(repoRoot, 'electron', 'build')} build`,
`Building the ${productName} application`
);
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')} rebuild`,
'Rebuild native dependencies'
`yarn --cwd ${join(repoRoot, 'electron', 'build')} rebuild`,
'Rebuilding native dependencies'
);
//------------------------------------------------------------------------------+
// Create a throw away dotenv file which we use to feed the builder with input. |
//------------------------------------------------------------------------------+
const dotenv = 'electron-builder.env';
if (fs.existsSync(path('..', 'build', dotenv))) {
rm('-rf', path('..', 'build', dotenv));
if (fs.existsSync(join(repoRoot, 'electron', 'build', dotenv))) {
rm('-rf', join(repoRoot, 'electron', 'build', dotenv));
}
// For the releases we use the desired tag as is defined by `$(Release.Tag)` from Azure.
// For the preview builds we use the version from the `electron/build/package.json` with the short commit hash.
fs.writeFileSync(path('..', 'build', dotenv), `ARDUINO_VERSION=${version}`);
fs.writeFileSync(
join(repoRoot, 'electron', 'build', dotenv),
`ARDUINO_VERSION=${version}`
);
//-----------------------------------+
// Package the electron application. |
//-----------------------------------+
exec(
`yarn --network-timeout 1000000 --cwd ${path('..', 'build')} package`,
`Packaging your ${productName} application`
`yarn --cwd ${join(repoRoot, 'electron', 'build')} package`,
`Packaging the ${productName} application`
);
//-----------------------------------------------------------------------------------------------------+
@@ -288,9 +294,16 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
shell.exit(1);
}
}
echo(`🎉 Success. Your application is at: ${path('..', 'build', 'dist')}`);
echo(
`🎉 Success. The application is at: ${join(
repoRoot,
'electron',
'build',
'dist'
)}`
);
} finally {
restore();
disposeAll();
}
//--------+
@@ -300,67 +313,24 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
if (toEcho) {
echo(`⏱️ >>> ${toEcho}...`);
}
const { code, stderr, stdout } = shell.exec(command);
if (code !== 0) {
echo(`🔥 Error when executing ${command} => ${stderr}`);
shell.exit(1);
}
const { stdout } = shell.exec(command);
if (toEcho) {
echo(`👌 <<< ${toEcho}.`);
}
return stdout;
}
function cp(options, source, destination) {
shell.cp(options, source, destination);
assertNoError();
}
function rm(options, ...files) {
shell.rm(options, files);
assertNoError();
}
function mv(options, source, destination) {
shell.mv(options, source, destination);
assertNoError();
}
function mkdir(options, ...dir) {
shell.mkdir(options, dir);
assertNoError();
}
function echo(command) {
return shell.echo(command);
}
function assertNoError() {
const error = shell.error();
if (error) {
echo(error);
restore();
shell.exit(1);
}
}
function restore() {
if (fs.existsSync(path(rootPath, '.node_modules'))) {
echo(
"🔧 >>> [Restore] Renaming the root '.node_modules' folder to 'node_modules'..."
);
mv('-f', path(rootPath, '.node_modules'), path(rootPath, 'node_modules'));
echo(
"👌 >>> [Restore] Renamed the root '.node_modules' folder to 'node_modules'."
);
}
}
async function copyFilesToBuildArtifacts() {
echo(`🚢 Detected CI, moving build artifacts...`);
const { platform } = process;
const cwd = path('..', 'build', 'dist');
const targetFolder = path('..', 'build', 'dist', 'build-artifacts');
const cwd = join(repoRoot, 'electron', 'build', 'dist');
const targetFolder = join(
repoRoot,
'electron',
'build',
'dist',
'build-artifacts'
);
mkdir('-p', targetFolder);
const filesToCopy = [];
const channelFile = getChannelFile(platform);
@@ -425,7 +395,7 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
async function recalculateArtifactsHash() {
echo(`🚢 Detected CI, recalculating artifacts hash...`);
const { platform } = process;
const cwd = path('..', 'build', 'dist');
const cwd = join(repoRoot, 'electron', 'build', 'dist');
const channelFilePath = join(cwd, getChannelFile(platform));
const yaml = require('yaml');
@@ -464,14 +434,14 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
* @param {BufferEncoding|undefined} [encoding="base64"]
* @param {object|undefined} [options]
*/
async function hashFile(
function hashFile(
file,
algorithm = 'sha512',
encoding = 'base64',
options
) {
const crypto = require('crypto');
return await new Promise((resolve, reject) => {
return new Promise((resolve, reject) => {
const hash = crypto.createHash(algorithm);
hash.on('error', reject).setEncoding(encoding);
fs.createReadStream(
@@ -493,17 +463,14 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
}
/**
* Joins tha path from `__dirname`.
* @param {string[]} allDependencies
* @param {string} [expectedVersion]
*/
function path(...paths) {
return join(__dirname, ...paths);
}
function verifyVersions(allDependencies, expectedVersion) {
const versions = new Set();
for (const dependency of allDependencies) {
versions.add(
require(`../working-copy/${dependency}/package.json`).version
readJson(join(repoRoot, dependency, 'package.json')).version
);
}
if (versions.size !== 1) {
@@ -527,4 +494,41 @@ ${fs.readFileSync(path('..', 'build', 'package.json')).toString()}
}
}
}
/**
* @param {string} configPath
* @return {Promise<import('child_process').ChildProcess>}
*/
function startNpmRegistry(configPath) {
return new Promise((resolve, reject) => {
const fork = require('child_process').fork(
require.resolve('verdaccio/bin/verdaccio'),
['-c', configPath]
);
fork.on('message', (msg) => {
if (typeof msg === 'object' && 'verdaccio_started' in msg) {
resolve(fork);
}
});
fork.on('error', reject);
fork.on('disconnect', reject);
});
}
/**
* @param {string} path
* @param {object} jsonObject
*/
function writeJson(path, jsonObject) {
fs.writeFileSync(path, JSON.stringify(jsonObject, null, 2) + '\n');
}
/**
* @param {string} path
* @return {object}
*/
function readJson(path) {
const raw = fs.readFileSync(path, { encoding: 'utf8' });
return JSON.parse(raw);
}
})();

19
electron/packager/npm-registry/config.yml Normal file
View File

@@ -0,0 +1,19 @@
storage: ./storage
uplinks:
npmjs:
url: 'https://registry.npmjs.org/'
packages:
'**':
access: $all
publish: $anonymous
unpublish: $anonymous
proxy: npmjs
server:
keepAliveTimeout: 60
listen:
- 'localhost:4873'
max_body_size: 100mb
log:
type: stdout
format: pretty
level: warn

3
electron/packager/package.json
View File

@@ -13,9 +13,9 @@
"author": "Arduino SA",
"license": "AGPL-3.0-or-later",
"dependencies": {
"7zip-min": "^1.1.1",
"@types/file-type": "^10.9.1",
"@types/temp": "^0.8.32",
"7zip-min": "^1.1.1",
"chai": "^4.2.0",
"crypto": "^1.0.1",
"dateformat": "^3.0.3",
@@ -28,6 +28,7 @@
"shelljs": "^0.8.3",
"sinon": "^9.0.1",
"temp": "^0.9.1",
"verdaccio": "6-next",
"yaml": "^1.10.2",
"yargs": "^12.0.5"
},

38
electron/packager/test/utils.test.js
View File

@@ -7,13 +7,13 @@ const testMe = require('../utils');
const sinon = require('sinon');
describe('utils', () => {
describe('adjustArchiveStructure', () => {
let consoleStub;
beforeEach(() => {
consoleStub = sinon.stub(console, 'log').value(() => { });
consoleStub = sinon.stub(console, 'log').value(() => {
/* NOOP */
});
});
afterEach(() => {
@@ -34,8 +34,15 @@ describe('utils', () => {
it('should reject when target directory does not exist', async () => {
try {
const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
await testMe.adjustArchiveStructure(zip, path.join(__dirname, 'some', 'missing', 'path'));
const zip = path.join(
__dirname,
'resources',
'zip-with-base-folder.zip'
);
await testMe.adjustArchiveStructure(
zip,
path.join(__dirname, 'some', 'missing', 'path')
);
throw new Error('Expected a rejection');
} catch (e) {
expect(e).to.be.an.instanceOf(Error);
@@ -45,7 +52,11 @@ describe('utils', () => {
it('should reject when target is a file', async () => {
try {
const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
const zip = path.join(
__dirname,
'resources',
'zip-with-base-folder.zip'
);
await testMe.adjustArchiveStructure(zip, path.join(__filename));
throw new Error('Expected a rejection');
} catch (e) {
@@ -56,7 +67,10 @@ describe('utils', () => {
it('should be a NOOP when the zip already has the desired base folder', async () => {
const zip = path.join(__dirname, 'resources', 'zip-with-base-folder.zip');
const actual = await testMe.adjustArchiveStructure(zip, track.mkdirSync());
const actual = await testMe.adjustArchiveStructure(
zip,
track.mkdirSync()
);
expect(actual).to.be.equal(zip);
});
@@ -92,7 +106,13 @@ describe('utils', () => {
const verifyOut = track.mkdirSync();
await unpack(actual, verifyOut);
expect(fs.lstatSync(path.join(verifyOut, 'zip-with-symlink', 'folder', 'symlinked-sub')).isSymbolicLink()).to.be.true;
expect(
fs
.lstatSync(
path.join(verifyOut, 'zip-with-symlink', 'folder', 'symlinked-sub')
)
.isSymbolicLink()
).to.be.true;
});
it('should adjust the archive structure if base folder is not present', async () => {
@@ -113,7 +133,5 @@ describe('utils', () => {
expect(subs).to.have.lengthOf(3);
expect(subs.sort()).to.be.deep.equal(['a.txt', 'b.txt', 'foo']);
});
});
});

1881
electron/packager/yarn.lock
View File

File diff suppressed because it is too large Load Diff

5
package.json
View File

@@ -25,7 +25,7 @@
"husky": "^6.0.0",
"ignore-styles": "^5.0.1",
"jsdom": "^11.5.1",
"lerna": "^3.20.2",
"lerna": "^6.1.0",
"lint-staged": "^11.0.0",
"node-gyp": "^9.3.0",
"prettier": "^2.3.1",
@@ -38,8 +38,7 @@
},
"resolutions": {
"@types/react": "18.0.0",
"@types/react-dom": "18.0.0",
"electron-rebuild": "3.2.9"
"@types/react-dom": "18.0.0"
},
"scripts": {
"prepare": "lerna run prepare && yarn download:plugins",

3883
yarn.lock
View File

File diff suppressed because it is too large Load Diff