XingFramework/Relayer

View on GitHub
dist/relayer.es5.js

Summary

Maintainability
F
1 mo
Test Coverage

File relayer.es5.js has 4827 lines of code (exceeds 250 allowed). Consider refactoring.
Open

define('relayer/jsonpath',[], function() {

  if (!Array.isArray) {
    Array.isArray = function(vArg) {
      return Object.prototype.toString.call(vArg) === "[object Array]";
Severity: Major
Found in dist/relayer.es5.js - About 1 wk to fix

    Function jsonPath has 185 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      function jsonPath(obj, expr, arg) {
        var P = {
          resultType: arg && arg.resultType || "value",
          flatten: arg && arg.flatten || false,
          wrap: (arg && arg.hasOwnProperty('wrap')) ? arg.wrap : true,
    Severity: Major
    Found in dist/relayer.es5.js - About 7 hrs to fix

      Function mapNestedRelationships has 57 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          mapNestedRelationships: function() {
            var $__16 = this;
            $traceurRuntime.superGet(this, $ListResourceMapper.prototype, "mapNestedRelationships").call(this);
            this.resource = this.mapped;
            var manyResourceMapper = this.manyResourceMapperFactory(this.transport, this.resource.pathGet("$.data"), this.relationshipDescription);
      Severity: Major
      Found in dist/relayer.es5.js - About 2 hrs to fix

        Function trace has 55 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

              trace: function(expr, val, path) {
                function addRet(elems) {
                  ret = ret.concat(elems);
                }
                if (!expr.length) {
        Severity: Major
        Found in dist/relayer.es5.js - About 2 hrs to fix

          Function ListRelationshipDescription has 17 arguments (exceeds 4 allowed). Consider refactoring.
          Open

            var ListRelationshipDescription = function ListRelationshipDescription(relationshipInitializerFactory, resourceMapperFactory, resourceSerializerFactory, inflector, singleRelationshipDescriptionFactory, ListResource, primaryResourceTransformerFactory, embeddedRelationshipTransformerFactory, individualFromListTransformerFactory, createResourceTransformerFactory, resolvedEndpointFactory, loadedDataEndpointFactory, templatedUrlFromUrlFactory, templatedUrlFactory, name, ResourceClass, initialValues) {
          Severity: Major
          Found in dist/relayer.es5.js - About 2 hrs to fix

            Function resourceFn has 42 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                get resourceFn() {
                  if (!this._resourceFn) {
                    var name = this.name;
                    var relationship = this.relationship;
                    var promiseEndpointFactory = this.promiseEndpointFactory;
            Severity: Minor
            Found in dist/relayer.es5.js - About 1 hr to fix

              Function pathSet has 42 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  pathSet: function(jsonpath, value) {
                    var path = jsonPath(this._response, jsonpath, {
                      wrap: true,
                      resultType: "path"
                    });
              Severity: Minor
              Found in dist/relayer.es5.js - About 1 hr to fix

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

                    pathClear: function(jsonpath) {
                      var path = jsonPath(this._response, jsonpath, {
                        wrap: true,
                        resultType: "path"
                      });
                Severity: Minor
                Found in dist/relayer.es5.js - About 1 hr to fix

                  Function SingleRelationshipDescription has 12 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                    var SingleRelationshipDescription = function SingleRelationshipDescription(relationshipInitializerFactory, resourceMapperFactory, resourceSerializerFactory, inflector, primaryResourceTransformerFactory, embeddedRelationshipTransformerFactory, resolvedEndpointFactory, loadedDataEndpointFactory, templatedUrlFactory, name, ResourceClass, initialValues) {
                  Severity: Major
                  Found in dist/relayer.es5.js - About 1 hr to fix

                    Function _resourceFn has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                            this._resourceFn = function(uriParams) {
                              var recursiveCall = arguments[1] !== (void 0) ? arguments[1] : false;
                              var $__10 = this;
                              if (relationship.async && this.isPersisted) {
                                var endpoint;
                    Severity: Minor
                    Found in dist/relayer.es5.js - About 1 hr to fix

                      Function setupProperty has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        ($traceurRuntime.createClass)(PropertiesBuilder, {setupProperty: function(key, properties) {
                            properties[STRING_PREFIX + key] = "@" + this._bindObj[key];
                            properties[BIND_PREFIX + key] = "=?bind" + this._bindObj[key][0].toUpperCase() + this._bindObj[key].slice(1);
                            Object.defineProperty(this._component.prototype, BIND_PREFIX + key, {
                              enumerable: true,
                      Severity: Minor
                      Found in dist/relayer.es5.js - About 1 hr to fix

                        Function ListResourceMapper has 10 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                          var ListResourceMapper = function ListResourceMapper(templatedUrlFromUrlFactory, resourceBuilderFactory, primaryResourceBuilderFactory, primaryResourceTransformerFactory, manyResourceMapperFactory, temporaryTemplatedUrlFactory, transport, response, relationshipDescription, endpoint) {
                        Severity: Major
                        Found in dist/relayer.es5.js - About 1 hr to fix

                          Function MultipleRelationshipDescription has 10 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                            var MultipleRelationshipDescription = function MultipleRelationshipDescription(relationshipInitializerFactory, resourceMapperFactory, resourceSerializerFactory, inflector, embeddedRelationshipTransformerFactory, singleFromManyTransformerFactory, loadedDataEndpointFactory, name, ResourceClass, initialValues) {
                          Severity: Major
                          Found in dist/relayer.es5.js - About 1 hr to fix

                            Function ResourceBuilder has 9 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                              var ResourceBuilder = function ResourceBuilder(templatedUrlFromUrlFactory, resolvedEndpointFactory, throwErrorTransformerFactory, createResourceTransformerFactory, transport, response, primaryResourceTransformer, ResourceClass, relationshipDescription) {
                            Severity: Major
                            Found in dist/relayer.es5.js - About 1 hr to fix

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

                                  linkedEndpoint: function(parent, uriParams) {
                                    var transport = parent.self().transport;
                                    var url,
                                        templatedUrl,
                                        primaryResourceTransformer,
                              Severity: Minor
                              Found in dist/relayer.es5.js - About 1 hr to fix

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

                                    get endpointFn() {
                                      if (!this._endpointFn) {
                                        var name = this.name;
                                        var description = this.relationship.ResourceClass.resourceDescription;
                                        var relationship = this.relationship;
                                Severity: Minor
                                Found in dist/relayer.es5.js - About 1 hr to fix

                                  Function JsonPropertyDecorator has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                  Open

                                    var JsonPropertyDecorator = function JsonPropertyDecorator(loadedDataEndpointFactory, embeddedPropertyTransformerFactory, promiseEndpointFactory, name, path, value, options) {
                                  Severity: Major
                                  Found in dist/relayer.es5.js - About 50 mins to fix

                                    Function RelationshipDescription has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                    Open

                                      var RelationshipDescription = function RelationshipDescription(relationshipInitializerFactory, resourceMapperFactory, resourceSerializerFactory, inflector, name, ResourceClass, initialValues) {
                                    Severity: Major
                                    Found in dist/relayer.es5.js - About 50 mins to fix

                                      Function ResourceMapper has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                      Open

                                        var ResourceMapper = function ResourceMapper(templatedUrlFromUrlFactory, resourceBuilderFactory, primaryResourceBuilderFactory, primaryResourceTransformerFactory, transport, response, relationshipDescription) {
                                      Severity: Major
                                      Found in dist/relayer.es5.js - About 50 mins to fix

                                        Function ResourceDescription has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                        Open

                                          var ResourceDescription = function ResourceDescription(jsonPropertyDecoratorFactory, relatedResourceDecoratorFactory, singleRelationshipDescriptionFactory, manyRelationshipDescriptionFactory, listRelationshipDescriptionFactory, mapRelationshipDescriptionFactory, inflector) {
                                        Severity: Major
                                        Found in dist/relayer.es5.js - About 50 mins to fix

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

                                                walk: function(loc, expr, val, path, f) {
                                          Severity: Minor
                                          Found in dist/relayer.es5.js - About 35 mins to fix

                                            Avoid too many return statements within this function.
                                            Open

                                                    return result.reduce(function(result, ea) {
                                                      var valOrPath = ea[resultType];
                                                      if (P.flatten && Array.isArray(valOrPath)) {
                                                        result = result.concat(valOrPath);
                                                      } else {
                                            Severity: Major
                                            Found in dist/relayer.es5.js - About 30 mins to fix

                                              Avoid too many return statements within this function.
                                              Open

                                                    return obj;
                                              Severity: Major
                                              Found in dist/relayer.es5.js - About 30 mins to fix

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

                                                define('relayer/relationshipDescriptions/ManyRelationshipDescription',["./MultipleRelationshipDescription", "../initializers/ManyRelationshipInitializer", "../mappers/ManyResourceMapper", "../serializers/ManyResourceSerializer", "xing-inflector", "../transformers/EmbeddedRelationshipTransformer", "../transformers/SingleFromManyTransformer", "../endpoints/LoadedDataEndpoint", "../injector"], function($__0,$__2,$__4,$__6,$__8,$__10,$__12,$__14,$__16) {
                                                
                                                  if (!$__0 || !$__0.__esModule)
                                                    $__0 = {default: $__0};
                                                  if (!$__2 || !$__2.__esModule)
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 days to fix
                                                dist/relayer.es5.js on lines 4479..4524

                                                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 533.

                                                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

                                                define('relayer/relationshipDescriptions/MapRelationshipDescription',["./MultipleRelationshipDescription", "../initializers/MapRelationshipInitializer", "../mappers/MapResourceMapper", "../serializers/MapResourceSerializer", "xing-inflector", "../transformers/EmbeddedRelationshipTransformer", "../transformers/SingleFromManyTransformer", "../endpoints/LoadedDataEndpoint", "../injector"], function($__0,$__2,$__4,$__6,$__8,$__10,$__12,$__14,$__16) {
                                                
                                                  if (!$__0 || !$__0.__esModule)
                                                    $__0 = {default: $__0};
                                                  if (!$__2 || !$__2.__esModule)
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 days to fix
                                                dist/relayer.es5.js on lines 3686..3731

                                                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 533.

                                                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

                                                    emptyData: function() {
                                                      var $__2 = this;
                                                      this._response = {
                                                        data: {},
                                                        links: {}
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 7 hrs to fix
                                                dist/cjs/relayer/Resource.js on lines 137..152

                                                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 192.

                                                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

                                                      try {
                                                        for (var $__4 = void 0,
                                                            $__3 = (path)[$traceurRuntime.toProperty(Symbol.iterator)](); !($__6 = ($__4 = $__3.next()).done); $__6 = true) {
                                                          var segment = $__4.value;
                                                          {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 7 hrs to fix
                                                dist/relayer.es5.js on lines 271..292

                                                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 176.

                                                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

                                                        try {
                                                          for (var $__4 = void 0,
                                                              $__3 = (path)[$traceurRuntime.toProperty(Symbol.iterator)](); !($__6 = ($__4 = $__3.next()).done); $__6 = true) {
                                                            var segment = $__4.value;
                                                            {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 7 hrs to fix
                                                dist/relayer.es5.js on lines 317..338

                                                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 176.

                                                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

                                                    resolve: function(backendResponds) {
                                                      var $__0 = this;
                                                      return backendResponds.then((function(fullResponse) {
                                                        if (fullResponse.status === 201 && fullResponse.headers().location) {
                                                          var locationUrl = $__0.absolutizeResponseLocation(fullResponse);
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 5 hrs to fix
                                                dist/cjs/relayer/Transport.js on lines 69..85

                                                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 146.

                                                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

                                                  ($traceurRuntime.createClass)(MapRelationshipInitializer, {initialize: function() {
                                                      var $__6 = this;
                                                      var relationship = {};
                                                      var response = {};
                                                      if (this.initialValues) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 5 hrs to fix
                                                dist/cjs/relayer/initializers/MapRelationshipInitializer.js on lines 39..53

                                                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 138.

                                                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

                                                  ($traceurRuntime.createClass)(ManyRelationshipInitializer, {initialize: function() {
                                                      var $__6 = this;
                                                      var relationship = [];
                                                      var response = [];
                                                      if (this.initialValues) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 4 hrs to fix
                                                dist/cjs/relayer/initializers/ManyRelationshipInitializer.js on lines 39..53

                                                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 122.

                                                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

                                                    _update: function(resource) {
                                                      var $__4 = this;
                                                      var request = this._transformRequest(this.resourceTransformers, resource);
                                                      var response = this.transport.put(this.templatedUrl.url, request);
                                                      response = response.then((function(data) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/cjs/relayer/endpoints/LoadedDataEndpoint.js on lines 48..57

                                                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 114.

                                                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

                                                      ["url", "uriTemplate", "uriParams"].forEach((function(func) {
                                                        $__16.mapped[func] = function() {
                                                          var $__20;
                                                          for (var args = [],
                                                              $__19 = 0; $__19 < arguments.length; $__19++)
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/relayer.es5.js on lines 4058..4066

                                                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

                                                      Object.keys(this.resource.relationships).forEach((function(key) {
                                                        $__16.mapped[key] = function() {
                                                          var $__20;
                                                          for (var args = [],
                                                              $__19 = 0; $__19 < arguments.length; $__19++)
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/relayer.es5.js on lines 4039..4047

                                                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

                                                  var $__1 = $__0,
                                                      Config = $__1.Config,
                                                      Run = $__1.Run,
                                                      Controller = $__1.Controller,
                                                      Directive = $__1.Directive,
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/relayer.es5.js on lines 2666..2677

                                                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 106.

                                                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

                                                  var $__5 = $__4,
                                                      ConfigInjector = $__5.ConfigInjector,
                                                      RunInjector = $__5.RunInjector,
                                                      ControllerInjector = $__5.ControllerInjector,
                                                      DirectiveInjector = $__5.DirectiveInjector,
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/relayer.es5.js on lines 2436..2447

                                                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 106.

                                                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

                                                    mapNestedRelationships: function() {
                                                      var $__6 = this;
                                                      Object.keys(this.response).forEach((function(responseKey) {
                                                        var response = $__6.response[responseKey];
                                                        var singleResourceMapper = $__6.singleRelationshipDescription.mapperFactory($__6.transport, response, $__6.singleRelationshipDescription);
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/cjs/relayer/mappers/MapResourceMapper.js on lines 46..54

                                                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 106.

                                                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 (overwrite) {
                                                        var newUrl = resource.pathGet(path);
                                                        if (newUrl) {
                                                          this._setUrl(newUrl);
                                                          this._paths.forEach((function(path) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/cjs/relayer/TemplatedUrl.js on lines 54..64

                                                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 101.

                                                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

                                                    mapNestedRelationships: function() {
                                                      var $__6 = this;
                                                      this.response.forEach((function(response) {
                                                        var resourceMapper = $__6.singleRelationshipDescription.mapperFactory($__6.transport, response, $__6.singleRelationshipDescription);
                                                        resourceMapper.uriTemplate = $__6.uriTemplate;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/cjs/relayer/mappers/ManyResourceMapper.js on lines 46..54

                                                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

                                                      return response.then((function(resolvedResponse) {
                                                        var resourceMapper = $__2.primaryResourceMapperFactory(endpoint.transport, resolvedResponse.data, $__2.relationshipDescription);
                                                        resourceMapper.uriTemplate = $__2.uriTemplate;
                                                        var resource = resourceMapper.map();
                                                        resource.templatedUrl.etag = resolvedResponse.etag;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 3 hrs to fix
                                                dist/cjs/relayer/transformers/CreateResourceTransformer.js on lines 36..42

                                                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 96.

                                                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

                                                      return response.then((function(resource) {
                                                        endpoint.resource = resource;
                                                        var elementIndex = $__6.findInRelationship(resource.relationships[$__6.relationshipName]);
                                                        if (elementIndex == -1) {
                                                          throw "Element Not Found In List";
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/cjs/relayer/transformers/IndividualFromListTransformer.js on lines 65..73

                                                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 93.

                                                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

                                                  var ManyResourceMapper = function ManyResourceMapper(singleRelationshipDescriptionFactory, transport, response, relationshipDescription) {
                                                    var useErrors = arguments[4] !== (void 0) ? arguments[4] : false;
                                                    $traceurRuntime.superConstructor($ManyResourceMapper).call(this, transport, response, relationshipDescription, useErrors);
                                                    this.singleRelationshipDescription = singleRelationshipDescriptionFactory("", this.ResourceClass);
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/relayer.es5.js on lines 4415..4419

                                                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 88.

                                                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

                                                  var MapResourceMapper = function MapResourceMapper(singleRelationshipDescriptionFactory, transport, response, relationshipDescription) {
                                                    var useErrors = arguments[4] !== (void 0) ? arguments[4] : false;
                                                    $traceurRuntime.superConstructor($MapResourceMapper).call(this, transport, response, relationshipDescription, useErrors);
                                                    this.singleRelationshipDescription = singleRelationshipDescriptionFactory("", this.ResourceClass);
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/relayer.es5.js on lines 3587..3591

                                                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 88.

                                                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

                                                  ($traceurRuntime.createClass)(SingleRelationshipInitializer, {initialize: function() {
                                                      var $__2 = this;
                                                      var relationship = new this.ResourceClass();
                                                      if (this.initialValues) {
                                                        Object.keys(this.initialValues).forEach((function(property) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/cjs/relayer/initializers/SingleRelationshipInitializer.js on lines 32..42

                                                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 87.

                                                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

                                                          var newPromise = (function() {
                                                            return $__10.load().then((function(resource) {
                                                              if (relationship.async) {
                                                                return resource[name](uriParams);
                                                              } else {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/cjs/relayer/decorators/RelatedResourceDecorator.js on lines 133..143

                                                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 84.

                                                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

                                                    create: function(resource, res, rej) {
                                                      return this.endpointPromise().then((function(endpoint) {
                                                        if (endpoint._create) {
                                                          return endpoint._create(resource);
                                                        } else {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/relayer.es5.js on lines 424..432

                                                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 83.

                                                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

                                                    update: function(resource, res, rej) {
                                                      return this.endpointPromise().then((function(endpoint) {
                                                        if (endpoint._update) {
                                                          return endpoint._update(resource);
                                                        } else {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/relayer.es5.js on lines 415..423

                                                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 83.

                                                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 (!this.relationships[name]) {
                                                              if (recursiveCall === false) {
                                                                endpoint = promiseEndpointFactory((function() {
                                                                  return $__10.self().load().then((function(resource) {
                                                                    return resource[name](uriParams, true);
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/cjs/relayer/decorators/RelatedResourceDecorator.js on lines 61..75

                                                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 81.

                                                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

                                                    annotationFor: function(AnnotationClass) {
                                                      var OriginalClass = AnnotationClass.originalClass || AnnotationClass;
                                                      if (this.AnnotatedClass.annotations) {
                                                        return this.AnnotatedClass.annotations.find((function(annotation) {
                                                          return annotation instanceof OriginalClass;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/relayer.es5.js on lines 1922..1931

                                                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 80.

                                                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

                                                  ($traceurRuntime.createClass)(MapResourceSerializer, {serialize: function() {
                                                      var $__6 = this;
                                                      return Object.keys(this.resource).reduce((function(data, key) {
                                                        data[key] = $__6.resourceSerializerFactory($__6.resource[key]).serialize();
                                                        return data;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/cjs/relayer/serializers/MapResourceSerializer.js on lines 39..46

                                                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 80.

                                                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

                                                    annotationsFor: function(AnnotationClass) {
                                                      var OriginalClass = AnnotationClass.originalClass || AnnotationClass;
                                                      if (this.AnnotatedClass.annotations) {
                                                        return this.AnnotatedClass.annotations.filter((function(annotation) {
                                                          return annotation instanceof OriginalClass;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 2 hrs to fix
                                                dist/relayer.es5.js on lines 1912..1921

                                                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 80.

                                                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

                                                  Inject(factory(ListRelationshipInitializer), factory(ListResourceMapper), factory(ListResourceSerializer), Inflector, factory(SingleRelationshipDescription), value(ListResource), factory(PrimaryResourceTransformer), factory(EmbeddedRelationshipTransformer), factory(IndividualFromListTransformer), factory(CreateResourceTransformer), factory(ResolvedEndpoint), factory(LoadedDataEndpoint), factory(TemplatedUrlFromUrl), factory(TemplatedUrl))(ListRelationshipDescription);
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 2 hrs to fix
                                                dist/relayer/relationshipDescriptions/ListRelationshipDescription.js on lines 164..179
                                                src/relayer/relationshipDescriptions/ListRelationshipDescription.js on lines 164..179

                                                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 76.

                                                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

                                                    underscore: function(key) {
                                                      if (!angular.isString(key)) {
                                                        return key;
                                                      }
                                                      return key.replace(/[A-Z]/g, function(match, index) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 3353..3360

                                                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 74.

                                                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

                                                    dasherize: function(key) {
                                                      if (!angular.isString(key)) {
                                                        return key;
                                                      }
                                                      return key.replace(/[A-Z]/g, function(match, index) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 3345..3352

                                                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 74.

                                                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

                                                    load: function(res, rej) {
                                                      return this.endpointPromise().then((function(endpoint) {
                                                        if (endpoint._load) {
                                                          return endpoint._load();
                                                        } else {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/endpoints/Endpoint.js on lines 40..48

                                                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 72.

                                                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

                                                  ($traceurRuntime.createClass)(FilterInjector, {
                                                    get annotationClass() {
                                                      return Filter;
                                                    },
                                                    instantiateOne: function(module, filter, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2590..2598

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(ConstantInjector, {
                                                    get annotationClass() {
                                                      return Constant;
                                                    },
                                                    instantiateOne: function(module, constant, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2590..2598
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(AnimationInjector, {
                                                    get annotationClass() {
                                                      return Animation;
                                                    },
                                                    instantiateOne: function(module, animation, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(FactoryInjector, {
                                                    get annotationClass() {
                                                      return Factory;
                                                    },
                                                    instantiateOne: function(module, factory, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2590..2598
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(ProviderInjector, {
                                                    get annotationClass() {
                                                      return Provider;
                                                    },
                                                    instantiateOne: function(module, provider, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2590..2598
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(DirectiveInjector, {
                                                    get annotationClass() {
                                                      return Directive;
                                                    },
                                                    instantiateOne: function(module, directive, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2590..2598
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(ServiceInjector, {
                                                    get annotationClass() {
                                                      return Service;
                                                    },
                                                    instantiateOne: function(module, service, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2562..2570
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2590..2598
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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

                                                  ($traceurRuntime.createClass)(ValueInjector, {
                                                    get annotationClass() {
                                                      return Value;
                                                    },
                                                    instantiateOne: function(module, value, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 7 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2506..2514
                                                dist/relayer.es5.js on lines 2520..2528
                                                dist/relayer.es5.js on lines 2534..2542
                                                dist/relayer.es5.js on lines 2548..2556
                                                dist/relayer.es5.js on lines 2576..2584
                                                dist/relayer.es5.js on lines 2590..2598
                                                dist/relayer.es5.js on lines 2604..2612

                                                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 71.

                                                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 4 locations. Consider refactoring.
                                                Open

                                                  function metadataValueOrCall(key, target, cb) {
                                                    if (metaMap.hasMetadata(key, target)) {
                                                      return metaMap.getMetadata(key, target);
                                                    } else {
                                                      var value = cb();
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 3 other locations - About 1 hr to fix
                                                dist/cjs/relayer/injector.js on lines 32..40
                                                dist/relayer/injector.js on lines 5..13
                                                src/relayer/injector.js on lines 5..13

                                                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 69.

                                                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

                                                    applyToResource: function(resource) {
                                                      this.allDecorators.forEach((function(decorator) {
                                                        decorator.resourceApply(resource);
                                                      }));
                                                      if (this.parentDescription) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 4634..4641
                                                dist/relayer.es5.js on lines 4642..4649

                                                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 69.

                                                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 (!(relationship instanceof TemplatedUrl)) {
                                                          var relationshipDefinition = $__4.resource.constructor.relationships[relationshipName];
                                                          var serializer = relationshipDefinition.serializerFactory(relationship);
                                                          $__4.resource.pathSet(relationshipDefinition.dataPath, serializer.serialize());
                                                        }
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/serializers/ResourceSerializer.js on lines 41..45

                                                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 69.

                                                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

                                                    applyToError: function(error) {
                                                      this.allDecorators.forEach((function(decorator) {
                                                        decorator.errorsApply(error);
                                                      }));
                                                      if (this.parentDescription) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 4626..4633
                                                dist/relayer.es5.js on lines 4642..4649

                                                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 69.

                                                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

                                                    applyToEndpoint: function(endpoint) {
                                                      this.allDecorators.forEach((function(decorator) {
                                                        decorator.endpointApply(endpoint);
                                                      }));
                                                      if (this.parentDescription) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 1 hr to fix
                                                dist/relayer.es5.js on lines 4626..4633
                                                dist/relayer.es5.js on lines 4634..4641

                                                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 69.

                                                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

                                                      return response.then((function(resolvedResponse) {
                                                        endpoint.templatedUrl.etag = resolvedResponse.etag;
                                                        return $__2.primaryResourceMapperFactory(endpoint.transport, resolvedResponse.data, $__2.relationshipDescription, endpoint).map();
                                                      })).catch((function(resolvedError) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/transformers/PrimaryResourceTransformer.js on lines 51..54

                                                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

                                                    initializeClasses: function() {
                                                      var $__18 = this;
                                                      resourcesToInitialize.forEach((function(resourceToInitialize) {
                                                        $__18.buildDescription(resourceToInitialize);
                                                      }));
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/ResourceDescription.js on lines 91..101

                                                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 67.

                                                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

                                                  ($traceurRuntime.createClass)(ConfigInjector, {
                                                    get annotationClass() {
                                                      return Config;
                                                    },
                                                    instantiateOne: function(module, config, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2477..2485

                                                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

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

                                                  ($traceurRuntime.createClass)(RunInjector, {
                                                    get annotationClass() {
                                                      return Run;
                                                    },
                                                    instantiateOne: function(module, run, metadata) {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2463..2471

                                                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

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

                                                  var DirectiveObject = function DirectiveObject(token) {
                                                    var dependencies = arguments[1] !== (void 0) ? arguments[1] : [];
                                                    this.dependencies = dependencies;
                                                    this.token = token;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 1742..1746

                                                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 65.

                                                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

                                                  var NgNamedAnnotation = function NgNamedAnnotation(token) {
                                                    var dependencies = arguments[1] !== (void 0) ? arguments[1] : [];
                                                    this.dependencies = dependencies;
                                                    this.token = token;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 2862..2866

                                                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 65.

                                                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

                                                      Object.defineProperty(this._component.prototype, STRING_PREFIX + key, {
                                                        enumerable: true,
                                                        configurable: true,
                                                        set: genericSetter(RAW_STRING, BINDING),
                                                        get: function() {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 3052..3059

                                                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 63.

                                                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

                                                      Object.defineProperty(this._component.prototype, BIND_PREFIX + key, {
                                                        enumerable: true,
                                                        configurable: true,
                                                        set: genericSetter(BINDING, RAW_STRING),
                                                        get: function() {
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 3060..3067

                                                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 63.

                                                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

                                                  ($traceurRuntime.createClass)(APIError, {handleMessage: function(attrName) {
                                                      if (this[attrName]) {
                                                        this.unhandled = this.unhandled.filter((function(name) {
                                                          return name != attrName;
                                                        }));
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/APIError.js on lines 43..50

                                                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 2 locations. Consider refactoring.
                                                Open

                                                    get relationships() {
                                                      if (!this.hasOwnProperty("_relationships")) {
                                                        this._relationships = Object.create(this._relationships || {});
                                                      }
                                                      return this._relationships;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 3854..3859

                                                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 60.

                                                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

                                                    get properties() {
                                                      if (!this.hasOwnProperty("_properties")) {
                                                        this._properties = Object.create(this._properties || {});
                                                      }
                                                      return this._properties;
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/relayer.es5.js on lines 3848..3853

                                                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 60.

                                                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

                                                    _transformRequest: function(transformers, request) {
                                                      var $__4 = this;
                                                      return transformers.slice(0).reverse().reduce((function(interimRequest, transformer) {
                                                        return transformer.transformRequest($__4, interimRequest);
                                                      }), request);
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/endpoints/ResolvedEndpoint.js on lines 85..92

                                                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 2 locations. Consider refactoring.
                                                Open

                                                    removeDataPathLink: function(resource, path) {
                                                      this._paths = this._paths.filter((function(pathLink) {
                                                        return (pathLink.resource != resource) || (pathLink.path != path);
                                                      }));
                                                    }
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 1 other location - About 1 hr to fix
                                                dist/cjs/relayer/TemplatedUrl.js on lines 72..76

                                                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 56.

                                                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

                                                    resourceApply: function(target) {
                                                      target.constructor.relationships[this.name] = this.relationship;
                                                      this.addFunction(target, this.resourceFn);
                                                    },
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 55 mins to fix
                                                dist/relayer.es5.js on lines 1200..1203

                                                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

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

                                                    get dataPath() {
                                                      this._dataPath = this._dataPath || ("$.data." + this.inflector.underscore(this.name));
                                                      return this._dataPath;
                                                    },
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 55 mins to fix
                                                dist/relayer.es5.js on lines 1236..1239

                                                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

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

                                                    get linksPath() {
                                                      this._linksPath = this._linksPath || ("$.links." + this.inflector.underscore(this.name));
                                                      return this._linksPath;
                                                    },
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 55 mins to fix
                                                dist/relayer.es5.js on lines 1244..1247

                                                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

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

                                                    errorsApply: function(target) {
                                                      target.constructor.relationships[this.name] = this.relationship;
                                                      this.addFunction(target, this.errorFn);
                                                    },
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 55 mins to fix
                                                dist/relayer.es5.js on lines 1196..1199

                                                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 (!Array.isArray) {
                                                    Array.isArray = function(vArg) {
                                                      return Object.prototype.toString.call(vArg) === "[object Array]";
                                                    };
                                                  }
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 55 mins to fix
                                                dist/cjs/relayer/jsonpath.js on lines 13..17

                                                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 53.

                                                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

                                                  Inject(factory(SingleRelationshipInitializer), factory(ResourceMapper), factory(ResourceSerializer), Inflector, factory(PrimaryResourceTransformer), factory(EmbeddedRelationshipTransformer), factory(ResolvedEndpoint), factory(LoadedDataEndpoint), factory(TemplatedUrl))(SingleRelationshipDescription);
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 50 mins to fix
                                                dist/relayer/relationshipDescriptions/SingleRelationshipDescription.js on lines 75..85
                                                src/relayer/relationshipDescriptions/SingleRelationshipDescription.js on lines 75..85

                                                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

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

                                                    findInRelationship: function(relationship) {
                                                      var url = this.templatedUrl(relationship);
                                                      return relationship.findIndex((function(resource) {
                                                        return (resource.pathGet('$.links.self') == url);
                                                      }));
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 50 mins to fix
                                                dist/cjs/relayer/transformers/IndividualFromListTransformer.js on lines 46..51

                                                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

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

                                                      return response.then((function(resource) {
                                                        endpoint.resource = resource;
                                                        return resource.relationships[$__2.relationshipName][$__2.property];
                                                      })).catch((function(error) {
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 45 mins to fix
                                                dist/cjs/relayer/transformers/SingleFromManyTransformer.js on lines 44..47

                                                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 50.

                                                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

                                                          var newPromise = (function() {
                                                            return $__10.load().then((function(resource) {
                                                              return loadedDataEndpointFactory(resource.self(), resource, [embeddedPropertyTransformerFactory(path)]);
                                                            }));
                                                          });
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 45 mins to fix
                                                dist/cjs/relayer/decorators/JsonPropertyDecorator.js on lines 105..109

                                                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 50.

                                                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

                                                  ($traceurRuntime.createClass)(ManyResourceSerializer, {serialize: function() {
                                                      var $__6 = this;
                                                      return this.resource.map((function(resource) {
                                                        return $__6.resourceSerializerFactory(resource).serialize();
                                                      }));
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 45 mins to fix
                                                dist/cjs/relayer/serializers/ManyResourceSerializer.js on lines 39..45

                                                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 50.

                                                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

                                                      for (var args = [],
                                                          $__1 = 1; $__1 < arguments.length; $__1++)
                                                        args[$__1 - 1] = arguments[$__1];
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 40 mins to fix
                                                dist/relayer.es5.js on lines 641..643
                                                dist/relayer.es5.js on lines 1708..1710

                                                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

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

                                                        for (var otherParams = [],
                                                            $__1 = 1; $__1 < arguments.length; $__1++)
                                                          otherParams[$__1 - 1] = arguments[$__1];
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 40 mins to fix
                                                dist/relayer.es5.js on lines 443..445
                                                dist/relayer.es5.js on lines 641..643

                                                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

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

                                                  var ManyRelationshipInitializer = function ManyRelationshipInitializer(singleRelationshipInitializerFactory, ResourceClass, initialValues) {
                                                    $traceurRuntime.superConstructor($ManyRelationshipInitializer).call(this, ResourceClass, initialValues);
                                                    this.singleRelationshipInitializerFactory = singleRelationshipInitializerFactory;
                                                  };
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 40 mins to fix
                                                dist/relayer.es5.js on lines 4373..4376

                                                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

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

                                                  var MapRelationshipInitializer = function MapRelationshipInitializer(singleRelationshipInitializerFactory, ResourceClass, initialValues) {
                                                    $traceurRuntime.superConstructor($MapRelationshipInitializer).call(this, ResourceClass, initialValues);
                                                    this.singleRelationshipInitializerFactory = singleRelationshipInitializerFactory;
                                                  };
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 40 mins to fix
                                                dist/relayer.es5.js on lines 3545..3548

                                                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

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

                                                      for (var args = [],
                                                          $__8 = 1; $__8 < arguments.length; $__8++)
                                                        args[$__8 - 1] = arguments[$__8];
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 2 other locations - About 40 mins to fix
                                                dist/relayer.es5.js on lines 443..445
                                                dist/relayer.es5.js on lines 1708..1710

                                                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

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

                                                    remove: function(res, rej) {
                                                      return this.endpointPromise().then((function(endpoint) {
                                                        return endpoint._remove();
                                                      })).then(res, rej);
                                                    }
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 35 mins to fix
                                                dist/cjs/relayer/endpoints/Endpoint.js on lines 66..70

                                                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 47.

                                                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

                                                  var ManyResourceSerializer = function ManyResourceSerializer(resourceSerializerFactory, resource) {
                                                    $traceurRuntime.superConstructor($ManyResourceSerializer).call(this, resource);
                                                    this.resourceSerializerFactory = resourceSerializerFactory;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 3 other locations - About 35 mins to fix
                                                dist/relayer.es5.js on lines 1417..1420
                                                dist/relayer.es5.js on lines 4113..4116
                                                dist/relayer.es5.js on lines 4457..4460

                                                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 47.

                                                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

                                                  var ListResourceSerializer = function ListResourceSerializer(manyResourceSerializerFactory, resource) {
                                                    $traceurRuntime.superConstructor($ListResourceSerializer).call(this, resource);
                                                    this.manyResourceSerializerFactory = manyResourceSerializerFactory;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 3 other locations - About 35 mins to fix
                                                dist/relayer.es5.js on lines 1417..1420
                                                dist/relayer.es5.js on lines 3629..3632
                                                dist/relayer.es5.js on lines 4457..4460

                                                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 47.

                                                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

                                                  var CreateResourceTransformer = function CreateResourceTransformer(relationshipDescription, uriTemplate) {
                                                    $traceurRuntime.superConstructor($CreateResourceTransformer).call(this, relationshipDescription);
                                                    this.uriTemplate = uriTemplate;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 3 other locations - About 35 mins to fix
                                                dist/relayer.es5.js on lines 3629..3632
                                                dist/relayer.es5.js on lines 4113..4116
                                                dist/relayer.es5.js on lines 4457..4460

                                                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 47.

                                                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

                                                  var MapResourceSerializer = function MapResourceSerializer(resourceSerializerFactory, resource) {
                                                    $traceurRuntime.superConstructor($MapResourceSerializer).call(this, resource);
                                                    this.resourceSerializerFactory = resourceSerializerFactory;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 3 other locations - About 35 mins to fix
                                                dist/relayer.es5.js on lines 1417..1420
                                                dist/relayer.es5.js on lines 3629..3632
                                                dist/relayer.es5.js on lines 4113..4116

                                                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 47.

                                                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 (path[0] !== "$") {
                                                          console.log(("Warning! root of normalized path '" + path + "' was '" + path[0] + "', not '$'"));
                                                        }
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 35 mins to fix
                                                dist/cjs/relayer/DataWrapper.js on lines 73..75

                                                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 46.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var PromiseEndpoint = function PromiseEndpoint(promiseFunction) {
                                                    $traceurRuntime.superConstructor($PromiseEndpoint).call(this);
                                                    this.endpointPromise = promiseFunction;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 562..565
                                                dist/relayer.es5.js on lines 570..573
                                                dist/relayer.es5.js on lines 585..588
                                                dist/relayer.es5.js on lines 828..831
                                                dist/relayer.es5.js on lines 1378..1381
                                                dist/relayer.es5.js on lines 3382..3385

                                                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 45.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var EmbeddedRelationshipTransformer = function EmbeddedRelationshipTransformer(relationshipName) {
                                                    $traceurRuntime.superConstructor($EmbeddedRelationshipTransformer).call(this);
                                                    this.relationshipName = relationshipName;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 562..565
                                                dist/relayer.es5.js on lines 570..573
                                                dist/relayer.es5.js on lines 585..588
                                                dist/relayer.es5.js on lines 828..831
                                                dist/relayer.es5.js on lines 863..866
                                                dist/relayer.es5.js on lines 1378..1381

                                                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 45.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var FactoryInjectable = function FactoryInjectable(Target) {
                                                    $traceurRuntime.superConstructor($FactoryInjectable).call(this);
                                                    this.Target = Target;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 562..565
                                                dist/relayer.es5.js on lines 585..588
                                                dist/relayer.es5.js on lines 828..831
                                                dist/relayer.es5.js on lines 863..866
                                                dist/relayer.es5.js on lines 1378..1381
                                                dist/relayer.es5.js on lines 3382..3385

                                                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 45.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var EmbeddedPropertyTransformer = function EmbeddedPropertyTransformer(path) {
                                                    $traceurRuntime.superConstructor($EmbeddedPropertyTransformer).call(this);
                                                    this.path = path;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 562..565
                                                dist/relayer.es5.js on lines 570..573
                                                dist/relayer.es5.js on lines 585..588
                                                dist/relayer.es5.js on lines 863..866
                                                dist/relayer.es5.js on lines 1378..1381
                                                dist/relayer.es5.js on lines 3382..3385

                                                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 45.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var PrimaryResourceTransformer = function PrimaryResourceTransformer(relationshipDescription) {
                                                    $traceurRuntime.superConstructor($PrimaryResourceTransformer).call(this);
                                                    this.relationshipDescription = relationshipDescription;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 562..565
                                                dist/relayer.es5.js on lines 570..573
                                                dist/relayer.es5.js on lines 585..588
                                                dist/relayer.es5.js on lines 828..831
                                                dist/relayer.es5.js on lines 863..866
                                                dist/relayer.es5.js on lines 3382..3385

                                                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 45.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var ValueInjectable = function ValueInjectable(value) {
                                                    $traceurRuntime.superConstructor($ValueInjectable).call(this);
                                                    this.value = value;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 570..573
                                                dist/relayer.es5.js on lines 585..588
                                                dist/relayer.es5.js on lines 828..831
                                                dist/relayer.es5.js on lines 863..866
                                                dist/relayer.es5.js on lines 1378..1381
                                                dist/relayer.es5.js on lines 3382..3385

                                                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 45.

                                                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 7 locations. Consider refactoring.
                                                Open

                                                  var ConstructableInjectable = function ConstructableInjectable(Target) {
                                                    $traceurRuntime.superConstructor($ConstructableInjectable).call(this);
                                                    this.Target = Target;
                                                  };
                                                Severity: Major
                                                Found in dist/relayer.es5.js and 6 other locations - About 30 mins to fix
                                                dist/relayer.es5.js on lines 562..565
                                                dist/relayer.es5.js on lines 570..573
                                                dist/relayer.es5.js on lines 828..831
                                                dist/relayer.es5.js on lines 863..866
                                                dist/relayer.es5.js on lines 1378..1381
                                                dist/relayer.es5.js on lines 3382..3385

                                                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 45.

                                                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

                                                      properties[BIND_PREFIX + key] = "=?bind" + this._bindObj[key][0].toUpperCase() + this._bindObj[key].slice(1);
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 30 mins to fix
                                                dist/relayer.es5.js on lines 3105..3105

                                                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 45.

                                                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

                                                      events[key] = "=?on" + this._bindObj[key][0].toUpperCase() + this._bindObj[key].slice(1);
                                                Severity: Minor
                                                Found in dist/relayer.es5.js and 1 other location - About 30 mins to fix
                                                dist/relayer.es5.js on lines 3051..3051

                                                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 45.

                                                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