Fix ESLint indentation warnings (#3800)

* Fix ESLint indentation warnings * Undo code reformatting within parentheses * Add exception for logical expressions * Update array expression rule * Disable rule for reProceduralOperator assignment * Fix indentation in static-filtering-parser.js
2024-07-05 11:37:01 +02:00 · 2021-08-03 19:44:40 +05:30 · 2021-08-03 19:44:40 +05:30 · 3ca5e6817d
commit 3ca5e6817d
parent 6b85b7f2b1
3 changed files with 113 additions and 99 deletions
--- a/platform/nodejs/eslintrc.json
+++ b/platform/nodejs/eslintrc.json
@ -9,7 +9,21 @@
        "sourceType": "module"
    },
    "rules": {
-        "indent": [ "warn", 4 ],
+        "indent": [
+          "warn",
+          4,
+          {
+            "ArrayExpression": "first",
+            "CallExpression": { "arguments": "first" },
+            "MemberExpression": "off",
+            "ObjectExpression": "off",
+            "ignoreComments": true,
+            "ignoredNodes": [
+              "AssignmentExpression:has(Literal)",
+              "LogicalExpression"
+            ]
+          }
+        ],
        "getter-return": "off",
        "no-control-regex": "off",
        "no-empty": [ "error", { "allowEmptyCatch": true } ],
--- a/platform/nodejs/index.js
+++ b/platform/nodejs/index.js
@ -166,7 +166,7 @@ function reset() {
 // module.exports. Once all included files are written like ES modules, using
 // export statements, this should no longer be necessary.
 if (typeof module !== 'undefined' && typeof exports !== 'undefined') {
-  module.exports = exports;
+    module.exports = exports;
 }

 export {
--- a/src/js/static-filtering-parser.js
+++ b/src/js/static-filtering-parser.js
@ -1312,7 +1312,7 @@ Parser.prototype.SelectorCompiler = class {
        this.rePseudoElement = /:(?::?after|:?before|:-?[a-z][a-z-]*[a-z])$/;
        this.reProceduralOperator = new RegExp([
            '^(?:',
-                Array.from(parser.proceduralOperatorTokens.keys()).join('|'),
+            Array.from(parser.proceduralOperatorTokens.keys()).join('|'),
            ')\\('
        ].join(''));
        this.reEatBackslashes = /\\([()])/g;
@ -2183,30 +2183,30 @@ Parser.prototype.OPTNotSupported = OPTNotSupported;

 const netOptionTokenDescriptors = new Map([
    [ '1p', OPTToken1p | OPTCanNegate ],
-        [ 'first-party', OPTToken1p | OPTCanNegate ],
+    /* synonym */ [ 'first-party', OPTToken1p | OPTCanNegate ],
    [ 'strict1p', OPTToken1pStrict ],
    [ '3p', OPTToken3p | OPTCanNegate ],
-        [ 'third-party', OPTToken3p | OPTCanNegate ],
+    /* synonym */ [ 'third-party', OPTToken3p | OPTCanNegate ],
    [ 'strict3p', OPTToken3pStrict ],
    [ 'all', OPTTokenAll | OPTNetworkType | OPTNonCspableType ],
    [ 'badfilter', OPTTokenBadfilter ],
    [ 'cname', OPTTokenCname | OPTAllowOnly | OPTModifierType ],
    [ 'csp', OPTTokenCsp | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
    [ 'css', OPTTokenCss | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
-        [ 'stylesheet', OPTTokenCss | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
+    /* synonym */ [ 'stylesheet', OPTTokenCss | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
    [ 'denyallow', OPTTokenDenyAllow | OPTMustAssign | OPTDomainList | OPTNeedDomainOpt | OPTNonCspableType ],
    [ 'doc', OPTTokenDoc | OPTNetworkType | OPTCanNegate | OPTModifiableType | OPTRedirectableType ],
-        [ 'document', OPTTokenDoc | OPTNetworkType | OPTCanNegate | OPTModifiableType | OPTRedirectableType ],
+    /* synonym */ [ 'document', OPTTokenDoc | OPTNetworkType | OPTCanNegate | OPTModifiableType | OPTRedirectableType ],
    [ 'domain', OPTTokenDomain | OPTMustAssign | OPTDomainList ],
    [ 'ehide', OPTTokenEhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'elemhide', OPTTokenEhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'elemhide', OPTTokenEhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'empty', OPTTokenEmpty | OPTBlockOnly | OPTModifierType ],
    [ 'frame', OPTTokenFrame | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType ],
-        [ 'subdocument', OPTTokenFrame | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType ],
+    /* synonym */ [ 'subdocument', OPTTokenFrame | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType ],
    [ 'font', OPTTokenFont | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType ],
    [ 'genericblock', OPTTokenGenericblock | OPTNotSupported ],
    [ 'ghide', OPTTokenGhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'generichide', OPTTokenGhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'generichide', OPTTokenGhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'header', OPTTokenHeader | OPTMustAssign | OPTAllowMayAssign | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'image', OPTTokenImage | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
    [ 'important', OPTTokenImportant | OPTBlockOnly ],
@ -2217,22 +2217,22 @@ const netOptionTokenDescriptors = new Map([
    [ 'mp4', OPTTokenMp4 | OPTNetworkType | OPTBlockOnly |  OPTModifierType ],
    [ '_', OPTTokenNoop ],
    [ 'object', OPTTokenObject | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
-        [ 'object-subrequest', OPTTokenObject | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
+    /* synonym */ [ 'object-subrequest', OPTTokenObject | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
    [ 'other', OPTTokenOther | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
    [ 'ping', OPTTokenPing | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'beacon', OPTTokenPing | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'beacon', OPTTokenPing | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'popunder', OPTTokenPopunder | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'popup', OPTTokenPopup | OPTNonNetworkType | OPTCanNegate | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'queryprune', OPTTokenQueryprune | OPTMayAssign | OPTModifierType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'removeparam', OPTTokenQueryprune | OPTMayAssign | OPTModifierType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'removeparam', OPTTokenQueryprune | OPTMayAssign | OPTModifierType | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'redirect', OPTTokenRedirect | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
-        [ 'rewrite', OPTTokenRedirect | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
+    /* synonym */ [ 'rewrite', OPTTokenRedirect | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
    [ 'redirect-rule', OPTTokenRedirectRule | OPTMustAssign | OPTAllowMayAssign | OPTModifierType | OPTNonCspableType ],
    [ 'script', OPTTokenScript | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
    [ 'shide', OPTTokenShide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'specifichide', OPTTokenShide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'specifichide', OPTTokenShide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
    [ 'xhr', OPTTokenXhr | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
-        [ 'xmlhttprequest', OPTTokenXhr | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
+    /* synonym */ [ 'xmlhttprequest', OPTTokenXhr | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
    [ 'webrtc', OPTTokenWebrtc | OPTNotSupported ],
    [ 'websocket', OPTTokenWebsocket | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
 ]);
@ -2242,30 +2242,30 @@ Parser.prototype.netOptionTokenDescriptors =

 Parser.netOptionTokenIds = new Map([
    [ '1p', OPTToken1p ],
-        [ 'first-party', OPTToken1p ],
+    /* synonym */ [ 'first-party', OPTToken1p ],
    [ 'strict1p', OPTToken1pStrict ],
    [ '3p', OPTToken3p ],
-        [ 'third-party', OPTToken3p ],
+    /* synonym */ [ 'third-party', OPTToken3p ],
    [ 'strict3p', OPTToken3pStrict ],
    [ 'all', OPTTokenAll ],
    [ 'badfilter', OPTTokenBadfilter ],
    [ 'cname', OPTTokenCname ],
    [ 'csp', OPTTokenCsp ],
    [ 'css', OPTTokenCss ],
-        [ 'stylesheet', OPTTokenCss ],
+    /* synonym */ [ 'stylesheet', OPTTokenCss ],
    [ 'denyallow', OPTTokenDenyAllow ],
    [ 'doc', OPTTokenDoc ],
-        [ 'document', OPTTokenDoc ],
+    /* synonym */ [ 'document', OPTTokenDoc ],
    [ 'domain', OPTTokenDomain ],
    [ 'ehide', OPTTokenEhide ],
-        [ 'elemhide', OPTTokenEhide ],
+    /* synonym */ [ 'elemhide', OPTTokenEhide ],
    [ 'empty', OPTTokenEmpty ],
    [ 'frame', OPTTokenFrame ],
-        [ 'subdocument', OPTTokenFrame ],
+    /* synonym */ [ 'subdocument', OPTTokenFrame ],
    [ 'font', OPTTokenFont ],
    [ 'genericblock', OPTTokenGenericblock ],
    [ 'ghide', OPTTokenGhide ],
-        [ 'generichide', OPTTokenGhide ],
+    /* synonym */ [ 'generichide', OPTTokenGhide ],
    [ 'header', OPTTokenHeader ],
    [ 'image', OPTTokenImage ],
    [ 'important', OPTTokenImportant ],
@ -2276,22 +2276,22 @@ Parser.netOptionTokenIds = new Map([
    [ 'mp4', OPTTokenMp4 ],
    [ '_', OPTTokenNoop ],
    [ 'object', OPTTokenObject ],
-        [ 'object-subrequest', OPTTokenObject ],
+    /* synonym */ [ 'object-subrequest', OPTTokenObject ],
    [ 'other', OPTTokenOther ],
    [ 'ping', OPTTokenPing ],
-        [ 'beacon', OPTTokenPing ],
+    /* synonym */ [ 'beacon', OPTTokenPing ],
    [ 'popunder', OPTTokenPopunder ],
    [ 'popup', OPTTokenPopup ],
    [ 'queryprune', OPTTokenQueryprune ],
-        [ 'removeparam', OPTTokenQueryprune ],
+    /* synonym */ [ 'removeparam', OPTTokenQueryprune ],
    [ 'redirect', OPTTokenRedirect ],
-        [ 'rewrite', OPTTokenRedirect ],
+    /* synonym */ [ 'rewrite', OPTTokenRedirect ],
    [ 'redirect-rule', OPTTokenRedirectRule ],
    [ 'script', OPTTokenScript ],
    [ 'shide', OPTTokenShide ],
-        [ 'specifichide', OPTTokenShide ],
+    /* synonym */ [ 'specifichide', OPTTokenShide ],
    [ 'xhr', OPTTokenXhr ],
-        [ 'xmlhttprequest', OPTTokenXhr ],
+    /* synonym */ [ 'xmlhttprequest', OPTTokenXhr ],
    [ 'webrtc', OPTTokenWebrtc ],
    [ 'websocket', OPTTokenWebsocket ],
 ]);
@ -2806,81 +2806,81 @@ Parser.regexUtils = Parser.prototype.regexUtils = (( ) => {

    const toTokenizableStr = node => {
        switch ( node.type ) {
-            case 1: /* T_SEQUENCE, 'Sequence' */ {
-                let s = '';
-                for ( let i = 0; i < node.val.length; i++ ) {
-                    s += toTokenizableStr(node.val[i]);
+        case 1: /* T_SEQUENCE, 'Sequence' */ {
+            let s = '';
+            for ( let i = 0; i < node.val.length; i++ ) {
+                s += toTokenizableStr(node.val[i]);
+            }
+            return s;
+        }
+        case 2: /* T_ALTERNATION, 'Alternation' */
+        case 8: /* T_CHARGROUP, 'CharacterGroup' */ {
+            let firstChar = 0;
+            let lastChar = 0;
+            for ( let i = 0; i < node.val.length; i++ ) {
+                const s = toTokenizableStr(node.val[i]);
+                if ( firstChar === 0 && firstCharCodeClass(s) === 1 ) {
+                    firstChar = 1;
                }
-                return s;
-            }
-            case 2: /* T_ALTERNATION, 'Alternation' */
-            case 8: /* T_CHARGROUP, 'CharacterGroup' */ {
-                let firstChar = 0;
-                let lastChar = 0;
-                for ( let i = 0; i < node.val.length; i++ ) {
-                    const s = toTokenizableStr(node.val[i]);
-                    if ( firstChar === 0 && firstCharCodeClass(s) === 1 ) {
-                        firstChar = 1;
-                    }
-                    if ( lastChar === 0 && lastCharCodeClass(s) === 1 ) {
-                        lastChar = 1;
-                    }
-                    if ( firstChar === 1 && lastChar === 1 ) { break; }
+                if ( lastChar === 0 && lastCharCodeClass(s) === 1 ) {
+                    lastChar = 1;
                }
-                return String.fromCharCode(firstChar, lastChar);
+                if ( firstChar === 1 && lastChar === 1 ) { break; }
            }
-            case 4: /* T_GROUP, 'Group' */ {
-                if ( node.flags.NegativeLookAhead === 1 ) { return '\x01'; }
-                if ( node.flags.NegativeLookBehind === 1 ) { return '\x01'; }
-                return toTokenizableStr(node.val);
-            }
-            case 16: /* T_QUANTIFIER, 'Quantifier' */ {
-                const s = toTokenizableStr(node.val);
-                const first = firstCharCodeClass(s);
-                const last = lastCharCodeClass(s);
-                if ( node.flags.min === 0 && first === 0 && last === 0 ) {
-                    return '';
-                }
-                return String.fromCharCode(first, last);
-            }
-            case 64: /* T_HEXCHAR, 'HexChar' */ {
-                return String.fromCharCode(parseInt(node.val.slice(1), 16));
-            }
-            case 128: /* T_SPECIAL, 'Special' */ {
-                const flags = node.flags;
-                if (
-                    flags.EndCharGroup === 1 || // dangling `]`
-                    flags.EndGroup === 1 ||     // dangling `)`
-                    flags.EndRepeats === 1      // dangling `}`
-                ) {
-                    throw new Error('Unmatched bracket');
-                }
-                return flags.MatchEnd === 1 ||
-                       flags.MatchStart === 1 ||
-                       flags.MatchWordBoundary === 1
-                    ? '\x00'
-                    : '\x01';
-            }
-            case 256: /* T_CHARS, 'Characters' */ {
-                for ( let i = 0; i < node.val.length; i++ ) {
-                    if ( firstCharCodeClass(node.val[i]) === 1 ) {
-                        return '\x01';
-                    }
-                }
-                return '\x00';
-            }
-            // Ranges are assumed to always involve token-related characters.
-            case 512: /* T_CHARRANGE, 'CharacterRange' */ {
-                return '\x01';
-            }
-            case 1024: /* T_STRING, 'String' */ {
-                return node.val;
-            }
-            case 2048: /* T_COMMENT, 'Comment' */ {
+            return String.fromCharCode(firstChar, lastChar);
+        }
+        case 4: /* T_GROUP, 'Group' */ {
+            if ( node.flags.NegativeLookAhead === 1 ) { return '\x01'; }
+            if ( node.flags.NegativeLookBehind === 1 ) { return '\x01'; }
+            return toTokenizableStr(node.val);
+        }
+        case 16: /* T_QUANTIFIER, 'Quantifier' */ {
+            const s = toTokenizableStr(node.val);
+            const first = firstCharCodeClass(s);
+            const last = lastCharCodeClass(s);
+            if ( node.flags.min === 0 && first === 0 && last === 0 ) {
                return '';
            }
-            default:
-                break;
+            return String.fromCharCode(first, last);
+        }
+        case 64: /* T_HEXCHAR, 'HexChar' */ {
+            return String.fromCharCode(parseInt(node.val.slice(1), 16));
+        }
+        case 128: /* T_SPECIAL, 'Special' */ {
+            const flags = node.flags;
+            if (
+                flags.EndCharGroup === 1 || // dangling `]`
+                flags.EndGroup === 1 ||     // dangling `)`
+                flags.EndRepeats === 1      // dangling `}`
+            ) {
+                throw new Error('Unmatched bracket');
+            }
+            return flags.MatchEnd === 1 ||
+                   flags.MatchStart === 1 ||
+                   flags.MatchWordBoundary === 1
+                ? '\x00'
+                : '\x01';
+        }
+        case 256: /* T_CHARS, 'Characters' */ {
+            for ( let i = 0; i < node.val.length; i++ ) {
+                if ( firstCharCodeClass(node.val[i]) === 1 ) {
+                    return '\x01';
+                }
+            }
+            return '\x00';
+        }
+        // Ranges are assumed to always involve token-related characters.
+        case 512: /* T_CHARRANGE, 'CharacterRange' */ {
+            return '\x01';
+        }
+        case 1024: /* T_STRING, 'String' */ {
+            return node.val;
+        }
+        case 2048: /* T_COMMENT, 'Comment' */ {
+            return '';
+        }
+        default:
+            break;
        }
        return '\x01';
    };