@scandipwa/magento-scripts 1.14.1-alpha.8 → 1.15.1

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/config.js

@@ -0,0 +1,54 @@
+// inspection tool classes
+const PHP_CS_FIXER_VALIDATION_INSPECTION = 'PhpCSFixerValidationInspection';
+const PHP_CS_VALIDATION_INSPECTION = 'PhpCSValidationInspection';
+const STYLELINT_INSPECTION = 'Stylelint';
+const ESLINT_INSPECTION = 'Eslint';
+const MESS_DETECTOR_VALIDATION_INSPECTION = 'MessDetectorValidationInspection';
+
+// options
+const CODING_STANDARD_OPTION_NAME = 'CODING_STANDARD';
+const CUSTOM_CODING_STANDARD_OPTION_VALUE = 'Custom';
+const CUSTOM_RULE_SET_PATH_OPTION_NAME = 'CUSTOM_RULESET_PATH';
+const MAGENTO2_CODING_STANDARD_OPTION_VALUE = 'Magento2';
+const EXTENSIONS_OPTION_NAME = 'EXTENSIONS';
+const WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME = 'WARNING_HIGHLIGHT_LEVEL_NAME';
+const WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE = 'ERROR';
+const SHOW_SNIFF_NAMES_OPTION_NAME = 'SHOW_SNIFF_NAMES';
+const USE_INSTALLED_PATHS_OPTION_NAME = 'USE_INSTALLED_PATHS';
+const INSTALLED_PATHS_OPTION_NAME = 'INSTALLED_PATHS';
+const CODESIZE_OPTION_NAME = 'CODESIZE';
+const CONTROVERSIAL_OPTION_NAME = 'CONTROVERSIAL';
+const DESIGN_OPTION_NAME = 'DESIGN';
+const UNUSED_CODE_OPTION_NAME = 'UNUSEDCODE';
+const NAMING_OPTION_NAME = 'NAMING';
+const CUSTOM_RULESETS_OPTION_NAME = 'customRulesets';
+const PHP_MD_RULESET_OPTION_VALUE = 'Magento PHPMD rule set';
+
+module.exports = {
+    options: {
+        CODESIZE_OPTION_NAME,
+        CONTROVERSIAL_OPTION_NAME,
+        DESIGN_OPTION_NAME,
+        UNUSED_CODE_OPTION_NAME,
+        NAMING_OPTION_NAME,
+        CUSTOM_RULESETS_OPTION_NAME,
+        PHP_MD_RULESET_OPTION_VALUE,
+        CODING_STANDARD_OPTION_NAME,
+        CUSTOM_CODING_STANDARD_OPTION_VALUE,
+        CUSTOM_RULE_SET_PATH_OPTION_NAME,
+        MAGENTO2_CODING_STANDARD_OPTION_VALUE,
+        EXTENSIONS_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE,
+        SHOW_SNIFF_NAMES_OPTION_NAME,
+        USE_INSTALLED_PATHS_OPTION_NAME,
+        INSTALLED_PATHS_OPTION_NAME
+    },
+    classes: {
+        PHP_CS_FIXER_VALIDATION_INSPECTION,
+        PHP_CS_VALIDATION_INSPECTION,
+        STYLELINT_INSPECTION,
+        ESLINT_INSPECTION,
+        MESS_DETECTOR_VALIDATION_INSPECTION
+    }
+};

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/custom-ruleset-path-config.js

@@ -0,0 +1,28 @@
+const pathExists = require('../../../../util/path-exists');
+const { phpCSConfigurationPath, phpCSConfigFormattedPath } = require('./paths');
+const { nameKey, valueKey } = require('../keys');
+const {
+    options: {
+        CUSTOM_RULE_SET_PATH_OPTION_NAME
+    }
+} = require('./config');
+
+const setupCustomRuleSetPathOption = async (config) => {
+    let hasChanges = false;
+    const customRuleSetPathOption = config.option.find(
+        (option) => option[nameKey] === CUSTOM_RULE_SET_PATH_OPTION_NAME
+    );
+    const phpCSConfigExists = await pathExists(phpCSConfigurationPath);
+
+    if (!customRuleSetPathOption && phpCSConfigExists) {
+        hasChanges = true;
+        config.option.push({
+            [nameKey]: CUSTOM_RULE_SET_PATH_OPTION_NAME,
+            [valueKey]: phpCSConfigFormattedPath
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupCustomRuleSetPathOption;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/default-properties-config.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-param-reassign */
+const properties = {
+    enabled: 'true',
+    enabled_by_default: 'true',
+    level: 'ERROR'
+};
+
+/**
+ * @param {Object} inspectionTool
+ * @param {{
+ *  enabled: 'true' | 'false',
+ *  enabled_by_default: 'true' | 'false',
+ *  level: 'ERROR' | 'WEAK WARNING'
+ * }} defaultProperties
+ * @returns {Boolean}
+ */
+const setupDefaultProperties = (inspectionTool, defaultProperties = properties) => {
+    let hasChanges = false;
+    if (!inspectionTool['@_enabled']) {
+        hasChanges = true;
+        inspectionTool['@_enabled'] = defaultProperties.enabled;
+    }
+
+    if (!inspectionTool['@_enabled_by_default']) {
+        hasChanges = true;
+        inspectionTool['@_enabled_by_default'] = defaultProperties.enabled_by_default;
+    }
+
+    if (!inspectionTool['@_level']) {
+        hasChanges = true;
+        inspectionTool['@_level'] = defaultProperties.level;
+    }
+
+    if (inspectionTool.option && !Array.isArray(inspectionTool.option)) {
+        hasChanges = true;
+        inspectionTool.option = [inspectionTool.option];
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupDefaultProperties;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/eslint-inspection-config.js

@@ -0,0 +1,37 @@
+const {
+    classes: {
+        ESLINT_INSPECTION
+    }
+} = require('./config');
+const { classKey } = require('../keys');
+const setupDefaultProperties = require('./default-properties-config');
+
+/**
+ * Set up Styelint configuration
+ *
+ * *function is async so it will be properly handled in Promise.all*
+ * @param {Array} inspectionToolsData
+ * @returns {Promise<Boolean>}
+ */
+const setupESLintInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const eslintConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === ESLINT_INSPECTION
+    );
+
+    if (eslintConfig) {
+        hasChanges = setupDefaultProperties(eslintConfig);
+    } else {
+        hasChanges = true;
+        inspectionToolsData.push({
+            [classKey]: ESLINT_INSPECTION,
+            '@_enabled': 'true',
+            '@_level': 'ERROR',
+            '@_enabled_by_default': 'true'
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupESLintInspection;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/index.js

@@ -0,0 +1,80 @@
+const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
+const pathExists = require('../../../../util/path-exists');
+const {
+    nameKey,
+    valueKey,
+    classKey
+} = require('../keys');
+const setupESLintInspection = require('./eslint-inspection-config');
+const setupMessDetectorValidationInspection = require('./mess-detector-validation-inspection-config');
+const setupPhpCSFixerValidationInspection = require('./php-cs-fixer-validation-inspection-config');
+const setupPhpCSValidationInspection = require('./php-cs-validation-inspection-config');
+const setupStyleLintInspection = require('./stylelint-inspection-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ */
+const setupInspectionToolsConfig = () => ({
+    title: 'Set up inspection tools configuration',
+    task: async (ctx, task) => {
+        const {
+            config: {
+                phpStorm
+            }
+        } = ctx;
+
+        if (await pathExists(phpStorm.inspectionTools.path)) {
+            const inspectionToolsData = await loadXmlFile(phpStorm.inspectionTools.path);
+            const inspectionTools = inspectionToolsData.component.profile.inspection_tool;
+            const hasChanges = await Promise.all([
+                setupPhpCSFixerValidationInspection(inspectionTools),
+                setupPhpCSValidationInspection(inspectionTools),
+                setupStyleLintInspection(inspectionTools),
+                setupMessDetectorValidationInspection(inspectionTools)
+            ]);
+
+            if (hasChanges.includes(true)) {
+                await buildXmlFile(phpStorm.inspectionTools.path, inspectionToolsData);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const inspectionToolsData = {
+            component: {
+                [nameKey]: 'InspectionProjectProfileManager',
+                profile: {
+                    '@_version': '1.0',
+                    option: {
+                        [nameKey]: 'myName',
+                        [valueKey]: 'Project Default'
+                    },
+                    inspection_tool: [
+                        {
+                            [classKey]: 'PhpStanGlobal',
+                            '@_enabled': 'true',
+                            '@_level': 'ERROR',
+                            '@_enabled_by_default': 'true'
+                        }
+                    ]
+                }
+            }
+        };
+        const inspectionTools = inspectionToolsData.component.profile.inspection_tool;
+
+        await Promise.all([
+            setupPhpCSFixerValidationInspection(inspectionTools),
+            setupPhpCSValidationInspection(inspectionTools),
+            setupStyleLintInspection(inspectionTools),
+            setupMessDetectorValidationInspection(inspectionTools),
+            setupStyleLintInspection(inspectionTools),
+            setupESLintInspection(inspectionTools)
+        ]);
+
+        await buildXmlFile(phpStorm.inspectionTools.path, inspectionToolsData);
+    }
+});
+
+module.exports = setupInspectionToolsConfig;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/magento-coding-standard-config.js

@@ -0,0 +1,26 @@
+const { nameKey, valueKey } = require('../keys');
+const {
+    options: {
+        CODING_STANDARD_OPTION_NAME,
+        MAGENTO2_CODING_STANDARD_OPTION_VALUE
+    }
+} = require('./config');
+
+const setupMagento2CodingStandardOption = async (config) => {
+    let hasChanges = false;
+    const codingStandardOption = config.option.find(
+        (option) => option[nameKey] === CODING_STANDARD_OPTION_NAME
+    );
+
+    if (!codingStandardOption) {
+        hasChanges = true;
+        config.option.push({
+            [nameKey]: CODING_STANDARD_OPTION_NAME,
+            [valueKey]: MAGENTO2_CODING_STANDARD_OPTION_VALUE
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMagento2CodingStandardOption;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/mess-detector-validation-inspection-config.js

@@ -0,0 +1,142 @@
+const { phpMDRuleSetFormattedPath } = require('./paths');
+const {
+    classes: {
+        MESS_DETECTOR_VALIDATION_INSPECTION
+    },
+    options: {
+        CODESIZE_OPTION_NAME,
+        CONTROVERSIAL_OPTION_NAME,
+        DESIGN_OPTION_NAME,
+        UNUSED_CODE_OPTION_NAME,
+        NAMING_OPTION_NAME,
+        CUSTOM_RULESETS_OPTION_NAME,
+        PHP_MD_RULESET_OPTION_VALUE
+    }
+} = require('./config');
+const {
+    classKey,
+    nameKey,
+    valueKey
+} = require('../keys');
+const setupDefaultProperties = require('./default-properties-config');
+
+const messDetectorBooleanOptionNames = [
+    CODESIZE_OPTION_NAME,
+    CONTROVERSIAL_OPTION_NAME,
+    DESIGN_OPTION_NAME,
+    UNUSED_CODE_OPTION_NAME,
+    NAMING_OPTION_NAME
+];
+
+const messDetectorDefaultRuleSetsListContent = {
+    RulesetDescriptor: {
+        option: [
+            {
+                [nameKey]: 'name',
+                [valueKey]: PHP_MD_RULESET_OPTION_VALUE
+            },
+            {
+                [nameKey]: 'path',
+                [valueKey]: phpMDRuleSetFormattedPath
+            }
+        ]
+    }
+};
+
+const messDetectorDefaultOptions = [
+    ...messDetectorBooleanOptionNames.map((optionName) => ({
+        [nameKey]: optionName,
+        [valueKey]: 'true'
+    })),
+    {
+        [nameKey]: CUSTOM_RULESETS_OPTION_NAME,
+        list: messDetectorDefaultRuleSetsListContent
+    }
+];
+
+/**
+ * @param {Array} inspectionToolsData
+ * @returns {Promise<Boolean>}
+ */
+const setupMessDetectorValidationInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const messDetectorConfig = inspectionToolsData.find((inspectionToolData) => inspectionToolData[classKey] === MESS_DETECTOR_VALIDATION_INSPECTION);
+    if (messDetectorConfig) {
+        const hasChangesInProperties = setupDefaultProperties(messDetectorConfig, {
+            enabled: 'true',
+            enabled_by_default: 'true',
+            level: 'WEAK WARNING'
+        });
+
+        if (hasChangesInProperties) {
+            hasChanges = true;
+        }
+
+        if (messDetectorConfig.option) {
+            messDetectorBooleanOptionNames.forEach((optionName) => {
+                const booleanOption = messDetectorConfig.option.find(
+                    (o) => o[nameKey] === optionName
+                );
+
+                if (!booleanOption) {
+                    hasChanges = true;
+                    messDetectorConfig.option.push({
+                        [nameKey]: optionName,
+                        [valueKey]: 'true'
+                    });
+                }
+            });
+
+            const customRulesetsOption = messDetectorConfig.option.find(
+                (o) => o[nameKey] === CUSTOM_RULESETS_OPTION_NAME
+            );
+
+            if (customRulesetsOption) {
+                if (!customRulesetsOption.list) {
+                    hasChanges = true;
+                    customRulesetsOption.list = [];
+                }
+
+                if (customRulesetsOption.list && !Array.isArray(customRulesetsOption.list)) {
+                    hasChanges = true;
+                    customRulesetsOption.list = [customRulesetsOption.list];
+                }
+
+                const correctRulesetsExists = customRulesetsOption.list.some(
+                    (r) => r.RulesetDescriptor.option.some(
+                        (o) => o[nameKey] === 'path' && o[valueKey] === phpMDRuleSetFormattedPath
+                    )
+                );
+
+                if (!correctRulesetsExists) {
+                    hasChanges = true;
+                    customRulesetsOption.list.push(
+                        messDetectorDefaultRuleSetsListContent
+                    );
+                }
+            } else {
+                hasChanges = true;
+                messDetectorConfig.option.push({
+                    [nameKey]: CUSTOM_RULESETS_OPTION_NAME,
+                    list: messDetectorDefaultRuleSetsListContent
+                });
+            }
+        } else {
+            hasChanges = true;
+            messDetectorConfig.option = messDetectorDefaultOptions;
+        }
+    } else {
+        hasChanges = true;
+        inspectionToolsData.push({
+            [classKey]: MESS_DETECTOR_VALIDATION_INSPECTION,
+            '@_enabled': 'true',
+            '@_level': 'WEAK WARNING',
+            '@_enabled_by_default': 'true',
+            option: messDetectorDefaultOptions
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMessDetectorValidationInspection;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/paths.js

@@ -0,0 +1,20 @@
+const path = require('path');
+const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const phpCompatibilityPath = path.join(process.cwd(), 'vendor', 'phpcompatibility', 'php-compatibility', 'PHPCompatibility');
+const phpCompatibilityRuleSetPath = path.join(phpCompatibilityPath, 'ruleset.xml');
+const phpCompatibilityFormattedPath = formatPathForPHPStormConfig(phpCompatibilityPath);
+const phpCSConfigurationPath = path.join(process.cwd(), '.php_cs.dist');
+const phpCSConfigFormattedPath = formatPathForPHPStormConfig(phpCSConfigurationPath);
+const phpMDRuleSetPath = path.join(process.cwd(), 'dev', 'tests', 'static', 'testsuite', 'Magento', 'Test', 'Php', '_files', 'phpmd', 'ruleset.xml');
+const phpMDRuleSetFormattedPath = formatPathForPHPStormConfig(phpMDRuleSetPath);
+
+module.exports = {
+    phpCompatibilityPath,
+    phpCompatibilityRuleSetPath,
+    phpCompatibilityFormattedPath,
+    phpCSConfigurationPath,
+    phpCSConfigFormattedPath,
+    phpMDRuleSetPath,
+    phpMDRuleSetFormattedPath
+};

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/php-cs-fixer-validation-inspection-config.js

@@ -0,0 +1,60 @@
+const {
+    classes: {
+        PHP_CS_FIXER_VALIDATION_INSPECTION
+    }
+} = require('./config');
+const { classKey } = require('../keys');
+const setupCodingStandardOption = require('./coding-standard-config');
+const setupCustomRuleSetPathOption = require('./custom-ruleset-path-config');
+const setupDefaultProperties = require('./default-properties-config');
+
+/**
+ * @param {Array} inspectionToolsData
+ * @returns {Promise<Boolean>}
+ */
+const setupPhpCSFixerValidationInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const phpCSFixerConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === PHP_CS_FIXER_VALIDATION_INSPECTION
+    );
+
+    if (phpCSFixerConfig) {
+        const hasChangesInProperties = setupDefaultProperties(phpCSFixerConfig);
+        if (hasChangesInProperties) {
+            hasChanges = true;
+        }
+
+        if (phpCSFixerConfig.option) {
+            const hasCodingStandardChanges = await setupCodingStandardOption(phpCSFixerConfig);
+            if (hasCodingStandardChanges) {
+                hasChanges = true;
+            }
+
+            const hasCustomRuleSetChanges = await setupCustomRuleSetPathOption(phpCSFixerConfig);
+            if (hasCustomRuleSetChanges) {
+                hasChanges = true;
+            }
+        } else {
+            hasChanges = true;
+            phpCSFixerConfig.option = [];
+            await setupCodingStandardOption(phpCSFixerConfig);
+            await setupCustomRuleSetPathOption(phpCSFixerConfig);
+        }
+    } else {
+        hasChanges = true;
+        const phpCSFixerConfig = {
+            [classKey]: PHP_CS_FIXER_VALIDATION_INSPECTION,
+            option: []
+        };
+
+        setupDefaultProperties(phpCSFixerConfig);
+        await setupCodingStandardOption(phpCSFixerConfig);
+        await setupCustomRuleSetPathOption(phpCSFixerConfig);
+
+        inspectionToolsData.push(phpCSFixerConfig);
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPhpCSFixerValidationInspection;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/php-cs-validation-inspection-config.js

@@ -0,0 +1,116 @@
+const {
+    classes: {
+        PHP_CS_VALIDATION_INSPECTION
+    },
+    options: {
+        CODING_STANDARD_OPTION_NAME,
+        MAGENTO2_CODING_STANDARD_OPTION_VALUE,
+        EXTENSIONS_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE,
+        SHOW_SNIFF_NAMES_OPTION_NAME
+    }
+} = require('./config');
+const {
+    classKey,
+    nameKey,
+    valueKey
+} = require('../keys');
+const setupDefaultProperties = require('./default-properties-config');
+const setupMagento2CodingStandardOption = require('./magento-coding-standard-config');
+
+const phpCSConfigDefaultOptions = [
+    {
+        [nameKey]: CODING_STANDARD_OPTION_NAME,
+        [valueKey]: MAGENTO2_CODING_STANDARD_OPTION_VALUE
+    },
+    {
+        [nameKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+        [valueKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE
+    },
+    {
+        [nameKey]: SHOW_SNIFF_NAMES_OPTION_NAME,
+        [valueKey]: 'true'
+    },
+    {
+        [nameKey]: EXTENSIONS_OPTION_NAME,
+        [valueKey]: 'php'
+    }
+];
+
+const setupPhpCSValidationInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const phpCSConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === PHP_CS_VALIDATION_INSPECTION
+    );
+
+    if (phpCSConfig) {
+        const hasChangesInProperties = setupDefaultProperties(phpCSConfig);
+        if (hasChangesInProperties) {
+            hasChanges = true;
+        }
+
+        if (phpCSConfig.option) {
+            const hasCodingStandardChanges = await setupMagento2CodingStandardOption(phpCSConfig);
+            if (hasCodingStandardChanges) {
+                hasChanges = true;
+            }
+
+            const warningHighlightLevelNameOption = phpCSConfig.option.find(
+                (option) => option[nameKey] === WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME
+            );
+
+            if (!warningHighlightLevelNameOption) {
+                hasChanges = true;
+                phpCSConfig.option.push({
+                    [nameKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+                    [valueKey]: WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE
+                });
+            }
+
+            const showSniffNamesOption = phpCSConfig.option.find(
+                (option) => option[nameKey] === SHOW_SNIFF_NAMES_OPTION_NAME
+            );
+
+            if (!showSniffNamesOption) {
+                hasChanges = true;
+                phpCSConfig.option.push({
+                    [nameKey]: SHOW_SNIFF_NAMES_OPTION_NAME,
+                    [valueKey]: 'true'
+                });
+            }
+
+            // we want php code sniffer to lint only php files
+            // for other files (js, css, scss) we have separate linter setups
+            const extensionsOption = phpCSConfig.option.find(
+                (option) => option[nameKey] === EXTENSIONS_OPTION_NAME
+            );
+
+            if (!extensionsOption) {
+                hasChanges = true;
+                phpCSConfig.option.push({
+                    [nameKey]: EXTENSIONS_OPTION_NAME,
+                    [valueKey]: 'php'
+                });
+            }
+        } else {
+            hasChanges = true;
+            phpCSConfig.option = phpCSConfigDefaultOptions;
+        }
+    } else {
+        hasChanges = true;
+
+        const phpCSConfig = {
+            [classKey]: PHP_CS_VALIDATION_INSPECTION,
+            option: phpCSConfigDefaultOptions
+        };
+
+        setupDefaultProperties(phpCSConfig);
+
+        inspectionToolsData.push(phpCSConfig);
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPhpCSValidationInspection;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/stylelint-inspection-config.js

@@ -0,0 +1,37 @@
+const {
+    classes: {
+        STYLELINT_INSPECTION
+    }
+} = require('./config');
+const { classKey } = require('../keys');
+const setupDefaultProperties = require('./default-properties-config');
+
+/**
+ * Set up Styelint configuration
+ *
+ * *function is async so it will be properly handled in Promise.all*
+ * @param {Array} inspectionToolsData
+ * @returns {Promise<Boolean>}
+ */
+const setupStyleLintInspection = async (inspectionToolsData) => {
+    let hasChanges = false;
+    const stylelintConfig = inspectionToolsData.find(
+        (inspectionToolData) => inspectionToolData[classKey] === STYLELINT_INSPECTION
+    );
+
+    if (stylelintConfig) {
+        hasChanges = setupDefaultProperties(stylelintConfig);
+    } else {
+        hasChanges = true;
+        inspectionToolsData.push({
+            [classKey]: STYLELINT_INSPECTION,
+            '@_enabled': 'true',
+            '@_level': 'ERROR',
+            '@_enabled_by_default': 'true'
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupStyleLintInspection;

package/lib/tasks/file-system/create-phpstorm-config/keys.js

@@ -0,0 +1,14 @@
+// xml property key names
+const classKey = '@_class';
+const nameKey = '@_name';
+const valueKey = '@_value';
+const toolPathKey = '@_tool_path';
+const standardsKey = '@_standards';
+
+module.exports = {
+    classKey,
+    nameKey,
+    valueKey,
+    toolPathKey,
+    standardsKey
+};