Administrator / new_rukzachok-1

  var Q = require('q');
  var mout = require('mout');
  var path = require('path');
  var mkdirp = require('mkdirp');
  var rimraf = require('../util/rimraf');
  var fs = require('../util/fs');
  var endpointParser = require('bower-endpoint-parser');
  var PackageRepository = require('./PackageRepository');
  var semver = require('../util/semver');
  var copy = require('../util/copy');
  var createError = require('../util/createError');
  var scripts = require('./scripts');
  var relativeToBaseDir = require('../util/relativeToBaseDir');
  
  function Manager(config, logger) {
      this._config = config;
      this._logger = logger;
      this._repository = new PackageRepository(this._config, this._logger);
  
      this.configure({});
  }
  
  // -----------------
  
  Manager.prototype.configure = function (setup) {
      var targetsHash = {};
      this._conflicted = {};
  
      // Targets - ignore those specified in ignoredDependencies
      this._targets = mout.array.reject(setup.targets || [], function (target) {
          return mout.array.contains(this._config.ignoredDependencies, target.name );
      }, this);
  
      this._targets.forEach(function (decEndpoint) {
          decEndpoint.initialName = decEndpoint.name;
          decEndpoint.dependants = mout.object.values(decEndpoint.dependants);
          targetsHash[decEndpoint.name] = true;
  
          // If the endpoint is marked as newly, make it unresolvable
          decEndpoint.unresolvable = !!decEndpoint.newly;
      });
  
      // Resolved & installed
      this._resolved = {};
      this._installed = {};
      mout.object.forOwn(setup.resolved, function (decEndpoint, name) {
          decEndpoint.dependants = mout.object.values(decEndpoint.dependants);
          this._resolved[name] = [decEndpoint];
          this._installed[name] = decEndpoint.pkgMeta;
      }, this);
  
      // Installed
      mout.object.mixIn(this._installed, setup.installed);
  
      // Incompatibles
      this._incompatibles = {};
      setup.incompatibles = this._uniquify(setup.incompatibles || []);
      setup.incompatibles.forEach(function (decEndpoint) {
          var name = decEndpoint.name;
  
          this._incompatibles[name] = this._incompatibles[name] || [];
          this._incompatibles[name].push(decEndpoint);
          decEndpoint.dependants = mout.object.values(decEndpoint.dependants);
  
          // Mark as conflicted so that the resolution is not removed
          this._conflicted[name] = true;
  
          // If not a target/resolved, add as target
          if (!targetsHash[name] && !this._resolved[name]) {
              this._targets.push(decEndpoint);
          }
      }, this);
  
      // Resolutions
      this._resolutions = setup.resolutions || {};
  
      // Uniquify targets
      this._targets = this._uniquify(this._targets);
  
      // Force-latest
      this._forceLatest = !!setup.forceLatest;
  
      return this;
  };
  
  /**
   * It starts recursive fetching of targets. The flow is as follows:
   *
   * 1. this._fetch() that calls:
   * 2. this._onFetchError() or this._onFetchSuccess() that calls:
   * 3. this._parseDependencies() that calls for all dependencies:
   * 4. this._fetch() again.
   *
   * Fetching and parsing of dependencies continues until all dependencies are fetched.
   *
   */
  Manager.prototype.resolve = function () {
      // If already resolving, error out
      if (this._working) {
          return Q.reject(createError('Already working', 'EWORKING'));
      }
  
      // Reset stuff
      this._fetching = {};
      this._nrFetching = 0;
      this._failed = {};
      this._hasFailed = false;
      this._deferred = Q.defer();
  
      // If there's nothing to resolve, simply dissect
      if (!this._targets.length) {
          process.nextTick(this._dissect.bind(this));
      // Otherwise, fetch each target from the repository
      // and let the process roll out
      } else {
          this._targets.forEach(this._fetch.bind(this));
      }
  
      // Unset working flag when done
      return this._deferred.promise
      .fin(function () {
          this._working = false;
      }.bind(this));
  };
  
  Manager.prototype.preinstall = function (json) {
      var that = this;
      var componentsDir = relativeToBaseDir(this._config.cwd)(this._config.directory);
  
      // If nothing to install, skip the code bellow
      if (mout.lang.isEmpty(that._dissected)) {
          return Q.resolve({});
      }
  
      return Q.nfcall(mkdirp, componentsDir)
      .then(function () {
          return scripts.preinstall(
              that._config, that._logger, that._dissected, that._installed, json
          );
      });
  };
  
  Manager.prototype.postinstall = function (json) {
      var that = this;
      var componentsDir = relativeToBaseDir(this._config.cwd)(this._config.directory);
  
      // If nothing to install, skip the code bellow
      if (mout.lang.isEmpty(that._dissected)) {
          return Q.resolve({});
      }
  
      return Q.nfcall(mkdirp, componentsDir)
      .then(function () {
          return scripts.postinstall(
              that._config, that._logger, that._dissected, that._installed, json
          );
      });
  };
  
  Manager.prototype.install = function (json) {
      var componentsDir;
      var componentsDirContents;
      var that = this;
  
      // If already resolving, error out
      if (this._working) {
          return Q.reject(createError('Already working', 'EWORKING'));
      }
  
      // If nothing to install, skip the code bellow
      if (mout.lang.isEmpty(that._dissected)) {
          return Q.resolve({});
      }
  
      componentsDir = relativeToBaseDir(this._config.cwd)(this._config.directory);
      return Q.nfcall(mkdirp, componentsDir)
      .then(function () {
          var promises = [];
          componentsDirContents = fs.readdirSync(componentsDir);
  
          mout.object.forOwn(that._dissected, function (decEndpoint, name) {
              var promise;
              var dst;
              var release = decEndpoint.pkgMeta._release;
              var exists = mout.array.contains(componentsDirContents, name);
  
              that._logger.action('install', name + (release ? '#' + release : ''), that.toData(decEndpoint));
  
              dst = path.join(componentsDir, name);
  
              if (exists && !that._installed[name] && !that._config.force) {
                  // There is a folder in the components directory that has
                  // this name, but it was not installed by bower.
                  that._logger.warn('skipped', name + ' was not installed because there is already a non-bower directory with that name in the components directory (' + path.relative(that._config.cwd, dst) + '). You can force installation with --force.');
                  return;
              }
  
              // Remove existent and copy canonical dir
              promise = Q.nfcall(rimraf, dst)
              .then(copy.copyDir.bind(copy, decEndpoint.canonicalDir, dst))
              .then(function () {
                  var metaFile = path.join(dst, '.bower.json');
  
                  decEndpoint.canonicalDir = dst;
  
                  // Store additional metadata in bower.json
                  return Q.nfcall(fs.readFile, metaFile)
                  .then(function (contents) {
                      var json = JSON.parse(contents.toString());
  
                      json._target = decEndpoint.target;
                      json._originalSource = decEndpoint.source;
                      if (decEndpoint.newly) {
                          json._direct = true;
                      }
  
                      json = JSON.stringify(json, null, '  ');
                      return Q.nfcall(fs.writeFile, metaFile, json);
                  });
              });
  
              promises.push(promise);
          });
  
          return Q.all(promises);
      })
      .then(function () {
          // Sync up dissected dependencies and dependants
          // See: https://github.com/bower/bower/issues/879
          mout.object.forOwn(that._dissected, function (pkg) {
              // Sync dependencies
              mout.object.forOwn(pkg.dependencies, function (dependency, name) {
                  var dissected = this._dissected[name] || (this._resolved[name] ? this._resolved[name][0] : dependency);
                  pkg.dependencies[name] = dissected;
              }, this);
  
              // Sync dependants
              pkg.dependants = pkg.dependants.map(function (dependant) {
                  var name = dependant.name;
                  var dissected = this._dissected[name] || (this._resolved[name] ? this._resolved[name][0] : dependant);
  
                  return dissected;
              }, this);
          }, that);
  
          // Resolve with meaningful data
          return mout.object.map(that._dissected, function (decEndpoint) {
              return this.toData(decEndpoint);
          }, that);
      })
      .fin(function () {
          this._working = false;
      }.bind(this));
  };
  
  Manager.prototype.toData = function (decEndpoint, extraKeys, upperDeps) {
      var names;
      var extra;
  
      var data = {};
  
      upperDeps = upperDeps || [];
      data.endpoint = mout.object.pick(decEndpoint, ['name', 'source', 'target']);
  
      if (decEndpoint.canonicalDir) {
          data.canonicalDir = decEndpoint.canonicalDir;
          data.pkgMeta = decEndpoint.pkgMeta;
      }
  
      if (extraKeys) {
          extra = mout.object.pick(decEndpoint, extraKeys);
          extra = mout.object.filter(extra, function (value) {
              return !!value;
          });
          mout.object.mixIn(data, extra);
      }
  
      if (decEndpoint.dependencies) {
          data.dependencies = {};
  
          // Call recursively for each dependency but ordered
          // by dependency names
          names = Object.keys(decEndpoint.dependencies).sort();
          names.forEach(function (name) {
  
              // Prevent from infinite recursion when installing cyclic
              // dependencies
              if (!mout.array.contains(upperDeps, name)) {
                  data.dependencies[name] = this.toData(decEndpoint.dependencies[name],
                      extraKeys,
                      upperDeps.concat(decEndpoint.name));
              }
          }, this);
      }
  
      data.nrDependants = mout.object.size(decEndpoint.dependants);
  
      return data;
  };
  
  Manager.prototype.getPackageRepository = function () {
      return this._repository;
  };
  
  // -----------------
  
  Manager.prototype._fetch = function (decEndpoint) {
      var name = decEndpoint.name;
  
      // Check if the whole process started to fail fast
      if (this._hasFailed) {
          return;
      }
  
      // Mark as being fetched
      this._fetching[name] = this._fetching[name] || [];
      this._fetching[name].push(decEndpoint);
      this._nrFetching++;
  
      // Fetch it from the repository
      // Note that the promise is stored in the decomposed endpoint
      // because it might be reused if a similar endpoint needs to be resolved
      return decEndpoint.promise = this._repository.fetch(decEndpoint)
      // When done, call onFetchSuccess
      .spread(this._onFetchSuccess.bind(this, decEndpoint))
      // If it fails, call onFetchFailure
      .fail(this._onFetchError.bind(this, decEndpoint));
  };
  
  Manager.prototype._onFetchSuccess = function (decEndpoint, canonicalDir, pkgMeta, isTargetable) {
      var name;
      var resolved;
      var index;
      var incompatibles;
      var initialName = decEndpoint.initialName != null ? decEndpoint.initialName : decEndpoint.name;
      var fetching = this._fetching[initialName];
  
      // Remove from being fetched list
      mout.array.remove(fetching, decEndpoint);
      this._nrFetching--;
  
      // Store some needed stuff
      decEndpoint.name = name = decEndpoint.name || pkgMeta.name;
      decEndpoint.canonicalDir = canonicalDir;
      decEndpoint.pkgMeta = pkgMeta;
      delete decEndpoint.promise;
  
      // Add to the resolved list
      // If there's an exact equal endpoint, replace instead of adding
      // This can happen because the name might not be known from the start
      resolved = this._resolved[name] = this._resolved[name] || [];
      index = mout.array.findIndex(resolved, function (resolved) {
          return resolved.target === decEndpoint.target;
      });
      if (index !== -1) {
          // Merge dependants
          decEndpoint.dependants.push.apply(decEndpoint.dependants, resolved[index.dependants]);
          decEndpoint.dependants = this._uniquify(decEndpoint.dependants);
          resolved.splice(index, 1);
      }
      resolved.push(decEndpoint);
  
      // Parse dependencies
      this._parseDependencies(decEndpoint, pkgMeta);
  
      // Check if there are incompatibilities for this package name
      // If there are, we need to fetch them
      incompatibles = this._incompatibles[name];
      if (incompatibles) {
          // Filter already resolved
          incompatibles = incompatibles.filter(function (incompatible) {
              return !resolved.some(function (decEndpoint) {
                  return incompatible.target === decEndpoint.target;
              });
          }, this);
          // Filter being resolved
          incompatibles = incompatibles.filter(function (incompatible) {
              return !fetching.some(function (decEndpoint) {
                  return incompatible.target === decEndpoint.target;
              });
          }, this);
  
          incompatibles.forEach(this._fetch.bind(this));
          delete this._incompatibles[name];
      }
  
      // If the package is not targetable, flag it
      // It will be needed later so that untargetable endpoints
      // will not get * converted to ^version
      if (!isTargetable) {
          decEndpoint.untargetable = true;
      }
  
      // If there are no more packages being fetched,
      // finish the resolve process by dissecting all resolved packages
      if (this._nrFetching <= 0) {
          process.nextTick(this._dissect.bind(this));
      }
  };
  
  Manager.prototype._onFetchError = function (decEndpoint, err) {
      var name = decEndpoint.name;
  
      err.data = err.data || {};
      err.data.endpoint = mout.object.pick(decEndpoint, ['name', 'source', 'target']);
  
      // Remove from being fetched list
      mout.array.remove(this._fetching[name], decEndpoint);
      this._nrFetching--;
  
      // Add to the failed list
      this._failed[name] = this._failed[name] || [];
      this._failed[name].push(err);
      delete decEndpoint.promise;
  
      // Make the whole process to fail fast
      this._failFast();
  
      // If there are no more packages being fetched,
      // finish the resolve process (with an error)
      if (this._nrFetching <= 0) {
          process.nextTick(this._dissect.bind(this));
      }
  };
  
  Manager.prototype._failFast = function () {
      if (this._hasFailed) {
          return;
      }
  
      this._hasFailed = true;
  
      // If after some amount of time all pending tasks haven't finished,
      // we force the process to end
      this._failFastTimeout = setTimeout(function () {
          this._nrFetching = Infinity;
          this._dissect();
      }.bind(this), 20000);
  };
  
  /**
   * Parses decEndpoint dependencies and fetches missing ones.
   *
   * It fetches all non-yet-fetching dependencies with _fetch.
   *
   *
   * @param {string} pkgMeta Metadata of package to resolve dependencies.
   */
  Manager.prototype._parseDependencies = function (decEndpoint, pkgMeta) {
      var pending = [];
  
      decEndpoint.dependencies = decEndpoint.dependencies || {};
  
      // Parse package dependencies
      mout.object.forOwn(pkgMeta.dependencies, function (value, key) {
          var resolved;
          var fetching;
          var compatible;
          var childDecEndpoint = endpointParser.json2decomposed(key, value);
  
          // Check if this depdendency should be skipped.
          if (mout.array.contains(this._config.ignoredDependencies, childDecEndpoint.name)) {
              this._logger.action('skipped', childDecEndpoint.name, this.toData(decEndpoint));
              return;
          }
  
          // Check if a compatible one is already resolved
          // If there's one, we don't need to resolve it twice
          resolved = this._resolved[key];
          if (resolved) {
              // Find if there's one with the exact same target
              compatible = mout.array.find(resolved, function (resolved) {
                  return childDecEndpoint.target === resolved.target;
              }, this);
  
              // If we found one, merge stuff instead of adding as resolved
              if (compatible) {
                  decEndpoint.dependencies[key] = compatible;
                  compatible.dependants.push(decEndpoint);
                  compatible.dependants = this._uniquify(compatible.dependants);
  
                  return;
              }
  
              // Find one that is compatible
              compatible = mout.array.find(resolved, function (resolved) {
                  return this._areCompatible(childDecEndpoint, resolved);
              }, this);
  
              // If we found one, add as resolved
              // and copy resolved properties from the compatible one
              if (compatible) {
                  decEndpoint.dependencies[key] = compatible;
                  childDecEndpoint.canonicalDir = compatible.canonicalDir;
                  childDecEndpoint.pkgMeta = compatible.pkgMeta;
                  childDecEndpoint.dependencies = compatible.dependencies;
                  childDecEndpoint.dependants = [decEndpoint];
                  this._resolved[key].push(childDecEndpoint);
  
                  return;
              }
          }
  
          // Check if a compatible one is being fetched
          // If there's one, we wait and reuse it to avoid resolving it twice
          fetching = this._fetching[key];
          if (fetching) {
              compatible = mout.array.find(fetching, function (fetching) {
                  return this._areCompatible(childDecEndpoint, fetching);
              }, this);
  
              if (compatible) {
                  pending.push(compatible.promise);
                  return;
              }
          }
  
          // Mark endpoint as unresolvable if the parent is also unresolvable
          childDecEndpoint.unresolvable = !!decEndpoint.unresolvable;
  
          // Otherwise, just fetch it from the repository
          decEndpoint.dependencies[key] = childDecEndpoint;
          childDecEndpoint.dependants = [decEndpoint];
          this._fetch(childDecEndpoint);
      }, this);
  
      if (pending.length > 0) {
          Q.all(pending)
          .then(function () {
              this._parseDependencies(decEndpoint, pkgMeta);
          }.bind(this));
      }
  };
  
  /**
   * After batch of packages has been fetched, the results are stored in _resolved hash.
   *
   * {
   *   packageName: [array, of, decEndpoints]
   * }
   *
   * This method takes all possible decEndpoints and selects only one of them per packageName.
   *
   * It stores selected packages in the this._dissected array.
   *
   * The _dissected array is used later on by install method to move packages to config.directory.
   */
  Manager.prototype._dissect = function () {
      var err;
      var componentsDir;
      var promise = Q.resolve();
      var suitables = {};
      var that = this;
  
      // If something failed, reject the whole resolve promise
      // with the first error
      if (this._hasFailed) {
          clearTimeout(this._failFastTimeout); // Cancel fail fast timeout
  
          err = mout.object.values(this._failed)[0][0];
          this._deferred.reject(err);
          return;
      }
  
      // Find a suitable version for each package name
      mout.object.forOwn(this._resolved, function (decEndpoints, name) {
          var semvers;
          var nonSemvers;
  
          // Filter out non-semver ones
          semvers = decEndpoints.filter(function (decEndpoint) {
              return !!decEndpoint.pkgMeta.version;
          });
  
          // Sort semver ones DESC
          semvers.sort(function (first, second) {
              var result = semver.rcompare(first.pkgMeta.version, second.pkgMeta.version);
  
              // If they are equal and one of them is a wildcard target,
              // give lower priority
              if (!result) {
                  if (first.target === '*') {
                      return 1;
                  }
                  if (second.target === '*') {
                      return -1;
                  }
              }
  
              return result;
          });
  
          // Convert wildcard targets to semver range targets if they are newly
          // Note that this can only be made if they can be targetable
          // If they are not, the resolver is incapable of handling targets
          semvers.forEach(function (decEndpoint) {
              if (decEndpoint.newly && decEndpoint.target === '*' && !decEndpoint.untargetable) {
                  decEndpoint.target = '^' + decEndpoint.pkgMeta.version;
                  decEndpoint.originalTarget = '*';
              }
          });
  
          // Filter non-semver ones
          nonSemvers = decEndpoints.filter(function (decEndpoint) {
              return !decEndpoint.pkgMeta.version;
          });
  
          promise = promise.then(function () {
              return that._electSuitable(name, semvers, nonSemvers)
              .then(function (suitable) {
                  suitables[name] = suitable;
              });
          });
      }, this);
  
      // After a suitable version has been elected for every package
      promise
      .then(function () {
          // Look for extraneous resolutions
          mout.object.forOwn(this._resolutions, function (resolution, name) {
              if (this._conflicted[name]) {
                  return;
              }
  
              // Packages that didn't have any conflicts in resolution yet have
              // "resolution" entry in bower.json are deemed unnecessary
              //
              // Probably in future we want to use them for force given resolution, but for now...
              // See: https://github.com/bower/bower/issues/1362
              this._logger.warn('extra-resolution', 'Unnecessary resolution: ' + name + '#' + resolution, {
                  name: name,
                  resolution: resolution,
                  action: 'delete'
              });
          }, this);
  
          // Filter only packages that need to be installed
          componentsDir = relativeToBaseDir(this._config.cwd)(this._config.directory);
          this._dissected = mout.object.filter(suitables, function (decEndpoint, name) {
              var installedMeta = this._installed[name];
              var dst;
  
              // Skip linked dependencies
              if (decEndpoint.linked) {
                  return false;
              }
  
              // Skip if source is the same as dest
              // FIXME: Shoudn't we force installation if force flag is used here?
              dst = path.join(componentsDir, name);
              if (dst === decEndpoint.canonicalDir) {
                  return false;
              }
  
              // We skip installing decEndpoint, if:
              //   1. We have installed package with the same name
              //   2. Packages have matching meta fields (needs explanation)
              //   3. We didn't force the installation
              if (installedMeta &&
                  installedMeta._target === decEndpoint.target &&
                  installedMeta._originalSource === decEndpoint.source &&
                  installedMeta._release === decEndpoint.pkgMeta._release
              ) {
                  return this._config.force;
              }
  
              return true;
          }, this);
      }.bind(this))
      .then(this._deferred.resolve, this._deferred.reject);
  };
  
  Manager.prototype._electSuitable = function (name, semvers, nonSemvers) {
      var suitable;
      var resolution;
      var unresolvable;
      var dataPicks;
      var save;
      var choices;
      var picks = [];
  
      // If there are both semver and non-semver, there's no way
      // to figure out the suitable one
      if (semvers.length && nonSemvers.length) {
          picks.push.apply(picks, semvers);
          picks.push.apply(picks, nonSemvers);
      // If there are only non-semver ones, the suitable is elected
      // only if there's one
      } else if (nonSemvers.length) {
          if (nonSemvers.length === 1) {
              return Q.resolve(nonSemvers[0]);
          }
  
          picks.push.apply(picks, nonSemvers);
      // If there are only semver ones, figure out which one is
      // compatible with every requirement
      } else {
          suitable = mout.array.find(semvers, function (subject) {
              return semvers.every(function (decEndpoint) {
                  return subject === decEndpoint ||
                         semver.satisfies(subject.pkgMeta.version, decEndpoint.target);
              });
          });
  
          if (suitable) {
              return Q.resolve(suitable);
          }
  
          picks.push.apply(picks, semvers);
      }
  
      // At this point, there's a conflict
      this._conflicted[name] = true;
  
      // Prepare data to be sent bellow
      // 1 - Sort picks by version/release
      picks.sort(function (pick1, pick2) {
          var version1 = pick1.pkgMeta.version;
          var version2 = pick2.pkgMeta.version;
          var comp;
  
          // If both have versions, compare their versions using semver
          if (version1 && version2) {
              comp = semver.compare(version1, version2);
              if (comp) {
                  return comp;
              }
          } else {
              // If one of them has a version, it's considered higher
              if (version1) {
                  return 1;
              }
              if (version2) {
                  return -1;
              }
          }
  
          // Give priority to the one with most dependants
          if (pick1.dependants.length > pick2.dependants.length) {
              return -1;
          }
          if (pick1.dependants.length < pick2.dependants.length) {
              return 1;
          }
  
          return 0;
      });
  
      // 2 - Transform data
      dataPicks = picks.map(function (pick) {
          var dataPick = this.toData(pick);
          dataPick.dependants = pick.dependants.map(this.toData, this);
          dataPick.dependants.sort(function (dependant1, dependant2) {
              return dependant1.endpoint.name.localeCompare(dependant2.endpoint.name);
          });
          return dataPick;
      }, this);
  
      // Check if there's a resolution that resolves the conflict
      // Note that if one of them is marked as unresolvable,
      // the resolution has no effect
      resolution = this._resolutions[name];
      unresolvable = mout.object.find(picks, function (pick) {
          return pick.unresolvable;
      });
  
      if (resolution && !unresolvable) {
          suitable = -1;
  
          // Range resolution
          if (semver.validRange(resolution)) {
              suitable = mout.array.findIndex(picks, function (pick) {
                  return pick.pkgMeta.version &&
                         semver.satisfies(pick.pkgMeta.version, resolution);
              });
          }
  
          // Exact match resolution (e.g. branches/tags)
          if (suitable === -1) {
              suitable = mout.array.findIndex(picks, function (pick) {
                  return pick.target === resolution ||
                         pick.pkgMeta._release === resolution;
              });
          }
  
          if (suitable === -1) {
              this._logger.warn('resolution', 'Unsuitable resolution declared for ' + name + ': ' + resolution, {
                  name: name,
                  picks: dataPicks,
                  resolution: resolution
              });
          } else {
              this._logger.conflict('solved', 'Unable to find suitable version for ' + name, {
                  name: name,
                  picks: dataPicks,
                  resolution: resolution,
                  suitable: dataPicks[suitable]
              });
              return Q.resolve(picks[suitable]);
          }
      }
  
      // If force latest is enabled, resolve to the highest semver version
      // or whatever non-semver if none available
      if (this._forceLatest) {
          suitable = picks.length - 1;
  
          this._logger.conflict('solved', 'Unable to find suitable version for ' + name, {
              name: name,
              picks: dataPicks,
              suitable: dataPicks[suitable],
              forced: true
          });
  
          // Save resolution
          this._storeResolution(picks[suitable]);
  
          return Q.resolve(picks[suitable]);
      }
  
      // If interactive is disabled, error out
      if (!this._config.interactive) {
          throw createError('Unable to find suitable version for ' + name, 'ECONFLICT', {
              name: name,
              picks: dataPicks
          });
      }
  
      // At this point the user needs to make a decision
      this._logger.conflict('incompatible', 'Unable to find suitable version for ' + name, {
          name: name,
          picks: dataPicks
      });
  
      choices = picks.map(function (pick, index) { return index + 1; });
      return Q.nfcall(this._logger.prompt.bind(this._logger), {
          type: 'input',
          message: 'Answer',
          validate: function (choice) {
              choice = Number(mout.string.trim(choice.trim(), '!'));
  
              if (!choice || choice < 1 || choice > picks.length) {
                  return 'Invalid choice';
              }
  
              return true;
          }
      })
      .then(function (choice) {
          var pick;
  
          // Sanitize choice
          choice = choice.trim();
          save = /^!/.test(choice) || /!$/.test(choice);  // Save if prefixed or suffixed with !
          choice = Number(mout.string.trim(choice, '!'));
          pick = picks[choice - 1];
  
          // Save resolution
          if (save) {
              this._storeResolution(pick);
          }
  
          return pick;
      }.bind(this));
  };
  
  Manager.prototype._storeResolution = function (pick) {
      var resolution;
      var name = pick.name;
  
      if (pick.target === '*') {
          resolution = pick.pkgMeta._release || '*';
      } else {
          resolution = pick.target;
      }
  
      this._logger.info('resolution', 'Saved ' + name + '#' + resolution + ' as resolution', {
          name: name,
          resolution: resolution,
          action: this._resolutions[name] ? 'edit' : 'add'
      });
      this._resolutions[name] = resolution;
  };
  
  /**
   * Checks if some endpoint is compatible with already resolved target.
   *
   * It is used in two situations:
   *   * checks if resolved component matches dependency constraint
   *   * checks if not resolved component matches already fetched component
   *
   * If candidate matches already resolved component, it won't be downloaded.
   *
   * @param {Endpoint} candidate endpoint
   * @param {Endpoint} resolved endpoint
   *
   * @return {Boolean}
   */
  Manager.prototype._areCompatible = function (candidate, resolved) {
      var resolvedVersion;
      var highestCandidate;
      var highestResolved;
      var candidateIsRange = semver.validRange(candidate.target);
      var resolvedIsRange = semver.validRange(resolved.target);
      var candidateIsVersion = semver.valid(candidate.target);
      var resolvedIsVersion = semver.valid(resolved.target);
  
      // Check if targets are equal
      if (candidate.target === resolved.target) {
          return true;
      }
  
      resolvedVersion = resolved.pkgMeta && resolved.pkgMeta.version;
      // If there is no pkgMeta, resolvedVersion is downloading now
      // Check based on target requirements
      if (!resolvedVersion) {
          // If one of the targets is range and other is version,
          // check version against the range
          if (candidateIsVersion && resolvedIsRange) {
              return semver.satisfies(candidate.target, resolved.target);
          }
  
          if (resolvedIsVersion && candidateIsRange) {
              return semver.satisfies(resolved.target, candidate.target);
          }
  
          if (resolvedIsVersion && candidateIsVersion) {
              return semver.eq(resolved.target, candidate.target);
          }
  
          // If both targets are range, check that both have same
          // higher cap
          if (resolvedIsRange && candidateIsRange) {
              highestCandidate =
                  this._getCap(semver.toComparators(candidate.target), 'highest');
              highestResolved =
                  this._getCap(semver.toComparators(resolved.target), 'highest');
  
              // This never happens, but you can't be sure without tests
              if (!highestResolved.version || !highestCandidate.version) {
                  return false;
              }
  
              return semver.eq(highestCandidate.version, highestResolved.version) &&
                  highestCandidate.comparator === highestResolved.comparator;
          }
          return false;
      }
  
      // If target is a version, compare against the resolved version
      if (candidateIsVersion) {
          return semver.eq(candidate.target, resolvedVersion);
      }
  
      // If target is a range, check if resolved version satisfies it
      if (candidateIsRange) {
          return semver.satisfies(resolvedVersion, candidate.target);
      }
  
      return false;
  };
  
  /**
   * Gets highest/lowest version from set of comparators.
   *
   * The only thing that matters for this function is version number.
   * Returned comparator is splitted to comparator and version parts.
   *
   * It is used to receive lowest / highest bound of toComparators result:
   * semver.toComparators('~0.1.1') // => [ [ '>=0.1.1-0', '<0.2.0-0' ] ]
   *
   * Examples:
   *
   * _getCap([['>=2.1.1-0', '<2.2.0-0'], '<3.2.0'], 'highest')
   * // => { comparator: '<', version: '3.2.0' }
   *
   * _getCap([['>=2.1.1-0', '<2.2.0-0'], '<3.2.0'], 'lowest')
   * // => { comparator: '>=', version: '2.1.1-0' }
   *
   * @param {Array.<Array|string>} comparators
   * @param {string} side, 'highest' (default) or 'lowest'
   *
   * @return {{ comparator: string, version: string }}
   */
  Manager.prototype._getCap = function (comparators, side) {
      var matches;
      var candidate;
      var cap = {};
      var compare = side === 'lowest' ? semver.lt : semver.gt;
  
      comparators.forEach(function (comparator) {
          // Get version of this comparator
          // If it's an array, call recursively
          if (Array.isArray(comparator)) {
              candidate = this._getCap(comparator, side);
  
              // Compare with the current highest version
              if (!cap.version || compare(candidate.version, cap.version)) {
                  cap = candidate;
              }
          // Otherwise extract the version from the comparator
          // using a simple regexp
          } else {
              matches = comparator.match(/(.*?)(\d+\.\d+\.\d+.*)$/);
              if (!matches) {
                  return;
              }
  
              // Compare with the current highest version
              if (!cap.version || compare(matches[2], cap.version)) {
                  cap.version = matches[2];
                  cap.comparator = matches[1];
              }
          }
      }, this);
  
      return cap;
  };
  
  /**
   * Filters out unique endpoints, comparing by name and then source.
   *
   * It leaves last matching endpoint.
   *
   * Examples:
   *
   *  manager._uniquify([
   *      { name: 'foo', source: 'google.com' },
   *      { name: 'foo', source: 'facebook.com' }
   *  ]);
   *  // => { name: 'foo', source: 'facebook.com' }
   *
   * @param {Array.<Endpoint>} decEndpoints
   * @return {Array.<Endpoint>} Filtered elements of decEndpoints
   *
   */
  Manager.prototype._uniquify = function (decEndpoints) {
      var length = decEndpoints.length;
  
      return decEndpoints.filter(function (decEndpoint, index) {
          var x;
          var current;
  
          for (x = index + 1; x < length; ++x) {
              current = decEndpoints[x];
  
              if (current === decEndpoint) {
                  return false;
              }
  
              // Compare name if both set
              // Fallback to compare sources
              if (!current.name && !decEndpoint.name) {
                  if (current.source !== decEndpoint.source) {
                      continue;
                  }
              } else if (current.name !== decEndpoint.name) {
                  continue;
              }
  
              // Compare targets if name/sources are equal
              if (current.target === decEndpoint.target) {
                  return false;
              }
          }
  
          return true;
      });
  };
  
  module.exports = Manager;