@scandipwa/magento-scripts 1.14.1-alpha.9 → 1.15.0

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
+};

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

@@ -0,0 +1,67 @@
+const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
+const pathExists = require('../../../../util/path-exists');
+const setupMessDetector = require('./mess-detector-config');
+const setupPHPCodeSniffer = require('./php-code-sniffer-config');
+const setupPHPCSFixer = require('./php-cs-fixer-config');
+const setupPHPProjectSharedConfiguration = require('./php-project-shared-configuration-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ */
+const setupPhpConfig = () => ({
+    title: 'Set up PHP configuration',
+    task: async (ctx, task) => {
+        const {
+            config: {
+                phpStorm,
+                phpStorm: {
+                    php: {
+                        phpLanguageLevel
+                    }
+                }
+            }
+        } = ctx;
+
+        if (await pathExists(phpStorm.php.path)) {
+            const phpConfigContent = await loadXmlFile(phpStorm.php.path);
+            const phpConfigs = phpConfigContent.project.component;
+            const hasChanges = await Promise.all([
+                setupMessDetector(phpConfigs),
+                setupPHPCodeSniffer(phpConfigs),
+                setupPHPCSFixer(phpConfigs),
+                setupPHPProjectSharedConfiguration(phpConfigs, phpLanguageLevel)
+            ]);
+
+            if (hasChanges.includes(true)) {
+                await buildXmlFile(phpStorm.php.path, phpConfigContent);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const phpConfigContent = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            },
+            project: {
+                '@_version': '4',
+                component: []
+            }
+        };
+        const phpConfigs = phpConfigContent.project.component;
+
+        await Promise.all([
+            setupMessDetector(phpConfigs),
+            setupPHPCodeSniffer(phpConfigs),
+            setupPHPCSFixer(phpConfigs),
+            setupPHPProjectSharedConfiguration(phpConfigs, phpLanguageLevel)
+        ]);
+
+        await buildXmlFile(phpStorm.php.path, phpConfigContent);
+    }
+});
+
+module.exports = setupPhpConfig;

package/lib/tasks/file-system/create-phpstorm-config/php-config/mess-detector-config.js

@@ -0,0 +1,54 @@
+const path = require('path');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey, toolPathKey } = require('../keys');
+const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const phpMDBinaryPath = path.join(process.cwd(), 'vendor', 'bin', 'phpmd');
+const phpMDBinaryFormattedPath = formatPathForPHPStormConfig(phpMDBinaryPath);
+
+const defaultMessDetectorSetting = {
+    MessDetectorConfiguration: {
+        [toolPathKey]: phpMDBinaryFormattedPath
+    }
+};
+
+/**
+ * @param {Array} phpConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupMessDetector = async (phpConfigs) => {
+    let hasChanges = false;
+    const messDetectorComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === 'MessDetector'
+    );
+
+    const isPhpMDBinPathExists = await pathExists(phpMDBinaryPath);
+
+    if (messDetectorComponent && isPhpMDBinPathExists) {
+        if (!Array.isArray(messDetectorComponent.phpmd_settings)) {
+            hasChanges = true;
+            messDetectorComponent.phpmd_settings = [messDetectorComponent.phpmd_settings];
+        }
+
+        const messDetectorConfiguration = messDetectorComponent.phpmd_settings.find(
+            (phpmdSetting) => phpmdSetting.MessDetectorConfiguration
+        );
+
+        if (!messDetectorConfiguration) {
+            hasChanges = true;
+            messDetectorComponent.phpmd_settings.push(defaultMessDetectorSetting);
+        }
+    } else if (isPhpMDBinPathExists) {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: 'MessDetector',
+            phpmd_settings: [
+                defaultMessDetectorSetting
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMessDetector;