--- /dev/null
+/**
+ * @fileoverview Rule to specify spacing of object literal keys and values
+ * @author Brandon Mills
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether a string contains a line terminator as defined in
+ * http://www.ecma-international.org/ecma-262/5.1/#sec-7.3
+ * @param {string} str String to test.
+ * @returns {boolean} True if str contains a line terminator.
+ */
+function containsLineTerminator(str) {
+ return astUtils.LINEBREAK_MATCHER.test(str);
+}
+
+/**
+ * Gets the last element of an array.
+ * @param {Array} arr An array.
+ * @returns {any} Last element of arr.
+ */
+function last(arr) {
+ return arr[arr.length - 1];
+}
+
+/**
+ * Checks whether a node is contained on a single line.
+ * @param {ASTNode} node AST Node being evaluated.
+ * @returns {boolean} True if the node is a single line.
+ */
+function isSingleLine(node) {
+ return (node.loc.end.line === node.loc.start.line);
+}
+
+/**
+ * Checks whether the properties on a single line.
+ * @param {ASTNode[]} properties List of Property AST nodes.
+ * @returns {boolean} True if all properies is on a single line.
+ */
+function isSingleLineProperties(properties) {
+ const [firstProp] = properties,
+ lastProp = last(properties);
+
+ return firstProp.loc.start.line === lastProp.loc.end.line;
+}
+
+/**
+ * Initializes a single option property from the configuration with defaults for undefined values
+ * @param {Object} toOptions Object to be initialized
+ * @param {Object} fromOptions Object to be initialized from
+ * @returns {Object} The object with correctly initialized options and values
+ */
+function initOptionProperty(toOptions, fromOptions) {
+ toOptions.mode = fromOptions.mode || "strict";
+
+ // Set value of beforeColon
+ if (typeof fromOptions.beforeColon !== "undefined") {
+ toOptions.beforeColon = +fromOptions.beforeColon;
+ } else {
+ toOptions.beforeColon = 0;
+ }
+
+ // Set value of afterColon
+ if (typeof fromOptions.afterColon !== "undefined") {
+ toOptions.afterColon = +fromOptions.afterColon;
+ } else {
+ toOptions.afterColon = 1;
+ }
+
+ // Set align if exists
+ if (typeof fromOptions.align !== "undefined") {
+ if (typeof fromOptions.align === "object") {
+ toOptions.align = fromOptions.align;
+ } else { // "string"
+ toOptions.align = {
+ on: fromOptions.align,
+ mode: toOptions.mode,
+ beforeColon: toOptions.beforeColon,
+ afterColon: toOptions.afterColon
+ };
+ }
+ }
+
+ return toOptions;
+}
+
+/**
+ * Initializes all the option values (singleLine, multiLine and align) from the configuration with defaults for undefined values
+ * @param {Object} toOptions Object to be initialized
+ * @param {Object} fromOptions Object to be initialized from
+ * @returns {Object} The object with correctly initialized options and values
+ */
+function initOptions(toOptions, fromOptions) {
+ if (typeof fromOptions.align === "object") {
+
+ // Initialize the alignment configuration
+ toOptions.align = initOptionProperty({}, fromOptions.align);
+ toOptions.align.on = fromOptions.align.on || "colon";
+ toOptions.align.mode = fromOptions.align.mode || "strict";
+
+ toOptions.multiLine = initOptionProperty({}, (fromOptions.multiLine || fromOptions));
+ toOptions.singleLine = initOptionProperty({}, (fromOptions.singleLine || fromOptions));
+
+ } else { // string or undefined
+ toOptions.multiLine = initOptionProperty({}, (fromOptions.multiLine || fromOptions));
+ toOptions.singleLine = initOptionProperty({}, (fromOptions.singleLine || fromOptions));
+
+ // If alignment options are defined in multiLine, pull them out into the general align configuration
+ if (toOptions.multiLine.align) {
+ toOptions.align = {
+ on: toOptions.multiLine.align.on,
+ mode: toOptions.multiLine.align.mode || toOptions.multiLine.mode,
+ beforeColon: toOptions.multiLine.align.beforeColon,
+ afterColon: toOptions.multiLine.align.afterColon
+ };
+ }
+ }
+
+ return toOptions;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+ meta: {
+ type: "layout",
+
+ docs: {
+ description: "enforce consistent spacing between keys and values in object literal properties",
+ category: "Stylistic Issues",
+ recommended: false,
+ url: "https://eslint.org/docs/rules/key-spacing"
+ },
+
+ fixable: "whitespace",
+
+ schema: [{
+ anyOf: [
+ {
+ type: "object",
+ properties: {
+ align: {
+ anyOf: [
+ {
+ enum: ["colon", "value"]
+ },
+ {
+ type: "object",
+ properties: {
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ on: {
+ enum: ["colon", "value"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ }
+ ]
+ },
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ },
+ {
+ type: "object",
+ properties: {
+ singleLine: {
+ type: "object",
+ properties: {
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ },
+ multiLine: {
+ type: "object",
+ properties: {
+ align: {
+ anyOf: [
+ {
+ enum: ["colon", "value"]
+ },
+ {
+ type: "object",
+ properties: {
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ on: {
+ enum: ["colon", "value"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ }
+ ]
+ },
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ }
+ },
+ additionalProperties: false
+ },
+ {
+ type: "object",
+ properties: {
+ singleLine: {
+ type: "object",
+ properties: {
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ },
+ multiLine: {
+ type: "object",
+ properties: {
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ },
+ align: {
+ type: "object",
+ properties: {
+ mode: {
+ enum: ["strict", "minimum"]
+ },
+ on: {
+ enum: ["colon", "value"]
+ },
+ beforeColon: {
+ type: "boolean"
+ },
+ afterColon: {
+ type: "boolean"
+ }
+ },
+ additionalProperties: false
+ }
+ },
+ additionalProperties: false
+ }
+ ]
+ }],
+ messages: {
+ extraKey: "Extra space after {{computed}}key '{{key}}'.",
+ extraValue: "Extra space before value for {{computed}}key '{{key}}'.",
+ missingKey: "Missing space after {{computed}}key '{{key}}'.",
+ missingValue: "Missing space before value for {{computed}}key '{{key}}'."
+ }
+ },
+
+ create(context) {
+
+ /**
+ * OPTIONS
+ * "key-spacing": [2, {
+ * beforeColon: false,
+ * afterColon: true,
+ * align: "colon" // Optional, or "value"
+ * }
+ */
+ const options = context.options[0] || {},
+ ruleOptions = initOptions({}, options),
+ multiLineOptions = ruleOptions.multiLine,
+ singleLineOptions = ruleOptions.singleLine,
+ alignmentOptions = ruleOptions.align || null;
+
+ const sourceCode = context.getSourceCode();
+
+ /**
+ * Checks whether a property is a member of the property group it follows.
+ * @param {ASTNode} lastMember The last Property known to be in the group.
+ * @param {ASTNode} candidate The next Property that might be in the group.
+ * @returns {boolean} True if the candidate property is part of the group.
+ */
+ function continuesPropertyGroup(lastMember, candidate) {
+ const groupEndLine = lastMember.loc.start.line,
+ candidateStartLine = candidate.loc.start.line;
+
+ if (candidateStartLine - groupEndLine <= 1) {
+ return true;
+ }
+
+ /*
+ * Check that the first comment is adjacent to the end of the group, the
+ * last comment is adjacent to the candidate property, and that successive
+ * comments are adjacent to each other.
+ */
+ const leadingComments = sourceCode.getCommentsBefore(candidate);
+
+ if (
+ leadingComments.length &&
+ leadingComments[0].loc.start.line - groupEndLine <= 1 &&
+ candidateStartLine - last(leadingComments).loc.end.line <= 1
+ ) {
+ for (let i = 1; i < leadingComments.length; i++) {
+ if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Determines if the given property is key-value property.
+ * @param {ASTNode} property Property node to check.
+ * @returns {boolean} Whether the property is a key-value property.
+ */
+ function isKeyValueProperty(property) {
+ return !(
+ (property.method ||
+ property.shorthand ||
+ property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
+ );
+ }
+
+ /**
+ * Starting from the given a node (a property.key node here) looks forward
+ * until it finds the last token before a colon punctuator and returns it.
+ * @param {ASTNode} node The node to start looking from.
+ * @returns {ASTNode} The last token before a colon punctuator.
+ */
+ function getLastTokenBeforeColon(node) {
+ const colonToken = sourceCode.getTokenAfter(node, astUtils.isColonToken);
+
+ return sourceCode.getTokenBefore(colonToken);
+ }
+
+ /**
+ * Starting from the given a node (a property.key node here) looks forward
+ * until it finds the colon punctuator and returns it.
+ * @param {ASTNode} node The node to start looking from.
+ * @returns {ASTNode} The colon punctuator.
+ */
+ function getNextColon(node) {
+ return sourceCode.getTokenAfter(node, astUtils.isColonToken);
+ }
+
+ /**
+ * Gets an object literal property's key as the identifier name or string value.
+ * @param {ASTNode} property Property node whose key to retrieve.
+ * @returns {string} The property's key.
+ */
+ function getKey(property) {
+ const key = property.key;
+
+ if (property.computed) {
+ return sourceCode.getText().slice(key.range[0], key.range[1]);
+ }
+
+ return property.key.name || property.key.value;
+ }
+
+ /**
+ * Reports an appropriately-formatted error if spacing is incorrect on one
+ * side of the colon.
+ * @param {ASTNode} property Key-value pair in an object literal.
+ * @param {string} side Side being verified - either "key" or "value".
+ * @param {string} whitespace Actual whitespace string.
+ * @param {int} expected Expected whitespace length.
+ * @param {string} mode Value of the mode as "strict" or "minimum"
+ * @returns {void}
+ */
+ function report(property, side, whitespace, expected, mode) {
+ const diff = whitespace.length - expected,
+ nextColon = getNextColon(property.key),
+ tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { includeComments: true }),
+ tokenAfterColon = sourceCode.getTokenAfter(nextColon, { includeComments: true }),
+ isKeySide = side === "key",
+ locStart = isKeySide ? tokenBeforeColon.loc.start : tokenAfterColon.loc.start,
+ isExtra = diff > 0,
+ diffAbs = Math.abs(diff),
+ spaces = Array(diffAbs + 1).join(" ");
+
+ if ((
+ diff && mode === "strict" ||
+ diff < 0 && mode === "minimum" ||
+ diff > 0 && !expected && mode === "minimum") &&
+ !(expected && containsLineTerminator(whitespace))
+ ) {
+ let fix;
+
+ if (isExtra) {
+ let range;
+
+ // Remove whitespace
+ if (isKeySide) {
+ range = [tokenBeforeColon.range[1], tokenBeforeColon.range[1] + diffAbs];
+ } else {
+ range = [tokenAfterColon.range[0] - diffAbs, tokenAfterColon.range[0]];
+ }
+ fix = function(fixer) {
+ return fixer.removeRange(range);
+ };
+ } else {
+
+ // Add whitespace
+ if (isKeySide) {
+ fix = function(fixer) {
+ return fixer.insertTextAfter(tokenBeforeColon, spaces);
+ };
+ } else {
+ fix = function(fixer) {
+ return fixer.insertTextBefore(tokenAfterColon, spaces);
+ };
+ }
+ }
+
+ let messageId = "";
+
+ if (isExtra) {
+ messageId = side === "key" ? "extraKey" : "extraValue";
+ } else {
+ messageId = side === "key" ? "missingKey" : "missingValue";
+ }
+
+ context.report({
+ node: property[side],
+ loc: locStart,
+ messageId,
+ data: {
+ computed: property.computed ? "computed " : "",
+ key: getKey(property)
+ },
+ fix
+ });
+ }
+ }
+
+ /**
+ * Gets the number of characters in a key, including quotes around string
+ * keys and braces around computed property keys.
+ * @param {ASTNode} property Property of on object literal.
+ * @returns {int} Width of the key.
+ */
+ function getKeyWidth(property) {
+ const startToken = sourceCode.getFirstToken(property);
+ const endToken = getLastTokenBeforeColon(property.key);
+
+ return endToken.range[1] - startToken.range[0];
+ }
+
+ /**
+ * Gets the whitespace around the colon in an object literal property.
+ * @param {ASTNode} property Property node from an object literal.
+ * @returns {Object} Whitespace before and after the property's colon.
+ */
+ function getPropertyWhitespace(property) {
+ const whitespace = /(\s*):(\s*)/u.exec(sourceCode.getText().slice(
+ property.key.range[1], property.value.range[0]
+ ));
+
+ if (whitespace) {
+ return {
+ beforeColon: whitespace[1],
+ afterColon: whitespace[2]
+ };
+ }
+ return null;
+ }
+
+ /**
+ * Creates groups of properties.
+ * @param {ASTNode} node ObjectExpression node being evaluated.
+ * @returns {Array.<ASTNode[]>} Groups of property AST node lists.
+ */
+ function createGroups(node) {
+ if (node.properties.length === 1) {
+ return [node.properties];
+ }
+
+ return node.properties.reduce((groups, property) => {
+ const currentGroup = last(groups),
+ prev = last(currentGroup);
+
+ if (!prev || continuesPropertyGroup(prev, property)) {
+ currentGroup.push(property);
+ } else {
+ groups.push([property]);
+ }
+
+ return groups;
+ }, [
+ []
+ ]);
+ }
+
+ /**
+ * Verifies correct vertical alignment of a group of properties.
+ * @param {ASTNode[]} properties List of Property AST nodes.
+ * @returns {void}
+ */
+ function verifyGroupAlignment(properties) {
+ const length = properties.length,
+ widths = properties.map(getKeyWidth), // Width of keys, including quotes
+ align = alignmentOptions.on; // "value" or "colon"
+ let targetWidth = Math.max(...widths),
+ beforeColon, afterColon, mode;
+
+ if (alignmentOptions && length > 1) { // When aligning values within a group, use the alignment configuration.
+ beforeColon = alignmentOptions.beforeColon;
+ afterColon = alignmentOptions.afterColon;
+ mode = alignmentOptions.mode;
+ } else {
+ beforeColon = multiLineOptions.beforeColon;
+ afterColon = multiLineOptions.afterColon;
+ mode = alignmentOptions.mode;
+ }
+
+ // Conditionally include one space before or after colon
+ targetWidth += (align === "colon" ? beforeColon : afterColon);
+
+ for (let i = 0; i < length; i++) {
+ const property = properties[i];
+ const whitespace = getPropertyWhitespace(property);
+
+ if (whitespace) { // Object literal getters/setters lack a colon
+ const width = widths[i];
+
+ if (align === "value") {
+ report(property, "key", whitespace.beforeColon, beforeColon, mode);
+ report(property, "value", whitespace.afterColon, targetWidth - width, mode);
+ } else { // align = "colon"
+ report(property, "key", whitespace.beforeColon, targetWidth - width, mode);
+ report(property, "value", whitespace.afterColon, afterColon, mode);
+ }
+ }
+ }
+ }
+
+ /**
+ * Verifies spacing of property conforms to specified options.
+ * @param {ASTNode} node Property node being evaluated.
+ * @param {Object} lineOptions Configured singleLine or multiLine options
+ * @returns {void}
+ */
+ function verifySpacing(node, lineOptions) {
+ const actual = getPropertyWhitespace(node);
+
+ if (actual) { // Object literal getters/setters lack colons
+ report(node, "key", actual.beforeColon, lineOptions.beforeColon, lineOptions.mode);
+ report(node, "value", actual.afterColon, lineOptions.afterColon, lineOptions.mode);
+ }
+ }
+
+ /**
+ * Verifies spacing of each property in a list.
+ * @param {ASTNode[]} properties List of Property AST nodes.
+ * @param {Object} lineOptions Configured singleLine or multiLine options
+ * @returns {void}
+ */
+ function verifyListSpacing(properties, lineOptions) {
+ const length = properties.length;
+
+ for (let i = 0; i < length; i++) {
+ verifySpacing(properties[i], lineOptions);
+ }
+ }
+
+ /**
+ * Verifies vertical alignment, taking into account groups of properties.
+ * @param {ASTNode} node ObjectExpression node being evaluated.
+ * @returns {void}
+ */
+ function verifyAlignment(node) {
+ createGroups(node).forEach(group => {
+ const properties = group.filter(isKeyValueProperty);
+
+ if (properties.length > 0 && isSingleLineProperties(properties)) {
+ verifyListSpacing(properties, multiLineOptions);
+ } else {
+ verifyGroupAlignment(properties);
+ }
+ });
+ }
+
+ //--------------------------------------------------------------------------
+ // Public API
+ //--------------------------------------------------------------------------
+
+ if (alignmentOptions) { // Verify vertical alignment
+
+ return {
+ ObjectExpression(node) {
+ if (isSingleLine(node)) {
+ verifyListSpacing(node.properties.filter(isKeyValueProperty), singleLineOptions);
+ } else {
+ verifyAlignment(node);
+ }
+ }
+ };
+
+ }
+
+ // Obey beforeColon and afterColon in each property as configured
+ return {
+ Property(node) {
+ verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);
+ }
+ };
+
+
+ }
+};
projects / dotfiles / .git / blobdiff