How to use process - 10 common examples

"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const assert = require("chai").assert,
    formatter = require("../../../../lib/cli-engine/formatters/junit"),
    process = require("process");

//------------------------------------------------------------------------------
// Tests
//------------------------------------------------------------------------------

const suppliedFilePath = (process.platform === "win32") ? "C:\\path\\to\\foo.js" : "/path/to/foo.js";
const expectedClassName = (process.platform === "win32") ? "C:\\path\\to\\foo" : "/path/to/foo";

describe("formatter:junit", () => {
    describe("when there are no problems", () => {
        const code = [];

        it("should not complain about anything", () => {
            const result = formatter(code);

            assert.strictEqual(result.replace(/\n/gu, ""), "");
        });
    });

    describe("when passed a single message", () => {
        const code = [{
            filePath: suppliedFilePath,

fatal: function fatal() {
            // simulate a bug
            process.nextTick(function throwIt() {
                throw new Error('bug in logger implementation');
            });
        }
    };

function main() {
    if (argv.help) {
        console.log(optimist.help())
        process.exit(0)
    }
    
    if (argv._.length == 0 || argv._[0] == null || argv._[0] == "") {
        logger.error('No URL provided.')
        console.log(optimist.help())
        process.exit(1)
    }

    argv.directory = path.resolve(argv.directory)
    if (!fs.existsSync(argv.directory)) {
        logger.error(`Directory ${argv.directory} does not exist.`)
        process.exit(1)
    }

    // Validate the URL first
    let url = argv._[0].trim()
    if (!url.endsWith('/')) {
        logger.info('Adding a trailing / automatically.')
        url += '/'
    }
    url = parseURL(url)

apply(compiler) {
    const { name, version, author: makers } = pkg;
    const normalizedAuthor = parseAuthor(makers);

    this.reports.project = { name, version, makers: normalizedAuthor };

    // check if the current build is production, via defined plugin
    const definePlugin = compiler.options.plugins.find(fn => fn.constructor.name === "DefinePlugin");

    if (definePlugin) {
      const pluginNodeEnv = definePlugin["definitions"]["process.env.NODE_ENV"];
      this.env.production = pluginNodeEnv === "production";
    }

    let jarvis;
    let isDev = !this.env.production;
    let { port, host } = this.options;

    if (!this.env.running) {
      jarvis = this.server = server.init(compiler, isDev);
      jarvis.http.listen(port, host, _ => {
        console.log(`[JARVIS] Starting dashboard on: http://${host}:${port}`);
        this.env.running = true;
        // if a new client is connected push current bundle info
        jarvis.io.on("connection", socket => {
          socket.emit("project", this.reports.project);
          socket.emit("progress", this.reports.progress);

function execute(command)
{
	// eslint-disable-next-line no-console
	console.log(`npm-scripts.js [INFO] executing command: ${command}`);

	try
	{
		execSync(command,	{ stdio: [ 'ignore', process.stdout, process.stderr ] });
	}
	catch (error)
	{
		process.exit(1);
	}
}

obj = JSON.parse(settings, 'utf8');
    console.log(obj);
} catch (e) {

    // automatic platform detection
    var os = require("os");
    var myPlatform = "Unknown";
    if (/^win/.test(process.platform)) {
        myPlatform = 'vs';
    }
    // TODO: make the difference between osx and ios
    else if (process.platform === "darwin") {
        myPlatform = 'osx';
    } else if (process.platform === "linux") {
        myPlatform = 'linux';
        if (process.arch === 'ia32') {
            myPlatform = 'linux';
        } else if (process.arch === 'arm') {
            if (os.cpus()[0].model.indexOf('ARMv6') == 0) {
                myPlatform = 'linuxarmv6l';
            } else {
                myPlatform = 'linuxarmv7l';
            }
        } else if (process.arch === 'x64') {
            myPlatform = 'linux64';
        }
    }

    obj = {
        "defaultOfPath": "",
        "advancedMode": false,
        "defaultPlatform": myPlatform,

WebpackBuildNotifierPlugin.prototype.registerSnoreToast = function () {
    // ensure the SnoreToast appId is registered, which is needed for Windows Toast notifications
    // this is necessary in Windows 8 and above, (Windows 10 post build 1709), where all notifications must be generated
    // by a valid application.
    // see: https://github.com/KDE/snoretoast, https://github.com/RoccoC/webpack-build-notifier/issues/20
    /* istanbul ignore else */
    if (process.platform === 'win32') {
        const versionParts = os.release().split('.');
        const winVer = +(`${versionParts[0]}.${versionParts[1]}`);
        /* istanbul ignore else */
        if (winVer >= 6.2) {
            // Windows version >= 8
            const snoreToast = path.join(
                require.resolve('node-notifier'),
                '../vendor/snoreToast',
                process.arch === 'x64' ? 'snoretoast-x64.exe' : 'snoretoast-x86.exe'
            );
            try {
                execFileSync(
                    snoreToast,
                    [
                        '-appID',
                        'Snore.DesktopToasts',
                        '-install',
                        'SnoreToast.lnk',
                        snoreToast,
                        'Snore.DesktopToasts'
                    ]
                );
                this.appName = 'Snore.DesktopToasts';
            } catch (e) {
                console.error('An error occurred while attempting to install the SnoreToast AppID!', e);

obj = JSON.parse(settings, 'utf8');
    console.log(obj);
} catch (e) {

    // automatic platform detection
    var os = require("os");
    var myPlatform = "Unknown";
    if (/^win/.test(process.platform)) {
        myPlatform = 'vs';
    }
    // TODO: make the difference between osx and ios
    else if (process.platform === "darwin") {
        myPlatform = 'osx';
    } else if (process.platform === "linux") {
        myPlatform = 'linux';
        if (process.arch === 'ia32') {
            myPlatform = 'linux';
        } else if (process.arch === 'arm') {
            if (os.cpus()[0].model.indexOf('ARMv6') == 0) {
                myPlatform = 'linuxarmv6l';
            } else {
                myPlatform = 'linuxarmv7l';
            }
        } else if (process.arch === 'x64') {
            myPlatform = 'linux64';
        }
    }

    obj = {
        "defaultOfPath": "",
        "advancedMode": false,
        "defaultPlatform": myPlatform,

const autorestArgs = process.argv.slice(2);

    // temporary: --help displays legacy AutoRest's -Help message
    if (autorestArgs.indexOf("--help") !== -1) {
      await legacyMain(["-Help"]);
      return;
    }

    if (isLegacy(autorestArgs)) {
      await legacyMain(autorestArgs);
    } else {
      await currentMain(autorestArgs);
    }

    // for relaxed profiling (assuming that no one calls `main` from electron... use AAAL!)
    if (require("process").versions.electron) await new Promise(_ => { });

    process.exit(0);
  } catch (e) {
    if (e instanceof Exception) {
      console.error(e.message);
      process.exit(e.exitCode);
    }

    if (e instanceof Error) {
      console.error(e);
      process.exit(1);
    }

    console.error(e);
    process.exit(1);
  }

#!/usr/bin/env node
'use strict';

const ora = require('ora');
const path = require('path');
const chalk = require('chalk');
const fs = require('fs-extra');
const semver = require('semver');
const process = require('process');
const { hashElement } = require('folder-hash');
const spawnAsync = require('@expo/spawn-async');

const nodeVersion = process.versions.node.split('-')[0]; // explode and truncate tag from version

// Validate that used Node version is supported
if (semver.satisfies(nodeVersion, '>=8.9.0')) {
  maybeRebuildAndRun();
} else {
  console.log(
    chalk.red(
      `Node version ${chalk.cyan(nodeVersion)} is not supported. Please use Node.js ${chalk.cyan('8.9.0')} or higher.`
    ),
  );
  process.exit(1);
}

async function maybeRebuildAndRun() {
  const rootDir = path.dirname(__dirname);
  const checksumFilePath = path.join(rootDir, 'build', '.checksum');