eslint/tests/lib/rules/rest-spread-spacing.js

   1 /**
   2  * @fileoverview Enforce spacing between rest and spread operators and their expressions.
   3  * @author Kai Cataldo
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Requirements
  10 //------------------------------------------------------------------------------
  11
  12 const rule = require("../../../lib/rules/rest-spread-spacing"),
  13     { RuleTester } = require("../../../lib/rule-tester");
  14
  15 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
  16
  17 ruleTester.run("rest-spread-spacing", rule, {
  18     valid: [
  19         "fn(...args)",
  20         "fn(...(args))",
  21         "fn(...( args ))",
  22         { code: "fn(...args)", options: ["never"] },
  23         { code: "fn(... args)", options: ["always"] },
  24         { code: "fn(...\targs)", options: ["always"] },
  25         { code: "fn(...\nargs)", options: ["always"] },
  26         "[...arr, 4, 5, 6]",
  27         "[...(arr), 4, 5, 6]",
  28         "[...( arr ), 4, 5, 6]",
  29         { code: "[...arr, 4, 5, 6]", options: ["never"] },
  30         { code: "[... arr, 4, 5, 6]", options: ["always"] },
  31         { code: "[...\tarr, 4, 5, 6]", options: ["always"] },
  32         { code: "[...\narr, 4, 5, 6]", options: ["always"] },
  33         "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
  34         { code: "let [a, b, ...arr] = [1, 2, 3, 4, 5];", options: ["never"] },
  35         { code: "let [a, b, ... arr] = [1, 2, 3, 4, 5];", options: ["always"] },
  36         { code: "let [a, b, ...\tarr] = [1, 2, 3, 4, 5];", options: ["always"] },
  37         { code: "let [a, b, ...\narr] = [1, 2, 3, 4, 5];", options: ["always"] },
  38         { code: "let n = { x, y, ...z };", parserOptions: { ecmaVersion: 2018 } },
  39         { code: "let n = { x, y, ...(z) };", parserOptions: { ecmaVersion: 2018 } },
  40         { code: "let n = { x, y, ...( z ) };", parserOptions: { ecmaVersion: 2018 } },
  41         { code: "let n = { x, y, ...z };", options: ["never"], parserOptions: { ecmaVersion: 2018 } },
  42         { code: "let n = { x, y, ... z };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
  43         { code: "let n = { x, y, ...\tz };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
  44         { code: "let n = { x, y, ...\nz };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
  45         { code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };", parserOptions: { ecmaVersion: 2018 } },
  46         { code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };", options: ["never"], parserOptions: { ecmaVersion: 2018 } },
  47         { code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
  48         { code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaVersion: 2018 } },
  49         { code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };", options: ["always"], parserOptions: { ecmaVersion: 2018 } }
  50     ],
  51
  52     invalid: [
  53         {
  54             code: "fn(... args)",
  55             output: "fn(...args)",
  56             errors: [{
  57                 line: 1,
  58                 column: 7,
  59                 messageId: "unexpectedWhitespace",
  60                 data: { type: "spread" },
  61                 type: "SpreadElement"
  62             }]
  63         },
  64         {
  65             code: "fn(...\targs)",
  66             output: "fn(...args)",
  67             errors: [{
  68                 line: 1,
  69                 column: 7,
  70                 messageId: "unexpectedWhitespace",
  71                 data: { type: "spread" },
  72                 type: "SpreadElement"
  73             }]
  74         },
  75         {
  76             code: "fn(...\nargs)",
  77             output: "fn(...args)",
  78             errors: [{
  79                 line: 1,
  80                 column: 7,
  81                 messageId: "unexpectedWhitespace",
  82                 data: { type: "spread" },
  83                 type: "SpreadElement"
  84             }]
  85         },
  86         {
  87             code: "fn(... args)",
  88             output: "fn(...args)",
  89             options: ["never"],
  90             errors: [{
  91                 line: 1,
  92                 column: 7,
  93                 messageId: "unexpectedWhitespace",
  94                 data: { type: "spread" },
  95                 type: "SpreadElement"
  96             }]
  97         },
  98         {
  99             code: "fn(...\targs)",
 100             output: "fn(...args)",
 101             options: ["never"],
 102             errors: [{
 103                 line: 1,
 104                 column: 7,
 105                 messageId: "unexpectedWhitespace",
 106                 data: { type: "spread" },
 107                 type: "SpreadElement"
 108             }]
 109         },
 110         {
 111             code: "fn(...\nargs)",
 112             output: "fn(...args)",
 113             options: ["never"],
 114             errors: [{
 115                 line: 1,
 116                 column: 7,
 117                 messageId: "unexpectedWhitespace",
 118                 data: { type: "spread" },
 119                 type: "SpreadElement"
 120             }]
 121         },
 122         {
 123             code: "fn(...args)",
 124             output: "fn(... args)",
 125             options: ["always"],
 126             errors: [{
 127                 line: 1,
 128                 column: 7,
 129                 messageId: "expectedWhitespace",
 130                 data: { type: "spread" },
 131                 type: "SpreadElement"
 132             }]
 133         },
 134         {
 135             code: "fn(... (args))",
 136             output: "fn(...(args))",
 137             errors: [{
 138                 line: 1,
 139                 column: 7,
 140                 messageId: "unexpectedWhitespace",
 141                 data: { type: "spread" },
 142                 type: "SpreadElement"
 143             }]
 144         },
 145         {
 146             code: "fn(... ( args ))",
 147             output: "fn(...( args ))",
 148             errors: [{
 149                 line: 1,
 150                 column: 7,
 151                 messageId: "unexpectedWhitespace",
 152                 data: { type: "spread" },
 153                 type: "SpreadElement"
 154             }]
 155         },
 156         {
 157             code: "fn(...(args))",
 158             output: "fn(... (args))",
 159             options: ["always"],
 160             errors: [{
 161                 line: 1,
 162                 column: 7,
 163                 messageId: "expectedWhitespace",
 164                 data: { type: "spread" },
 165                 type: "SpreadElement"
 166             }]
 167         },
 168         {
 169             code: "fn(...( args ))",
 170             output: "fn(... ( args ))",
 171             options: ["always"],
 172             errors: [{
 173                 line: 1,
 174                 column: 7,
 175                 messageId: "expectedWhitespace",
 176                 data: { type: "spread" },
 177                 type: "SpreadElement"
 178             }]
 179         },
 180         {
 181             code: "[... arr, 4, 5, 6]",
 182             output: "[...arr, 4, 5, 6]",
 183             errors: [{
 184                 line: 1,
 185                 column: 5,
 186                 messageId: "unexpectedWhitespace",
 187                 data: { type: "spread" },
 188                 type: "SpreadElement"
 189             }]
 190         },
 191         {
 192             code: "[...\tarr, 4, 5, 6]",
 193             output: "[...arr, 4, 5, 6]",
 194             errors: [{
 195                 line: 1,
 196                 column: 5,
 197                 messageId: "unexpectedWhitespace",
 198                 data: { type: "spread" },
 199                 type: "SpreadElement"
 200             }]
 201         },
 202         {
 203             code: "[...\narr, 4, 5, 6]",
 204             output: "[...arr, 4, 5, 6]",
 205             errors: [{
 206                 line: 1,
 207                 column: 5,
 208                 messageId: "unexpectedWhitespace",
 209                 data: { type: "spread" },
 210                 type: "SpreadElement"
 211             }]
 212         },
 213         {
 214             code: "[... arr, 4, 5, 6]",
 215             output: "[...arr, 4, 5, 6]",
 216             options: ["never"],
 217             errors: [{
 218                 line: 1,
 219                 column: 5,
 220                 messageId: "unexpectedWhitespace",
 221                 data: { type: "spread" },
 222                 type: "SpreadElement"
 223             }]
 224         },
 225         {
 226             code: "[...\tarr, 4, 5, 6]",
 227             output: "[...arr, 4, 5, 6]",
 228             options: ["never"],
 229             errors: [{
 230                 line: 1,
 231                 column: 5,
 232                 messageId: "unexpectedWhitespace",
 233                 data: { type: "spread" },
 234                 type: "SpreadElement"
 235             }]
 236         },
 237         {
 238             code: "[...\narr, 4, 5, 6]",
 239             output: "[...arr, 4, 5, 6]",
 240             options: ["never"],
 241             errors: [{
 242                 line: 1,
 243                 column: 5,
 244                 messageId: "unexpectedWhitespace",
 245                 data: { type: "spread" },
 246                 type: "SpreadElement"
 247             }]
 248         },
 249         {
 250             code: "[...arr, 4, 5, 6]",
 251             output: "[... arr, 4, 5, 6]",
 252             options: ["always"],
 253             errors: [{
 254                 line: 1,
 255                 column: 5,
 256                 messageId: "expectedWhitespace",
 257                 data: { type: "spread" },
 258                 type: "SpreadElement"
 259             }]
 260         },
 261         {
 262             code: "[... (arr), 4, 5, 6]",
 263             output: "[...(arr), 4, 5, 6]",
 264             errors: [{
 265                 line: 1,
 266                 column: 5,
 267                 messageId: "unexpectedWhitespace",
 268                 data: { type: "spread" },
 269                 type: "SpreadElement"
 270             }]
 271         },
 272         {
 273             code: "[... ( arr ), 4, 5, 6]",
 274             output: "[...( arr ), 4, 5, 6]",
 275             errors: [{
 276                 line: 1,
 277                 column: 5,
 278                 messageId: "unexpectedWhitespace",
 279                 data: { type: "spread" },
 280                 type: "SpreadElement"
 281             }]
 282         },
 283         {
 284             code: "[...(arr), 4, 5, 6]",
 285             output: "[... (arr), 4, 5, 6]",
 286             options: ["always"],
 287             errors: [{
 288                 line: 1,
 289                 column: 5,
 290                 messageId: "expectedWhitespace",
 291                 data: { type: "spread" },
 292                 type: "SpreadElement"
 293             }]
 294         },
 295         {
 296             code: "[...( arr ), 4, 5, 6]",
 297             output: "[... ( arr ), 4, 5, 6]",
 298             options: ["always"],
 299             errors: [{
 300                 line: 1,
 301                 column: 5,
 302                 messageId: "expectedWhitespace",
 303                 data: { type: "spread" },
 304                 type: "SpreadElement"
 305             }]
 306         },
 307         {
 308             code: "let [a, b, ... arr] = [1, 2, 3, 4, 5];",
 309             output: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 310             errors: [{
 311                 line: 1,
 312                 column: 15,
 313                 messageId: "unexpectedWhitespace",
 314                 data: { type: "rest" },
 315                 type: "RestElement"
 316             }]
 317         },
 318         {
 319             code: "let [a, b, ...\tarr] = [1, 2, 3, 4, 5];",
 320             output: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 321             errors: [{
 322                 line: 1,
 323                 column: 15,
 324                 messageId: "unexpectedWhitespace",
 325                 data: { type: "rest" },
 326                 type: "RestElement"
 327             }]
 328         },
 329         {
 330             code: "let [a, b, ...\narr] = [1, 2, 3, 4, 5];",
 331             output: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 332             errors: [{
 333                 line: 1,
 334                 column: 15,
 335                 messageId: "unexpectedWhitespace",
 336                 data: { type: "rest" },
 337                 type: "RestElement"
 338             }]
 339         },
 340         {
 341             code: "let [a, b, ... arr] = [1, 2, 3, 4, 5];",
 342             output: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 343             options: ["never"],
 344             errors: [{
 345                 line: 1,
 346                 column: 15,
 347                 messageId: "unexpectedWhitespace",
 348                 data: { type: "rest" },
 349                 type: "RestElement"
 350             }]
 351         },
 352         {
 353             code: "let [a, b, ...\tarr] = [1, 2, 3, 4, 5];",
 354             output: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 355             options: ["never"],
 356             errors: [{
 357                 line: 1,
 358                 column: 15,
 359                 messageId: "unexpectedWhitespace",
 360                 data: { type: "rest" },
 361                 type: "RestElement"
 362             }]
 363         },
 364         {
 365             code: "let [a, b, ...\narr] = [1, 2, 3, 4, 5];",
 366             output: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 367             options: ["never"],
 368             errors: [{
 369                 line: 1,
 370                 column: 15,
 371                 messageId: "unexpectedWhitespace",
 372                 data: { type: "rest" },
 373                 type: "RestElement"
 374             }]
 375         },
 376         {
 377             code: "let [a, b, ...arr] = [1, 2, 3, 4, 5];",
 378             output: "let [a, b, ... arr] = [1, 2, 3, 4, 5];",
 379             options: ["always"],
 380             errors: [{
 381                 line: 1,
 382                 column: 15,
 383                 messageId: "expectedWhitespace",
 384                 data: { type: "rest" },
 385                 type: "RestElement"
 386             }]
 387         },
 388         {
 389             code: "let n = { x, y, ... z };",
 390             output: "let n = { x, y, ...z };",
 391             parserOptions: { ecmaVersion: 2018 },
 392             errors: [{
 393                 line: 1,
 394                 column: 20,
 395                 messageId: "unexpectedWhitespace",
 396                 data: { type: "spread property" },
 397                 type: "SpreadElement"
 398             }]
 399         },
 400         {
 401             code: "let n = { x, y, ...\tz };",
 402             output: "let n = { x, y, ...z };",
 403             parserOptions: { ecmaVersion: 2018 },
 404             errors: [{
 405                 line: 1,
 406                 column: 20,
 407                 messageId: "unexpectedWhitespace",
 408                 data: { type: "spread property" },
 409                 type: "SpreadElement"
 410             }]
 411         },
 412         {
 413             code: "let n = { x, y, ...\nz };",
 414             output: "let n = { x, y, ...z };",
 415             parserOptions: { ecmaVersion: 2018 },
 416             errors: [{
 417                 line: 1,
 418                 column: 20,
 419                 messageId: "unexpectedWhitespace",
 420                 data: { type: "spread property" },
 421                 type: "SpreadElement"
 422             }]
 423         },
 424         {
 425             code: "let n = { x, y, ... z };",
 426             output: "let n = { x, y, ...z };",
 427             options: ["never"],
 428             parserOptions: { ecmaVersion: 2018 },
 429             errors: [{
 430                 line: 1,
 431                 column: 20,
 432                 messageId: "unexpectedWhitespace",
 433                 data: { type: "spread property" },
 434                 type: "SpreadElement"
 435             }]
 436         },
 437         {
 438             code: "let n = { x, y, ...\tz };",
 439             output: "let n = { x, y, ...z };",
 440             options: ["never"],
 441             parserOptions: { ecmaVersion: 2018 },
 442             errors: [{
 443                 line: 1,
 444                 column: 20,
 445                 messageId: "unexpectedWhitespace",
 446                 data: { type: "spread property" },
 447                 type: "SpreadElement"
 448             }]
 449         },
 450         {
 451             code: "let n = { x, y, ...\nz };",
 452             output: "let n = { x, y, ...z };",
 453             options: ["never"],
 454             parserOptions: { ecmaVersion: 2018 },
 455             errors: [{
 456                 line: 1,
 457                 column: 20,
 458                 messageId: "unexpectedWhitespace",
 459                 data: { type: "spread property" },
 460                 type: "SpreadElement"
 461             }]
 462         },
 463         {
 464             code: "let n = { x, y, ...z };",
 465             output: "let n = { x, y, ... z };",
 466             options: ["always"],
 467             parserOptions: { ecmaVersion: 2018 },
 468             errors: [{
 469                 line: 1,
 470                 column: 20,
 471                 messageId: "expectedWhitespace",
 472                 data: { type: "spread property" },
 473                 type: "SpreadElement"
 474             }]
 475         },
 476         {
 477             code: "let n = { x, y, ... (z) };",
 478             output: "let n = { x, y, ...(z) };",
 479             options: ["never"],
 480             parserOptions: { ecmaVersion: 2018 },
 481             errors: [{
 482                 line: 1,
 483                 column: 20,
 484                 messageId: "unexpectedWhitespace",
 485                 data: { type: "spread property" },
 486                 type: "SpreadElement"
 487             }]
 488         },
 489         {
 490             code: "let n = { x, y, ... ( z ) };",
 491             output: "let n = { x, y, ...( z ) };",
 492             options: ["never"],
 493             parserOptions: { ecmaVersion: 2018 },
 494             errors: [{
 495                 line: 1,
 496                 column: 20,
 497                 messageId: "unexpectedWhitespace",
 498                 data: { type: "spread property" },
 499                 type: "SpreadElement"
 500             }]
 501         },
 502         {
 503             code: "let n = { x, y, ...(z) };",
 504             output: "let n = { x, y, ... (z) };",
 505             options: ["always"],
 506             parserOptions: { ecmaVersion: 2018 },
 507             errors: [{
 508                 line: 1,
 509                 column: 20,
 510                 messageId: "expectedWhitespace",
 511                 data: { type: "spread property" },
 512                 type: "SpreadElement"
 513             }]
 514         },
 515         {
 516             code: "let n = { x, y, ...( z ) };",
 517             output: "let n = { x, y, ... ( z ) };",
 518             options: ["always"],
 519             parserOptions: { ecmaVersion: 2018 },
 520             errors: [{
 521                 line: 1,
 522                 column: 20,
 523                 messageId: "expectedWhitespace",
 524                 data: { type: "spread property" },
 525                 type: "SpreadElement"
 526             }]
 527         },
 528         {
 529             code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
 530             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 531             parserOptions: { ecmaVersion: 2018 },
 532             errors: [{
 533                 line: 1,
 534                 column: 16,
 535                 messageId: "unexpectedWhitespace",
 536                 data: { type: "rest property" },
 537                 type: "RestElement"
 538             }]
 539         },
 540         {
 541             code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };",
 542             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 543             parserOptions: { ecmaVersion: 2018 },
 544             errors: [{
 545                 line: 1,
 546                 column: 16,
 547                 messageId: "unexpectedWhitespace",
 548                 data: { type: "rest property" },
 549                 type: "RestElement"
 550             }]
 551         },
 552         {
 553             code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };",
 554             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 555             parserOptions: { ecmaVersion: 2018 },
 556             errors: [{
 557                 line: 1,
 558                 column: 16,
 559                 messageId: "unexpectedWhitespace",
 560                 data: { type: "rest property" },
 561                 type: "RestElement"
 562             }]
 563         },
 564         {
 565             code: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
 566             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 567             options: ["never"],
 568             parserOptions: { ecmaVersion: 2018 },
 569             errors: [{
 570                 line: 1,
 571                 column: 16,
 572                 messageId: "unexpectedWhitespace",
 573                 data: { type: "rest property" },
 574                 type: "RestElement"
 575             }]
 576         },
 577         {
 578             code: "let { x, y, ...\tz } = { x: 1, y: 2, a: 3, b: 4 };",
 579             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 580             options: ["never"],
 581             parserOptions: { ecmaVersion: 2018 },
 582             errors: [{
 583                 line: 1,
 584                 column: 16,
 585                 messageId: "unexpectedWhitespace",
 586                 data: { type: "rest property" },
 587                 type: "RestElement"
 588             }]
 589         },
 590         {
 591             code: "let { x, y, ...\nz } = { x: 1, y: 2, a: 3, b: 4 };",
 592             output: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 593             options: ["never"],
 594             parserOptions: { ecmaVersion: 2018 },
 595             errors: [{
 596                 line: 1,
 597                 column: 16,
 598                 messageId: "unexpectedWhitespace",
 599                 data: { type: "rest property" },
 600                 type: "RestElement"
 601             }]
 602         },
 603         {
 604             code: "let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };",
 605             output: "let { x, y, ... z } = { x: 1, y: 2, a: 3, b: 4 };",
 606             options: ["always"],
 607             parserOptions: { ecmaVersion: 2018 },
 608             errors: [{
 609                 line: 1,
 610                 column: 16,
 611                 messageId: "expectedWhitespace",
 612                 data: { type: "rest property" },
 613                 type: "RestElement"
 614             }]
 615         }
 616     ]
 617 });