feat: build-target options

.travis.yml

@@ -1,9 +1,7 @@
-os: osx
 language: node_js
 node_js:
 - '6'
 script: npm run nexe-build
 env:
-  - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
-notifications:
-  email: false
+  global:
+    secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=

.vscode/settings.json

@@ -3,7 +3,6 @@
   "prettier.semi": false,
   "prettier.singleQuote": true,
   "prettier.typescriptEnable": ["typescript"],
-  "editor.trimAutoWhitespace": true,
   "files.exclude": {
     "**/.git": true,
     "**/.svn": true,

circle.yml

@@ -1,8 +1,3 @@
-machine:
-  node:
-    version: 6.11.2
-  services:
-    - docker
 test:
   override:
     - npm run nexe-build

examples/native-build/package.json

@@ -13,6 +13,6 @@
     "zmq": "^2.15.3"
   },
   "devDependencies": {
-    "fuse-box": "^2.2.31"
+    "fuse-box": "^2.2.1-beta.7"
   }
 }

package.json

@@ -2,7 +2,7 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "2.0.0-rc.4",
+  "version": "2.0.0-rc.1",
   "contributors": [
     "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
     "Jared Allard <jaredallard@outlook.com>",
@@ -11,8 +11,7 @@
   "scripts": {
     "nexe-build": "ts-node tasks/build",
     "prebuild": "rimraf lib && npm run lint",
-    "prepublish": "npm test && npm run build",
-    "test": "mocha test/**/*.spec.ts",
+    "prepublish": "npm run build",
     "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
     "build": "tsc --declaration"
   },
@@ -35,7 +34,7 @@
     "app-builder": "^5.1.0",
     "chalk": "^1.1.3",
     "download": "^6.2.0",
-    "fuse-box": "2.2.31",
+    "fuse-box": "^2.2.1",
     "globby": "^6.1.0",
     "minimist": "^1.2.0",
     "mkdirp": "^0.5.1",
@@ -46,18 +45,17 @@
   },
   "devDependencies": {
     "@types/bluebird": "^3.5.8",
-    "@types/chai": "^4.0.4",
     "@types/chalk": "^0.4.31",
+    "@types/execa": "0.7.0",
     "@types/globby": "^0.6.0",
     "@types/minimist": "^1.2.0",
     "@types/mkdirp": "^0.3.29",
-    "@types/mocha": "^2.2.42",
     "@types/ora": "^0.3.31",
     "@types/pify": "0.0.28",
     "@types/rimraf": "0.0.28",
-    "chai": "^4.1.2",
+    "execa": "0.8.0",
     "got": "^7.1.0",
-    "mocha": "^3.5.0",
+    "mocha": "^3.2.0",
     "prettier": "^1.6.1",
     "ts-node": "3.3.0",
     "typescript": "^2.4.1"

src/bundling/fuse.ts

@@ -1,6 +1,6 @@
 import { NexeCompiler } from '../compiler'
 import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
-import { readFileAsync, writeFileAsync } from '../util'
+import { readFileAsync } from '../util'
 //import NativeModulePlugin from './fuse-native-module-plugin'
 
 function createBundle(filename: string, options: { name: string; minify: any; cwd: string }) {
@@ -53,10 +53,5 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
     name: compiler.options.name,
     minify: compiler.options.compress
   })
-
-  if (compiler.options.debugBundle) {
-    await writeFileAsync(compiler.options.debugBundle, compiler.input)
-  }
-
   return next()
 }

src/compiler.ts

@@ -8,9 +8,7 @@ import { Logger } from './logger'
 import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
 import { NexeOptions, nexeVersion } from './options'
 import { NexeTarget } from './target'
-import download = require('download')
-import { getLatestGitRelease } from './releases'
-import { IncomingMessage } from 'http'
+import { getLatestGitRelease, storeAsset } from './releases'
 
 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
@@ -37,7 +35,7 @@ export class NexeCompiler {
   public input: string
   public bundledInput?: string
   public output: string | null
-  public targets: NexeTarget[]
+
   public resources: { bundle: string; index: { [key: string]: number[] } } = {
     index: {},
     bundle: ''
@@ -53,7 +51,6 @@ export class NexeCompiler {
 
   constructor(public options: NexeOptions) {
     const { python } = (this.options = options)
-    this.targets = options.targets as NexeTarget[]
     this.log.step('nexe ' + nexeVersion, 'info')
     if (python) {
       if (isWindows) {
@@ -96,7 +93,7 @@ export class NexeCompiler {
     return this.log.flush()
   }
 
-  public getNodeExecutableLocation(target?: NexeTarget) {
+  private _getNodeExecutableLocation(target?: NexeTarget) {
     if (target) {
       return join(this.options.temp, target.toString())
     }
@@ -134,35 +131,19 @@ export class NexeCompiler {
       `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
     )
     await this._runBuildCommandAsync(make, buildOptions)
-    return createReadStream(this.getNodeExecutableLocation())
+    return createReadStream(this._getNodeExecutableLocation())
   }
 
   private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
-    const downloadOptions: any = {
-      headers: {
-        'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-      }
-    }
-    const githubRelease = await getLatestGitRelease(downloadOptions)
+    const githubRelease = await getLatestGitRelease()
     const assetName = target.toString()
     const asset = githubRelease.assets.find(x => x.name === assetName)
 
     if (!asset) {
-      throw new Error(`${assetName} not available, create it using the --build flag`)
+      throw new Error(`${assetName} not available, create one using --build`)
     }
-    const filename = this.getNodeExecutableLocation(target)
-    await download(
-      asset.browser_download_url,
-      dirname(filename),
-      downloadOptions
-    ).on('response', (res: IncomingMessage) => {
-      const total = +res.headers['content-length']!
-      let current = 0
-      res.on('data', data => {
-        current += data.length
-        this.compileStep.modify(`Downloading...${(current / total * 100).toFixed()}%`)
-      })
-    })
+    const filename = this._getNodeExecutableLocation(target)
+    await storeAsset(asset, dirname(filename))
     return createReadStream(filename)
   }
 
@@ -191,13 +172,14 @@ export class NexeCompiler {
   async compileAsync(target: NexeTarget) {
     const step = (this.compileStep = this.log.step('Compiling result'))
     const build = this.options.build
-    const location = this.getNodeExecutableLocation(build ? undefined : target)
+    const location = this._getNodeExecutableLocation(target)
     let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
     const header = this._generateHeader()
-    if (!build && !binary) {
-      step.modify('Fetching prebuilt binary')
+
+    if (target && !build) {
       binary = await this._fetchPrebuiltBinaryAsync(target)
     }
+
     if (!binary) {
       binary = await this._buildAsync()
       step.log('Node binary compiled')

src/nexe.ts

@@ -9,12 +9,11 @@ import {
   NexePatch
 } from './options'
 import cli from './steps/cli'
-import bundle from './steps/bundle'
+import bundle from './bundling/fuse'
 import download from './steps/download'
 import artifacts from './steps/artifacts'
 import patches from './patches'
 import { rimrafAsync } from './util'
-import { NexeTarget } from './target'
 
 async function compile(
   compilerOptions?: Partial<NexeOptions>,
@@ -25,14 +24,10 @@ async function compile(
   const build = compiler.options.build
 
   if (options.clean) {
-    let path = compiler.src
-    if (!options.build) {
-      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
-    }
     const step = compiler.log.step('Cleaning up nexe build artifacts...')
-    step.log(`Deleting contents at: ${path}`)
-    await rimrafAsync(path)
-    step.log(`Deleted contents at: ${path}`)
+    step.log(`Deleting directory and contents at: ${compiler.src}`)
+    await rimrafAsync(compiler.src)
+    step.log(`Deleted directory and contents at: ${compiler.src}`)
     return compiler.quit()
   }
 

src/options.ts

@@ -1,12 +1,11 @@
 import * as parseArgv from 'minimist'
 import { NexeCompiler } from './compiler'
-import { isWindows, padRight } from './util'
+import { isWindows } from './util'
 import { basename, extname, join, isAbsolute, relative } from 'path'
 import { getTarget, NexeTarget } from './target'
 import { EOL } from 'os'
-import * as chalk from 'chalk'
 
-export const nexeVersion = '2.0.0-rc.4'
+export const nexeVersion = '2.0.0-rc.1'
 
 export interface NexePatch {
   (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
@@ -39,7 +38,6 @@ export interface NexeOptions {
   verbose?: boolean
   info?: boolean
   ico?: string
-  debugBundle?: boolean
   warmup?: string
   compress?: boolean
   clean?: boolean
@@ -49,6 +47,10 @@ export interface NexeOptions {
   downloadOptions: any
 }
 
+function padRight(str: string, l: number) {
+  return (str + ' '.repeat(l)).substr(0, l)
+}
+
 const defaults = {
   version: process.version.slice(1),
   flags: [],
@@ -80,25 +82,24 @@ const alias = {
   l: 'loglevel'
 }
 const argv = parseArgv(process.argv, { alias, default: defaults })
-const g = chalk.gray
 const help =
   `
 nexe --help              CLI OPTIONS
 
-  -i   --input      ${g('=index.js')}               -- application entry point
-  -o   --output     ${g('=my-app.exe')}             -- path to output file
-  -t   --target     ${g('=mac-x64-8.4.0')}          -- *target a prebuilt binary
-  -n   --name       ${g('=my-app')}                 -- main app module name
-  -v   --version    ${g(`=${padRight(process.version.slice(1), 23)}`)}-- node version
-  -p   --python     ${g('=/path/to/python2')}       -- python executable
-  -f   --flag       ${g('="--expose-gc"')}          -- *v8 flags to include during compilation
-  -c   --configure  ${g('="--with-dtrace"')}        -- *pass arguments to the configure step
-  -m   --make       ${g('="--loglevel"')}           -- *pass arguments to the make/build step
-  -s   --snapshot   ${g('=/path/to/snapshot')}      -- build with warmup snapshot
-  -r   --resource   ${g('=./paths/**/*')}           -- *embed file bytes within the binary
   -b   --build                              -- build from source
-       --bundle     ${g('=./path/to/config')}       -- pass a module path that exports nexeBundle
-       --temp       ${g('=./path/to/temp')}         -- default './nexe'
+  -i   --input      =index.js               -- application entry point
+  -o   --output     =my-app.exe             -- path to output file
+  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
+  -n   --name       =my-app                 -- main app module name
+  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
+  -p   --python     =/path/to/python2       -- python executable
+  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
+  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure step
+  -m   --make       ="--loglevel"           -- *pass arguments to the make/build step
+  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
+  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
+       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
+       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
        --no-bundle                          -- set when input is already bundled
        --cwd                                -- set the current working directory for the command
        --ico                                -- file name for alternate icon file (windows)
@@ -170,15 +171,13 @@ function findInput(input: string, cwd: string) {
   if (isEntryFile(maybeInput)) {
     return maybeInput
   }
-  if (!process.stdin.isTTY) {
-    return ''
-  }
   try {
     const main = require.resolve(cwd)
     return './' + relative(cwd, main)
   } catch (e) {
     void e
   }
+
   return ''
 }
 
@@ -196,26 +195,26 @@ function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOption
   options.input = findInput(options.input, options.cwd)
   options.loglevel = extractLogLevel(options)
   options.flags = flattenFilter(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets).map(getTarget)
+  options.targets = flattenFilter(opts.target, options.targets)
   options.make = flattenFilter(options.vcBuild, options.make)
   options.configure = flattenFilter(options.configure)
   options.resources = flattenFilter(opts.resource, options.resources)
   options.rc = options.rc || extractCliMap(/^rc-.*/, options)
 
-  if (!options.targets.length) {
-    options.targets = [getTarget(options.version)]
-  }
+  options.targets = options.targets.map(getTarget)
 
-  if (options.build) {
+  if (options.build && options.targets.length) {
     const { arch } = options.targets[0] as NexeTarget
     if (isWindows) {
-      options.make = Array.from(new Set(options.make.concat(arch)))
+      options.make = Array.from(new Set(options.make.concat([arch])))
     } else {
       options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
     }
   }
 
-  options.version = (options.targets[0] as NexeTarget).version
+  if (!options.targets.length) {
+    options.targets = [getTarget(options.version)]
+  }
 
   options.patches = options.patches.map(x => {
     if (typeof x === 'string') {

src/releases.ts

@@ -42,6 +42,11 @@ export function getLatestGitRelease(options?: any) {
   return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
 }
 
+export async function storeAsset(asset: GitAsset, dest: string, headers?: any) {
+  const options = headers ? { headers } : undefined
+  await download(asset.browser_download_url, dest, options as any)
+}
+
 export async function getUnBuiltReleases(options?: any) {
   const nodeReleases = await getJson<NodeRelease[]>(
     'https://nodejs.org/download/release/index.json'

src/steps/download.ts

@@ -3,7 +3,6 @@ import { pathExistsAsync } from '../util'
 import { LogStep } from '../logger'
 import { IncomingMessage } from 'http'
 import { NexeCompiler } from '../compiler'
-import { NexeTarget } from '../target'
 
 function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
   const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
@@ -28,8 +27,8 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
  * @param {*} next
  */
 export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src, log, targets: [{ version }] } = compiler
-  const { sourceUrl, downloadOptions } = compiler.options
+  const { src, log } = compiler
+  const { version, sourceUrl, downloadOptions } = compiler.options
   const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
   const step = log.step(`Downloading Node.js source from: ${url}`)
   if (await pathExistsAsync(src)) {

src/target.ts

@@ -8,15 +8,14 @@ export { platforms, architectures }
 
 export interface NexeTarget {
   version: string
-  platform: NodePlatform | string
-  arch: NodeArch | string
+  platform: NodePlatform
+  arch: NodeArch
 }
 
 //TODO bsd
 const prettyPlatform: { [key: string]: NodePlatform } = {
   win32: 'windows',
   windows: 'windows',
-  win: 'windows',
   darwin: 'mac',
   macos: 'mac',
   mac: 'mac',
@@ -37,7 +36,7 @@ function isVersion(x: string) {
   if (!x) {
     return false
   }
-  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ''))
+  return /\d/.test(x.replace(/v|\./g, ''))
 }
 
 function isPlatform(x: string): x is NodePlatform {
@@ -62,7 +61,7 @@ export function targetsEqual(a: NexeTarget, b: NexeTarget) {
   return a.arch === b.arch && a.platform === b.platform && a.version === b.version
 }
 
-export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
+export function getTarget(target: string | NexeTarget = ''): NexeTarget {
   let arch = process.arch as NodeArch,
     platform = prettyPlatform[process.platform],
     version = process.version.slice(1)
@@ -76,7 +75,7 @@ export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget
     .split('-')
     .forEach(x => {
       if (isVersion(x)) {
-        version = x.replace(/v/g, '')
+        version = x
       }
       if (isPlatform(x)) {
         platform = prettyPlatform[x]

src/util.ts

@@ -22,10 +22,6 @@ function falseOnEnoent(e: any) {
   throw e
 }
 
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
-
 function dequote(input: string) {
   input = input.trim()
   const singleQuote = input.startsWith("'") && input.endsWith("'")
@@ -61,7 +57,6 @@ function isDirectoryAsync(path: string) {
 
 export {
   dequote,
-  padRight,
   isWindows,
   rimrafAsync,
   statAsync,

tasks/build.ts

@@ -12,16 +12,13 @@ import got = require('got')
 const env = process.env,
   branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
   isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
-  isLinux = Boolean(env.CIRCLECI),
+  isLinux = Boolean(env.TRAVIS),
   isWindows = Boolean(env.APPVEYOR),
-  isMac = Boolean(env.TRAVIS),
+  isMac = Boolean(env.CIRCLECI),
   isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
     || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
     || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = { 
-    'Authorization': 'token ' + env.GITHUB_TOKEN,
-    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-  }
+  headers = { 'Authorization': 'token ' + env.GITHUB_TOKEN }
 
 if (require.main === module) {
   if (!isPullRequest) {
@@ -60,7 +57,7 @@ async function build () {
       options = {
         empty: true,
         build: true,
-        target,
+        target, //FIXME
         output
       }
     
@@ -81,8 +78,7 @@ async function build () {
         body: await readFileAsync(output),
         headers: {
           'Authorization': 'token ' + env.GITHUB_TOKEN,
-          'Content-Type': 'application/octet-stream',
-          'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
+          'Content-Type': 'application/octet-stream'
         }
       })
       console.log(target + ' uploaded.')

tasks/ci.ts

@@ -3,7 +3,7 @@ import got = require('got')
 import * as assert from 'assert'
 const { env } = process
 
-export function triggerMacBuild(release: NexeTarget, branch: string) {
+export function triggerDockerBuild(release: NexeTarget, branch: string) {
   assert.ok(env.TRAVIS_TOKEN)
   const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
   return got(travis, {
@@ -14,7 +14,7 @@ export function triggerMacBuild(release: NexeTarget, branch: string) {
         config: {
           merge_mode: 'deep_merge',
           env: {
-            NEXE_VERSION: release.toString()
+            NEXE_VERSION: release
           }
         }
       }
@@ -26,7 +26,7 @@ export function triggerMacBuild(release: NexeTarget, branch: string) {
   })
 }
 
-export function triggerDockerBuild (release: NexeTarget, branch: string) {
+export function triggerMacBuild (release: NexeTarget, branch: string) {
   assert.ok(env.CIRCLE_TOKEN)
   const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${env.CIRCLE_TOKEN}`
   return got(circle, {

tasks/docker.ts

@@ -1,73 +1,32 @@
 import { NexeTarget } from '../src/target'
-import { writeFileAsync, readFileAsync } from '../src/util'
-import { spawn } from 'child_process'
-import got = require('got')
-import { createWriteStream, WriteStream } from 'fs'
+import { writeFileAsync } from '../src/util'
+import exec = require('execa')
 
-function alpine (target: NexeTarget, nexeVersion: string) {  
+function alpine (target: NexeTarget, nexeVersion: string) {
+  const version = target.version
   return `
-FROM i386/alpine:3.4
+FROM i386/alpine:3.6
 RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
-ENV NODE_VERSION=${target.version}
-ENV NEXE_VERSION=beta
 WORKDIR /
-
-RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
-  cd /node-v\${NODE_VERSION} && \
+RUN curl -sSL https://nodejs.org/dist/v${version}/node-v${version}.tar.gz | tar -xz && \
+  cd /node-v${version} && \
   ./configure --prefix=/usr --fully-static && \
-  make -j$(getconf _NPROCESSORS_ONLN) && \
+  make -j$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1) && \
   make install && \
   paxctl -cm /usr/bin/node
 
-RUN mkdir /nexe_temp && mv node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
-  npm install -g nexe@\${NEXE_VERSION} && \
-  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out
-`.trim()
-}
+RUN mkdir nexe_temp && mv node-v${version} nexe_temp/${version}
+RUN npm i nexe@beta -g
+ENV NEXE_TEMP=/nexe_temp
 
-export async function runAsync (command: string, output: WriteStream) {
-  const commands = command.split(/\r?\n/)
-    .filter(x => x.trim())
-    .map(x => x.trim().split(' '))
-  const sequence = Promise.resolve()
-  for (const command of commands) {
-    await new Promise((resolve, reject) => {
-      const cp = spawn(command.shift() as string, command)
-      cp.stderr.pipe(output)
-      cp.stdout.pipe(output)
-      const close = function (this: any, e: Error) {
-        this.kill()
-        e ? reject(e) : resolve()
-      }
-      cp.on('error', (e) => {
-        output.write(e.stack)
-      })
-      .on('close', close)
-      .on('exit', close)
-    })
-  }
+RUN nexe --empty -c="--fully-static" -o /nexe-out`.trim()
 }
 
 export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
   await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
-  const outFilename = 'nexe-alpine-build-log.txt'
-  const output = createWriteStream(outFilename)
-  try {
-    await runAsync(`
-    docker build -t nexe-alpine .
-    docker run -d --name nexe nexe-alpine sh
-    docker cp nexe:/out out
-    docker rm nexe
-  `, output)
-  } catch(e) {
-    console.log(e)
-  } finally {
-    output.close()
-    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
-      body: await readFileAsync(outFilename),
-      method: 'PUT'
-    })
-    .then(x => console.log(x.body))
-    .catch(e => console.log('Error posting log', e))
-  }
+  const option = { stido: 'inherit' } as any
+  await exec('docker', ['build', '-t', 'nexe-alpine', '.'], option)
+  await exec('docker', ['run', '--name', 'nexe', 'nexe-alpine'], option)
+  await exec('docker', ['cp', 'nexe:/nexe-out', 'out'], option)
+  await exec('docker', ['rm', 'nexe'], option)
 }

test/mocha.opts

@@ -1,3 +0,0 @@
---check-leaks
---require ts-node/register
---recursive

test/target.spec.ts

@@ -1,28 +0,0 @@
-import { padRight, isWindows } from '../src/util'
-import { expect } from 'chai'
-import { blue as b } from 'chalk'
-import { getTarget, NexeTarget } from '../src/target'
-
-const arch = (isWindows && process.arch === 'ia32') ? 'x86' : process.arch
-
-describe('Targets', () => {
-  [
-    ['win-ia32-6.11.2', 'windows-x86-6.11.2'],
-    [{ version: '6.11.2', platform: 'win', arch: 'ia32' }, 'windows-x86-6.11.2'],
-    ['win32-x64-6.11.2', 'windows-x64-6.11.2'],
-    ['darwin-x64-v8.4.0', 'mac-x64-8.4.0'],
-    ['static-x86-6.10.3', 'alpine-x86-6.10.3'],
-    ['linux-x32', `linux-x86-${process.version.slice(1)}`],
-    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
-    ['not-a-thing', getTarget(process).toString()]
-  ].forEach(([input, expected]) => {
-    it(`${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
-      expect(getTarget(input).toString()).to.equal(expected)
-    })
-  })
-
-  it ('should stringify and toString', () => {
-    expect(JSON.stringify(getTarget(process))).to.equal(`"${getTarget(process)}"`)
-  })
-})
-