1. module gulp-msbuild
   1. function gulp-msbuild (options)
   2. object gulp-msbuild.msbuild_command_builder
   3. object gulp-msbuild.msbuild_finder
   4. object gulp-msbuild.msbuild_runner
2. module gulp-msbuild.msbuild_command_builder
   1. function gulp-msbuild.msbuild_command_builder.buildArguments (options)
   2. function gulp-msbuild.msbuild_command_builder.construct (file, options)
3. module gulp-msbuild.msbuild_finder
   1. function gulp-msbuild.msbuild_finder.find (options)
4. module gulp-msbuild.msbuild_runner
   1. function gulp-msbuild.msbuild_runner.startMsBuildTask (options, file, callback)

module gulp-msbuild

function gulp-msbuild (options)

• description and source-code

  gulp-msbuild = function (options) {
    var mergedOptions = _.cloneDeep(mergeOptionsWithDefaults(options));
    validateOptions(mergedOptions);
  
    var stream = through.obj(function(file, enc, callback) {
      var self = this;
      if (!file || !file.path) {
        self.push(file);
        return callback();
      }
  
      return msbuildRunner.startMsBuildTask(mergedOptions, file, function(err) {
        if (err) return callback(err);
        self.push(file);
        if (mergedOptions.emitEndEvent) self.emit("end");
        return callback();
      });
    });
  
    return stream;
  }

• example usage

  n/a

module gulp-msbuild.msbuild_command_builder

function gulp-msbuild.msbuild_command_builder.buildArguments (options)

• description and source-code

  buildArguments = function (options) {
    var args = [];
    args.push('/target:' + options.targets.join(';'));
    args.push('/verbosity:' + options.verbosity);
    if (options.toolsVersion) {
      var version = parseFloat(options.toolsVersion).toFixed(1);
      if (isNaN(version)) {
        version = '4.0';
      }
      args.push('/toolsversion:' + version);
    }
  
    if (options.nologo) {
      args.push('/nologo');
    }
  
    if (options.fileLoggerParameters) {
      args.push('/flp:' + options.fileLoggerParameters);
    }
  
    if (options.consoleLoggerParameters) {
      args.push('/clp:' + options.consoleLoggerParameters);
    }
  
    if (options.loggerParameters) {
      args.push('/logger:' + options.loggerParameters);
    }
  
    // xbuild does not support the `maxcpucount` argument and throws if provided
    if (options.maxcpucount >= 0 && options.msbuildPath !== 'xbuild') {
      if (options.maxcpucount === 0) {
        args.push('/maxcpucount');
      } else {
        args.push('/maxcpucount:' + options.maxcpucount);
      }
    }
  
    if (options.nodeReuse === false) {
      args.push('/nodeReuse:False')
    }
  
    if (options.configuration) {
      options.properties = _.extend({
        'Configuration': options.configuration
      }, options.properties);
    }
  
    if (options.solutionPlatform) {
      options.properties = _.extend({
        'Platform': options.solutionPlatform
      }, options.properties);
    }
  
    for (var property in options.properties) {
      args.push('/property:' + property + '=' + options.properties[property]);
    }
  
    if (options.customArgs) {
      args = args.concat(options.customArgs);
    }
  
    return args;
  }

• example usage

  ...
    var newOptions = _.cloneDeep(options);
  
    Object.keys(newOptions.properties).forEach(function(prop) {
      var context = { file: file };
      newOptions.properties[prop] = gutil.template(newOptions.properties[prop], context);
    });
  
    var args = this.buildArguments(newOptions);
  
    return {
      executable: path.normalize(options.msbuildPath),
      args: [file.path].concat(args)
    };
  };
  ...

function gulp-msbuild.msbuild_command_builder.construct (file, options)

• description and source-code

  construct = function (file, options) {
    if (!options || Object.keys(options).length <= 0) {
      throw new PluginError(constants.PLUGIN_NAME, 'No options specified!');
    }
  
    if (!options.msbuildPath) {
      var msbuildFinder = require('./msbuild-finder');
      options.msbuildPath = msbuildFinder.find(options);
    }
  
    var newOptions = _.cloneDeep(options);
  
    Object.keys(newOptions.properties).forEach(function(prop) {
      var context = { file: file };
      newOptions.properties[prop] = gutil.template(newOptions.properties[prop], context);
    });
  
    var args = this.buildArguments(newOptions);
  
    return {
      executable: path.normalize(options.msbuildPath),
      args: [file.path].concat(args)
    };
  }

• example usage

  ...
  'use strict';
  
  var commandBuilder = require('./msbuild-command-builder');
  var gutil = require('gulp-util');
  var childProcess = require('child_process');
  
  module.exports.startMsBuildTask = function (options, file, callback) {
  var command = commandBuilder.construct(file, options);
  
  if (options.logCommand) {
    gutil.log(gutil.colors.cyan('Using MSBuild command:'), command.executable, command.args.join(' '));
  }
  
  var io = ['ignore'];
  ...

module gulp-msbuild.msbuild_finder

function gulp-msbuild.msbuild_finder.find (options)

• description and source-code

  find = function (options) {
    if (!options.platform.match(/^win/)) {
      return 'xbuild';
    }
  
    var msbuildRoot;
    var is64Bit = options.architecture === 'x64';
  
    // On 64-bit systems msbuild is always under the x86 directory. If this
    // doesn't exist we are on a 32-bit system. See also:
    // https://blogs.msdn.microsoft.com/visualstudio/2013/07/24/msbuild-is-now-part-of-visual-studio/
    var pathRoot;
    if (is64Bit) {
      pathRoot = process.env['ProgramFiles(x86)'] || 'C:/Program Files (x86)';
    } else {
      pathRoot = process.env['ProgramFiles'] || 'C:/Program Files';
    }
  
    if (options.toolsVersion === 'auto') {
      var result = autoDetectVersion(pathRoot);
      msbuildRoot = result[0]
      options.toolsVersion = result[1];
    } else {
      if (options.toolsVersion === 15.0) {
        var msbuildDir = detectMsBuild15Dir(pathRoot);
        if (msbuildDir) {
          msbuildRoot = msbuildDir;
        } else {
          msbuildRoot = pathRoot;
        }
      } else {
        msbuildRoot = pathRoot;
      }
    }
  
    var version = constants.MSBUILD_VERSIONS[options.toolsVersion];
    if (!version) {
      throw new PluginError(constants.PLUGIN_NAME, 'No MSBuild Version was supplied!');
    }
  
    if (version === '12.0' || version === '14.0' || version === '15.0') {
      var x64_dir = is64Bit ? 'amd64' : '';
      return path.join(msbuildRoot, 'MSBuild', version, 'Bin', x64_dir, 'MSBuild.exe');
    } else {
      var framework = is64Bit ? 'Framework64' : 'Framework';
      return path.join(options.windir, 'Microsoft.Net', framework, version, 'MSBuild.exe');
    }
  }

• example usage

  ...
  module.exports.construct = function(file, options) {
  if (!options || Object.keys(options).length <= 0) {
    throw new PluginError(constants.PLUGIN_NAME, 'No options specified!');
  }
  
  if (!options.msbuildPath) {
    var msbuildFinder = require('./msbuild-finder');
    options.msbuildPath = msbuildFinder.find(options);
  }
  
  var newOptions = _.cloneDeep(options);
  
  Object.keys(newOptions.properties).forEach(function(prop) {
    var context = { file: file };
    newOptions.properties[prop] = gutil.template(newOptions.properties[prop], context);
  ...

module gulp-msbuild.msbuild_runner

function gulp-msbuild.msbuild_runner.startMsBuildTask (options, file, callback)

• description and source-code

  startMsBuildTask = function (options, file, callback) {
    var command = commandBuilder.construct(file, options);
  
    if (options.logCommand) {
      gutil.log(gutil.colors.cyan('Using MSBuild command:'), command.executable, command.args.join(' '));
    }
  
    var io = ['ignore'];
  
    io.push(options.stdout ? process.stdout : 'ignore');
    io.push(options.stderr ? process.stderr : 'ignore');
  
    var spawnOptions = { stdio: io };
  
    var cp = childProcess.spawn(command.executable, command.args, spawnOptions);
  
    cp.on('error', function (err) {
      if (err) {
        gutil.log(err);
        gutil.log(gutil.colors.red('MSBuild failed!'));
  
        if (options.errorOnFail) {
          return callback(err);
        }
      }
  
      return callback();
    });
  
    cp.on('close', function (code, signal) {
      if (code === 0) {
        gutil.log(gutil.colors.cyan('MSBuild complete!'));
      } else {
        var msg;
  
        if (code != null) {
          // Exited normally, but failed.
          msg = 'MSBuild failed with code ' + code + '!';
        } else {
          // Killed by parent process.
          msg = 'MSBuild killed with signal ' + signal + '!';
        }
  
        gutil.log(gutil.colors.red(msg));
  
        if (options.errorOnFail) {
          return callback(new Error(msg));
        }
      }
  
      return callback();
    });
  }

• example usage

  ...
  var stream = through.obj(function(file, enc, callback) {
    var self = this;
    if (!file || !file.path) {
      self.push(file);
      return callback();
    }
  
    return msbuildRunner.startMsBuildTask(mergedOptions, file, function(err) {
      if (err) return callback(err);
      self.push(file);
      if (mergedOptions.emitEndEvent) self.emit("end");
      return callback();
    });
  });
  ...