Initial commit

node_modules/stylelint/lib/utils/whitespaceChecker.js

@@ -0,0 +1,306 @@
+"use strict"
+
+const configurationError = require("./configurationError")
+const isSingleLineString = require("./isSingleLineString")
+const isWhitespace = require("./isWhitespace")
+
+/**
+ * Create a whitespaceChecker, which exposes the following functions:
+ * - `before()`
+ * - `beforeAllowingIndentation()`
+ * - `after()`
+ * - `afterOneOnly()`
+ *
+ * @param {"space"|"newline"} targetWhitespace - This is a keyword instead
+ *   of the actual character (e.g. " ") in order to accommodate
+ *   different styles of newline ("\n" vs "\r\n")
+ * @param {
+ *     "always"|"never"
+ *     |"always-single-line"|"always-multi-line"
+ *     | "never-single-line"|"never-multi-line"
+ *   } expectation
+ * @param {object} messages - An object of message functions;
+ *   calling `before*()` or `after*()` and the `expectation` that is passed
+ *   determines which message functions are required
+ * @param {function} [messages.exectedBefore]
+ * @param {function} [messages.rejectedBefore]
+ * @param {function} [messages.expectedAfter]
+ * @param {function} [messages.rejectedAfter]
+ * @param {function} [messages.expectedBeforeSingleLine]
+ * @param {function} [messages.rejectedBeforeSingleLine]
+ * @param {function} [messages.expectedBeforeMultiLine]
+ * @param {function} [messages.rejectedBeforeMultiLine]
+ * @return {object} The checker, with its exposed checking functions
+ */
+module.exports = function (
+  targetWhitespace/*: "space" | "newline"*/,
+  expectation/*: "always" | "never" | "always-single-line"
+    | "always-multi-line" | "never-single-line"|"never-multi-line"*/,
+  messages/*: Object*/
+)/*: {
+  before: Function,
+  beforeAllowingIndentation: Function,
+  after: Function,
+  afterOneOnly: Function
+}*/ {
+  // Keep track of active arguments in order to avoid passing
+  // too much stuff around, making signatures long and confusing.
+  // This variable gets reset anytime a checking function is called.
+  let activeArgs
+
+  /**
+   * Check for whitespace *before* a character.
+   *
+   * @param {object} args - Named arguments object
+   * @param {string} args.source - The source string
+   * @param {number} args.index - The index of the character to check before
+   * @param {function} args.err - If a violation is found, this callback
+   *   will be invoked with the relevant warning message.
+   *   Typically this callback will report() the violation.
+   * @param {function} args.errTarget - If a violation is found, this string
+   *   will be sent to the relevant warning message.
+   * @param {string} [args.lineCheckStr] - Single- and multi-line checkers
+   *   will use this string to determine whether they should proceed,
+   *   i.e. if this string is one line only, single-line checkers will check,
+   *   multi-line checkers will ignore.
+   *   If none is passed, they will use `source`.
+   * @param {boolean} [args.onlyOneChar=false] - Only check *one* character before.
+   *   By default, "always-*" checks will look for the `targetWhitespace` one
+   *   before and then ensure there is no whitespace two before. This option
+   *   bypasses that second check.
+   * @param {boolean} [args.allowIndentation=false] - Allow arbitrary indentation
+   *   between the `targetWhitespace` (almost definitely a newline) and the `index`.
+   *   With this option, the checker will see if a newline *begins* the whitespace before
+   *   the `index`.
+   */
+  function before(args) {
+    const source = args.source
+    const index = args.index
+    const err = args.err
+    const errTarget = args.errTarget
+    const lineCheckStr = args.lineCheckStr
+    const onlyOneChar = args.onlyOneChar === undefined ? false : args.onlyOneChar
+    const allowIndentation = args.allowIndentation === undefined ? false : args.allowIndentation
+
+    activeArgs = { source, index, err, errTarget, onlyOneChar, allowIndentation }
+    switch (expectation) {
+      case "always":
+        expectBefore()
+        break
+      case "never":
+        rejectBefore()
+        break
+      case "always-single-line":
+        if (!isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        expectBefore(messages.expectedBeforeSingleLine)
+        break
+      case "never-single-line":
+        if (!isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        rejectBefore(messages.rejectedBeforeSingleLine)
+        break
+      case "always-multi-line":
+        if (isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        expectBefore(messages.expectedBeforeMultiLine)
+        break
+      case "never-multi-line":
+        if (isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        rejectBefore(messages.rejectedBeforeMultiLine)
+        break
+      default:
+        throw configurationError(`Unknown expectation "${expectation}"`)
+    }
+  }
+
+  /**
+   * Check for whitespace *after* a character.
+   *
+   * Parameters are pretty much the same as for `before()`, above, just substitute
+   * the word "after" for "before".
+   */
+  function after(args) {
+    const source = args.source
+    const index = args.index
+    const err = args.err
+    const errTarget = args.errTarget
+    const lineCheckStr = args.lineCheckStr
+    const onlyOneChar = args.onlyOneChar === undefined ? false : args.onlyOneChar
+
+    activeArgs = { source, index, err, errTarget, onlyOneChar }
+    switch (expectation) {
+      case "always":
+        expectAfter()
+        break
+      case "never":
+        rejectAfter()
+        break
+      case "always-single-line":
+        if (!isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        expectAfter(messages.expectedAfterSingleLine)
+        break
+      case "never-single-line":
+        if (!isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        rejectAfter(messages.rejectedAfterSingleLine)
+        break
+      case "always-multi-line":
+        if (isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        expectAfter(messages.expectedAfterMultiLine)
+        break
+      case "never-multi-line":
+        if (isSingleLineString(lineCheckStr || source)) {
+          return
+        }
+        rejectAfter(messages.rejectedAfterMultiLine)
+        break
+      default:
+        throw configurationError(`Unknown expectation "${expectation}"`)
+    }
+  }
+
+  function beforeAllowingIndentation(obj) {
+    before(Object.assign({}, obj, { allowIndentation: true }))
+  }
+
+  function expectBefore() {
+    const messageFunc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : messages.expectedBefore
+
+    if (activeArgs.allowIndentation) {
+      expectBeforeAllowingIndentation(messageFunc)
+      return
+    }
+
+    const _activeArgs = activeArgs
+    const source = _activeArgs.source,
+      index = _activeArgs.index
+
+    const oneCharBefore = source[index - 1]
+    const twoCharsBefore = source[index - 2]
+
+    if (!isValue(oneCharBefore)) {
+      return
+    }
+
+    if (targetWhitespace === "space" && oneCharBefore === " ") {
+      if (activeArgs.onlyOneChar || !isWhitespace(twoCharsBefore)) {
+        return
+      }
+    }
+
+    activeArgs.err(messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index]))
+  }
+
+  function expectBeforeAllowingIndentation() {
+    const messageFunc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : messages.expectedBefore
+    const _activeArgs2 = activeArgs
+    const source = _activeArgs2.source,
+      index = _activeArgs2.index,
+      err = _activeArgs2.err
+
+    const expectedChar = function () {
+      if (targetWhitespace === "newline") {
+        return "\n"
+      }
+    }()
+    let i = index - 1
+    while (source[i] !== expectedChar) {
+      if (source[i] === "\t" || source[i] === " ") {
+        i--
+        continue
+      }
+      err(messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index]))
+      return
+    }
+  }
+
+  function rejectBefore() {
+    const messageFunc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : messages.rejectedBefore
+    const _activeArgs3 = activeArgs
+    const source = _activeArgs3.source,
+      index = _activeArgs3.index
+
+    const oneCharBefore = source[index - 1]
+
+    if (isValue(oneCharBefore) && isWhitespace(oneCharBefore)) {
+      activeArgs.err(messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index]))
+    }
+  }
+
+  function afterOneOnly(obj) {
+    after(Object.assign({}, obj, { onlyOneChar: true }))
+  }
+
+  function expectAfter() {
+    const messageFunc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : messages.expectedAfter
+    const _activeArgs4 = activeArgs
+    const source = _activeArgs4.source,
+      index = _activeArgs4.index
+
+    const oneCharAfter = source[index + 1]
+    const twoCharsAfter = source[index + 2]
+
+    if (!isValue(oneCharAfter)) {
+      return
+    }
+
+    if (targetWhitespace === "newline") {
+      // If index is followed by a Windows CR-LF ...
+      if (oneCharAfter === "\r" && twoCharsAfter === "\n") {
+        if (activeArgs.onlyOneChar || !isWhitespace(source[index + 3])) {
+          return
+        }
+      }
+
+      // If index is followed by a Unix LF ...
+      if (oneCharAfter === "\n") {
+        if (activeArgs.onlyOneChar || !isWhitespace(twoCharsAfter)) {
+          return
+        }
+      }
+    }
+
+    if (targetWhitespace === "space" && oneCharAfter === " ") {
+      if (activeArgs.onlyOneChar || !isWhitespace(twoCharsAfter)) {
+        return
+      }
+    }
+
+    activeArgs.err(messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index]))
+  }
+
+  function rejectAfter() {
+    const messageFunc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : messages.rejectedAfter
+    const _activeArgs5 = activeArgs
+    const source = _activeArgs5.source,
+      index = _activeArgs5.index
+
+    const oneCharAfter = source[index + 1]
+
+    if (isValue(oneCharAfter) && isWhitespace(oneCharAfter)) {
+      activeArgs.err(messageFunc(activeArgs.errTarget ? activeArgs.errTarget : source[index]))
+    }
+  }
+
+  return {
+    before,
+    beforeAllowingIndentation,
+    after,
+    afterOneOnly,
+  }
+}
+
+function isValue(x) {
+  return x !== undefined && x !== null
+}