How to use the promise.denodeify function in promise

(function() {
  var promise = require('promise'),
      fs = require('fs'),
      sh = require('child_process');

  var reportError = function(err) {
    console.log(err);
    throw err;
  };

  module.exports.reportError = reportError;

  // Promise representation of some Node.js function
  module.exports.mkdir = promise.denodeify(fs.mkdir);
  module.exports.writeFile = promise.denodeify(fs.writeFile);
  module.exports.readFile = promise.denodeify(fs.readFile);
  module.exports.exec = promise.denodeify(sh.exec);
})();

this.compiler.supportsIntel = !!this.compiler.intelAsm;
}

Compile.prototype.newTempDir = function () {
    return new Promise(function (resolve, reject) {
        temp.mkdir('compiler-explorer-compiler', function (err, dirPath) {
            if (err)
                reject("Unable to open temp file: " + err);
            else
                resolve(dirPath);
        });
    });
};

Compile.prototype.writeFile = Promise.denodeify(fs.writeFile);
Compile.prototype.readFile = Promise.denodeify(fs.readFile);
Compile.prototype.stat = Promise.denodeify(fs.stat);
Compile.prototype.couldHaveOptOutput = function(options, version) {
    //TODO(jared): a compiler meta data gatherer could improve this
    return version.toLowerCase().indexOf("clang") > -1 && 
          options.some((x) => x == "-fsave-optimization-record");
};

Compile.prototype.getRemote = function () {
    if (this.compiler.exe === null && this.compiler.remote)
        return this.compiler.remote;
    return false;
};

Compile.prototype.exec = function(compiler, args, options) {
    // Here only so can be overridden by compiler implementations.
    return exec.execute(compiler, args, options);

Resource.prototype.sync = Promise.denodeify(function(callback) {
  var self = this;
  var target = self._client._update;
  if (!self._getBase().id) {
    target = self._client._remoteCreate;
  }

  target.call(self._client, self, function(err, rawResponse, rawResource) {
    if (err) return callback(err);
    self._construct(rawResource, self._client);
    return callback(null, self);
  });
});

Resource.prototype.delete = Promise.denodeify(function(callback) {
  var self = this;
  self._client._delete(self, function(err) {
    if (err) return callback(err);

    self._client._resourceCache.removeFromCache(self);
    self._getBase().id = null;
    self._getRaw().id = null;

    return callback();
  });
});

Resource.prototype._tweakLinksTo = function(method, resource) {
  var self = this;
  if (!self._raw.relationships) return;
  Object.keys(self._raw.relationships).forEach(function(i) {

return function(callback) {
        var gulp = require('gulp')
        var cp = require('child_process')
        var fs = require('fs')
        var path = require('path')
        var hogan = require('hogan.js')
        var Promise = require('promise')
        var readFile = Promise.denodeify(fs.readFile)
        var writeFile = Promise.denodeify(fs.writeFile)
        var symlink = Promise.denodeify(fs.symlink)
        var exec = Promise.denodeify(cp.exec)
        var del = Promise.denodeify(require('del'))

        var dest = path.resolve(process.cwd(), options.dest)

        function compileConfig() {
            if (options.data.conf.env != 'prod') options.data.env = options.data.conf.env
            options.data.version = options.data.conf.version
            return readFile(dest + '/config.tpl', 'utf-8')
                .then(function(tpl) {
                    tpl = hogan.compile(tpl).render(options.data)
                    return writeFile(dest + '/config.xml', tpl)
                })
        }

        function prepare() {
            return exec('cd ' + dest + '; cordova prepare')

_loadImage: function (path, image) {

		if (image instanceof Buffer) {
			return Promise.denodeify(PNGImage.loadImage).call(PNGImage, image);

		} else if ((typeof path === 'string') && !image) {
			return Promise.denodeify(PNGImage.readImage).call(PNGImage, path);

		} else {
			return image;
		}
	},

rename(tempPath, path + name).then(function () {
            var unlink = promise.denodeify(fs.unlink);
            unlink(tempPath);
        }).then(function () {
                if (index == req.files.file.length - 1) {

var fs = require('fs');
var Promise = require('promise');
var debug = require('debug')('repo-copy:lib');
var _path = require('path');
var ignore = require('ignore');
var glob = require('glob');
var fstream = require('fstream');
var tar = require('tar');
var zlib = require('zlib');
var AdmZip = require('adm-zip');

module.exports = {
  mkdirPromise: Promise.denodeify(fs.mkdir),
  validateProgram: (program) => {
    if (program.copy){
      if (program.args.length === 0)
        return new Error('Need to provide a repository path');
      try {
        var stat = fs.statSync(program.out);
        if (!stat.isDirectory()){
          return new Error('The output must be a folder');
        }
      } catch (e) {
        return new Error('The output folder can\'t be founded');
      }
    }else if (program.compress){
      if (program.args.length === 0)
        return new Error('Need to provide a repository path');
    }else{

function uploadFile(req, res, path, index) {
    var tempPath = req.files.file[index].path;
    var name = req.files.file[index].name;
    if (tempPath) {
        var rename = promise.denodeify(fs.rename);
        rename(tempPath, path + name).then(function () {
            var unlink = promise.denodeify(fs.unlink);
            unlink(tempPath);
        }).then(function () {
            if (index == req.files.file.length - 1) {
                var resObj = {
                    code: 1,
                    des: '上传成功'
                };
                res.send(resObj);
            } else {
                uploadFile(req, res, path, index + 1);
            }
        });
    }
}

const flatfile = require('flat-file-db')
const promise = require('promise')

const db = flatfile.sync(process.env.DB_NAME || 'views.db')

module.exports = {
  put: promise.denodeify(db.put.bind(db)),

  has: (key) => Promise.resolve(db.has(key)),
  get: (key, options) => {
    const value = db.get(key) || { views: [] }

    return {
      views: value.views.filter(view => {
        if (options && options.before && view.time > options.before) return false
        if (options && options.after && view.time < options.after) return false
        return true
      })
    }
  },
  keys: () => Promise.resolve(db.keys()),

  getAll: async function getAll(options) {

var fs = require('fs');
var assert = require('assert');
var Promise = require('promise');
var isPromise = require('is-promise');

var tr = (module.exports = function (transformer) {
  return new Transformer(transformer);
});
tr.Transformer = Transformer;
tr.normalizeFn = normalizeFn;
tr.normalizeFnAsync = normalizeFnAsync;
tr.normalize = normalize;
tr.normalizeAsync = normalizeAsync;
if (fs.readFile) {
  tr.readFile = Promise.denodeify(fs.readFile);
  tr.readFileSync = fs.readFileSync;
} else {
  tr.readFile = function () { throw new Error('fs.readFile unsupported'); };
  tr.readFileSync = function () { throw new Error('fs.readFileSync unsupported'); };
}

function normalizeFn(result) {
  if (typeof result === 'function') {
    return {fn: result, dependencies: []};
  } else if (result && typeof result === 'object' && typeof result.fn === 'function') {
    if ('dependencies' in result) {
      if (!Array.isArray(result.dependencies)) {
        throw new Error('Result should have a dependencies property that is an array');
      }
    } else {
      result.dependencies = [];