eslint-plugin-standard - npm Package Compare versions

Comparing version 1.3.3 to 2.0.0

package.json

 {
   "name": "eslint-plugin-standard",
   "description": "ESlint Plugin for the Standard Linter",
-  "version": "1.3.3",
+  "version": "2.0.0",
   "author": "Jamund Ferguson <[e-mail]>",
@@ -6,0 +6,0 @@ "bugs": {

rules/array-bracket-even-spacing.js

@@ -0,1 +1,3 @@
+'use strict'
+
 /**
@@ -9,4 +11,2 @@ * @fileoverview Disallows or enforces spaces inside of array brackets.
  */
-'use strict'
-
 // ------------------------------------------------------------------------------
@@ -16,176 +16,182 @@ // Rule Definition
 
-module.exports = function (context) {
-  var spaced = context.options[0] === 'always'
-  var either = context.options[0] === 'either'
+module.exports = {
+  meta: {
+    docs: {}
+  },
 
-  /**
-   * Determines whether an option is set, relative to the spacing option.
-   * If spaced is "always", then check whether option is set to false.
-   * If spaced is "never", then check whether option is set to true.
-   * @param {Object} option - The option to exclude.
-   * @returns {boolean} Whether or not the property is excluded.
-   */
-  function isOptionSet (option) {
-    return context.options[1] != null ? context.options[1][option] === !spaced : false
-  }
+  create: function (context) {
+    var spaced = context.options[0] === 'always'
+    var either = context.options[0] === 'either'
 
-  var options = {
-    either: either,
-    spaced: spaced,
-    singleElementException: isOptionSet('singleValue'),
-    objectsInArraysException: isOptionSet('objectsInArrays'),
-    arraysInArraysException: isOptionSet('arraysInArrays')
-  }
+    /**
+     * Determines whether an option is set, relative to the spacing option.
+     * If spaced is "always", then check whether option is set to false.
+     * If spaced is "never", then check whether option is set to true.
+     * @param {Object} option - The option to exclude.
+     * @returns {boolean} Whether or not the property is excluded.
+     */
+    function isOptionSet (option) {
+      return context.options[1] != null ? context.options[1][option] === !spaced : false
+    }
 
-  // --------------------------------------------------------------------------
-  // Helpers
-  // --------------------------------------------------------------------------
+    var options = {
+      either: either,
+      spaced: spaced,
+      singleElementException: isOptionSet('singleValue'),
+      objectsInArraysException: isOptionSet('objectsInArrays'),
+      arraysInArraysException: isOptionSet('arraysInArrays')
+    }
 
-  /**
-   * Determines whether two adjacent tokens are have whitespace between them.
-   * @param {Object} left - The left token object.
-   * @param {Object} right - The right token object.
-   * @returns {boolean} Whether or not there is space between the tokens.
-   */
-  function isSpaced (left, right) {
-    return left.range[1] < right.range[0]
-  }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
 
-  /**
-   * Determines whether two adjacent tokens are on the same line.
-   * @param {Object} left - The left token object.
-   * @param {Object} right - The right token object.
-   * @returns {boolean} Whether or not the tokens are on the same line.
-   */
-  function isSameLine (left, right) {
-    return left.loc.start.line === right.loc.start.line
-  }
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced (left, right) {
+      return left.range[1] < right.range[0]
+    }
 
-  /**
-   * Reports that there shouldn't be a space after the first token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportNoBeginningSpace (node, token) {
-    context.report(node, token.loc.start,
-      "There should be no space after '" + token.value + "'")
-  }
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine (left, right) {
+      return left.loc.start.line === right.loc.start.line
+    }
 
-  /**
-   * Reports that there shouldn't be a space before the last token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportNoEndingSpace (node, token) {
-    context.report(node, token.loc.start,
-      "There should be no space before '" + token.value + "'")
-  }
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space after '" + token.value + "'")
+    }
 
-  /**
-   * Reports that there should be a space after the first token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportRequiredBeginningSpace (node, token) {
-    context.report(node, token.loc.start,
-      "A space is required after '" + token.value + "'")
-  }
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space before '" + token.value + "'")
+    }
 
-  /**
-   * Reports that there should be a space before the last token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportRequiredEndingSpace (node, token) {
-    context.report(node, token.loc.start,
-      "A space is required before '" + token.value + "'")
-  }
+    /**
+     * Reports that there should be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required after '" + token.value + "'")
+    }
 
-  /**
-   * Checks if a start and end brace in a node are spaced evenly
-   * and not too long (>1 space)
-   * @param node
-   * @param start
-   * @param end
-   * @returns {boolean}
-   */
-  function isEvenlySpacedAndNotTooLong (node, start, end) {
-    var expectedSpace = start[1].range[0] - start[0].range[1]
-    var endSpace = end[1].range[0] - end[0].range[1]
-    return endSpace === expectedSpace && endSpace <= 1
-  }
+    /**
+     * Reports that there should be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required before '" + token.value + "'")
+    }
 
-  /**
-   * Validates the spacing around array brackets
-   * @param {ASTNode} node - The node we're checking for spacing
-   * @returns {void}
-   */
-  function validateArraySpacing (node) {
-    if (node.elements.length === 0) {
-      return
+    /**
+     * Checks if a start and end brace in a node are spaced evenly
+     * and not too long (>1 space)
+     * @param node
+     * @param start
+     * @param end
+     * @returns {boolean}
+     */
+    function isEvenlySpacedAndNotTooLong (node, start, end) {
+      var expectedSpace = start[1].range[0] - start[0].range[1]
+      var endSpace = end[1].range[0] - end[0].range[1]
+      return endSpace === expectedSpace && endSpace <= 1
     }
 
-    var first = context.getFirstToken(node)
-    var second = context.getFirstToken(node, 1)
-    var penultimate = context.getLastToken(node, 1)
-    var last = context.getLastToken(node)
+    /**
+     * Validates the spacing around array brackets
+     * @param {ASTNode} node - The node we're checking for spacing
+     * @returns {void}
+     */
+    function validateArraySpacing (node) {
+      if (node.elements.length === 0) {
+        return
+      }
 
-    var openingBracketMustBeSpaced =
-    options.objectsInArraysException && second.value === '{' ||
-    options.arraysInArraysException && second.value === '[' ||
-    options.singleElementException && node.elements.length === 1
-      ? !options.spaced : options.spaced
+      var first = context.getFirstToken(node)
+      var second = context.getFirstToken(node, 1)
+      var penultimate = context.getLastToken(node, 1)
+      var last = context.getLastToken(node)
 
-    var closingBracketMustBeSpaced =
-    options.objectsInArraysException && penultimate.value === '}' ||
-    options.arraysInArraysException && penultimate.value === ']' ||
-    options.singleElementException && node.elements.length === 1
-      ? !options.spaced : options.spaced
+      var openingBracketMustBeSpaced =
+      options.objectsInArraysException && second.value === '{' ||
+      options.arraysInArraysException && second.value === '[' ||
+      options.singleElementException && node.elements.length === 1
+        ? !options.spaced : options.spaced
 
-    // we only care about evenly spaced things
-    if (options.either) {
-      // newlines at any point means return
-      if (!isSameLine(first, last)) {
-        return
-      }
+      var closingBracketMustBeSpaced =
+      options.objectsInArraysException && penultimate.value === '}' ||
+      options.arraysInArraysException && penultimate.value === ']' ||
+      options.singleElementException && node.elements.length === 1
+        ? !options.spaced : options.spaced
 
-      // confirm that the object expression/literal is spaced evenly
-      if (!isEvenlySpacedAndNotTooLong(node, [first, second], [penultimate, last])) {
-        context.report(node, 'Expected consistent spacing')
-      }
+      // we only care about evenly spaced things
+      if (options.either) {
+        // newlines at any point means return
+        if (!isSameLine(first, last)) {
+          return
+        }
 
-      return
-    }
+        // confirm that the object expression/literal is spaced evenly
+        if (!isEvenlySpacedAndNotTooLong(node, [first, second], [penultimate, last])) {
+          context.report(node, 'Expected consistent spacing')
+        }
 
-    if (isSameLine(first, second)) {
-      if (openingBracketMustBeSpaced && !isSpaced(first, second)) {
-        reportRequiredBeginningSpace(node, first)
+        return
       }
-      if (!openingBracketMustBeSpaced && isSpaced(first, second)) {
-        reportNoBeginningSpace(node, first)
+
+      if (isSameLine(first, second)) {
+        if (openingBracketMustBeSpaced && !isSpaced(first, second)) {
+          reportRequiredBeginningSpace(node, first)
+        }
+        if (!openingBracketMustBeSpaced && isSpaced(first, second)) {
+          reportNoBeginningSpace(node, first)
+        }
       }
-    }
 
-    if (isSameLine(penultimate, last)) {
-      if (closingBracketMustBeSpaced && !isSpaced(penultimate, last)) {
-        reportRequiredEndingSpace(node, last)
+      if (isSameLine(penultimate, last)) {
+        if (closingBracketMustBeSpaced && !isSpaced(penultimate, last)) {
+          reportRequiredEndingSpace(node, last)
+        }
+        if (!closingBracketMustBeSpaced && isSpaced(penultimate, last)) {
+          reportNoEndingSpace(node, last)
+        }
       }
-      if (!closingBracketMustBeSpaced && isSpaced(penultimate, last)) {
-        reportNoEndingSpace(node, last)
-      }
     }
-  }
 
-  // --------------------------------------------------------------------------
-  // Public
-  // --------------------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
 
-  return {
-    ArrayPattern: validateArraySpacing,
-    ArrayExpression: validateArraySpacing
+    return {
+      ArrayPattern: validateArraySpacing,
+      ArrayExpression: validateArraySpacing
+    }
   }
 }

rules/computed-property-even-spacing.js

@@ -0,1 +1,3 @@
+'use strict'
+
 /**
@@ -6,4 +8,2 @@ * @fileoverview Disallows or enforces spaces inside computed properties.
  */
-'use strict'
-
 // ------------------------------------------------------------------------------
@@ -13,129 +13,135 @@ // Rule Definition
 
-module.exports = function (context) {
-  var propertyNameMustBeSpaced = context.options[0] === 'always' // default is "never"
-  var propertyNameMustBeEven = context.options[0] === 'even' // default is "never"
+module.exports = {
+  meta: {
+    docs: {}
+  },
 
-  // --------------------------------------------------------------------------
-  // Helpers
-  // --------------------------------------------------------------------------
+  create: function (context) {
+    var propertyNameMustBeSpaced = context.options[0] === 'always' // default is "never"
+    var propertyNameMustBeEven = context.options[0] === 'even' // default is "never"
 
-  /**
-   * Determines whether two adjacent tokens are have whitespace between them.
-   * @param {Object} left - The left token object.
-   * @param {Object} right - The right token object.
-   * @returns {boolean} Whether or not there is space between the tokens.
-   */
-  function isSpaced (left, right) {
-    return left.range[1] < right.range[0]
-  }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
 
-  /**
-   * Determines whether two adjacent tokens are on the same line.
-   * @param {Object} left - The left token object.
-   * @param {Object} right - The right token object.
-   * @returns {boolean} Whether or not the tokens are on the same line.
-   */
-  function isSameLine (left, right) {
-    return left.loc.start.line === right.loc.start.line
-  }
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced (left, right) {
+      return left.range[1] < right.range[0]
+    }
 
-  /**
-   * Reports that there shouldn't be a space after the first token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportNoBeginningSpace (node, token) {
-    context.report(node, token.loc.start,
-      "There should be no space after '" + token.value + "'")
-  }
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine (left, right) {
+      return left.loc.start.line === right.loc.start.line
+    }
 
-  /**
-   * Reports that there shouldn't be a space before the last token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportNoEndingSpace (node, token) {
-    context.report(node, token.loc.start,
-      "There should be no space before '" + token.value + "'")
-  }
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space after '" + token.value + "'")
+    }
 
-  /**
-   * Reports that there should be a space after the first token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportRequiredBeginningSpace (node, token) {
-    context.report(node, token.loc.start,
-      "A space is required after '" + token.value + "'")
-  }
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space before '" + token.value + "'")
+    }
 
-  /**
-   * Reports that there should be a space before the last token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportRequiredEndingSpace (node, token) {
-    context.report(node, token.loc.start,
-      "A space is required before '" + token.value + "'")
-  }
+    /**
+     * Reports that there should be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required after '" + token.value + "'")
+    }
 
-  /**
-   * Returns a function that checks the spacing of a node on the property name
-   * that was passed in.
-   * @param {String} propertyName The property on the node to check for spacing
-   * @returns {Function} A function that will check spacing on a node
-   */
-  function checkSpacing (propertyName) {
-    return function (node) {
-      if (!node.computed) {
-        return
-      }
+    /**
+     * Reports that there should be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required before '" + token.value + "'")
+    }
 
-      var property = node[propertyName]
-
-      var before = context.getTokenBefore(property)
-      var first = context.getFirstToken(property)
-      var last = context.getLastToken(property)
-      var after = context.getTokenAfter(property)
-      var startSpace, endSpace
-
-      if (propertyNameMustBeEven) {
-        if (!isSameLine(before, after)) {
-          context.report(node, 'Expected "[" and "]" to be on the same line')
+    /**
+     * Returns a function that checks the spacing of a node on the property name
+     * that was passed in.
+     * @param {String} propertyName The property on the node to check for spacing
+     * @returns {Function} A function that will check spacing on a node
+     */
+    function checkSpacing (propertyName) {
+      return function (node) {
+        if (!node.computed) {
           return
         }
-        startSpace = first.loc.start.column - before.loc.end.column
-        endSpace = after.loc.start.column - last.loc.end.column
 
-        if (startSpace !== endSpace || startSpace > 1) {
-          context.report(node, 'Expected 1 or 0 spaces around "[" and "]"')
-        }
+        var property = node[propertyName]
 
-        return
-      }
+        var before = context.getTokenBefore(property)
+        var first = context.getFirstToken(property)
+        var last = context.getLastToken(property)
+        var after = context.getTokenAfter(property)
+        var startSpace, endSpace
 
-      if (isSameLine(before, first)) {
-        if (propertyNameMustBeSpaced) {
-          if (!isSpaced(before, first) && isSameLine(before, first)) {
-            reportRequiredBeginningSpace(node, before)
+        if (propertyNameMustBeEven) {
+          if (!isSameLine(before, after)) {
+            context.report(node, 'Expected "[" and "]" to be on the same line')
+            return
           }
-        } else {
-          if (isSpaced(before, first)) {
-            reportNoBeginningSpace(node, before)
+          startSpace = first.loc.start.column - before.loc.end.column
+          endSpace = after.loc.start.column - last.loc.end.column
+
+          if (startSpace !== endSpace || startSpace > 1) {
+            context.report(node, 'Expected 1 or 0 spaces around "[" and "]"')
           }
+
+          return
         }
-      }
 
-      if (isSameLine(last, after)) {
-        if (propertyNameMustBeSpaced) {
-          if (!isSpaced(last, after) && isSameLine(last, after)) {
-            reportRequiredEndingSpace(node, after)
+        if (isSameLine(before, first)) {
+          if (propertyNameMustBeSpaced) {
+            if (!isSpaced(before, first) && isSameLine(before, first)) {
+              reportRequiredBeginningSpace(node, before)
+            }
+          } else {
+            if (isSpaced(before, first)) {
+              reportNoBeginningSpace(node, before)
+            }
           }
-        } else {
-          if (isSpaced(last, after)) {
-            reportNoEndingSpace(node, after)
+        }
+
+        if (isSameLine(last, after)) {
+          if (propertyNameMustBeSpaced) {
+            if (!isSpaced(last, after) && isSameLine(last, after)) {
+              reportRequiredEndingSpace(node, after)
+            }
+          } else {
+            if (isSpaced(last, after)) {
+              reportNoEndingSpace(node, after)
+            }
           }
@@ -145,12 +151,12 @@ }
     }
-  }
 
-  // --------------------------------------------------------------------------
-  // Public
-  // --------------------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
 
-  return {
-    Property: checkSpacing('key'),
-    MemberExpression: checkSpacing('property')
+    return {
+      Property: checkSpacing('key'),
+      MemberExpression: checkSpacing('property')
+    }
   }
 }

rules/object-curly-even-spacing.js

@@ -0,1 +1,3 @@
+'use strict'
+
 /**
@@ -9,4 +11,2 @@ * @fileoverview Disallows or enforces spaces inside of object literals.
  */
-'use strict'
-
 // ------------------------------------------------------------------------------
@@ -16,192 +16,214 @@ // Rule Definition
 
-module.exports = function (context) {
-  var spaced = context.options[0] === 'always'
-  var either = context.options[0] === 'either'
+module.exports = {
+  meta: {
+    docs: {}
+  },
 
-  /**
-   * Determines whether an option is set, relative to the spacing option.
-   * If spaced is "always", then check whether option is set to false.
-   * If spaced is "never", then check whether option is set to true.
-   * @param {Object} option - The option to exclude.
-   * @returns {boolean} Whether or not the property is excluded.
-   */
-  function isOptionSet (option) {
-    return context.options[1] != null ? context.options[1][option] === !spaced : false
-  }
+  create: function (context) {
+    var spaced = context.options[0] === 'always'
+    var either = context.options[0] === 'either'
 
-  var options = {
-    spaced: spaced,
-    either: either,
-    arraysInObjectsException: isOptionSet('arraysInObjects'),
-    objectsInObjectsException: isOptionSet('objectsInObjects')
-  }
+    /**
+     * Determines whether an option is set, relative to the spacing option.
+     * If spaced is "always", then check whether option is set to false.
+     * If spaced is "never", then check whether option is set to true.
+     * @param {Object} option - The option to exclude.
+     * @returns {boolean} Whether or not the property is excluded.
+     */
+    function isOptionSet (option) {
+      return context.options[1] != null ? context.options[1][option] === !spaced : false
+    }
 
-  // --------------------------------------------------------------------------
-  // Helpers
-  // --------------------------------------------------------------------------
+    var options = {
+      spaced: spaced,
+      either: either,
+      arraysInObjectsException: isOptionSet('arraysInObjects'),
+      objectsInObjectsException: isOptionSet('objectsInObjects')
+    }
 
-  /**
-   * Determines whether two adjacent tokens are have whitespace between them.
-   * @param {Object} left - The left token object.
-   * @param {Object} right - The right token object.
-   * @returns {boolean} Whether or not there is space between the tokens.
-   */
-  function isSpaced (left, right) {
-    return left.range[1] < right.range[0]
-  }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
 
-  /**
-   * Determines whether two adjacent tokens are on the same line.
-   * @param {Object} left - The left token object.
-   * @param {Object} right - The right token object.
-   * @returns {boolean} Whether or not the tokens are on the same line.
-   */
-  function isSameLine (left, right) {
-    return left.loc.start.line === right.loc.start.line
-  }
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced (left, right) {
+      return left.range[1] < right.range[0]
+    }
 
-  /**
-   * Reports that there shouldn't be a space after the first token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportNoBeginningSpace (node, token) {
-    context.report(node, token.loc.start,
-      "There should be no space after '" + token.value + "'")
-  }
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine (left, right) {
+      return left.loc.start.line === right.loc.start.line
+    }
 
-  /**
-   * Reports that there shouldn't be a space before the last token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportNoEndingSpace (node, token) {
-    context.report(node, token.loc.start,
-      "There should be no space before '" + token.value + "'")
-  }
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space after '" + token.value + "'")
+    }
 
-  /**
-   * Reports that there should be a space after the first token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportRequiredBeginningSpace (node, token) {
-    context.report(node, token.loc.start,
-      "A space is required after '" + token.value + "'")
-  }
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space before '" + token.value + "'")
+    }
 
-  /**
-   * Reports that there should be a space before the last token
-   * @param {ASTNode} node - The node to report in the event of an error.
-   * @param {Token} token - The token to use for the report.
-   * @returns {void}
-   */
-  function reportRequiredEndingSpace (node, token) {
-    context.report(node, token.loc.start,
-      "A space is required before '" + token.value + "'")
-  }
+    /**
+     * Reports that there should be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required after '" + token.value + "'")
+    }
 
-  /**
-   * Checks if a start and end brace in a node are spaced evenly
-   * and not too long (>1 space)
-   * @param node
-   * @param start
-   * @param end
-   * @returns {boolean}
-   */
-  function isEvenlySpacedAndNotTooLong (node, start, end) {
-    var expectedSpace = start[1].range[0] - start[0].range[1]
-    var endSpace = end[1].range[0] - end[0].range[1]
-    return endSpace === expectedSpace && endSpace <= 1
-  }
+    /**
+     * Reports that there should be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required before '" + token.value + "'")
+    }
 
-  /**
-   * Determines if spacing in curly braces is valid.
-   * @param {ASTNode} node The AST node to check.
-   * @param {Token} first The first token to check (should be the opening brace)
-   * @param {Token} second The second token to check (should be first after the opening brace)
-   * @param {Token} penultimate The penultimate token to check (should be last before closing brace)
-   * @param {Token} last The last token to check (should be closing brace)
-   * @returns {void}
-   */
-  function validateBraceSpacing (node, first, second, penultimate, last) {
-    var closingCurlyBraceMustBeSpaced =
-    options.arraysInObjectsException && penultimate.value === ']' ||
-    options.objectsInObjectsException && penultimate.value === '}'
-      ? !options.spaced : options.spaced
+    /**
+     * Checks if a start and end brace in a node are spaced evenly
+     * and not too long (>1 space)
+     * @param node
+     * @param start
+     * @param end
+     * @returns {boolean}
+     */
+    function isEvenlySpacedAndNotTooLong (node, start, end) {
+      var expectedSpace = start[1].range[0] - start[0].range[1]
+      var endSpace = end[1].range[0] - end[0].range[1]
+      return endSpace === expectedSpace && endSpace <= 1
+    }
 
-    // we only care about evenly spaced things
-    if (options.either) {
-      // newlines at any point means return
-      if (!isSameLine(first, last)) {
-        return
-      }
+    /**
+     * Determines if spacing in curly braces is valid.
+     * @param {ASTNode} node The AST node to check.
+     * @param {Token} first The first token to check (should be the opening brace)
+     * @param {Token} second The second token to check (should be first after the opening brace)
+     * @param {Token} penultimate The penultimate token to check (should be last before closing brace)
+     * @param {Token} last The last token to check (should be closing brace)
+     * @returns {void}
+     */
+    function validateBraceSpacing (node, first, second, penultimate, last) {
+      var closingCurlyBraceMustBeSpaced =
+      options.arraysInObjectsException && penultimate.value === ']' ||
+      options.objectsInObjectsException && penultimate.value === '}'
+        ? !options.spaced : options.spaced
 
-      // confirm that the object expression/literal is spaced evenly
-      if (!isEvenlySpacedAndNotTooLong(node, [first, second], [penultimate, last])) {
-        context.report(node, 'Expected consistent spacing')
-      }
+      // we only care about evenly spaced things
+      if (options.either) {
+        // newlines at any point means return
+        if (!isSameLine(first, last)) {
+          return
+        }
 
-      return
-    }
+        // confirm that the object expression/literal is spaced evenly
+        if (!isEvenlySpacedAndNotTooLong(node, [first, second], [penultimate, last])) {
+          context.report(node, 'Expected consistent spacing')
+        }
 
-    // { and key are on same line
-    if (isSameLine(first, second)) {
-      if (options.spaced && !isSpaced(first, second)) {
-        reportRequiredBeginningSpace(node, first)
+        return
       }
-      if (!options.spaced && isSpaced(first, second)) {
-        reportNoBeginningSpace(node, first)
+
+      // { and key are on same line
+      if (isSameLine(first, second)) {
+        if (options.spaced && !isSpaced(first, second)) {
+          reportRequiredBeginningSpace(node, first)
+        }
+        if (!options.spaced && isSpaced(first, second)) {
+          reportNoBeginningSpace(node, first)
+        }
       }
-    }
 
-    // final key and } ore on the same line
-    if (isSameLine(penultimate, last)) {
-      if (closingCurlyBraceMustBeSpaced && !isSpaced(penultimate, last)) {
-        reportRequiredEndingSpace(node, last)
+      // final key and } ore on the same line
+      if (isSameLine(penultimate, last)) {
+        if (closingCurlyBraceMustBeSpaced && !isSpaced(penultimate, last)) {
+          reportRequiredEndingSpace(node, last)
+        }
+        if (!closingCurlyBraceMustBeSpaced && isSpaced(penultimate, last)) {
+          reportNoEndingSpace(node, last)
+        }
       }
-      if (!closingCurlyBraceMustBeSpaced && isSpaced(penultimate, last)) {
-        reportNoEndingSpace(node, last)
-      }
     }
-  }
 
-  // --------------------------------------------------------------------------
-  // Public
-  // --------------------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
 
-  return {
-    // var {x} = y
-    ObjectPattern: function (node) {
-      if (node.properties.length === 0) {
-        return
-      }
+    return {
+      // var {x} = y
+      ObjectPattern: function (node) {
+        if (node.properties.length === 0) {
+          return
+        }
 
-      var firstSpecifier = node.properties[0]
-      var lastSpecifier = node.properties[node.properties.length - 1]
+        var firstSpecifier = node.properties[0]
+        var lastSpecifier = node.properties[node.properties.length - 1]
 
-      var first = context.getTokenBefore(firstSpecifier)
-      var second = context.getFirstToken(firstSpecifier)
-      var penultimate = context.getLastToken(lastSpecifier)
-      var last = context.getTokenAfter(lastSpecifier)
+        var first = context.getTokenBefore(firstSpecifier)
+        var second = context.getFirstToken(firstSpecifier)
+        var penultimate = context.getLastToken(lastSpecifier)
+        var last = context.getTokenAfter(lastSpecifier)
 
-      // support trailing commas
-      if (last.value === ',') {
-        penultimate = last
-        last = context.getTokenAfter(last)
-      }
+        // support trailing commas
+        if (last.value === ',') {
+          penultimate = last
+          last = context.getTokenAfter(last)
+        }
 
-      validateBraceSpacing(node, first, second, penultimate, last)
-    },
+        validateBraceSpacing(node, first, second, penultimate, last)
+      },
 
-    // import {y} from 'x'
-    ImportDeclaration: function (node) {
-      var firstSpecifier = node.specifiers[0]
-      var lastSpecifier = node.specifiers[node.specifiers.length - 1]
+      // import {y} from 'x'
+      ImportDeclaration: function (node) {
+        var firstSpecifier = node.specifiers[0]
+        var lastSpecifier = node.specifiers[node.specifiers.length - 1]
 
-      // don't do anything for namespace or default imports
-      if (firstSpecifier && lastSpecifier && firstSpecifier.type === 'ImportSpecifier' && lastSpecifier.type === 'ImportSpecifier') {
+        // don't do anything for namespace or default imports
+        if (firstSpecifier && lastSpecifier && firstSpecifier.type === 'ImportSpecifier' && lastSpecifier.type === 'ImportSpecifier') {
+          var first = context.getTokenBefore(firstSpecifier)
+          var second = context.getFirstToken(firstSpecifier)
+          var penultimate = context.getLastToken(lastSpecifier)
+          var last = context.getTokenAfter(lastSpecifier)
+
+          validateBraceSpacing(node, first, second, penultimate, last)
+        }
+      },
+
+      // export {name} from 'yo'
+      ExportNamedDeclaration: function (node) {
+        if (!node.specifiers.length) {
+          return
+        }
+
+        var firstSpecifier = node.specifiers[0]
+        var lastSpecifier = node.specifiers[node.specifiers.length - 1]
         var first = context.getTokenBefore(firstSpecifier)
@@ -213,35 +235,19 @@ var second = context.getFirstToken(firstSpecifier)
         validateBraceSpacing(node, first, second, penultimate, last)
-      }
-    },
+      },
 
-    // export {name} from 'yo'
-    ExportNamedDeclaration: function (node) {
-      if (!node.specifiers.length) {
-        return
-      }
+      // var y = {x: 'y'}
+      ObjectExpression: function (node) {
+        if (node.properties.length === 0) {
+          return
+        }
 
-      var firstSpecifier = node.specifiers[0]
-      var lastSpecifier = node.specifiers[node.specifiers.length - 1]
-      var first = context.getTokenBefore(firstSpecifier)
-      var second = context.getFirstToken(firstSpecifier)
-      var penultimate = context.getLastToken(lastSpecifier)
-      var last = context.getTokenAfter(lastSpecifier)
+        var first = context.getFirstToken(node)
+        var second = context.getFirstToken(node, 1)
+        var penultimate = context.getLastToken(node, 1)
+        var last = context.getLastToken(node)
 
-      validateBraceSpacing(node, first, second, penultimate, last)
-    },
-
-    // var y = {x: 'y'}
-    ObjectExpression: function (node) {
-      if (node.properties.length === 0) {
-        return
+        validateBraceSpacing(node, first, second, penultimate, last)
       }
-
-      var first = context.getFirstToken(node)
-      var second = context.getFirstToken(node, 1)
-      var penultimate = context.getLastToken(node, 1)
-      var last = context.getLastToken(node)
-
-      validateBraceSpacing(node, first, second, penultimate, last)
     }
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

72252

increased by1.52%

Lines of code

1982

increased by0.76%

No dependency changes