pulsar/script/build

#!/usr/bin/env node

'use strict'

const CONFIG = require('./config')

if (process.argv.includes('--no-bootstrap')) {
  console.log('Skipping bootstrap')
} else {
  // Bootstrap first to ensure all the dependencies used later in this script
  // are installed.
  const path = require('path')
  const childProcess = require('child_process')
  childProcess.execFileSync(process.execPath, [path.join(CONFIG.scriptRootPath, 'bootstrap')], { env: process.env, cwd: CONFIG.repositoryRootPath, stdio: 'inherit' });
}

// Required to load CS files in this build script, such as those in `donna`
require('coffee-script/register')
require('colors')

const path = require('path')
const yargs = require('yargs')
const argv = yargs
  .usage('Usage: $0 [options]')
  .help('help')
  .describe('existing-binaries', 'Use existing Atom binaries (skip clean/transpile/cache)')
  .describe('code-sign', 'Code-sign executables (macOS and Windows only)')
  .describe('test-sign', 'Test-sign executables (macOS only)')
  .describe('create-windows-installer', 'Create installer (Windows only)')
  .describe('create-debian-package', 'Create .deb package (Linux only)')
  .describe('create-rpm-package', 'Create .rpm package (Linux only)')
  .describe('compress-artifacts', 'Compress Atom binaries (and symbols on macOS)')
  .describe('generate-api-docs', 'Only build the API documentation')
  .describe('install', 'Install Atom')
  .string('install')
  .describe('ci', 'Install dependencies quickly (package-lock.json files must be up to date)')
  .wrap(yargs.terminalWidth())
  .argv

const checkChromedriverVersion = require('./lib/check-chromedriver-version')
const cleanOutputDirectory = require('./lib/clean-output-directory')
const codeSignOnMac = require('./lib/code-sign-on-mac')
const codeSignOnWindows = require('./lib/code-sign-on-windows')
const compressArtifacts = require('./lib/compress-artifacts')
const copyAssets = require('./lib/copy-assets')
const createDebianPackage = require('./lib/create-debian-package')
const createRpmPackage = require('./lib/create-rpm-package')
const createWindowsInstaller = require('./lib/create-windows-installer')
const dumpSymbols = require('./lib/dump-symbols')
const generateAPIDocs = require('./lib/generate-api-docs')
const generateMetadata = require('./lib/generate-metadata')
const generateModuleCache = require('./lib/generate-module-cache')
const generateStartupSnapshot = require('./lib/generate-startup-snapshot')
const installApplication = require('./lib/install-application')
const notarizeOnMac = require('./lib/notarize-on-mac')
const packageApplication = require('./lib/package-application')
const prebuildLessCache = require('./lib/prebuild-less-cache')
const testSignOnMac = require('./lib/test-sign-on-mac')

process.on('unhandledRejection', function (e) {
  console.error(e.stack || e)
  process.exit(1)
})

process.env.ELECTRON_VERSION = CONFIG.appMetadata.electronVersion

async function transpile() {
  const { spawn, Thread, Worker } = require(`${CONFIG.scriptRunnerModulesPath}/threads`)

  const transpilePackagesWithCustomTranspilerPaths = await spawn(new Worker('./lib/transpile-packages-with-custom-transpiler-paths'))
  const transpilePackagesWithCustomTranspilerPathsPromise = transpilePackagesWithCustomTranspilerPaths()

  const transpileBabelPaths = await spawn(new Worker('./lib/transpile-babel-paths'))
  const transpileBabelPathsPromise = transpileBabelPaths()

  const transpileCoffeeScriptPaths = await spawn(new Worker('./lib/transpile-coffee-script-paths'))
  const transpileCoffeeScriptPathsPromise = transpileCoffeeScriptPaths()

  const transpileCsonPaths = await spawn(new Worker('./lib/transpile-cson-paths'))
  const transpileCsonPathsPromise = transpileCsonPaths()

  const transpilePegJsPaths = await spawn(new Worker('./lib/transpile-peg-js-paths'))
  const transpilePegJsPathsPromise = transpilePegJsPaths()

  await transpilePackagesWithCustomTranspilerPathsPromise;
  await Thread.terminate(transpilePackagesWithCustomTranspilerPaths)

  await transpileBabelPathsPromise;
  await Thread.terminate(transpileBabelPaths)

  await transpileCoffeeScriptPathsPromise;
  await Thread.terminate(transpileCoffeeScriptPaths)

  await transpileCsonPathsPromise;
  await Thread.terminate(transpileCsonPaths)

  await transpilePegJsPathsPromise;
  await Thread.terminate(transpilePegJsPaths)
}

async function singAndCreateInstaller(packagedAppPath) {
      switch (process.platform) {
        case 'darwin': {
          if (argv.codeSign) {
            await codeSignOnMac(packagedAppPath)
            await notarizeOnMac(packagedAppPath)
          } else if (argv.testSign) {
            testSignOnMac(packagedAppPath)
          } else {
            console.log('Skipping code-signing. Specify the --code-sign option to perform code-signing'.gray)
          }
          break
        }
        case 'win32': {
          if (argv.testSign) {
            console.log('Test signing is not supported on Windows, skipping.'.gray)
          }

          if (argv.codeSign) {
            const executablesToSign = [ path.join(packagedAppPath, CONFIG.executableName) ]
            if (argv.createWindowsInstaller) {
              executablesToSign.push(path.join(__dirname, 'node_modules', '@atom', 'electron-winstaller', 'vendor', 'Squirrel.exe'))
            }
            codeSignOnWindows(executablesToSign)
          } else {
            console.log('Skipping code-signing. Specify the --code-sign option to perform code-signing'.gray)
          }
          if (argv.createWindowsInstaller) {
            return createWindowsInstaller(packagedAppPath)
              .then((installerPath) => {
                argv.codeSign && codeSignOnWindows([installerPath])
                return packagedAppPath
              })
          } else {
            console.log('Skipping creating installer. Specify the --create-windows-installer option to create a Squirrel-based Windows installer.'.gray)
          }
          break
        }
        case 'linux': {
          if (argv.createDebianPackage) {
            createDebianPackage(packagedAppPath)
          } else {
            console.log('Skipping creating debian package. Specify the --create-debian-package option to create it.'.gray)
          }

          if (argv.createRpmPackage) {
            createRpmPackage(packagedAppPath)
          } else {
            console.log('Skipping creating rpm package. Specify the --create-rpm-package option to create it.'.gray)
          }
          break
        }
      }

      return Promise.resolve(packagedAppPath)
}


async function build() {

  if (!argv.existingBinaries) {
    checkChromedriverVersion()
    await cleanOutputDirectory()
    await copyAssets()
    await transpile()
    generateModuleCache()
    prebuildLessCache()
    generateMetadata()
    generateAPIDocs()
    if (!argv.generateApiDocs) {
      await dumpSymbols()
    }
  }

  if (!argv.generateApiDocs) {
      const packagedAppPath = await packageApplication()
      await generateStartupSnapshot(packagedAppPath)
      await singAndCreateInstaller(packagedAppPath)
      if (argv.compressArtifacts) {
        compressArtifacts(packagedAppPath)
      } else {
        console.log('Skipping artifacts compression. Specify the --compress-artifacts option to compress Atom binaries (and symbols on macOS)'.gray)
      }

      if (argv.install != null) {
        installApplication(packagedAppPath, argv.install)
      } else {
        console.log('Skipping installation. Specify the --install option to install Atom'.gray)
      }
  }

}


build().then(() => {process.exit(0)}).catch((e) =>  {throw e;})