1622

pending completion

Build # 1622

Build Type

push

travis-ci

Committed by

yannickcr

Commit Message

Revert "[Fix] jsx-indent with tabs (fixes #1057)"

This reverts commit 6e5f68806.

Conflicts:
	lib/rules/jsx-indent.js
	tests/lib/rules/jsx-indent.js

Run Details

25 of 25 new or added lines in 1 file covered. (100.0%)

3120 of 3225 relevant lines covered (96.74%)

1148.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.0

/lib/rules/jsx-indent.js

/**
 * @fileoverview Validate JSX indentation
 * @author Yannick Croissant

 * This rule has been ported and modified from eslint and nodeca.
 * @author Vitaly Puzrin
 * @author Gyandeep Singh
 * @copyright 2015 Vitaly Puzrin. All rights reserved.
 * @copyright 2015 Gyandeep Singh. All rights reserved.
 Copyright (C) 2014 by Vitaly Puzrin

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the 'Software'), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
'use strict';

// ------------------------------------------------------------------------------
// Rule Definition
// ------------------------------------------------------------------------------
module.exports = {
  meta: {
    docs: {
      description: 'Validate JSX indentation',
      category: 'Stylistic Issues',
      recommended: false
    },
    fixable: 'whitespace',
    schema: [{
      oneOf: [{
        enum: ['tab']
      }, {
        type: 'integer'
      }]
    }]
  },

  create: function(context) {

    var MESSAGE = 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.';

    var extraColumnStart = 0;
    var indentType = 'space';
    var indentSize = 4;

    var sourceCode = context.getSourceCode();

    if (context.options.length) {
      if (context.options[0] === 'tab') {
        indentSize = 1;
        indentType = 'tab';
      } else if (typeof context.options[0] === 'number') {
        indentSize = context.options[0];
        indentType = 'space';
      }
    }

    var indentChar = indentType === 'space' ? ' ' : '\t';

    /**
     * Responsible for fixing the indentation issue fix
     * @param {ASTNode} node Node violating the indent rule
     * @param {Number} needed Expected indentation character count
     * @returns {Function} function to be executed by the fixer
     * @private
     */
    function getFixerFunction(node, needed) {
      return function(fixer) {
        var indent = Array(needed + 1).join(indentChar);
        return fixer.replaceTextRange(
          [node.start - node.loc.start.column, node.start],
          indent
        );
      };
    }

    /**
     * Reports a given indent violation and properly pluralizes the message
     * @param {ASTNode} node Node violating the indent rule
     * @param {Number} needed Expected indentation character count
     * @param {Number} gotten Indentation character count in the actual node/code
     * @param {Object} loc Error line and column location
     */
    function report(node, needed, gotten, loc) {
      var msgContext = {
        needed: needed,
        type: indentType,
        characters: needed === 1 ? 'character' : 'characters',
        gotten: gotten
      };

      if (loc) {
        context.report({
          node: node,
          loc: loc,
          message: MESSAGE,
          data: msgContext,
          fix: getFixerFunction(node, needed)
        });
      } else {
        context.report({
          node: node,
          message: MESSAGE,
          data: msgContext,
          fix: getFixerFunction(node, needed)
        });
      }
    }

    /**
     * Get node indent
     * @param {ASTNode} node Node to examine
     * @param {Boolean} byLastLine get indent of node's last line
     * @param {Boolean} excludeCommas skip comma on start of line
     * @return {Number} Indent
     */
    function getNodeIndent(node, byLastLine, excludeCommas) {
      byLastLine = byLastLine || false;
      excludeCommas = excludeCommas || false;

      var src = sourceCode.getText(node, node.loc.start.column + extraColumnStart);
      var lines = src.split('\n');
      if (byLastLine) {
        src = lines[lines.length - 1];
      } else {
        src = lines[0];
      }

      var skip = excludeCommas ? ',' : '';

      var regExp;
      if (indentType === 'space') {
        regExp = new RegExp('^[ ' + skip + ']+');
      } else {
        regExp = new RegExp('^[\t' + skip + ']+');
      }

      var indent = regExp.exec(src);
      return indent ? indent[0].length : 0;
    }

    /**
     * Checks node is the first in its own start line. By default it looks by start line.
     * @param {ASTNode} node The node to check
     * @return {Boolean} true if its the first in the its start line
     */
    function isNodeFirstInLine(node) {
      var token = node;
      do {
        token = sourceCode.getTokenBefore(token);
      } while (token.type === 'JSXText' && /^\s*$/.test(token.value));
      var startLine = node.loc.start.line;
      var endLine = token ? token.loc.end.line : -1;

      return startLine !== endLine;
    }

  /**
   * Check if the node is the right member of a logical expression
   * @param {ASTNode} node The node to check
   * @return {Boolean} true if its the case, false if not
   */
    function isRightInLogicalExp(node) {
      return (
        node.parent &&
        node.parent.parent &&
        node.parent.parent.type === 'LogicalExpression' &&
        node.parent.parent.right === node.parent
      );
    }

  /**
   * Check if the node is the alternate member of a conditional expression
   * @param {ASTNode} node The node to check
   * @return {Boolean} true if its the case, false if not
   */
    function isAlternateInConditionalExp(node) {
      return (
        node.parent &&
        node.parent.parent &&
        node.parent.parent.type === 'ConditionalExpression' &&
        node.parent.parent.alternate === node.parent &&
        sourceCode.getTokenBefore(node).value !== '('
      );
    }

    /**
     * Check indent for nodes list
     * @param {ASTNode} node The node to check
     * @param {Number} indent needed indent
     * @param {Boolean} excludeCommas skip comma on start of line
     */
    function checkNodesIndent(node, indent, excludeCommas) {
      var nodeIndent = getNodeIndent(node, false, excludeCommas);
      var isCorrectRightInLogicalExp = isRightInLogicalExp(node) && (nodeIndent - indent) === indentSize;
      var isCorrectAlternateInCondExp = isAlternateInConditionalExp(node) && (nodeIndent - indent) === 0;
      if (
        nodeIndent !== indent &&
        isNodeFirstInLine(node) &&
        !isCorrectRightInLogicalExp &&
        !isCorrectAlternateInCondExp
      ) {
        report(node, indent, nodeIndent);
      }
    }

    return {
      JSXOpeningElement: function(node) {
        var prevToken = sourceCode.getTokenBefore(node);
        if (!prevToken) {
          return;
        }
        // Use the parent in a list or an array
        if (prevToken.type === 'JSXText' || prevToken.type === 'Punctuator' && prevToken.value === ',') {
          prevToken = sourceCode.getNodeByRangeIndex(prevToken.start);
          prevToken = prevToken.type === 'Literal' ? prevToken.parent : prevToken;
        // Use the first non-punctuator token in a conditional expression
        } else if (prevToken.type === 'Punctuator' && prevToken.value === ':') {
          do {
            prevToken = sourceCode.getTokenBefore(prevToken);
          } while (prevToken.type === 'Punctuator');
          prevToken = sourceCode.getNodeByRangeIndex(prevToken.start);
          while (prevToken.parent && prevToken.parent.type !== 'ConditionalExpression') {
            prevToken = prevToken.parent;
          }
        }
        prevToken = prevToken.type === 'JSXExpressionContainer' ? prevToken.expression : prevToken;

        var parentElementIndent = getNodeIndent(prevToken);
        var indent = (
          prevToken.loc.start.line === node.loc.start.line ||
          isRightInLogicalExp(node) ||
          isAlternateInConditionalExp(node)
        ) ? 0 : indentSize;
        checkNodesIndent(node, parentElementIndent + indent);
      },
      JSXClosingElement: function(node) {
        if (!node.parent) {
          return;
        }
        var peerElementIndent = getNodeIndent(node.parent.openingElement);
        checkNodesIndent(node, peerElementIndent);
      },
      JSXExpressionContainer: function(node) {
        if (!node.parent) {
          return;
        }
        var parentNodeIndent = getNodeIndent(node.parent);
        checkNodesIndent(node, parentNodeIndent + indentSize);
      }
    };

  }
};

1	/**
2	* @fileoverview Validate JSX indentation
3	* @author Yannick Croissant
4
5	* This rule has been ported and modified from eslint and nodeca.
6	* @author Vitaly Puzrin
7	* @author Gyandeep Singh
8	* @copyright 2015 Vitaly Puzrin. All rights reserved.
9	* @copyright 2015 Gyandeep Singh. All rights reserved.
10	Copyright (C) 2014 by Vitaly Puzrin
11
12	Permission is hereby granted, free of charge, to any person obtaining a copy
13	of this software and associated documentation files (the 'Software'), to deal
14	in the Software without restriction, including without limitation the rights
15	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16	copies of the Software, and to permit persons to whom the Software is
17	furnished to do so, subject to the following conditions:
18
19	The above copyright notice and this permission notice shall be included in
20	all copies or substantial portions of the Software.
21
22	THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
25	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28	THE SOFTWARE.
29	*/
30	'use strict';
31
32	// ------------------------------------------------------------------------------
33	// Rule Definition
34	// ------------------------------------------------------------------------------
35	module.exports = {	7✔
36	meta: {
37	docs: {
38	description: 'Validate JSX indentation',
39	category: 'Stylistic Issues',
40	recommended: false
41	},
42	fixable: 'whitespace',
43	schema: [{
44	oneOf: [{
45	enum: ['tab']
46	}, {
47	type: 'integer'
48	}]
49	}]
50	},
51
52	create: function(context) {
53
54	var MESSAGE = 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.';	483✔
55
56	var extraColumnStart = 0;	483✔
57	var indentType = 'space';	483✔
58	var indentSize = 4;	483✔
59
60	var sourceCode = context.getSourceCode();	483✔
61
62	if (context.options.length) {	483✔
63	if (context.options[0] === 'tab') {	182✔
64	indentSize = 1;	42✔
65	indentType = 'tab';	42✔
66	} else if (typeof context.options[0] === 'number') {	140✔
67	indentSize = context.options[0];	140✔
68	indentType = 'space';	140✔
69	}
70	}
71
72	var indentChar = indentType === 'space' ? ' ' : '\t';	483✔
73
74	/**
75	* Responsible for fixing the indentation issue fix
76	* @param {ASTNode} node Node violating the indent rule
77	* @param {Number} needed Expected indentation character count
78	* @returns {Function} function to be executed by the fixer
79	* @private
80	*/
81	function getFixerFunction(node, needed) {	7✔
82	return function(fixer) {	231✔
83	var indent = Array(needed + 1).join(indentChar);	231✔
84	return fixer.replaceTextRange(	231✔
85	[node.start - node.loc.start.column, node.start],
86	indent
87	);
88	};
89	}
90
91	/**
92	* Reports a given indent violation and properly pluralizes the message
93	* @param {ASTNode} node Node violating the indent rule
94	* @param {Number} needed Expected indentation character count
95	* @param {Number} gotten Indentation character count in the actual node/code
96	* @param {Object} loc Error line and column location
97	*/
98	function report(node, needed, gotten, loc) {	7✔
99	var msgContext = {	231✔
100	needed: needed,
101	type: indentType,
102	characters: needed === 1 ? 'character' : 'characters',
103	gotten: gotten
104	};
105
106	if (loc) {	231✔
107	context.report({	×
108	node: node,
109	loc: loc,
110	message: MESSAGE,
111	data: msgContext,
112	fix: getFixerFunction(node, needed)
113	});
114	} else {
115	context.report({	231✔
116	node: node,
117	message: MESSAGE,
118	data: msgContext,
119	fix: getFixerFunction(node, needed)
120	});
121	}
122	}
123
124	/**
125	* Get node indent
126	* @param {ASTNode} node Node to examine
127	* @param {Boolean} byLastLine get indent of node's last line
128	* @param {Boolean} excludeCommas skip comma on start of line
129	* @return {Number} Indent
130	*/
131	function getNodeIndent(node, byLastLine, excludeCommas) {	7✔
132	byLastLine = byLastLine \|\| false;	2,422✔
133	excludeCommas = excludeCommas \|\| false;	2,422✔
134
135	var src = sourceCode.getText(node, node.loc.start.column + extraColumnStart);	2,422✔
136	var lines = src.split('\n');	2,422✔
137	if (byLastLine) {	2,422✔
138	src = lines[lines.length - 1];	×
139	} else {
140	src = lines[0];	2,422✔
141	}
142
143	var skip = excludeCommas ? ',' : '';	2,422✔
144
145	var regExp;	2,422✔
146	if (indentType === 'space') {	2,422✔
147	regExp = new RegExp('^[ ' + skip + ']+');	2,184✔
148	} else {
149	regExp = new RegExp('^[\t' + skip + ']+');	238✔
150	}
151
152	var indent = regExp.exec(src);	2,422✔
153	return indent ? indent[0].length : 0;	2,422✔
154	}
155
156	/**
157	* Checks node is the first in its own start line. By default it looks by start line.
158	* @param {ASTNode} node The node to check
159	* @return {Boolean} true if its the first in the its start line
160	*/
161	function isNodeFirstInLine(node) {	7✔
162	var token = node;	301✔
163	do {	301✔
164	token = sourceCode.getTokenBefore(token);	385✔
165	} while (token.type === 'JSXText' && /^\s*$/.test(token.value));
166	var startLine = node.loc.start.line;	301✔
167	var endLine = token ? token.loc.end.line : -1;	301✔
168
169	return startLine !== endLine;	301✔
170	}
171
172	/**
173	* Check if the node is the right member of a logical expression
174	* @param {ASTNode} node The node to check
175	* @return {Boolean} true if its the case, false if not
176	*/
177	function isRightInLogicalExp(node) {	7✔
178	return (	1,904✔
179	node.parent &&
180	node.parent.parent &&
181	node.parent.parent.type === 'LogicalExpression' &&
182	node.parent.parent.right === node.parent
183	);
184	}
185
186	/**
187	* Check if the node is the alternate member of a conditional expression
188	* @param {ASTNode} node The node to check
189	* @return {Boolean} true if its the case, false if not
190	*/
191	function isAlternateInConditionalExp(node) {	7✔
192	return (	1,876✔
193	node.parent &&
194	node.parent.parent &&
195	node.parent.parent.type === 'ConditionalExpression' &&
196	node.parent.parent.alternate === node.parent &&
197	sourceCode.getTokenBefore(node).value !== '('
198	);
199	}
200
201	/**
202	* Check indent for nodes list
203	* @param {ASTNode} node The node to check
204	* @param {Number} indent needed indent
205	* @param {Boolean} excludeCommas skip comma on start of line
206	*/
207	function checkNodesIndent(node, indent, excludeCommas) {	7✔
208	var nodeIndent = getNodeIndent(node, false, excludeCommas);	1,211✔
209	var isCorrectRightInLogicalExp = isRightInLogicalExp(node) && (nodeIndent - indent) === indentSize;	1,211✔
210	var isCorrectAlternateInCondExp = isAlternateInConditionalExp(node) && (nodeIndent - indent) === 0;	1,211✔
211	if (	1,211✔
212	nodeIndent !== indent &&
213	isNodeFirstInLine(node) &&
214	!isCorrectRightInLogicalExp &&
215	!isCorrectAlternateInCondExp
216	) {
217	report(node, indent, nodeIndent);	231✔
218	}
219	}
220
221	return {	483✔
222	JSXOpeningElement: function(node) {
223	var prevToken = sourceCode.getTokenBefore(node);	952✔
224	if (!prevToken) {	952✔
225	return;	147✔
226	}
227	// Use the parent in a list or an array
228	if (prevToken.type === 'JSXText' \|\| prevToken.type === 'Punctuator' && prevToken.value === ',') {	805✔
229	prevToken = sourceCode.getNodeByRangeIndex(prevToken.start);	196✔
230	prevToken = prevToken.type === 'Literal' ? prevToken.parent : prevToken;	196✔
231	// Use the first non-punctuator token in a conditional expression
232	} else if (prevToken.type === 'Punctuator' && prevToken.value === ':') {	609✔
233	do {	112✔
234	prevToken = sourceCode.getTokenBefore(prevToken);	378✔
235	} while (prevToken.type === 'Punctuator');
236	prevToken = sourceCode.getNodeByRangeIndex(prevToken.start);	112✔
237	while (prevToken.parent && prevToken.parent.type !== 'ConditionalExpression') {	112✔
238	prevToken = prevToken.parent;	245✔
239	}
240	}
241	prevToken = prevToken.type === 'JSXExpressionContainer' ? prevToken.expression : prevToken;	805✔
242
243	var parentElementIndent = getNodeIndent(prevToken);	805✔
244	var indent = (	805✔
245	prevToken.loc.start.line === node.loc.start.line \|\|
246	isRightInLogicalExp(node) \|\|
247	isAlternateInConditionalExp(node)
248	) ? 0 : indentSize;
249	checkNodesIndent(node, parentElementIndent + indent);	805✔
250	},
251	JSXClosingElement: function(node) {
252	if (!node.parent) {	259✔
253	return;	×
254	}
255	var peerElementIndent = getNodeIndent(node.parent.openingElement);	259✔
256	checkNodesIndent(node, peerElementIndent);	259✔
257	},
258	JSXExpressionContainer: function(node) {
259	if (!node.parent) {	147✔
260	return;	×
261	}
262	var parentNodeIndent = getNodeIndent(node.parent);	147✔
263	checkNodesIndent(node, parentNodeIndent + indentSize);	147✔
264	}
265	};
266
267	}
268	};

yannickcr / eslint-plugin-react / 1622

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous