Blame view

node_modules/eslint/lib/rules/multiline-ternary.js 3.14 KB
ce4c83ff   wxy   初始提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
  /**
   * @fileoverview Enforce newlines between operands of ternary expressions
   * @author Kai Cataldo
   */
  
  "use strict";
  
  const astUtils = require("../ast-utils");
  
  //------------------------------------------------------------------------------
  // Rule Definition
  //------------------------------------------------------------------------------
  
  module.exports = {
      meta: {
          docs: {
              description: "enforce newlines between operands of ternary expressions",
              category: "Stylistic Issues",
              recommended: false,
              url: "https://eslint.org/docs/rules/multiline-ternary"
          },
          schema: [
              {
                  enum: ["always", "always-multiline", "never"]
              }
          ]
      },
  
      create(context) {
          const option = context.options[0];
          const multiline = option !== "never";
          const allowSingleLine = option === "always-multiline";
  
          //--------------------------------------------------------------------------
          // Helpers
          //--------------------------------------------------------------------------
  
          /**
           * Tests whether node is preceded by supplied tokens
           * @param {ASTNode} node - node to check
           * @param {ASTNode} parentNode - parent of node to report
           * @param {boolean} expected - whether newline was expected or not
           * @returns {void}
           * @private
           */
          function reportError(node, parentNode, expected) {
              context.report({
                  node,
                  message: "{{expected}} newline between {{typeOfError}} of ternary expression.",
                  data: {
                      expected: expected ? "Expected" : "Unexpected",
                      typeOfError: node === parentNode.test ? "test and consequent" : "consequent and alternate"
                  }
              });
          }
  
          //--------------------------------------------------------------------------
          // Public
          //--------------------------------------------------------------------------
  
          return {
              ConditionalExpression(node) {
                  const areTestAndConsequentOnSameLine = astUtils.isTokenOnSameLine(node.test, node.consequent);
                  const areConsequentAndAlternateOnSameLine = astUtils.isTokenOnSameLine(node.consequent, node.alternate);
  
                  if (!multiline) {
                      if (!areTestAndConsequentOnSameLine) {
                          reportError(node.test, node, false);
                      }
  
                      if (!areConsequentAndAlternateOnSameLine) {
                          reportError(node.consequent, node, false);
                      }
                  } else {
                      if (allowSingleLine && node.loc.start.line === node.loc.end.line) {
                          return;
                      }
  
                      if (areTestAndConsequentOnSameLine) {
                          reportError(node.test, node, true);
                      }
  
                      if (areConsequentAndAlternateOnSameLine) {
                          reportError(node.consequent, node, true);
                      }
                  }
              }
          };
      }
  };