build-strap 3.0.0 → 4.0.0-dev.4

package/src/publish.js

@@ -1,144 +0,0 @@
-// @flow
-import path from 'path';
-import fs from 'fs-extra';
-import { run, buildLog } from './run';
-import { getVersion, type Version } from './version';
-import { getPkgName } from './pkg';
-import {
-  artifactoryNpm,
-  artifactoryStandard,
-  type ArtifactoryConfig,
-  type ArtifactoryCreds,
-} from './artifactory';
-import { npmPublish } from './npm';
-import type { NpmConfig, NpmCreds } from './npm';
-import { tgzDir, type ArtifactInfo } from './tgz';
-
-export type CreateArtifactOptions = {
-  distDir: string, // What to bundle up and publish
-  outDir: string, // Where the bundled tgz file should go
-  fileName?: string, // (optional) Specify the tgz file name
-};
-
-export type Artifact = {
-  name: string,
-  version: Version,
-  info: ArtifactInfo,
-  fileName: string,
-  filePath: string,
-}
-
-// create tgz from distDir in outDir
-export async function createArtifact({
-  distDir,
-  outDir,
-  fileName,
-}: CreateArtifactOptions): Promise<Artifact> {
-  const version = await getVersion();
-  const name = getPkgName();
-
-  buildLog(`gzipping ${name} v${version.info}...`);
-
-  const tgzFileName = fileName || `${name}-${version.info}.tgz`;
-  const tgzFilePath = path.join(outDir, tgzFileName);
-  const info = await tgzDir(distDir, tgzFilePath, {
-    prefix: 'package',
-  });
-
-  buildLog(`md5: ${info.md5}`);
-  buildLog(`sha1: ${info.sha1}`);
-  buildLog(`sha512: ${info.sha512}`);
-  buildLog(`size: ${info.size} bytes`);
-
-  return {
-    name,
-    version,
-    info,
-    fileName: tgzFileName,
-    filePath: tgzFilePath,
-  };
-}
-
-export type PublishConfiguration = {
-  ...CreateArtifactOptions,
-  doPublish: boolean, // Actually publish?
-  prePublishFn?: () => any, // (optional) Callback to invoke before publishing
-  artifactoryConfig?: ArtifactoryConfig, // (optional) Artifactory config info (normally in package.json)
-  artifactoryCreds?: ArtifactoryCreds, // (optional) Artifactory credentials (normally from ENV var)
-  npmPath?: string, // (optional) Path to npm executable
-  npmTag?: string, // (optional) tag to apply to npm package
-  npmSkipExisting?: boolean, // (optional) if true, don't error when artifact already exists (skip publish)
-  npmConfig?: NpmConfig, // (optional) Npm config info (normally in package.json)
-  npmCreds?: NpmCreds, // (optional) Npm credentials (normally from ENV var)
-  npmAuthToken?: string, // (optional) Npm auth token (normally from ENV var)
-};
-
-// tgz the distDir, and copy it to the outDir
-// if toArtifactory is true, also publishes to artifactory
-export async function publish({
-  distDir,
-  outDir,
-  doPublish,
-  prePublishFn,
-  fileName,
-  artifactoryConfig,
-  artifactoryCreds,
-  npmPath,
-  npmTag,
-  npmSkipExisting = false,
-  npmConfig,
-  npmCreds,
-  npmAuthToken,
-}: PublishConfiguration) {
-  if (typeof prePublishFn === 'function') {
-    await run(async () => {
-      await prePublishFn();
-    });
-  }
-
-  const {
-    info,
-    filePath: tgzFilePath,
-    fileName: tgzFileName,
-  } = await createArtifact({ distDir, outDir, fileName });
-
-  if (!doPublish) {
-    buildLog(
-      'Skipping publish for dev build. Use `--publish` arg to publish for real.',
-    );
-    return;
-  }
-
-  // Publish to all repos configured in package.json
-  await fs.copyFile(
-    path.join(distDir, 'package.json'),
-    path.join(outDir, 'package.json'),
-  );
-  const artifact = fs.createReadStream(tgzFilePath);
-  await Promise.all([
-    npmPublish({
-      publishPath: tgzFilePath,
-      npmConfig,
-      npmCreds,
-      npmAuthToken,
-      tag: npmTag,
-      skipExisting: npmSkipExisting,
-      npmPath,
-    }),
-    artifactoryStandard(
-      artifact,
-      info,
-      tgzFileName,
-      artifactoryConfig,
-      artifactoryCreds,
-    ),
-    artifactoryNpm(
-      distDir,
-      artifactoryConfig,
-      artifactoryCreds,
-      npmPath,
-      npmTag,
-      npmSkipExisting,
-    ),
-  ]);
-}

package/src/run.js

@@ -1,89 +0,0 @@
-// @flow
-export function format(time?: Date = new Date()): string {
-  return time.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, '$1');
-}
-
-const silenceLogs = process.argv.includes('--silence-buildLog');
-
-export function buildLog(msg: string, time?: Date) {
-  if (silenceLogs) {
-    return;
-  }
-  console.info(`[${format(time || new Date())}] ${msg}`);
-}
-
-export type RunnableModule<T> =
-  | (() => Promise<T>)
-  | { default: () => Promise<T> };
-
-export async function run<T>(
-  fn: RunnableModule<T>,
-  ...options: any[]
-): Promise<T> {
-  if (fn == null) {
-    throw new Error(`Invalid argument passed to run(${fn})`);
-  }
-  const task = typeof fn === 'function' ? fn : fn.default;
-  if (typeof task !== 'function') {
-    throw new Error(
-      'First argument to run must be a function or module with default function.',
-    );
-  }
-  const start = new Date();
-  buildLog(`Starting '${task.name}'...`, start);
-  const result = await task(...options);
-  const end = new Date();
-  const time = end.getTime() - start.getTime();
-  buildLog(`Finished '${task.name}' after ${time} ms`, end);
-  return result;
-}
-
-export type RunCliOptions<T> = {
-  resolveFn?: (path: string) => RunnableModule<T>,
-  defaultAction?: string | RunnableModule<T>,
-  argv?: string[],
-  passthroughArgv?: boolean,
-};
-
-export async function runCli<T>({
-  resolveFn = (path: string) =>
-    // $FlowFixMe
-    require(`./${path}`).default, // eslint-disable-line
-  defaultAction = 'publish',
-  argv = process.argv,
-  passthroughArgv = false,
-}: RunCliOptions<T> = {}): Promise<T> {
-  const module =
-    argv.length > 2
-      ? resolveFn(argv[2])
-      : typeof defaultAction === 'string'
-      ? resolveFn(defaultAction)
-      : defaultAction;
-  const args = Array.isArray(passthroughArgv)
-    ? passthroughArgv.includes(argv[2] || defaultAction)
-      ? argv.slice(3)
-      : []
-    : passthroughArgv
-    ? argv.slice(3)
-    : [];
-  return run(module, ...args).catch((err) => {
-    console.error((err && err.stack) || err);
-    process.exit(1);
-    throw err;
-  });
-}
-
-export function handleEntryPoint<T>(
-  mainModule: typeof module,
-  mainModuleFilename: string,
-  cliOptions?: RunCliOptions<T>,
-) {
-  if (require.main === mainModule) {
-    delete require.cache[mainModuleFilename]; // eslint-disable-line no-underscore-dangle
-    runCli(cliOptions);
-  }
-}
-
-handleEntryPoint(module, __filename);
-
-export default run;

package/src/test.js

@@ -1,55 +0,0 @@
-// @flow
-import { run, buildLog } from './run';
-import { onKillSignal } from './cp';
-
-export async function karmaTest(
-  karma: Object,
-  karmaConfig: any,
-  preTestFn?: () => any,
-  watch: boolean = process.argv.includes('--watch'),
-) {
-  // Lazy require karma
-  const { Server, runner, stopper, config } = karma;
-
-  const testConfig = config.parseConfig(karmaConfig, {
-    autoWatch: false,
-    singleRun: !watch,
-  });
-  const server = new Server(testConfig, (exitCode) => {
-    buildLog(`Karma has exited with code ${exitCode}`);
-  });
-  onKillSignal(() => stopper.stop(testConfig));
-
-  let started = false;
-  async function doTest() {
-    if (!started) {
-      await Promise.all([
-        new Promise((resolve) => {
-          server.on('browsers_ready', resolve);
-        }),
-        server.start(),
-      ]);
-      started = true;
-    }
-    if (watch) {
-      // await server.refreshFiles();
-      await new Promise((resolve, reject) => {
-        runner.run(testConfig, (exitCode) => {
-          buildLog(`Karma run completed with exit code ${exitCode}`);
-          if (exitCode === 0 || watch) {
-            resolve(exitCode);
-          } else {
-            reject(exitCode);
-          }
-        });
-      });
-    }
-  }
-
-  if (typeof preTestFn === 'function') {
-    // preTestFn is expected to callback and run doTest
-    await run(preTestFn, doTest);
-  } else {
-    await doTest();
-  }
-}

package/src/tgz.js

@@ -1,101 +0,0 @@
-// @flow
-import path from 'path';
-import tar from 'tar';
-import fs from 'fs';
-import crypto from 'crypto';
-import StreamCounter from 'stream-counter';
-import { makeDir } from './fs';
-import { buildLog } from './run';
-
-export type ArtifactInfo = {
-  md5: string,
-  sha1: string,
-  sha512: string,
-  size: number,
-  contentType?: string,
-};
-
-const generateHash = async (
-  stream: stream$Readable,
-  type: 'md5' | 'sha1' | 'sha512',
-): Promise<string> =>
-  new Promise((resolve, reject) => {
-    stream
-      .pipe(crypto.createHash(type).setEncoding('hex'))
-      .on('finish', function () {
-        resolve(this.read());
-      })
-      .on('end', function () {
-        resolve(this.read());
-      })
-      .on('error', (err) => reject(err));
-  });
-
-const countBytes = async (stream: stream$Readable): Promise<number> =>
-  new Promise((resolve, reject) => {
-    const counter = new StreamCounter();
-    stream
-      .pipe(counter)
-      .on('finish', () => resolve(counter.bytes))
-      .on('end', () => resolve(counter.bytes))
-      .on('error', (err) => reject(err));
-  });
-
-const writeStreamToFile = async (stream: stream$Readable, filePath: string) =>
-  new Promise((resolve, reject) => {
-    stream
-      .pipe(fs.createWriteStream(filePath))
-      .on('finish', () => {
-        buildLog(`Successfully wrote file: ${filePath}`);
-        resolve();
-      })
-      .on('error', (err) => reject(err));
-  });
-
-// Take the given file (path or stream) and compute the info that artifactory needs.
-// md5 + sha1 hash, and size in bytes
-export async function getArtifactInfo(
-  artifact: string | stream$Readable,
-): Promise<ArtifactInfo> {
-  // make it into a stream
-  const stream: stream$Readable =
-    typeof artifact === 'string' ? fs.createReadStream(artifact) : artifact;
-
-  const [md5, sha1, sha512, size] = await Promise.all([
-    generateHash(stream, 'md5'),
-    generateHash(stream, 'sha1'),
-    generateHash(stream, 'sha512'),
-    countBytes(stream),
-  ]);
-  return { md5, sha1, sha512, size };
-}
-
-// Creates a gzipped tarball of a directory, returns sha1 + md5 hash and size of resulting file
-export async function tgzDir(
-  srcDir: string,
-  outPath: string,
-  options?: ?{ [string]: any },
-): Promise<ArtifactInfo> {
-  await makeDir(path.dirname(outPath));
-  const tgzStream = tar.c(
-    // $FlowFixMe
-    {
-      gzip: true,
-      cwd: srcDir,
-      portable: true,
-      // $FlowFixMe
-      ...options,
-    },
-    ['.'],
-  );
-
-  // write the file to disk (outPath)
-  const [info] = await Promise.all([
-    getArtifactInfo(tgzStream),
-    writeStreamToFile(tgzStream, `${outPath}`),
-  ]);
-  return {
-    ...info,
-    contentType: 'application/gzip',
-  };
-}

package/src/version.js

@@ -1,141 +0,0 @@
-// @flow
-import fs from 'fs';
-import { gitInfo } from './git';
-import { hgInfo } from './hg';
-import { getCfg, getPkg } from './pkg';
-import { buildLog } from './run';
-
-export function getBuild(): string {
-  let arg = process.argv.find((el) => /^--buildNum=\d+$/.test(el));
-  arg = arg && arg.substr(11);
-  return arg || process.env.BUILD_NUMBER || '0';
-}
-
-export function getReleaseBranch(): string {
-  const { releaseBranch } = getCfg();
-  return releaseBranch || 'master';
-}
-
-type RepoType = 'git' | 'hg' | 'unknown';
-export function getRepoType(): RepoType {
-  const { repoType } = getCfg();
-
-  return (
-    repoType ||
-    (fs.existsSync('./.hg')
-      ? 'hg'
-      : fs.existsSync('./.git')
-      ? 'git'
-      : 'unknown')
-  );
-}
-
-type RepoInfo = {
-  branch: string,
-  revision: string,
-};
-
-export async function getRepoInfo(): Promise<RepoInfo> {
-  const repoType = getRepoType();
-  const { branch, revision } =
-    repoType === 'git'
-      ? await gitInfo()
-      : repoType === 'hg'
-      ? await hgInfo()
-      : {};
-  if (!branch || !revision) {
-    throw new Error('Failed to parse branch and revision from source repo.');
-  }
-  return { branch, revision };
-}
-
-export function getDevBranch(): string {
-  const { devBranch } = getCfg();
-  return devBranch || getRepoType() === 'hg' ? 'default' : 'dev';
-}
-
-export async function getIsRelease(
-  passedBranch?: ?string = null,
-  releaseOverride?: ?boolean = null,
-): Promise<boolean> {
-  const branch = passedBranch || (await getRepoInfo()).branch;
-  return releaseOverride != null
-    ? releaseOverride
-    : process.argv.includes('--force-release-version')
-    ? true
-    : branch === getReleaseBranch();
-}
-
-let cacheVersion = true;
-export function useVersionCache(useCache: boolean = true): void {
-  cacheVersion = useCache;
-}
-
-export type Version = {|
-  branch: string,
-  build: string,
-  info: string,
-  isRelease: boolean,
-  major: string,
-  minor: string,
-  name: string,
-  npm: string,
-  patch: string,
-  revision: string,
-  short: string,
-|};
-
-let version = null;
-export async function getVersion(
-  logIt: boolean = true,
-  release: ?boolean = null,
-): Promise<Version> {
-  if (!cacheVersion || version == null) {
-    const { version: pkgVers, name } = getPkg();
-    const { branch, revision } = await getRepoInfo();
-    const [, major, minor, patch] =
-      pkgVers.match(/^(\d+)\.(\d+)\.(\d+)$/) || [];
-    if (!major || !minor || !patch) {
-      throw new Error('Invalid version format in package.json');
-    }
-    const build = getBuild();
-    const isRelease = await getIsRelease(branch, release);
-    const short = `${major}.${minor}.${patch}`;
-    const npm = `${short}${isRelease ? '' : `-${branch}.${build}`}`;
-    const info = `${short}${
-      isRelease ? `+${build}.` : `-${branch}.${build}+`
-    }${revision}`;
-    version = {
-      name,
-      branch,
-      revision,
-      major,
-      minor,
-      patch,
-      build,
-      short,
-      isRelease,
-      npm,
-      info,
-    };
-    if (logIt) buildLog(`Building version ${info}`);
-  }
-  return version;
-}
-
-export async function getBanner(): Promise<string> {
-  const { copyright = '' } = getCfg();
-  const { info, name } = await getVersion();
-  const today = new Date();
-  return `${name} v${info} | (c) ${today.getFullYear()} ${copyright} | built on ${today.toISOString()}`;
-}
-
-export async function getVersionCode(): Promise<string> {
-  return `// This file is auto-generated
-export const version = ${JSON.stringify(await getVersion(), null, 2)}`;
-}
-
-export async function getUniqueBuildTag(): Promise<string> {
-  const { branch, revision, build } = await getVersion();
-  return `${branch}-${revision}-${build}`;
-}

package/src/yarn.js

@@ -1,123 +0,0 @@
-// @flow
-import md5File from 'md5-file';
-import fs from 'fs-extra';
-import path from 'path';
-import { spawnAdv } from './cp';
-import type { SpawnOptions, SpawnResult } from './cp';
-import { buildLog } from './run';
-import { readDir } from './fs';
-import { getPkg } from './pkg';
-
-export type YarnOptions = {|
-  args?: string[],
-  spawnOptions?: ?SpawnOptions,
-|};
-
-export async function yarnAdv(opts?: YarnOptions): Promise<SpawnResult> {
-  const { args = [], spawnOptions } = opts || {};
-  const localYarn = path.join(
-    path.dirname(process.execPath),
-    '/node_modules/yarn/bin/yarn.js',
-  );
-
-  const spawnOpts = {
-    stdio: 'inherit',
-    shell: true,
-    env: process.env,
-    ...spawnOptions,
-  };
-
-  return (await fs.exists(localYarn))
-    ? // prefer to use local copy of yarn
-      spawnAdv(process.execPath, [localYarn, ...args], spawnOpts)
-    : // fall back to globally installed yarn
-      spawnAdv('yarn', args, spawnOpts);
-}
-
-export async function yarn(opts?: YarnOptions): Promise<string> {
-  const { args = [], spawnOptions } = opts || {};
-  return yarnAdv({
-    args,
-    spawnOptions: { rejectOnErrorCode: true, ...spawnOptions },
-  }).then((r) => r.output);
-}
-
-export const yarnFiles = ['./package.json', './yarn.lock'];
-
-export type YarnInstallOptions = {|
-  nodeModulesPath?: string,
-  hashFilePath?: string,
-  force?: boolean,
-|};
-
-// Smart yarn invocation, only if package changed
-export async function yarnInstall(opts?: YarnInstallOptions) {
-  const {
-    nodeModulesPath = './node_modules',
-    hashFilePath = './download/buildHash_yarn.md5',
-    force = false,
-  } = opts || {};
-  await fs.ensureDir(nodeModulesPath);
-  const currentHash = (
-    await Promise.all(yarnFiles.map(async (f) => md5File(f)))
-  ).join('|');
-  await fs.ensureFile(hashFilePath);
-  const prevHash = await fs.readFile(hashFilePath, 'utf8');
-  if (currentHash !== prevHash) {
-    buildLog(
-      'node package definition changed since last build, invoking yarn.',
-    );
-  } else if (!(await readDir(`${nodeModulesPath}/**/*.js`)).length) {
-    buildLog('node packages missing, invoking yarn.');
-  } else if (force) {
-    buildLog('node packages unchanged, but yarn forced on command line...');
-  } else {
-    buildLog('node packages unchanged since last build, skipping yarn.');
-    return;
-  }
-  await yarn();
-  await fs.writeFile(hashFilePath, currentHash);
-}
-
-export type YarnUpgradeOptions = {|
-  /**
-   * Use `yarn outdated` to find packages that should be upgraded
-   * May include breaking changes (major version changes)
-   */
-  outdated?: boolean,
-  /**
-   * `false` by default
-   * we assume any package with an explicit version shouldn't be touched
-   */
-  all?: boolean,
-|};
-
-export async function yarnUpgrade(opts?: YarnUpgradeOptions) {
-  const { outdated = false, all = false } = opts || {};
-  if (outdated) {
-    const { code, stdout } = await yarnAdv({
-      args: ['outdated'],
-      spawnOptions: { stdio: 'pipe', captureOutput: true },
-    });
-    if (code === 0) {
-      buildLog('No outdated packages.');
-    } else {
-      const { dependencies = {}, devDependencies = {} } = getPkg();
-      const packages = stdout
-        .split('\n')
-        .slice(5, -1)
-        .map((l) => l.split(/\s+/)[0])
-        .filter(
-          (p) =>
-            all || !/^\d/.test(dependencies[p] || devDependencies[p] || ''),
-        );
-      if (packages.length) {
-        await yarn({ args: ['add', ...packages] });
-        buildLog(`Upgraded: ${packages.join(', ')}`);
-      } else {
-        buildLog('No eligible outdated packages');
-      }
-    }
-  }
-  await yarn({ args: ['upgrade'] });
-}