Sign upLogin

mbroadst/rethunk

View on GitHub
Star
lib/term.js

Summary

Maintainability
F
4 mos
Test Coverage

File term.js has 2755 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"use strict";
var Promise = require('bluebird');
var protodef = require('./protodef.js');
var termTypes = protodef.Term.TermType;
Severity: Major
Found in lib/term.js - About 1 wk to fix

    Function expr has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
    Open

    Term.prototype.expr = function(expression, nestingLevel) {
  var self = this;
  self._noPrefix(self, 'expr');
  if (self._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    Severity: Minor
    Found in lib/term.js - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function _arityRange has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

    Term.prototype._arityRange = function(args, min, max, method, term) {
  var foundArgs = false, _len = args.length;
  if (args.length < min) {
    for (var i = 0; i < _len; ++i) {
      if ((args[i] instanceof Term) && (args[i]._query[0] === termTypes.ARGS)) {
    Severity: Minor
    Found in lib/term.js - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Consider simplifying this complex logical expression.
    Open

          if ((key !== 'timeout')
        && (key !==  'attempts')
        && (key !==  'redirects')
        && (key !==  'verify')
        && (key !==  'resultFormat')
    Severity: Critical
    Found in lib/term.js - About 3 hrs to fix

      Function expr has 73 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      Term.prototype.expr = function(expression, nestingLevel) {
  var self = this;
  self._noPrefix(self, 'expr');
  if (self._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
      Severity: Major
      Found in lib/term.js - About 2 hrs to fix

        Function run has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

        Term.prototype.run = function(connection, options, callback) {
  if (!!this._error) {
    return Promise.reject(new errors.ReqlRuntimeError(this._error, this._query, { b: this._frames }));
  }
        Severity: Minor
        Found in lib/term.js - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Consider simplifying this complex logical expression.
        Open

                if ((key === 'readMode') || (key === 'durability') || (key === 'db') ||
            (key === 'noreply') || (key === 'arrayLimit') || (key === 'profile') ||
            (key === 'minBatchRows') || (key === 'maxBatchRows') || (key === 'maxBatchBytes') ||
            (key === 'maxBatchSeconds') || (key === 'firstBatchScaledownFactor')) {
          sendOptions = true;
        Severity: Critical
        Found in lib/term.js - About 2 hrs to fix

          Function _run has 51 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          Term.prototype._run = function(connection, options) {
  var self = this;
  return new Promise(function(resolve, reject) {
    var token = connection._getToken();
          Severity: Major
          Found in lib/term.js - About 2 hrs to fix

            Function orderBy has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
            Open

            Term.prototype.orderBy = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'orderBy', this);
            Severity: Minor
            Found in lib/term.js - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Consider simplifying this complex logical expression.
            Open

                    } else if ((key !== 'timeFormat') && (key !== 'groupFormat') &&
                   (key !== 'binaryFormat') && (key !== 'cursor') &&
                   (key !== 'readable') && (key !== 'writable') &&
                   (key !== 'transform') && (key !== 'stream') &&
                   (key !== 'highWaterMark')) {
            Severity: Critical
            Found in lib/term.js - About 1 hr to fix

              Function run has 39 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              Term.prototype.run = function(connection, options, callback) {
  if (!!this._error) {
    return Promise.reject(new errors.ReqlRuntimeError(this._error, this._query, { b: this._frames }));
  }
              Severity: Minor
              Found in lib/term.js - About 1 hr to fix

                Function time has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
                Open

                Term.prototype.time = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._noPrefix(this, 'time');
                Severity: Minor
                Found in lib/term.js - About 1 hr to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function http has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                Term.prototype.http = function(url, options) {
  this._noPrefix(this, 'http');
  if (this._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 1, 2, 'http', this);
                Severity: Minor
                Found in lib/term.js - About 1 hr to fix

                  Function random has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  Term.prototype.random = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  var self = this;
  self._noPrefix(this, 'random');
                  Severity: Minor
                  Found in lib/term.js - About 1 hr to fix

                    Function orderBy has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    Term.prototype.orderBy = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'orderBy', this);
                    Severity: Minor
                    Found in lib/term.js - About 1 hr to fix

                      Function group has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      Term.prototype.group = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  var self = this;
  self._arityRange(_args, 1, Infinity, 'group', self);
                      Severity: Minor
                      Found in lib/term.js - About 1 hr to fix

                        Function slice has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        Term.prototype.slice = function(start, end, options) {
  if (this._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 1, 3, 'slice', this);
                        Severity: Minor
                        Found in lib/term.js - About 1 hr to fix

                          Function tableCreate has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          Term.prototype.tableCreate = function(table, options) {
  var self = this;
  if (self._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                          Severity: Minor
                          Found in lib/term.js - About 1 hr to fix

                            Function indexCreate has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            Term.prototype.indexCreate = function(name, fn, options) {
  if (this._fastArityRange(arguments.length, 1, 3) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 1, 3, 'indexCreate', this);
                            Severity: Minor
                            Found in lib/term.js - About 1 hr to fix

                              Function slice has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                              Open

                              Term.prototype.slice = function(start, end, options) {
  if (this._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 1, 3, 'slice', this);
                              Severity: Minor
                              Found in lib/term.js - About 55 mins to fix

                              Cognitive Complexity

                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                              A method's cognitive complexity is based on a few simple rules:

                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                              • Code is considered more complex for each "break in the linear flow of the code"
                              • Code is considered more complex when "flow breaking structures are nested"

                              Further reading

                              Function toStream has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                              Open

                              Term.prototype.toStream = function(connection, options) {
  var args;
  if (helper.isPlainObject(connection) &&
      (typeof connection._isConnection === 'function') && (connection._isConnection() === true)) {
    if (helper.isPlainObject(options) === false) options = {};
                              Severity: Minor
                              Found in lib/term.js - About 55 mins to fix

                              Cognitive Complexity

                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                              A method's cognitive complexity is based on a few simple rules:

                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                              • Code is considered more complex for each "break in the linear flow of the code"
                              • Code is considered more complex when "flow breaking structures are nested"

                              Further reading

                              Function max has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                              Open

                              Term.prototype.max = function(field) {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'max', this);
                              Severity: Minor
                              Found in lib/term.js - About 45 mins to fix

                              Cognitive Complexity

                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                              A method's cognitive complexity is based on a few simple rules:

                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                              • Code is considered more complex for each "break in the linear flow of the code"
                              • Code is considered more complex when "flow breaking structures are nested"

                              Further reading

                              Function min has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                              Open

                              Term.prototype.min = function(field) {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'min', this);
                              Severity: Minor
                              Found in lib/term.js - About 45 mins to fix

                              Cognitive Complexity

                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                              A method's cognitive complexity is based on a few simple rules:

                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                              • Code is considered more complex for each "break in the linear flow of the code"
                              • Code is considered more complex when "flow breaking structures are nested"

                              Further reading

                              Consider simplifying this complex logical expression.
                              Open

                                    if ((key !== 'shards') && (key !== 'replicas') &&
        (key !== 'dryRun') && (key !== 'primaryReplicaTag') &&
        (key !== 'nonvotingReplicaTags') && (key !== 'emergencyRepair')) {
        throw new errors.ReqlDriverError('Unrecognized option `'+key+'` in `reconfigure`', self._query, 'Available options are shards: <number>, replicas: <number>, primaryReplicaTag: <object>, dryRun <boolean>, emergencyRepair: <string>, nonvotingReplicaTags: <array<string>>');
      }
                              Severity: Major
                              Found in lib/term.js - About 40 mins to fix

                                Function _arityRange has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                Open

                                Term.prototype._arityRange = function(args, min, max, method, term) {
                                Severity: Minor
                                Found in lib/term.js - About 35 mins to fix

                                  Function random has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  Term.prototype.random = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  var self = this;
  self._noPrefix(this, 'random');
                                  Severity: Minor
                                  Found in lib/term.js - About 35 mins to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Function indexCreate has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  Term.prototype.indexCreate = function(name, fn, options) {
  if (this._fastArityRange(arguments.length, 1, 3) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 1, 3, 'indexCreate', this);
                                  Severity: Minor
                                  Found in lib/term.js - About 35 mins to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Function union has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  Term.prototype.union = function() {
  var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}

  var term = new Term(this._r);
  term._query.push(termTypes.UNION);
                                  Severity: Minor
                                  Found in lib/term.js - About 35 mins to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Function Term has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  function Term(r, value, error) {
  var self = this;
  var term = function(field) {
    if (Term.prototype._fastArity(arguments.length, 1) === false) {
      var _len = arguments.length; var _args = new Array(_len);
                                  Severity: Minor
                                  Found in lib/term.js - About 35 mins to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Function group has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  Term.prototype.group = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  var self = this;
  self._arityRange(_args, 1, Infinity, 'group', self);
                                  Severity: Minor
                                  Found in lib/term.js - About 35 mins to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Function _fillArgs has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  Term.prototype._fillArgs = function(args) {
  var foundError = false;
  var internalArgs = [];

  var _len = args.length;
                                  Severity: Minor
                                  Found in lib/term.js - About 35 mins to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Avoid too many return statements within this function.
                                  Open

                                        return new Term(self._r, expression);
                                  Severity: Major
                                  Found in lib/term.js - About 30 mins to fix

                                    Avoid too many return statements within this function.
                                    Open

                                        return term;
                                    Severity: Major
                                    Found in lib/term.js - About 30 mins to fix

                                      Avoid too many return statements within this function.
                                      Open

                                          return self._r.binary(expression);
                                      Severity: Major
                                      Found in lib/term.js - About 30 mins to fix

                                        Avoid too many return statements within this function.
                                        Open

                                          return self;
                                        Severity: Major
                                        Found in lib/term.js - About 30 mins to fix

                                          Avoid too many return statements within this function.
                                          Open

                                                  return new Term(self._r, expression, 'Cannot convert `Infinity` to JSON');
                                          Severity: Major
                                          Found in lib/term.js - About 30 mins to fix

                                            Avoid too many return statements within this function.
                                            Open

                                                return term;
                                            Severity: Major
                                            Found in lib/term.js - About 30 mins to fix

                                              Avoid too many return statements within this function.
                                              Open

                                                    return new Term(self._r, null, expression);
                                              Severity: Major
                                              Found in lib/term.js - About 30 mins to fix

                                                Avoid too many return statements within this function.
                                                Open

                                                      return new Term(self._r, expression);
                                                Severity: Major
                                                Found in lib/term.js - About 30 mins to fix

                                                  Avoid too many return statements within this function.
                                                  Open

                                                          return new Term(self._r, expression, 'Cannot convert `NaN` to JSON');
                                                  Severity: Major
                                                  Found in lib/term.js - About 30 mins to fix

                                                    Avoid too many return statements within this function.
                                                    Open

                                                          return new Term(self._r, expression);
                                                    Severity: Major
                                                    Found in lib/term.js - About 30 mins to fix

                                                      Function _arity has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                      Open

                                                      Term.prototype._arity = function(args, num, method, term) {
  var foundArgs = false; var _len = args.length;
  for (var i = 0; i < _len; ++i) {
    if ((args[i] instanceof Term) && (args[i]._query[0] === termTypes.ARGS)) {
      foundArgs = true;
                                                      Severity: Minor
                                                      Found in lib/term.js - About 25 mins to fix

                                                      Cognitive Complexity

                                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                      A method's cognitive complexity is based on a few simple rules:

                                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                      • Code is considered more complex for each "break in the linear flow of the code"
                                                      • Code is considered more complex when "flow breaking structures are nested"

                                                      Further reading

                                                      Function distinct has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                      Open

                                                      Term.prototype.distinct = function(options) {
  var self = this;
  if (self._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Minor
                                                      Found in lib/term.js - About 25 mins to fix

                                                      Cognitive Complexity

                                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                      A method's cognitive complexity is based on a few simple rules:

                                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                      • Code is considered more complex for each "break in the linear flow of the code"
                                                      • Code is considered more complex when "flow breaking structures are nested"

                                                      Further reading

                                                      Function split has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                      Open

                                                      Term.prototype.split = function(separator, max) {
  if (this._fastArityRange(arguments.length, 0, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 2, 'split', this);
                                                      Severity: Minor
                                                      Found in lib/term.js - About 25 mins to fix

                                                      Cognitive Complexity

                                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                      A method's cognitive complexity is based on a few simple rules:

                                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                      • Code is considered more complex for each "break in the linear flow of the code"
                                                      • Code is considered more complex when "flow breaking structures are nested"

                                                      Further reading

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

                                                      Term.prototype.replace = function(newValue, options) {
  var self = this;
  if (self._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 481..505

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 335.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.update = function(newValue, options) {
  var self = this;
  if (self._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 507..531

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 335.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.max = function(field) {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'max', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1238..1261

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 307.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.min = function(field) {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'min', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1263..1286

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 307.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.wait = function(options) {
  var self = this;
  if (self._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    self._arityRange(_args, 0, 1, 'wait', self);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 533..557

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 302.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.delete = function(options) {
  var self = this;
  if (self._fastArityRange(arguments.length, 1, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 2966..2986

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 302.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.and = function() {
  var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}

  var term = new Term(this._r);
  term._query.push(termTypes.AND);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1761..1775

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 242.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.or = function() {
  var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}

  var term = new Term(this._r);
  term._query.push(termTypes.OR);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1745..1759

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 242.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.sum = function(field) {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'sum', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1221..1237

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 223.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.avg = function(field) {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'avg', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1203..1219

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 223.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.insertAt = function(index, value) {
  if (this._fastArity(arguments.length, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 2, 'insertAt', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 3027..3038

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 211.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.desc = function(field) {
  this._noPrefix(this, 'desc');
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 902..915

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 211.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.asc = function(field) {
  this._noPrefix(this, 'asc');
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 887..900

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 211.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.grant = function(name, access) {
  if (this._fastArity(arguments.length, 2) === false) {
    var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 2, 'grant', this);
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 1523..1535

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 211.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.ge = function(other) {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'ge', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 3 other locations - About 1 day to fix
                                                      lib/term.js on lines 1807..1820
                                                      lib/term.js on lines 1837..1850
                                                      lib/term.js on lines 1852..1865

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 207.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.le = function(other) {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'le', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 3 other locations - About 1 day to fix
                                                      lib/term.js on lines 1807..1820
                                                      lib/term.js on lines 1822..1835
                                                      lib/term.js on lines 1837..1850

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 207.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.gt = function(other) {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'gt', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 3 other locations - About 1 day to fix
                                                      lib/term.js on lines 1822..1835
                                                      lib/term.js on lines 1837..1850
                                                      lib/term.js on lines 1852..1865

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 207.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.lt = function(other) {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'lt', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 3 other locations - About 1 day to fix
                                                      lib/term.js on lines 1807..1820
                                                      lib/term.js on lines 1822..1835
                                                      lib/term.js on lines 1852..1865

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 207.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.pluck = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'pluck', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1777..1790
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.ne = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'ne', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1777..1790

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.div = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'div', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1777..1790
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.without = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'without', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1777..1790
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.sub = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'sub', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1777..1790
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.hasFields = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'hasFields', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1777..1790
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.eq = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'eq', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1701..1714
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 8 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.mul = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  this._arityRange(_args, 1, Infinity, 'mul', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 7 other locations - About 1 day to fix
                                                      lib/term.js on lines 1323..1337
                                                      lib/term.js on lines 1339..1353
                                                      lib/term.js on lines 1507..1521
                                                      lib/term.js on lines 1686..1699
                                                      lib/term.js on lines 1716..1729
                                                      lib/term.js on lines 1777..1790
                                                      lib/term.js on lines 1792..1805

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.polygon = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  // Arity check is done by r.polygon
  this._noPrefix(this, 'polygon');
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 2844..2859

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.line = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
  // Arity check is done by r.line
  this._noPrefix(this, 'line');
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 2872..2888

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 206.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.db = function(db) {
  this._noPrefix(this, 'db');
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 2610..2624

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 203.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.json = function(json) {
  this._noPrefix(this, 'json');
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 574..587

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 203.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.offsetsOf = function(predicate) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'indexesOf', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 2410..2422

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 200.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.forEach = function(func) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'forEach', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 day to fix
                                                      lib/term.js on lines 992..1004

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 200.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.limit = function(value) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'limit', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.setIntersection = function(other) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'setIntersection', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.setInsert = function(other) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'setInsert', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.getField = function(field) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, '(...)', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.includes = function(geometry) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'includes', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.prepend = function(value) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'prepend', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.polygonSub = function(geometry) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'polygonSub', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.indexDrop = function(name) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'indexDrop', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.get = function(primaryKey) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'get', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.setUnion = function(other) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'setUnion', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.default = function(expression) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'default', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.intersects = function(geometry) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'intersects', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.bracket = function(field) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, '(...)', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.coerceTo = function(type) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'coerceTo', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.append = function(value) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'append', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.setDifference = function(other) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'setDifference', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.inTimezone = function(timezone) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'inTimezone', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.skip = function(value) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'skip', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.mod = function(b) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'mod', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1409..1421
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 20 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.difference = function(other) {
  if (this._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 1, 'difference', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 19 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 360..372
                                                      lib/term.js on lines 620..632
                                                      lib/term.js on lines 917..929
                                                      lib/term.js on lines 931..943
                                                      lib/term.js on lines 1381..1393
                                                      lib/term.js on lines 1395..1407
                                                      lib/term.js on lines 1423..1435
                                                      lib/term.js on lines 1437..1449
                                                      lib/term.js on lines 1451..1463
                                                      lib/term.js on lines 1465..1477
                                                      lib/term.js on lines 1479..1491
                                                      lib/term.js on lines 1493..1505
                                                      lib/term.js on lines 1731..1743
                                                      lib/term.js on lines 2033..2045
                                                      lib/term.js on lines 2424..2436
                                                      lib/term.js on lines 2568..2580
                                                      lib/term.js on lines 2816..2828
                                                      lib/term.js on lines 2830..2842
                                                      lib/term.js on lines 2890..2902

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 193.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.indexWait = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}

  var term = new Term(this._r);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 374..387

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 191.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.indexStatus = function() {
  var _len = arguments.length; var _args = new Array(_len);
  for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}

  var term = new Term(this._r);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 389..402

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 191.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.ungroup = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'ungroup', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 559..571

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 178.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.sync = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'sync', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 1174..1186

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 178.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.floor = function() {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'floor', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 1931..1943

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 177.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.ceil = function() {
  if (this._fastArityRange(arguments.length, 0, 1) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arityRange(_args, 0, 1, 'ceil', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 1917..1929

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 177.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.keys = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'keys', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.typeOf = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'typeOf', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.fill = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'fill', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.minutes = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'minutes', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.seconds = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'seconds', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.isEmpty = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'isEmpty', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.timeOfDay = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'timeOfDay', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.timezone = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'timezone', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.info = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'info', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.toISO8601 = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'toISO8601', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.status = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'status', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.values = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'keys', this);
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.not = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'not', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.toEpochTime = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'toEpochTime', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.config = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'config', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.year = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'year', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.dayOfWeek = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'dayOfWeek', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.toGeojson = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'toGeojson', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.indexList = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'indexList', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.dayOfYear = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'dayOfYear', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.hours = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'hours', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.date = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'date', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.month = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'month', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.day = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'day', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.toJsonString = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'toJSON', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964
                                                      lib/term.js on lines 3015..3025

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 26 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.rebalance = function() {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'rebalance', this);
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 25 other locations - About 7 hrs to fix
                                                      lib/term.js on lines 312..324
                                                      lib/term.js on lines 1007..1019
                                                      lib/term.js on lines 1584..1596
                                                      lib/term.js on lines 1598..1609
                                                      lib/term.js on lines 1867..1879
                                                      lib/term.js on lines 2047..2059
                                                      lib/term.js on lines 2082..2094
                                                      lib/term.js on lines 2096..2108
                                                      lib/term.js on lines 2110..2122
                                                      lib/term.js on lines 2124..2136
                                                      lib/term.js on lines 2138..2150
                                                      lib/term.js on lines 2152..2164
                                                      lib/term.js on lines 2166..2178
                                                      lib/term.js on lines 2180..2192
                                                      lib/term.js on lines 2194..2206
                                                      lib/term.js on lines 2208..2220
                                                      lib/term.js on lines 2222..2234
                                                      lib/term.js on lines 2236..2248
                                                      lib/term.js on lines 2582..2594
                                                      lib/term.js on lines 2596..2608
                                                      lib/term.js on lines 2723..2734
                                                      lib/term.js on lines 2751..2763
                                                      lib/term.js on lines 2923..2935
                                                      lib/term.js on lines 2938..2950
                                                      lib/term.js on lines 2952..2964

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.upcase = function(regex) {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'upcase', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 1656..1668

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.downcase = function(regex) {
  if (this._fastArity(arguments.length, 0) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    this._arity(_args, 0, 'upcase', this);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 7 hrs to fix
                                                      lib/term.js on lines 1642..1654

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 175.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        } else if (args.length > max) {
    for (var z = 0; z < _len; z++) {
      if ((args[z] instanceof Term) && (args[z]._query[0] === termTypes.ARGS)) {
        foundArgs = true;
        break;
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 5 hrs to fix
                                                      lib/term.js on lines 3160..3184

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 147.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        if (args.length < min) {
    for (var i = 0; i < _len; ++i) {
      if ((args[i] instanceof Term) && (args[i]._query[0] === termTypes.ARGS)) {
        foundArgs = true;
        break;
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 5 hrs to fix
                                                      lib/term.js on lines 3172..3184

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 147.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype._toTransformStream = function(connection, options) {
  if (this._query[0] !== termTypes.TABLE)
    throw new errors.ReqlDriverError('Cannot create a writable stream on something else than a table.');

  if (helper.isPlainObject(connection) &&
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 3 hrs to fix
                                                      lib/term.js on lines 187..195

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 110.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype._toWritableStream = function(connection, options) {
  if (this._query[0] !== termTypes.TABLE)
    throw new errors.ReqlDriverError('Cannot create a writable stream on something else than a table.');

  if (helper.isPlainObject(connection) &&
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 3 hrs to fix
                                                      lib/term.js on lines 197..205

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 110.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                      Open

                                                        if (helper.isPlainObject(options)) {
    helper.loopKeys(options, function(obj, key) {
      if (key !== 'overwrite') {
        throw new errors.ReqlDriverError('Unrecognized option `' + key + '` in `indexRename`',
          self._query, 'Available options are overwrite <bool>');
                                                      Severity: Major
                                                      Found in lib/term.js and 2 other locations - About 3 hrs to fix
                                                      lib/term.js on lines 607..615
                                                      lib/term.js on lines 710..718

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 109.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                      Open

                                                        if (helper.isPlainObject(options)) {
    helper.loopKeys(options, function(obj, key) {
      if (key !== 'default') {
        throw new errors.ReqlDriverError('Unrecognized option `' + key + '` in `filter`', self._query,
          'Available option is filter');
                                                      Severity: Major
                                                      Found in lib/term.js and 2 other locations - About 3 hrs to fix
                                                      lib/term.js on lines 417..425
                                                      lib/term.js on lines 607..615

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 109.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                      Open

                                                        if (helper.isPlainObject(options)) {
    helper.loopKeys(options, function(obj, key) {
      if (key !== 'readMode') {
        throw new errors.ReqlDriverError('Unrecognized option `' + key + '` in `table`', self._query,
          'Available option is readMode <string>');
                                                      Severity: Major
                                                      Found in lib/term.js and 2 other locations - About 3 hrs to fix
                                                      lib/term.js on lines 417..425
                                                      lib/term.js on lines 710..718

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 109.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        if (self._fastArity(arguments.length, 2) === false) {
    var _len = arguments.length; var _args = new Array(_len);
    for (var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    self._arity(_args, 2, 'getNearest', self);
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 3 hrs to fix
                                                      lib/term.js on lines 2990..2993

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 98.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        if (self._fastArity(arguments.length, 1) === false) {
    var _len = arguments.length;var _args = new Array(_len); for(var _i = 0; _i < _len; _i++) {_args[_i] = arguments[_i];}
    self._arity(_args, 1, 'reconfigure', self);
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 3 hrs to fix
                                                      lib/term.js on lines 2791..2795

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 98.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                          helper.loopKeys(options, function(obj, key) {
      if ((key !== 'primaryKey') && (key !== 'durability') && (key !== 'shards') &&
          (key !== 'replicas') && (key !== 'primaryReplicaTag')) {
        throw new errors.ReqlDriverError('Unrecognized option `' + key + '` in `tableCreate`', self._query,
          'Available options are primaryKey <string>, durability <string>, shards <number>, ' +
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 2 hrs to fix
                                                      lib/term.js on lines 2802..2809

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 90.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                          helper.loopKeys(options, function(obj, key) {
      if ((key !== 'index') && (key !== 'maxResults') && (key !== 'maxDist') &&
          (key !== 'unit') && (key !== 'geoSystem')) {
        throw new errors.ReqlDriverError('Unrecognized option `' + key + '` in `getNearest`', self._query,
          'Available options are index <string>, maxResults <number>, maxDist <number>, unit <string>, ' +
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 2 hrs to fix
                                                      lib/term.js on lines 259..266

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 90.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                              if ((key === 'readMode') || (key === 'durability') || (key === 'db') ||
            (key === 'noreply') || (key === 'arrayLimit') || (key === 'profile') ||
            (key === 'minBatchRows') || (key === 'maxBatchRows') || (key === 'maxBatchBytes') ||
            (key === 'maxBatchSeconds') || (key === 'firstBatchScaledownFactor')) {
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 2 hrs to fix
                                                      lib/term.js on lines 2639..2649

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 85.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                            if ((key !== 'timeout')
        && (key !==  'attempts')
        && (key !==  'redirects')
        && (key !==  'verify')
        && (key !==  'resultFormat')
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 2 hrs to fix
                                                      lib/term.js on lines 111..114

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 85.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.dbList = function() {
  this._noPrefix(this, 'dbList');

  var term = new Term(this._r);
  term._query.push(termTypes.DB_LIST);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 hr to fix
                                                      lib/term.js on lines 1960..1966

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 68.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                      Term.prototype.now = function() {
  this._noPrefix(this, 'now');

  var term = new Term(this._r);
  term._query.push(termTypes.NOW);
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 hr to fix
                                                      lib/term.js on lines 229..235

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 68.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Identical blocks of code found in 3 locations. Consider refactoring.
                                                      Open

                                                        if ((_args.length > 0) && (helper.isPlainObject(_args[_args.length-1])) && (_args[_args.length-1].index !== undefined)) {
    term._fillArgs(args);
    term._query.push(new Term(this._r).expr(translateOptions(_args[_args.length-1]))._query);
  }
  else if (_args.length > 0) {
                                                      Severity: Major
                                                      Found in lib/term.js and 2 other locations - About 1 hr to fix
                                                      lib/term.js on lines 869..882
                                                      lib/term.js on lines 1033..1040

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 66.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Identical blocks of code found in 3 locations. Consider refactoring.
                                                      Open

                                                        if ((_args.length > 0) && (helper.isPlainObject(_args[_args.length - 1])) &&
      (_args[_args.length - 1].index !== undefined)) {
    term._fillArgs(args);
    term._query.push(new Term(this._r).expr(translateOptions(_args[_args.length - 1]))._query);
  } else {
                                                      Severity: Major
                                                      Found in lib/term.js and 2 other locations - About 1 hr to fix
                                                      lib/term.js on lines 646..655
                                                      lib/term.js on lines 1033..1040

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 66.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Identical blocks of code found in 3 locations. Consider refactoring.
                                                      Open

                                                        if ((_args.length > 1) && (helper.isPlainObject(_args[_args.length-1])) && (_args[_args.length-1].interleave !== undefined)) {
    term._fillArgs(args);
    term._query.push(new Term(this._r).expr(translateOptions(_args[_args.length-1]))._query);
  }
  else if (_args.length > 0) {
                                                      Severity: Major
                                                      Found in lib/term.js and 2 other locations - About 1 hr to fix
                                                      lib/term.js on lines 646..655
                                                      lib/term.js on lines 869..882

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 66.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        for(var i=0; i<_args.length-1; i++) {
    args.push(new Term(this._r).expr(_args[i]));
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 hr to fix
                                                      lib/term.js on lines 643..645

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 62.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        for(var i=0; i<_args.length-1; i++) {
    args.push(new Term(this._r).expr(_args[i]));
  }
                                                      Severity: Major
                                                      Found in lib/term.js and 1 other location - About 1 hr to fix
                                                      lib/term.js on lines 1030..1032

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 62.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.maxval = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.MAXVAL);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.wednesday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.WEDNESDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.july = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.JULY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.thursday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.THURSDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.friday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.FRIDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.march = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.MARCH);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.august = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.AUGUST);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.november = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.NOVEMBER);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.monday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.MONDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.tuesday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.TUESDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.february = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.FEBRUARY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.september = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.SEPTEMBER);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.minval = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.MINVAL);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.april = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.APRIL);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.december = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.DECEMBER);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.sunday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.SUNDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.january = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.JANUARY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.may = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.MAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.october = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.OCTOBER);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.saturday = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.SATURDAY);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2322..2326
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      Similar blocks of code found in 21 locations. Consider refactoring.
                                                      Open

                                                      Term.prototype.june = function() {
  var term = new Term(this._r);
  term._query.push(termTypes.JUNE);
  return term;
};
                                                      Severity: Major
                                                      Found in lib/term.js and 20 other locations - About 1 hr to fix
                                                      lib/term.js on lines 685..689
                                                      lib/term.js on lines 691..695
                                                      lib/term.js on lines 2250..2254
                                                      lib/term.js on lines 2256..2260
                                                      lib/term.js on lines 2262..2266
                                                      lib/term.js on lines 2268..2272
                                                      lib/term.js on lines 2274..2278
                                                      lib/term.js on lines 2280..2284
                                                      lib/term.js on lines 2286..2290
                                                      lib/term.js on lines 2292..2296
                                                      lib/term.js on lines 2298..2302
                                                      lib/term.js on lines 2304..2308
                                                      lib/term.js on lines 2310..2314
                                                      lib/term.js on lines 2316..2320
                                                      lib/term.js on lines 2328..2332
                                                      lib/term.js on lines 2334..2338
                                                      lib/term.js on lines 2340..2344
                                                      lib/term.js on lines 2346..2350
                                                      lib/term.js on lines 2352..2356
                                                      lib/term.js on lines 2358..2362

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 57.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        else if (_args.length > 0) {
    args.push(new Term(this._r).expr(_args[_args.length-1]));
    term._fillArgs(args);
  }
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 55 mins to fix
                                                      lib/term.js on lines 650..655

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 54.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        else if (_args.length > 0) {
    args.push(new Term(this._r).expr(_args[_args.length-1]));
    term._fillArgs(args);
  } else {
    term._fillArgs(args);
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 55 mins to fix
                                                      lib/term.js on lines 1037..1040

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 54.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        if (helper.isPlainObject(options)) {
    term._query.push(new Term(this._r).expr(translateOptions(options))._query);
  }
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 55 mins to fix
                                                      lib/term.js on lines 2562..2564

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 54.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        if (helper.isPlainObject(options)) {
    term._query.push(new Term(this._r).expr(translateOptions(options))._query);
  }
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 55 mins to fix
                                                      lib/term.js on lines 2076..2078

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 54.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                            term._query.push(new Term(self._r).expr(translateOptions(_args[_args.length - 1]))._query);
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 50 mins to fix
                                                      lib/term.js on lines 1905..1905

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 51.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                            term._query.push(new Term(self._r).expr(translateOptions(_args[_args.length - 1]))._query);
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 50 mins to fix
                                                      lib/term.js on lines 1142..1142

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 51.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                          } else {
      args.push(new Term(this._r).expr(_args[_args.length - 1])._wrap());
    }
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 40 mins to fix
                                                      lib/term.js on lines 813..815

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 49.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

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

                                                        if (_args.length> 0) {
    args.push(new Term(this._r).expr(_args[_args.length-1])._wrap());
  }
                                                      Severity: Minor
                                                      Found in lib/term.js and 1 other location - About 40 mins to fix
                                                      lib/term.js on lines 878..880

                                                      Duplicated Code

                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                      Tuning

                                                      This issue has a mass of 49.

                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                      Refactorings

                                                      Further Reading

                                                      There are no issues that match your filters.

                                                      Category
                                                      Status