Initial commit

node_modules/stylelint/lib/assignDisabledRanges.js

@@ -0,0 +1,181 @@
+/* @flow */
+"use strict"
+const _ = require("lodash")
+
+const COMMAND_PREFIX = "stylelint-"
+const disableCommand = COMMAND_PREFIX + "disable"
+const enableCommand = COMMAND_PREFIX + "enable"
+const disableLineCommand = COMMAND_PREFIX + "disable-line"
+const disableNextLineCommand = COMMAND_PREFIX + "disable-next-line"
+const ALL_RULES = "all"
+
+/*:: type disabledRangeObject = {
+  [ruleName: string]: Array<{
+    start: number,
+    end?: number,
+  }>
+}*/
+
+// Run it like a plugin ...
+module.exports = function (
+  root/*: Object*/,
+  result/*: Object*/
+) {
+  result.stylelint = result.stylelint || {}
+
+  // Most of the functions below work via side effects mutating
+  // this object
+  const disabledRanges/*: disabledRangeObject*/ = {
+    all: [],
+  }
+  result.stylelint.disabledRanges = disabledRanges
+  root.walkComments(checkComment)
+
+  return result
+
+  function processDisableLineCommand(comment/*: postcss$comment*/) {
+    getCommandRules(disableLineCommand, comment.text).forEach(ruleName => {
+      disableLine(comment.source.start.line, ruleName, comment)
+    })
+  }
+
+  function processDisableNextLineCommand(comment/*: postcss$comment*/) {
+    getCommandRules(disableNextLineCommand, comment.text).forEach(ruleName => {
+      disableLine(comment.source.start.line + 1, ruleName, comment)
+    })
+  }
+
+  function disableLine(
+    line/*: number*/,
+    ruleName/*: string*/,
+    comment/*: postcss$comment*/
+  ) {
+    if (ruleIsDisabled(ALL_RULES)) {
+      throw comment.error("All rules have already been disabled", { plugin: "stylelint" })
+    }
+    if (ruleIsDisabled(ruleName)) {
+      throw comment.error(`"${ruleName}" has already been disabled`, { plugin: "stylelint" })
+    }
+    if (ruleName === ALL_RULES) {
+      Object.keys(disabledRanges).forEach(disabledRuleName => {
+        startDisabledRange(line, disabledRuleName)
+        endDisabledRange(line, disabledRuleName)
+      })
+    } else {
+      startDisabledRange(line, ruleName)
+      endDisabledRange(line, ruleName)
+    }
+  }
+
+  function processDisableCommand(comment/*: postcss$comment*/) {
+    getCommandRules(disableCommand, comment.text).forEach(ruleToDisable => {
+      if (ruleToDisable === ALL_RULES) {
+        if (ruleIsDisabled(ALL_RULES)) {
+          throw comment.error("All rules have already been disabled", { plugin: "stylelint" })
+        }
+        Object.keys(disabledRanges).forEach(ruleName => {
+          startDisabledRange(comment.source.start.line, ruleName)
+        })
+        return
+      }
+
+      if (ruleIsDisabled(ruleToDisable)) {
+        throw comment.error(`"${ruleToDisable}" has already been disabled`, { plugin: "stylelint" })
+      }
+      startDisabledRange(comment.source.start.line, ruleToDisable)
+    })
+  }
+
+  function processEnableCommand(comment/*: postcss$comment*/) {
+    getCommandRules(enableCommand, comment.text).forEach(ruleToEnable => {
+      if (ruleToEnable === ALL_RULES) {
+        if (_.values(disabledRanges).every(ranges => _.isEmpty(ranges) || !!_.last(ranges.end))) {
+          throw comment.error("No rules have been disabled", { plugin: "stylelint" })
+        }
+        Object.keys(disabledRanges).forEach(ruleName => {
+          if (!_.get(_.last(disabledRanges[ruleName]), "end")) {
+            endDisabledRange(comment.source.end.line, ruleName)
+          }
+        })
+        return
+      }
+
+      if (ruleIsDisabled(ALL_RULES) && disabledRanges[ruleToEnable] === undefined) {
+        // Get a starting point from the where all rules were disabled
+        if (!disabledRanges[ruleToEnable]) {
+          disabledRanges[ruleToEnable] = _.cloneDeep(disabledRanges.all)
+        } else {
+          disabledRanges[ruleToEnable].push(_.clone(_.last(disabledRanges[ALL_RULES])))
+        }
+        endDisabledRange(comment.source.end.line, ruleToEnable)
+        return
+      }
+
+      if (ruleIsDisabled(ruleToEnable)) {
+        endDisabledRange(comment.source.end.line, ruleToEnable)
+        return
+      }
+
+      throw comment.error(`"${ruleToEnable}" has not been disabled`, { plugin: "stylelint" })
+    })
+  }
+
+  function checkComment(comment/*: postcss$comment*/) {
+    const text = comment.text
+
+    // Ignore comments that are not relevant commands
+
+    if (text.indexOf(COMMAND_PREFIX) !== 0) {
+      return result
+    }
+
+    if (text.indexOf(disableLineCommand) === 0) {
+      processDisableLineCommand(comment)
+    } else if (text.indexOf(disableNextLineCommand) === 0) {
+      processDisableNextLineCommand(comment)
+    } else if (text.indexOf(disableCommand) === 0) {
+      processDisableCommand(comment)
+    } else if (text.indexOf(enableCommand) === 0) {
+      processEnableCommand(comment)
+    }
+  }
+
+  function getCommandRules(
+    command/*: string*/,
+    fullText/*: string*/
+  )/*: Array<string>*/ {
+    const rules = _.compact(fullText.slice(command.length).split(",")).map(r => r.trim())
+    if (_.isEmpty(rules)) {
+      return [ALL_RULES]
+    }
+    return rules
+  }
+
+  function startDisabledRange(line/*: number*/, ruleName/*: string*/) {
+    const rangeObj = { start: line }
+    ensureRuleRanges(ruleName)
+    disabledRanges[ruleName].push(rangeObj)
+  }
+
+  function endDisabledRange(line/*: number*/, ruleName/*: string*/) {
+    const lastRangeForRule = _.last(disabledRanges[ruleName])
+    if (!lastRangeForRule) {
+      return
+    }
+    // Add an `end` prop to the last range of that rule
+    lastRangeForRule.end = line
+  }
+
+  function ensureRuleRanges(ruleName/*: string*/) {
+    if (!disabledRanges[ruleName]) {
+      disabledRanges[ruleName] = _.cloneDeep(disabledRanges.all)
+    }
+  }
+
+  function ruleIsDisabled(ruleName/*: string*/)/*: boolean*/ {
+    if (disabledRanges[ruleName] === undefined) return false
+    if (_.last(disabledRanges[ruleName]) === undefined) return false
+    if (_.get(_.last(disabledRanges[ruleName]), "end") === undefined) return true
+    return false
+  }
+}