mambax7/alumni-26x

File semver-mod.js has 863 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*! Modified semver.js for node.js (v4.3.3, 3/27/2015) *//*
 semver-mod.js by R.Garrison (@Mottie)
 semver.js by @isaacs: https://github.com/isaacs/node-semver
 ( all modifications have been labeled )
 */

Function inc has 69 lines of code (exceeds 25 allowed). Consider refactoring.

Open

SemVer.prototype.inc = function(release, identifier) {
  switch (release) {
    case 'premajor':
      this.prerelease.length = 0;
      this.patch = 0;

Function outside has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function outside(version, range, hilo, loose) {
  version = new SemVer(version, loose);
  range = new Range(range, loose);

  var gtfn, ltefn, ltfn, comp, ecomp;

Function replaceXRange has 47 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function replaceXRange(comp, loose) {
  comp = comp.trim();
  var r = loose ? re[XRANGELOOSE] : re[XRANGE];
  return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
    debug('xRange', comp, ret, gtlt, M, m, p, pr);

Function replaceCaret has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function replaceCaret(comp, loose) {
  debug('caret', comp, loose);
  var r = loose ? re[CARETLOOSE] : re[CARET];
  return comp.replace(r, function(_, M, m, p, pr) {
    debug('caret', comp, _, M, m, p, pr);

Function hyphenReplace has 13 arguments (exceeds 4 allowed). Consider refactoring.

Open

function hyphenReplace($0,
                       from, fM, fm, fp, fpr, fb,
                       to, tM, tm, tp, tpr, tb) {

Function SemVer has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function SemVer(version, loose) {
  if (version instanceof SemVer) {
    if (version.loose === loose)
      return version;
    else

Avoid deeply nested control flow statements.

Open

          if (v1[key] !== v2[key]) {
            return 'pre'+key;
          }

Avoid deeply nested control flow statements.

Open

        if (xm)
          M = +M + 1
        else
          m = +m + 1

Avoid too many return statements within this function.

Open

  return true;

Avoid too many return statements within this function.

Open

      return 1;

Avoid too many return statements within this function.

Open

    return null;

Avoid too many return statements within this function.

Open

      return compareIdentifiers(a, b);

Avoid too many return statements within this function.

Open

      return -1;

Avoid too many return statements within this function.

Open

  return true;

Avoid too many return statements within this function.

Open

    return new SemVer(version, loose);

Identical blocks of code found in 2 locations. Consider refactoring.

Open

SemVer.prototype.inc = function(release, identifier) {
  switch (release) {
    case 'premajor':
      this.prerelease.length = 0;
      this.patch = 0;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function replaceCaret(comp, loose) {
  debug('caret', comp, loose);
  var r = loose ? re[CARETLOOSE] : re[CARET];
  return comp.replace(r, function(_, M, m, p, pr) {
    debug('caret', comp, _, M, m, p, pr);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function SemVer(version, loose) {
  if (version instanceof SemVer) {
    if (version.loose === loose)
      return version;
    else

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function replaceXRange(comp, loose) {
  comp = comp.trim();
  var r = loose ? re[XRANGELOOSE] : re[XRANGE];
  return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
    debug('xRange', comp, ret, gtlt, M, m, p, pr);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function outside(version, range, hilo, loose) {
  version = new SemVer(version, loose);
  range = new Range(range, loose);

  var gtfn, ltefn, ltfn, comp, ecomp;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Range.prototype.parseRange = function(range) {
  var loose = this.loose;
  range = range.trim();
  debug('range', range, loose);
  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function replaceTilde(comp, loose) {
  var r = loose ? re[TILDELOOSE] : re[TILDE];
  return comp.replace(r, function(_, M, m, p, pr) {
    debug('tilde', comp, _, M, m, p, pr);
    var ret;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function cmp(a, op, b, loose) {
  var ret;
  switch (op) {
    case '===':
      if (typeof a === 'object') a = a.version;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

SemVer.prototype.comparePre = function(other) {
  if (!(other instanceof SemVer))
    other = new SemVer(other, this.loose);

  // NOT having a prerelease is > having one

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function hyphenReplace($0,
                       from, fM, fm, fp, fpr, fb,
                       to, tM, tm, tp, tpr, tb) {

  if (isX(fM))

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function testSet(set, version) {
  for (var i = 0; i < set.length; i++) {
    if (!set[i].test(version))
      return false;
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function diff(version1, version2) {
  if (eq(version1, version2)) {
    return null;
  } else {
    var v1 = parse(version1);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function Range(range, loose) {
  if ((range instanceof Range) && range.loose === loose)
    return range;

  if (!(this instanceof Range))

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Comparator.prototype.parse = function(comp) {
  var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
  var m = comp.match(r);

  if (!m)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function Comparator(comp, loose) {
  if (comp instanceof Comparator) {
    if (comp.loose === loose)
      return comp;
    else

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

/* nomin */ if (typeof process === 'object' &&
    /* nomin */ process.env &&
    /* nomin */ process.env.NODE_DEBUG &&
    /* nomin */ /\bsemver\b/i.test(process.env.NODE_DEBUG))
  /* nomin */ debug = function() {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function compareIdentifiers(a, b) {
  var anum = numeric.test(a);
  var bnum = numeric.test(b);

  if (anum && bnum) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Range.prototype.test = function(version) {
  if (!version)
    return false;

  if (typeof version === 'string')

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function parse(version, loose) {
  if (version instanceof SemVer)
    return version;

  if (typeof version !== 'string')

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

SemVer.prototype.format = function() {
  this.version = this.major + '.' + this.minor + '.' + this.patch;
  if (this.prerelease.length)
    this.version += '-' + this.prerelease.join('.');
  return this.version;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function parseComparator(comp, loose) {
  debug('comp', comp);
  comp = replaceCarets(comp, loose);
  debug('caret', comp);
  comp = replaceTildes(comp, loose);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Comparator.prototype.test = function(version) {
  debug('Comparator.test', version, this.loose);

  if (this.semver === ANY)
    return true;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

SemVer.prototype.compareMain = function(other) {
  if (!(other instanceof SemVer))
    other = new SemVer(other, this.loose);

  return compareIdentifiers(this.major, other.major) ||

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Range.prototype.format = function() {
  this.range = this.set.map(function(comps) {
    return comps.join(' ').trim();
  }).join('||').trim();
  return this.range;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

SemVer.prototype.compare = function(other) {
  debug('SemVer.compare', this.version, this.loose, other);
  if (!(other instanceof SemVer))
    other = new SemVer(other, this.loose);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function toComparators(range, loose) {
  return new Range(range, loose).set.map(function(comp) {
    return comp.map(function(c) {
      return c.value;
    }).join(' ').trim().split(' ');

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
                   '(?:' + src[PRERELEASE] + ')?' +
                   src[BUILD] + '?' +

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
                        '(?:' + src[PRERELEASELOOSE] + ')?' +
                        src[BUILD] + '?' +

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function inc(version, release, loose, identifier) {
  if (typeof(loose) === 'string') {
    identifier = loose;
    loose = undefined;
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function maxSatisfying(versions, range, loose) {
  return versions.filter(function(version) {
    return satisfies(version, range, loose);
  }).sort(function(a, b) {
    return rcompare(a, b, loose);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

for (var i = 0; i < R; i++) {
  debug(i, src[i]);
  if (!re[i])
    re[i] = new RegExp(src[i]);
}

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

function replaceCarets(comp, loose) {
  return comp.trim().split(/\s+/).map(function(comp) {
    return replaceCaret(comp, loose);
  }).join(' ');
}

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

function replaceTildes(comp, loose) {
  return comp.trim().split(/\s+/).map(function(comp) {
    return replaceTilde(comp, loose);
  }).join(' ');
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function replaceXRanges(comp, loose) {
  debug('replaceXRanges', comp, loose);
  return comp.split(/\s+/).map(function(comp) {
    return replaceXRange(comp, loose);
  }).join(' ');

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')';

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +
                   '(' + src[NUMERICIDENTIFIER] + ')';

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function replaceStars(comp, loose) {
  debug('replaceStars', comp, loose);
  // Looseness is ignored here.  star is always as loose as it gets!
  return comp.trim().replace(re[STAR], '');
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function satisfies(version, range, loose) {
  try {
    range = new Range(range, loose);
  } catch (er) {
    return false;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
                        '\\s+-\\s+' +
                        '(' + src[XRANGEPLAINLOOSE] + ')' +
                        '\\s*$';

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function validRange(range, loose) {
  try {
    // Return '*' instead of '' so that truthiness works.
    // This will throw if it's invalid anyway
    return new Range(range, loose).range || '*';

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
                   '\\s+-\\s+' +
                   '(' + src[XRANGEPLAIN] + ')' +
                   '\\s*$';

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function clean(version, loose) {
  var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
  return s ? s.version : null;
}

• Read up
  Read up