TypeScript which.sync函数代码示例

export function createNvim(): Neovim {
  let p = which.sync('nvim')
  let proc = cp.spawn(p, ['-u', 'NORC', '-i', 'NONE', '--embed', '--headless'], {
    shell: false
  })
  return attach({ proc })
}

export function detect(): DartSdkExecutableMap {
  let sdk: DartSdkExecutableMap;
  try {
    const dartExecutable = which.sync('dart');
    if (process.platform === 'win32') {
      sdk = {
        ANALYZER: 'dartanalyzer.bat',
        DARTDOCGEN: 'dartdoc.bat',
        DARTFMT: 'dartfmt.bat',
        PUB: 'pub.bat',
        VM: 'dart.exe'
      };
    } else {
      sdk = {
        ANALYZER: 'dartanalyzer',
        DARTDOCGEN: 'dartdoc',
        DARTFMT: 'dartfmt',
        PUB: 'pub',
        VM: 'dart'
      };
    }
    console.log('Dart SDK detected:', dartExecutable);
    console.log('- dart: ' + child_process.spawnSync(sdk.VM, ['--version']).stderr.toString().replace(/\n/g, ''));
    console.log('- pub: ' + child_process.spawnSync(sdk.PUB, ['--version']).stdout.toString().replace(/\n/g, ''));

    return sdk;
  } catch (e) {
    console.log('Dart SDK is not available.');
    return null;
  }
}

export function executable(command: string): boolean {
  try {
    which.sync(command)
  } catch (e) {
    return false
  }
  return true
}

    function which(executable: string) {
        try {
            var resolved = whichlib.sync(executable);
        } catch(e) {
            //jssh.error(executable)('Not found.');

            // Silently return `""`, as the BASH `which` does.
            // Then we can use this command to test if some executable is installed.
            return jssh.returnString('');
        }
        return jssh.returnString(resolved);
    }

export default function findPodfile() {
  try {
    which.sync('pod');
  } catch (e) {
    console.warn('Cannot find Cocoapods executable');
    return null;
  }
  const podFilePaths = glob.sync('**/Podfile', { ignore: ['node_modules/**', 'ios/Pods/**'] });
  if (podFilePaths.length === 1) {
    return podFilePaths[0];
  }
  return null;
}

    public getLogProcess(): any {
        try {
            which.sync("adb");
        } catch (e) {
            throw new Error("ADB command not found. Please ensure it is installed and available on your path.");
        }

        if (!this.isDeviceAvailable()) {
            throw new Error("No Android devices found. Re-run this command after starting one.");
        }

        return childProcess.spawn("adb", ["logcat"]);
    }

/* eslint-env jest */
import * as cp from 'child_process';
// eslint-disable-next-line import/no-extraneous-dependencies
import * as which from 'which';
import { attach } from '../attach';

try {
  which.sync('nvim');
} catch (e) {
  // eslint-disable-next-line no-console
  console.error(
    'A Neovim installation is required to run the tests',
    '(see https://github.com/neovim/neovim/wiki/Installing)'
  );
  process.exit(1);
}

describe('Neovim API', () => {
  let proc;
  let nvim;

  beforeAll(async done => {
    proc = cp.spawn(
      'nvim',
      ['-u', 'NONE', '-N', '--embed', '-c', 'set noswapfile', 'test.js'],
      {
        cwd: __dirname,
      }
    );

    nvim = await attach({ proc });

export function getPluginPath(plugin) {
    return fs.realpathSync(which.sync(plugin))
}

  protected async createMessageTransports(encoding: string): Promise<MessageTransports | null> {
    function getEnvironment(env: any): any {
      if (!env) return process.env
      return Object.assign({}, process.env, env)
    }

    function startedInDebugMode(): boolean {
      let args: string[] = (process as any).execArgv
      if (args) {
        return args.some(
          arg =>
            /^--debug=?/.test(arg) ||
            /^--debug-brk=?/.test(arg) ||
            /^--inspect=?/.test(arg) ||
            /^--inspect-brk=?/.test(arg)
        )
      }
      return false
    }

    let server = this._serverOptions
    // We got a function.
    if (Is.func(server)) {
      let result = await Promise.resolve(server())
      if (MessageTransports.is(result)) {
        this._isDetached = !!result.detached
        return result
      } else if (StreamInfo.is(result)) {
        this._isDetached = !!result.detached
        return {
          reader: new StreamMessageReader(result.reader),
          writer: new StreamMessageWriter(result.writer)
        }
      } else {
        let cp: ChildProcess
        if (ChildProcessInfo.is(result)) {
          cp = result.process
          this._isDetached = result.detached
        } else {
          cp = result
          this._isDetached = false
        }
        cp.stderr.on('data', data => this.appendOutput(data, encoding))
        return {
          reader: new StreamMessageReader(cp.stdout),
          writer: new StreamMessageWriter(cp.stdin)
        }
      }
    }
    let json = server as NodeModule | Executable
    let runDebug = server as { run: any; debug: any }
    if (runDebug.run || runDebug.debug) {
      // We are under debugging. So use debug as well.
      if (typeof v8debug === 'object' || this._forceDebug || startedInDebugMode()) {
        json = runDebug.debug
      } else {
        json = runDebug.run
      }
    } else {
      json = server as NodeModule | Executable
    }
    let serverWorkingDir = await this._getServerWorkingDir(json.options)
    if (NodeModule.is(json) && json.module) {
      let node = json
      let transport = node.transport || TransportKind.stdio
      let args: string[] = []
      let options: ForkOptions = node.options || Object.create(null)
      let runtime = node.runtime || process.execPath
      if (options.execArgv) options.execArgv.forEach(element => args.push(element))
      if (transport != TransportKind.ipc) args.push(node.module)
      if (node.args) node.args.forEach(element => args.push(element))
      let execOptions: SpawnOptions = Object.create(null)
      execOptions.cwd = serverWorkingDir
      execOptions.env = getEnvironment(options.env)
      let pipeName: string | undefined
      if (transport === TransportKind.ipc) {
        execOptions.stdio = [null, null, null]
        args.push('--node-ipc')
      } else if (transport === TransportKind.stdio) {
        args.push('--stdio')
      } else if (transport === TransportKind.pipe) {
        pipeName = generateRandomPipeName()
        args.push(`--pipe=${pipeName}`)
      } else if (Transport.isSocket(transport)) {
        args.push(`--socket=${transport.port}`)
      }
      args.push(`--clientProcessId=${process.pid.toString()}`)
      if (transport === TransportKind.ipc) {
        let forkOptions: cp.ForkOptions = {
          cwd: serverWorkingDir,
          env: getEnvironment(options.env),
          stdio: [null, null, null, 'ipc'],
          execPath: runtime,
          execArgv: options.execArgv || [],
        }
        let serverProcess = cp.fork(node.module, args, forkOptions)
        if (!serverProcess || !serverProcess.pid) {
          throw new Error(`Launching server ${node.module} failed.`)
        }
        this._serverProcess = serverProcess
//.........这里部分代码省略.........

import * as which from 'which';

import {
    Configuration,
    PlatformInfo,
    ProcedureConfiguration,
    Project
} from './';

import {
    Dictionary
} from '../lang';

import * as Style from '../utils/style';

const NPM_EXECUTABLE = which.sync('npm');

export class Procedure {
    readonly description: string;

    private command: string;
    private cwd: string;
    private env: Dictionary<string>;
    private args: string[];

    private platforms: PlatformInfo[];
    private platformSpecified: boolean;

    constructor(
        private config: ProcedureConfiguration,
        private project: Project