stylelint/dist/lintSource.js

A mighty, modern CSS linter.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

exports.default = function (stylelint) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  if (!options.filePath && options.code === undefined && !options.existingPostcssResult) {
    return Promise.reject("You must provide filePath, code, or existingPostcssResult");
  }

  var inputFilePath = options.code !== undefined ? options.codeFilename : options.filePath;

  return stylelint.isPathIgnored(inputFilePath).then(function (isIgnored) {
    if (isIgnored) {
      var postcssResult = options.existingPostcssResult || createEmptyPostcssResult(inputFilePath);
      postcssResult.stylelint = postcssResult.stylelint || {};
      postcssResult.stylelint.ignored = true;
      postcssResult.standaloneIgnored = true; // TODO: remove need for this
      return postcssResult;
    }

    var configSearchPath = stylelint._options.configFile || inputFilePath;
    return stylelint.getConfigForFile(configSearchPath).then(function (_ref) {
      var config = _ref.config;
      var existingPostcssResult = options.existingPostcssResult;

      if (existingPostcssResult) {
        return lintPostcssResult(stylelint, existingPostcssResult, config).then(function () {
          return existingPostcssResult;
        });
      }

      return stylelint._getPostcssResult({
        code: options.code,
        codeFilename: options.codeFilename,
        filePath: inputFilePath,
        codeProcessors: config.codeProcessors
      }).then(function (postcssResult) {
        return lintPostcssResult(stylelint, postcssResult, config).then(function () {
          return postcssResult;
        });
      });
    });
  });
};

var _flowDeclarations = require("./flow-declarations");

var _result = require("postcss/lib/result");

var _result2 = _interopRequireDefault(_result);

var _lodash = require("lodash");

var _lodash2 = _interopRequireDefault(_lodash);

var _assignDisabledRanges = require("./assignDisabledRanges");

var _assignDisabledRanges2 = _interopRequireDefault(_assignDisabledRanges);

var _utils = require("./utils");

var _rules = require("./rules");

var _rules2 = _interopRequireDefault(_rules);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function lintPostcssResult(stylelint, postcssResult, config) {
  postcssResult.stylelint = postcssResult.stylelint || {};
  postcssResult.stylelint.ruleSeverities = {};
  postcssResult.stylelint.customMessages = {};
  postcssResult.stylelint.quiet = config.quiet;

  var postcssRoot = postcssResult.root;
  (0, _assignDisabledRanges2.default)(postcssRoot, postcssResult);
  if (stylelint._options.reportNeedlessDisables || stylelint._options.ignoreDisables) {
    postcssResult.stylelint.ignoreDisables = true;
  }

  // Promises for the rules. Although the rule code runs synchronously now,
  // the use of Promises makes it compatible with the possibility of async
  // rules down the line.
  var performRules = [];

  Object.keys(config.rules).forEach(function (ruleName) {
    var ruleFunction = _rules2.default[ruleName] || config.pluginFunctions[ruleName];

    if (!ruleFunction) {
      throw (0, _utils.configurationError)("Undefined rule " + ruleName);
    }

    var ruleSettings = config.rules[ruleName];
    var primaryOption = ruleSettings[0];
    var secondaryOptions = ruleSettings[1];

    if (primaryOption === null) {
      return;
    }

    // Log the rule's severity in the PostCSS result
    var defaultSeverity = config.defaultSeverity || "error";
    postcssResult.stylelint.ruleSeverities[ruleName] = _lodash2.default.get(secondaryOptions, "severity", defaultSeverity);
    postcssResult.stylelint.customMessages[ruleName] = secondaryOptions && secondaryOptions.message;

    var performRule = Promise.resolve().then(function () {
      ruleFunction(primaryOption, secondaryOptions)(postcssRoot, postcssResult);
    });
    performRules.push(performRule);
  });

  return Promise.all(performRules);
}

// Run stylelint on a PostCSS Result, either one that is provided
// or one that we create

function createEmptyPostcssResult(filePath) {
  return {
    root: {
      source: {
        input: { file: filePath }
      }
    },
    messages: [],
    stylelint: { stylelintError: null }
  };
}