Smile-SA/elasticsuite

View on GitHub
src/module-elasticsuite-core/view/base/web/js/MutationObserver.js

Summary

Maintainability
D
2 days
Test Coverage

File MutationObserver.js has 329 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/**
 * @license
 * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
Severity: Minor
Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 3 hrs to fix

    Method 'observe' has a complexity of 9.
    Open

            observe: function(target, options) {

    Limit Cyclomatic Complexity (complexity)

    Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

    function a(x) {
        if (true) {
            return x; // 1st path
        } else if (false) {
            return x+1; // 2nd path
        } else {
            return 4; // 3rd path
        }
    }

    Rule Details

    This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

    Examples of incorrect code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/
    
    function a(x) {
        if (true) {
            return x;
        } else if (false) {
            return x+1;
        } else {
            return 4; // 3rd path
        }
    }

    Examples of correct code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/
    
    function a(x) {
        if (true) {
            return x;
        } else {
            return 4;
        }
    }

    Options

    Optionally, you may specify a max object property:

    "complexity": ["error", 2]

    is equivalent to

    "complexity": ["error", { "max": 2 }]

    Deprecated: the object property maximum is deprecated. Please use the property max instead.

    When Not To Use It

    If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

    Further Reading

    Related Rules

    • [max-depth](max-depth.md)
    • [max-len](max-len.md)
    • [max-nested-callbacks](max-nested-callbacks.md)
    • [max-params](max-params.md)
    • [max-statements](max-statements.md) Source: http://eslint.org/docs/rules/

    Consider simplifying this complex logical expression.
    Open

                if (!options.childList && !options.attributes && !options.characterData ||
    
                    // 1.2
                    options.attributeOldValue && !options.attributes ||
    
    
    Severity: Critical
    Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 2 hrs to fix

      Function has too many statements (32). Maximum allowed is 30.
      Open

      (function(global) {

      enforce a maximum number of statements allowed in function blocks (max-statements)

      The max-statements rule allows you to specify the maximum number of statements allowed in a function.

      function foo() {
        var bar = 1; // one statement
        var baz = 2; // two statements
        var qux = 3; // three statements
      }

      Rule Details

      This rule enforces a maximum number of statements allowed in function blocks.

      Options

      This rule has a number or object option:

      • "max" (default 10) enforces a maximum number of statements allows in function blocks

      Deprecated: The object property maximum is deprecated; please use the object property max instead.

      This rule has an object option:

      • "ignoreTopLevelFunctions": true ignores top-level functions

      max

      Examples of incorrect code for this rule with the default { "max": 10 } option:

      /*eslint max-statements: ["error", 10]*/
      /*eslint-env es6*/
      
      function foo() {
        var foo1 = 1;
        var foo2 = 2;
        var foo3 = 3;
        var foo4 = 4;
        var foo5 = 5;
        var foo6 = 6;
        var foo7 = 7;
        var foo8 = 8;
        var foo9 = 9;
        var foo10 = 10;
      
        var foo11 = 11; // Too many.
      }
      
      let foo = () => {
        var foo1 = 1;
        var foo2 = 2;
        var foo3 = 3;
        var foo4 = 4;
        var foo5 = 5;
        var foo6 = 6;
        var foo7 = 7;
        var foo8 = 8;
        var foo9 = 9;
        var foo10 = 10;
      
        var foo11 = 11; // Too many.
      };

      Examples of correct code for this rule with the default { "max": 10 } option:

      /*eslint max-statements: ["error", 10]*/
      /*eslint-env es6*/
      
      function foo() {
        var foo1 = 1;
        var foo2 = 2;
        var foo3 = 3;
        var foo4 = 4;
        var foo5 = 5;
        var foo6 = 6;
        var foo7 = 7;
        var foo8 = 8;
        var foo9 = 9;
        var foo10 = 10;
        return function () {
      
          // The number of statements in the inner function does not count toward the
          // statement maximum.
      
          return 42;
        };
      }
      
      let foo = () => {
        var foo1 = 1;
        var foo2 = 2;
        var foo3 = 3;
        var foo4 = 4;
        var foo5 = 5;
        var foo6 = 6;
        var foo7 = 7;
        var foo8 = 8;
        var foo9 = 9;
        var foo10 = 10;
        return function () {
      
          // The number of statements in the inner function does not count toward the
          // statement maximum.
      
          return 42;
        };
      }

      ignoreTopLevelFunctions

      Examples of additional correct code for this rule with the { "max": 10 }, { "ignoreTopLevelFunctions": true } options:

      /*eslint max-statements: ["error", 10, { "ignoreTopLevelFunctions": true }]*/
      
      function foo() {
        var foo1 = 1;
        var foo2 = 2;
        var foo3 = 3;
        var foo4 = 4;
        var foo5 = 5;
        var foo6 = 6;
        var foo7 = 7;
        var foo8 = 8;
        var foo9 = 9;
        var foo10 = 10;
        var foo11 = 11;
      }

      Related Rules

      • [complexity](complexity.md)
      • [max-depth](max-depth.md)
      • [max-len](max-len.md)
      • [max-nested-callbacks](max-nested-callbacks.md)
      • [max-params](max-params.md) Source: http://eslint.org/docs/rules/

      Function handleEvent has 62 lines of code (exceeds 40 allowed). Consider refactoring.
      Open

              handleEvent: function(e) {
                  // Stop propagation since we are managing the propagation manually.
                  // This means that other mutation events on the page will not work
                  // correctly but that is by design.
                  e.stopImmediatePropagation();
      Severity: Major
      Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 1 hr to fix

        Method 'handleEvent' has a complexity of 7.
        Open

                handleEvent: function(e) {

        Limit Cyclomatic Complexity (complexity)

        Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

        function a(x) {
            if (true) {
                return x; // 1st path
            } else if (false) {
                return x+1; // 2nd path
            } else {
                return 4; // 3rd path
            }
        }

        Rule Details

        This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

        Examples of incorrect code for a maximum of 2:

        /*eslint complexity: ["error", 2]*/
        
        function a(x) {
            if (true) {
                return x;
            } else if (false) {
                return x+1;
            } else {
                return 4; // 3rd path
            }
        }

        Examples of correct code for a maximum of 2:

        /*eslint complexity: ["error", 2]*/
        
        function a(x) {
            if (true) {
                return x;
            } else {
                return 4;
            }
        }

        Options

        Optionally, you may specify a max object property:

        "complexity": ["error", 2]

        is equivalent to

        "complexity": ["error", { "max": 2 }]

        Deprecated: the object property maximum is deprecated. Please use the property max instead.

        When Not To Use It

        If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

        Further Reading

        Related Rules

        • [max-depth](max-depth.md)
        • [max-len](max-len.md)
        • [max-nested-callbacks](max-nested-callbacks.md)
        • [max-params](max-params.md)
        • [max-statements](max-statements.md) Source: http://eslint.org/docs/rules/

        Avoid too many return statements within this function.
        Open

                return null;
        Severity: Minor
        Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 30 mins to fix

          Avoid too many return statements within this function.
          Open

                                      return getRecordWithOldValue(oldValue);
          Severity: Minor
          Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 30 mins to fix

            Avoid too many return statements within this function.
            Open

                                    return record;
            Severity: Minor
            Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 30 mins to fix

              Avoid too many return statements within this function.
              Open

                                      return record;
              Severity: Minor
              Found in src/module-elasticsuite-core/view/base/web/js/MutationObserver.js - About 30 mins to fix

                'record' is already defined.
                Open

                                    var record = getRecord('characterData', target);

                disallow variable redeclaration (no-redeclare)

                In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                Rule Details

                This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                Examples of incorrect code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                var a = 10;

                Examples of correct code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                // ...
                a = 10;

                Options

                This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                builtinGlobals

                Examples of incorrect code for the { "builtinGlobals": true } option:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                
                var Object = 0;

                Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                /*eslint-env browser*/
                
                var top = 0;

                The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

                Expected return with your callback function.
                Open

                                    var record = callback(options);

                Enforce Return After Callback (callback-return)

                The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

                function doSomething(err, callback) {
                    if (err) {
                        return callback(err);
                    }
                    callback();
                }

                To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

                Rule Details

                This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

                Options

                The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

                Default callback names

                Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

                /*eslint callback-return: "error"*/
                
                function foo(err, callback) {
                    if (err) {
                        callback(err);
                    }
                    callback();
                }

                Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

                /*eslint callback-return: "error"*/
                
                function foo(err, callback) {
                    if (err) {
                        return callback(err);
                    }
                    callback();
                }

                Supplied callback names

                Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

                /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/
                
                function foo(err, done) {
                    if (err) {
                        done(err);
                    }
                    done();
                }
                
                function bar(err, send) {
                    if (err) {
                        send.error(err);
                    }
                    send.success();
                }

                Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

                /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/
                
                function foo(err, done) {
                    if (err) {
                        return done(err);
                    }
                    done();
                }
                
                function bar(err, send) {
                    if (err) {
                        return send.error(err);
                    }
                    send.success();
                }

                Known Limitations

                Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

                • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
                • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

                Passing the callback by reference

                The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

                Example of a false negative when this rule reports correct code:

                /*eslint callback-return: "error"*/
                
                function foo(err, callback) {
                    if (err) {
                        setTimeout(callback, 0); // this is bad, but WILL NOT warn
                    }
                    callback();
                }

                Triggering the callback within a nested function

                The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

                Example of a false negative when this rule reports correct code:

                /*eslint callback-return: "error"*/
                
                function foo(err, callback) {
                    if (err) {
                        process.nextTick(function() {
                            return callback(); // this is bad, but WILL NOT warn
                        });
                    }
                    callback();
                }

                If/else statements

                The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

                Example of a false positive when this rule reports incorrect code:

                /*eslint callback-return: "error"*/
                
                function foo(err, callback) {
                    if (err) {
                        callback(err); // this is fine, but WILL warn
                    } else {
                        callback();    // this is fine, but WILL warn
                    }
                }

                When Not To Use It

                There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

                Further Reading

                Related Rules

                'target' is already defined.
                Open

                                    var target = e.target;

                disallow variable redeclaration (no-redeclare)

                In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                Rule Details

                This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                Examples of incorrect code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                var a = 10;

                Examples of correct code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                // ...
                a = 10;

                Options

                This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                builtinGlobals

                Examples of incorrect code for the { "builtinGlobals": true } option:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                
                var Object = 0;

                Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                /*eslint-env browser*/
                
                var top = 0;

                The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

                'oldValue' is already defined.
                Open

                                    var oldValue = e.prevValue;

                disallow variable redeclaration (no-redeclare)

                In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                Rule Details

                This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                Examples of incorrect code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                var a = 10;

                Examples of correct code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                // ...
                a = 10;

                Options

                This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                builtinGlobals

                Examples of incorrect code for the { "builtinGlobals": true } option:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                
                var Object = 0;

                Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                /*eslint-env browser*/
                
                var top = 0;

                The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

                Unnecessary semicolon.
                Open

                    };

                disallow unnecessary semicolons (no-extra-semi)

                Typing mistakes and misunderstandings about where semicolons are required can lead to semicolons that are unnecessary. While not technically an error, extra semicolons can cause confusion when reading code.

                Rule Details

                This rule disallows unnecessary semicolons.

                Examples of incorrect code for this rule:

                /*eslint no-extra-semi: "error"*/
                
                var x = 5;;
                
                function foo() {
                    // code
                };

                Examples of correct code for this rule:

                /*eslint no-extra-semi: "error"*/
                
                var x = 5;
                
                var foo = function() {
                    // code
                };

                When Not To Use It

                If you intentionally use extra semicolons then you can disable this rule.

                Related Rules

                'record' is already defined.
                Open

                                    var record = getRecord('childList', e.target.parentNode);

                disallow variable redeclaration (no-redeclare)

                In JavaScript, it's possible to redeclare the same variable name using var. This can lead to confusion as to where the variable is actually declared and initialized.

                Rule Details

                This rule is aimed at eliminating variables that have multiple declarations in the same scope.

                Examples of incorrect code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                var a = 10;

                Examples of correct code for this rule:

                /*eslint no-redeclare: "error"*/
                
                var a = 3;
                // ...
                a = 10;

                Options

                This rule takes one optional argument, an object with a boolean property "builtinGlobals". It defaults to false. If set to true, this rule also checks redeclaration of built-in globals, such as Object, Array, Number...

                builtinGlobals

                Examples of incorrect code for the { "builtinGlobals": true } option:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                
                var Object = 0;

                Examples of incorrect code for the { "builtinGlobals": true } option and the browser environment:

                /*eslint no-redeclare: ["error", { "builtinGlobals": true }]*/
                /*eslint-env browser*/
                
                var top = 0;

                The browser environment has many built-in global variables (for example, top). Some of built-in global variables cannot be redeclared. Source: http://eslint.org/docs/rules/

                Return statement should not contain assignment.
                Open

                        return currentRecord = new MutationRecord(type, target);

                Disallow Assignment in return Statement (no-return-assign)

                One of the interesting, and sometimes confusing, aspects of JavaScript is that assignment can happen at almost any point. Because of this, an errant equals sign can end up causing assignment when the true intent was to do a comparison. This is especially true when using a return statement. For example:

                function doSomething() {
                    return foo = bar + 2;
                }

                It is difficult to tell the intent of the return statement here. It's possible that the function is meant to return the result of bar + 2, but then why is it assigning to foo? It's also possible that the intent was to use a comparison operator such as == and that this code is an error.

                Because of this ambiguity, it's considered a best practice to not use assignment in return statements.

                Rule Details

                This rule aims to eliminate assignments from return statements. As such, it will warn whenever an assignment is found as part of return.

                Options

                The rule takes one option, a string, which must contain one of the following values:

                • except-parens (default): Disallow assignments unless they are enclosed in parentheses.
                • always: Disallow all assignments.

                except-parens

                This is the default option. It disallows assignments unless they are enclosed in parentheses.

                Examples of incorrect code for the default "except-parens" option:

                /*eslint no-return-assign: "error"*/
                
                function doSomething() {
                    return foo = bar + 2;
                }
                
                function doSomething() {
                    return foo += 2;
                }

                Examples of correct code for the default "except-parens" option:

                /*eslint no-return-assign: "error"*/
                
                function doSomething() {
                    return foo == bar + 2;
                }
                
                function doSomething() {
                    return foo === bar + 2;
                }
                
                function doSomething() {
                    return (foo = bar + 2);
                }

                always

                This option disallows all assignments in return statements. All assignments are treated as problems.

                Examples of incorrect code for the "always" option:

                /*eslint no-return-assign: ["error", "always"]*/
                
                function doSomething() {
                    return foo = bar + 2;
                }
                
                function doSomething() {
                    return foo += 2;
                }
                
                function doSomething() {
                    return (foo = bar + 2);
                }

                Examples of correct code for the "always" option:

                /*eslint no-return-assign: ["error", "always"]*/
                
                function doSomething() {
                    return foo == bar + 2;
                }
                
                function doSomething() {
                    return foo === bar + 2;
                }

                When Not To Use It

                If you want to allow the use of assignment operators in a return statement, then you can safely disable this rule. Source: http://eslint.org/docs/rules/

                Move the invocation into the parens that contain the function.
                Open

                (function(global) {

                Require IIFEs to be Wrapped (wrap-iife)

                You can immediately invoke function expressions, but not function declarations. A common technique to create an immediately-invoked function expression (IIFE) is to wrap a function declaration in parentheses. The opening parentheses causes the contained function to be parsed as an expression, rather than a declaration.

                // function expression could be unwrapped
                var x = function () { return { y: 1 };}();
                
                // function declaration must be wrapped
                function () { /* side effects */ }(); // SyntaxError

                Rule Details

                This rule requires all immediately-invoked function expressions to be wrapped in parentheses.

                Options

                This rule has two options, a string option and an object option.

                String option:

                • "outside" enforces always wrapping the call expression. The default is "outside".
                • "inside" enforces always wrapping the function expression.
                • "any" enforces always wrapping, but allows either style.

                Object option:

                • "functionPrototypeMethods": true additionally enforces wrapping function expressions invoked using .call and .apply. The default is false.

                outside

                Examples of incorrect code for the default "outside" option:

                /*eslint wrap-iife: ["error", "outside"]*/
                
                var x = function () { return { y: 1 };}(); // unwrapped
                var x = (function () { return { y: 1 };})(); // wrapped function expression

                Examples of correct code for the default "outside" option:

                /*eslint wrap-iife: ["error", "outside"]*/
                
                var x = (function () { return { y: 1 };}()); // wrapped call expression

                inside

                Examples of incorrect code for the "inside" option:

                /*eslint wrap-iife: ["error", "inside"]*/
                
                var x = function () { return { y: 1 };}(); // unwrapped
                var x = (function () { return { y: 1 };}()); // wrapped call expression

                Examples of correct code for the "inside" option:

                /*eslint wrap-iife: ["error", "inside"]*/
                
                var x = (function () { return { y: 1 };})(); // wrapped function expression

                any

                Examples of incorrect code for the "any" option:

                /*eslint wrap-iife: ["error", "any"]*/
                
                var x = function () { return { y: 1 };}(); // unwrapped

                Examples of correct code for the "any" option:

                /*eslint wrap-iife: ["error", "any"]*/
                
                var x = (function () { return { y: 1 };}()); // wrapped call expression
                var x = (function () { return { y: 1 };})(); // wrapped function expression

                functionPrototypeMethods

                Examples of incorrect code for this rule with the "inside", { "functionPrototypeMethods": true } options:

                /* eslint wrap-iife: [2, "inside", { functionPrototypeMethods: true }] */
                
                var x = function(){ foo(); }()
                var x = (function(){ foo(); }())
                var x = function(){ foo(); }.call(bar)
                var x = (function(){ foo(); }.call(bar))

                Examples of correct code for this rule with the "inside", { "functionPrototypeMethods": true } options:

                /* eslint wrap-iife: [2, "inside", { functionPrototypeMethods: true }] */
                
                var x = (function(){ foo(); })()
                var x = (function(){ foo(); }).call(bar)

                Source: http://eslint.org/docs/rules/

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

                        removeListeners_: function(node) {
                            var options = this.options;
                            if (options.attributes)
                                node.removeEventListener('DOMAttrModified', this, true);
                
                
                src/module-elasticsuite-core/view/base/web/js/MutationObserver.js on lines 376..389

                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

                        addListeners_: function(node) {
                            var options = this.options;
                            if (options.attributes)
                                node.addEventListener('DOMAttrModified', this, true);
                
                
                src/module-elasticsuite-core/view/base/web/js/MutationObserver.js on lines 395..408

                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

                There are no issues that match your filters.

                Category
                Status