How to use pify - 10 common examples

function createRenderer (bundle, manifest) {
  // Create bundle renderer to give a fresh context for every request
  this.renderer = createBundleRenderer(bundle, Object.assign({
    clientManifest: manifest,
    runInNewContext: false,
    inject: false,
    baseDir: this.options.dir
  }, this.options.build.ssr))
  this.renderToString = pify(this.renderer.renderToString)
  this.renderToStream = this.renderer.renderToStream
}

import fs from 'fs';
import path from 'path';
import test from 'ava';
import pify from 'pify';
import fn from '..';

process.chdir(__dirname);

const readFile = pify(fs.readFile);
const hasRule = (results, ruleId) => results[0].messages.some(x => x.ruleId === ruleId);

test('.lintText()', t => {
	const {results} = fn.lintText('\'use strict\'\nconsole.log(\'unicorn\');\n');
	t.true(hasRule(results, 'semi'));
});

test('default `ignores`', t => {
	const result = fn.lintText('\'use strict\'\nconsole.log(\'unicorn\');\n', {
		filename: 'node_modules/ignored/index.js'
	});
	t.is(result.errorCount, 0);
	t.is(result.warningCount, 0);
});

test('`ignores` option', t => {

import './support.js';

import FileChangeCache from '../src/file-change-cache';
import path from 'path';
import fs from 'fs';
import pify from 'pify';
const pfs = pify(fs);

describe('The file changed cache', function() {
  beforeEach(function() {
    this.fixture = new FileChangeCache(null);
  });

  it("Correctly computes a file hash for a canned file", async function() {
    const expectedInfo = {
      hash: '4a92e95074156e8b46869519c43ddf10b59299a4',
      hasSourceMap: false,
      isInNodeModules: false,
      isMinified: false,
      isFileBinary: false
    };

    let input = path.resolve(__dirname, '..', 'test', 'fixtures', 'valid.js');

test('prevent clockout before clockin', async t => {
	const timecard = t.context.timecard;
	const fixture = path.join(fixtures, 'blank.json');
	const data = await pify(fs.readFile)(fixture, 'utf8');
	await timecard.load(data);

	timecard.clockout().catch(err => {
		t.true(err.search('You must clockin before clocking out') > -1);
	});
});

it('is a promise wrapper around glob', async () => {
      module._glob = null;
      const mockGlob = jest.fn().mockReturnValue('foo');
      pify.mockReturnValue(mockGlob);

      const actual = await module.glob('pattern');

      expect(actual).toEqual('foo');
      expect(pify).toHaveBeenCalledWith(glob);
      expect(mockGlob).toHaveBeenCalledWith('pattern');
    });
  });

it('is a promise wrapper around fs.readFile', async () => {
      module._readFile = null;
      const mockReadFile = jest.fn().mockReturnValue('foo');
      pify.mockReturnValue(mockReadFile);

      const actual = await module.read('filepath');

      expect(actual).toEqual('foo');
      expect(pify).toHaveBeenCalledWith(fs.readFile);
      expect(mockReadFile).toHaveBeenCalledWith('filepath');
    });
  });

*/

import {ChildProcess, fork, ForkOptions, spawn, SpawnOptions} from 'child_process';
import {mkdir, readFile, stat, Stats, writeFile} from 'fs';
import glob from 'glob';
import {ncp} from 'ncp';
import once from 'once';
import path from 'path';
import pify from 'pify';
import rimraf from 'rimraf';
import tmp from 'tmp';

export const BUILD_DIRECTORY = 'build';

export const globP: (pattern: string) => Promise = pify(glob);
export const ncpP: (src: string, dest: string) => Promise = pify(ncp);
export const readFileP: (path: string, encoding?: string) =>
    Promise = pify(readFile);
export const writeFileP: (path: string, data: string, encoding?: string) =>
    Promise = pify(writeFile);
export const statP: (path: string) => Promise = pify(stat);
export const tmpDirP: () => Promise = pify(tmp.dir);
export const rimrafP: (f: string) => Promise = pify(rimraf);
export const mkdirP: (path: string, mode?: number) => Promise =
    pify(mkdir);

export function nodule(nodule: string) {
  return path.relative(BUILD_DIRECTORY, `node_modules/${nodule}`);
}

export function existsP(path: string): Promise {
  return statP(path).then(

import './support.js';

import fs from 'fs';
import path from 'path';
import rimraf from 'rimraf';
import mkdirp from 'mkdirp';
import FileChangeCache from '../src/file-change-cache';
import CompileCache from '../src/compile-cache';
import pify from 'pify';

const pfs = pify(fs);

let testCount=0;

describe('The compile cache', function() {
  beforeEach(function() {
    this.appRootDir = path.join(__dirname, '..');
    this.fileChangeCache = new FileChangeCache(this.appRootDir);

    this.tempCacheDir = path.join(__dirname, `__compile_cache_${testCount++}`);
    mkdirp.sync(this.tempCacheDir);
    this.fixture = new CompileCache(this.tempCacheDir, this.fileChangeCache);
  });

  afterEach(function() {
    rimraf.sync(this.tempCacheDir);
  });

            .then(() => pify(fs.readFile)(filePath))
            .then(data => {

import fs from 'fs'
import temp from 'temp'
import pify from 'pify'

temp.track()
export const tmpdir = pify(cb => temp.mkdir(null, cb))
export const exists = fs.existsSync