eslint/tests/lib/rules/space-infix-ops.js

   1 /**
   2  * @fileoverview Require spaces around infix operators
   3  * @author Michael Ficarra
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Requirements
  10 //------------------------------------------------------------------------------
  11
  12 const rule = require("../../../lib/rules/space-infix-ops"),
  13     { RuleTester } = require("../../../lib/rule-tester"),
  14     parser = require("../../fixtures/fixture-parser");
  15
  16 const ruleTester = new RuleTester();
  17
  18 ruleTester.run("space-infix-ops", rule, {
  19     valid: [
  20         "a + b",
  21         "a + ++b",
  22         "a++ + b",
  23         "a++ + ++b",
  24         "a     + b",
  25         "(a) + (b)",
  26         "((a)) + ((b))",
  27         "(((a))) + (((b)))",
  28         "a + +b",
  29         "a + (b)",
  30         "a + +(b)",
  31         "a + (+(b))",
  32         "(a + b) + (c + d)",
  33         "a = b",
  34         "a ? b : c",
  35         "var a = b",
  36         { code: "const my_object = {key: 'value'};", parserOptions: { ecmaVersion: 6 } },
  37         { code: "var {a = 0} = bar;", parserOptions: { ecmaVersion: 6 } },
  38         { code: "function foo(a = 0) { }", parserOptions: { ecmaVersion: 6 } },
  39         { code: "a ** b", parserOptions: { ecmaVersion: 7 } },
  40         { code: "a|0", options: [{ int32Hint: true }] },
  41         { code: "a |0", options: [{ int32Hint: true }] },
  42
  43         // Type Annotations
  44         { code: "function foo(a: number = 0) { }", parser: parser("type-annotations/function-parameter-type-annotation"), parserOptions: { ecmaVersion: 6 } },
  45         { code: "function foo(): Bar { }", parser: parser("type-annotations/function-return-type-annotation"), parserOptions: { ecmaVersion: 6 } },
  46         { code: "var foo: Bar = '';", parser: parser("type-annotations/variable-declaration-init-type-annotation"), parserOptions: { ecmaVersion: 6 } },
  47         { code: "const foo = function(a: number = 0): Bar { };", parser: parser("type-annotations/function-expression-type-annotation"), parserOptions: { ecmaVersion: 6 } },
  48
  49         // TypeScript Type Aliases
  50         { code: "type Foo<T> = T;", parser: parser("typescript-parsers/type-alias"), parserOptions: { ecmaVersion: 6 } },
  51
  52         { code: "a &&= b", parserOptions: { ecmaVersion: 2021 } },
  53         { code: "a ||= b", parserOptions: { ecmaVersion: 2021 } },
  54         { code: "a ??= b", parserOptions: { ecmaVersion: 2021 } }
  55     ],
  56     invalid: [
  57         {
  58             code: "a+b",
  59             output: "a + b",
  60             errors: [{
  61                 messageId: "missingSpace",
  62                 data: { operator: "+" },
  63                 type: "BinaryExpression",
  64                 line: 1,
  65                 column: 2,
  66                 endColumn: 3
  67             }]
  68         },
  69         {
  70             code: "a +b",
  71             output: "a + b",
  72             errors: [{
  73                 messageId: "missingSpace",
  74                 data: { operator: "+" },
  75                 type: "BinaryExpression",
  76                 line: 1,
  77                 column: 3,
  78                 endColumn: 4
  79             }]
  80         },
  81         {
  82             code: "a+ b",
  83             output: "a + b",
  84             errors: [{
  85                 messageId: "missingSpace",
  86                 data: { operator: "+" },
  87                 type: "BinaryExpression",
  88                 line: 1,
  89                 column: 2,
  90                 endColumn: 3
  91             }]
  92         },
  93         {
  94             code: "a||b",
  95             output: "a || b",
  96             errors: [{
  97                 messageId: "missingSpace",
  98                 data: { operator: "||" },
  99                 type: "LogicalExpression",
 100                 line: 1,
 101                 column: 2,
 102                 endColumn: 4
 103             }]
 104         },
 105         {
 106             code: "a ||b",
 107             output: "a || b",
 108             errors: [{
 109                 messageId: "missingSpace",
 110                 data: { operator: "||" },
 111                 type: "LogicalExpression",
 112                 line: 1,
 113                 column: 3,
 114                 endColumn: 5
 115             }]
 116         },
 117         {
 118             code: "a|| b",
 119             output: "a || b",
 120             errors: [{
 121                 messageId: "missingSpace",
 122                 data: { operator: "||" },
 123                 type: "LogicalExpression",
 124                 line: 1,
 125                 column: 2,
 126                 endColumn: 4
 127             }]
 128         },
 129         {
 130             code: "a=b",
 131             output: "a = b",
 132             errors: [{
 133                 messageId: "missingSpace",
 134                 data: { operator: "=" },
 135                 type: "AssignmentExpression",
 136                 line: 1,
 137                 column: 2
 138             }]
 139         },
 140         {
 141             code: "a= b",
 142             output: "a = b",
 143             errors: [{
 144                 messageId: "missingSpace",
 145                 data: { operator: "=" },
 146                 type: "AssignmentExpression",
 147                 line: 1,
 148                 column: 2
 149             }]
 150         },
 151         {
 152             code: "a =b",
 153             output: "a = b",
 154             errors: [{
 155                 messageId: "missingSpace",
 156                 data: { operator: "=" },
 157                 type: "AssignmentExpression",
 158                 line: 1,
 159                 column: 3
 160             }]
 161         },
 162         {
 163             code: "a?b:c",
 164             output: "a ? b:c",
 165             errors: [{
 166                 messageId: "missingSpace",
 167                 data: { operator: "?" },
 168                 type: "ConditionalExpression",
 169                 line: 1,
 170                 column: 2,
 171                 endColumn: 3
 172             }]
 173         },
 174         {
 175             code: "a?b : c",
 176             output: "a ? b : c",
 177             errors: [{
 178                 messageId: "missingSpace",
 179                 data: { operator: "?" },
 180                 type: "ConditionalExpression",
 181                 line: 1,
 182                 column: 2,
 183                 endColumn: 3
 184             }]
 185         },
 186         {
 187             code: "a ? b:c",
 188             output: "a ? b : c",
 189             errors: [{
 190                 messageId: "missingSpace",
 191                 data: { operator: ":" },
 192                 type: "ConditionalExpression",
 193                 line: 1,
 194                 column: 6,
 195                 endColumn: 7
 196             }]
 197         },
 198         {
 199             code: "a? b : c",
 200             output: "a ? b : c",
 201             errors: [{
 202                 messageId: "missingSpace",
 203                 data: { operator: "?" },
 204                 type: "ConditionalExpression",
 205                 line: 1,
 206                 column: 2,
 207                 endColumn: 3
 208             }]
 209         },
 210         {
 211             code: "a ?b : c",
 212             output: "a ? b : c",
 213             errors: [{
 214                 messageId: "missingSpace",
 215                 data: { operator: "?" },
 216                 type: "ConditionalExpression",
 217                 line: 1,
 218                 column: 3,
 219                 endColumn: 4
 220             }]
 221         },
 222         {
 223             code: "a ? b: c",
 224             output: "a ? b : c",
 225             errors: [{
 226                 messageId: "missingSpace",
 227                 data: { operator: ":" },
 228                 type: "ConditionalExpression",
 229                 line: 1,
 230                 column: 6,
 231                 endColumn: 7
 232             }]
 233         },
 234         {
 235             code: "a ? b :c",
 236             output: "a ? b : c",
 237             errors: [{
 238                 messageId: "missingSpace",
 239                 data: { operator: ":" },
 240                 type: "ConditionalExpression",
 241                 line: 1,
 242                 column: 7,
 243                 endColumn: 8
 244             }]
 245         },
 246         {
 247             code: "var a=b;",
 248             output: "var a = b;",
 249             errors: [{
 250                 messageId: "missingSpace",
 251                 data: { operator: "=" },
 252                 type: "VariableDeclarator",
 253                 line: 1,
 254                 column: 6
 255             }]
 256         },
 257         {
 258             code: "var a= b;",
 259             output: "var a = b;",
 260             errors: [{
 261                 messageId: "missingSpace",
 262                 data: { operator: "=" },
 263                 type: "VariableDeclarator",
 264                 line: 1,
 265                 column: 6
 266             }]
 267         },
 268         {
 269             code: "var a =b;",
 270             output: "var a = b;",
 271             errors: [{
 272                 messageId: "missingSpace",
 273                 data: { operator: "=" },
 274                 type: "VariableDeclarator",
 275                 line: 1,
 276                 column: 7
 277             }]
 278         },
 279         {
 280             code: "var a = b, c=d;",
 281             output: "var a = b, c = d;",
 282             errors: [{
 283                 messageId: "missingSpace",
 284                 data: { operator: "=" },
 285                 type: "VariableDeclarator",
 286                 line: 1,
 287                 column: 13
 288             }]
 289         },
 290         {
 291             code: "a| 0",
 292             output: "a | 0",
 293             options: [{
 294                 int32Hint: true
 295             }],
 296             errors: [{
 297                 messageId: "missingSpace",
 298                 data: { operator: "|" },
 299                 type: "BinaryExpression",
 300                 line: 1,
 301                 column: 2
 302             }]
 303         },
 304         {
 305             code: "var output = test || (test && test.value) ||(test2 && test2.value);",
 306             output: "var output = test || (test && test.value) || (test2 && test2.value);",
 307             errors: [{
 308                 messageId: "missingSpace",
 309                 data: { operator: "||" },
 310                 type: "LogicalExpression",
 311                 line: 1,
 312                 column: 43
 313             }]
 314         },
 315         {
 316             code: "var output = a ||(b && c.value) || (d && e.value);",
 317             output: "var output = a || (b && c.value) || (d && e.value);",
 318             errors: [{
 319                 messageId: "missingSpace",
 320                 data: { operator: "||" },
 321                 type: "LogicalExpression",
 322                 line: 1,
 323                 column: 16
 324             }]
 325         },
 326         {
 327             code: "var output = a|| (b && c.value) || (d && e.value);",
 328             output: "var output = a || (b && c.value) || (d && e.value);",
 329             errors: [{
 330                 messageId: "missingSpace",
 331                 data: { operator: "||" },
 332                 type: "LogicalExpression",
 333                 line: 1,
 334                 column: 15
 335             }]
 336         },
 337         {
 338             code: "const my_object={key: 'value'}",
 339             output: "const my_object = {key: 'value'}",
 340             parserOptions: { ecmaVersion: 6 },
 341             errors: [{
 342                 messageId: "missingSpace",
 343                 data: { operator: "=" },
 344                 type: "VariableDeclarator",
 345                 line: 1,
 346                 column: 16
 347             }]
 348         },
 349         {
 350             code: "var {a=0}=bar;",
 351             output: "var {a = 0} = bar;",
 352             parserOptions: { ecmaVersion: 6 },
 353             errors: [{
 354                 messageId: "missingSpace",
 355                 data: { operator: "=" },
 356                 line: 1,
 357                 column: 7,
 358                 type: "AssignmentPattern"
 359             }, {
 360                 messageId: "missingSpace",
 361                 data: { operator: "=" },
 362                 line: 1,
 363                 column: 10,
 364                 type: "VariableDeclarator"
 365             }]
 366         },
 367         {
 368             code: "function foo(a=0) { }",
 369             output: "function foo(a = 0) { }",
 370             parserOptions: { ecmaVersion: 6 },
 371             errors: [{
 372                 messageId: "missingSpace",
 373                 data: { operator: "=" },
 374                 line: 1,
 375                 column: 15,
 376                 type: "AssignmentPattern"
 377             }]
 378         },
 379         {
 380             code: "a**b",
 381             output: "a ** b",
 382             parserOptions: { ecmaVersion: 7 },
 383             errors: [{
 384                 messageId: "missingSpace",
 385                 data: { operator: "**" },
 386                 line: 1,
 387                 column: 2,
 388                 type: "BinaryExpression"
 389             }]
 390         },
 391         {
 392             code: "'foo'in{}",
 393             output: "'foo' in {}",
 394             errors: [{
 395                 messageId: "missingSpace",
 396                 data: { operator: "in" },
 397                 line: 1,
 398                 column: 6,
 399                 type: "BinaryExpression"
 400             }]
 401         },
 402         {
 403             code: "'foo'instanceof{}",
 404             output: "'foo' instanceof {}",
 405             errors: [{
 406                 messageId: "missingSpace",
 407                 data: { operator: "instanceof" },
 408                 line: 1,
 409                 column: 6,
 410                 type: "BinaryExpression"
 411             }]
 412         },
 413
 414         // Type Annotations
 415         {
 416             code: "var a: Foo= b;",
 417             output: "var a: Foo = b;",
 418             parser: parser("type-annotations/variable-declaration-init-type-annotation-no-space"),
 419             errors: [{
 420                 messageId: "missingSpace",
 421                 data: { operator: "=" },
 422                 type: "VariableDeclarator",
 423                 line: 1,
 424                 column: 11
 425             }]
 426         },
 427         {
 428             code: "function foo(a: number=0): Foo { }",
 429             output: "function foo(a: number = 0): Foo { }",
 430             parser: parser("type-annotations/function-declaration-type-annotation-no-space"),
 431             parserOptions: { ecmaVersion: 6 },
 432             errors: [{
 433                 messageId: "missingSpace",
 434                 data: { operator: "=" },
 435                 line: 1,
 436                 column: 23,
 437                 type: "AssignmentPattern"
 438             }]
 439         },
 440
 441         {
 442             code: "a&&=b",
 443             output: "a &&= b",
 444             parserOptions: { ecmaVersion: 2021 },
 445             errors: [{
 446                 messageId: "missingSpace",
 447                 data: { operator: "&&=" },
 448                 line: 1,
 449                 column: 2,
 450                 endLine: 1,
 451                 endColumn: 5,
 452                 type: "AssignmentExpression"
 453             }]
 454         },
 455         {
 456             code: "a ||=b",
 457             output: "a ||= b",
 458             parserOptions: { ecmaVersion: 2021 },
 459             errors: [{
 460                 messageId: "missingSpace",
 461                 data: { operator: "||=" },
 462                 line: 1,
 463                 column: 3,
 464                 endLine: 1,
 465                 endColumn: 6,
 466                 type: "AssignmentExpression"
 467             }]
 468         },
 469         {
 470             code: "a??= b",
 471             output: "a ??= b",
 472             parserOptions: { ecmaVersion: 2021 },
 473             errors: [{
 474                 messageId: "missingSpace",
 475                 data: { operator: "??=" },
 476                 line: 1,
 477                 column: 2,
 478                 endLine: 1,
 479                 endColumn: 5,
 480                 type: "AssignmentExpression"
 481             }]
 482         }
 483     ]
 484 });