@scandipwa/magento-scripts 1.14.0 → 1.14.1-alpha.2

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

@@ -0,0 +1,154 @@
+const path = require('path');
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
+const pathExists = require('../../../util/path-exists');
+const { formatPathForPHPStormConfig } = require('./xml-utils');
+
+const pathToModulesConfig = path.join(process.cwd(), '.idea', 'modules.xml');
+const excludeFoldersPaths = [
+    'bin',
+    'dev',
+    'pub',
+    'setup',
+    'var/cache',
+    'var/page_cache',
+    'var/log'
+].map((p) => `file://$MODULE_DIR$/${p}`);
+
+/**
+ * Will retrieve project config file path from module.xml
+ *
+ * @returns {Promise<String>}
+ */
+const getProjectConfigFilePath = async () => {
+    const modulesConfigData = await loadXmlFile(pathToModulesConfig);
+    return modulesConfigData.project.component.modules.module['@_filepath'].replace('$PROJECT_DIR$', process.cwd());
+};
+
+/**
+ * @returns {Array<{'@_url': string}>}
+ */
+const getExcludedFoldersConfig = (projectConfigData) => {
+    if (!projectConfigData.module) {
+        projectConfigData.module = {
+            '@_type': 'WEB_MODULE',
+            '@_version': '4'
+        };
+    }
+
+    if (!projectConfigData.module.component) {
+        projectConfigData.module.component = {
+            '@_name': 'NewModuleRootManager',
+            orderEntry: [
+                {
+                    '@_type': 'inheritedJdk'
+                },
+                {
+                    '@_type': 'sourceFolder',
+                    '@_forTest': 'false'
+                }
+            ]
+        };
+    }
+
+    if (!projectConfigData.module.component.content) {
+        projectConfigData.module.component.content = {
+            '@_url': 'file://$MODULE_DIR$'
+        };
+    }
+
+    if (!projectConfigData.module.component.content.excludeFolder) {
+        projectConfigData.module.component.content.excludeFolder = [];
+    }
+
+    return projectConfigData
+        .module.component.content.excludeFolder;
+};
+
+const setupExcludedFolders = (excludedFoldersConfig) => {
+    let hasChanges = false;
+    // filter excluded folders to get ones that needs to be added to excluded folders list
+    const missingExcludedFolders = excludeFoldersPaths
+        .filter(
+            (excludeFoldersPath) => !excludedFoldersConfig.some(
+                (config) => config['@_url'] === excludeFoldersPath
+            )
+        );
+
+    if (missingExcludedFolders.length > 0) {
+        hasChanges = true;
+        missingExcludedFolders.forEach((missingExcludedFolder) => {
+            excludedFoldersConfig.unshift({
+                '@_url': missingExcludedFolder
+            });
+        });
+    }
+
+    return hasChanges;
+};
+
+const createModulesXML = async () => {
+    const filePath = path.join(process.cwd(), '.idea', `${path.parse(process.cwd()).base}.iml`);
+    const fileFormattedPath = formatPathForPHPStormConfig(filePath);
+    const fileFormattedUrl = `file://${fileFormattedPath}`;
+
+    const modulesConfig = {
+        '?xml': {
+            '@_version': '1.0',
+            '@_encoding': 'UTF-8'
+        },
+        project: {
+            '@_version': '4',
+            component: {
+                '@_name': 'ProjectModuleManager',
+                modules: [
+                    {
+                        module: {
+                            '@_fileurl': fileFormattedUrl,
+                            '@_filepath': fileFormattedPath
+                        }
+                    }
+                ]
+            }
+        }
+    };
+
+    await buildXmlFile(pathToModulesConfig, modulesConfig);
+
+    return filePath;
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupExcludedFoldersConfig = () => ({
+    title: 'Set up excluded folders configuration',
+    task: async (ctx, task) => {
+        if (await pathExists(pathToModulesConfig)) {
+            const projectFilePath = await getProjectConfigFilePath();
+            const projectConfigData = await loadXmlFile(projectFilePath);
+            const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
+            const hasChanges = setupExcludedFolders(excludedFoldersConfig);
+            if (hasChanges) {
+                await buildXmlFile(projectFilePath, projectConfigData);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const projectFilePath = await createModulesXML();
+        const projectConfigData = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            }
+        };
+        const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
+        setupExcludedFolders(excludedFoldersConfig);
+
+        await buildXmlFile(projectFilePath, projectConfigData);
+    }
+});
+
+module.exports = setupExcludedFoldersConfig;

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

@@ -0,0 +1,27 @@
+const setupWorkspaceConfig = require('./workspace-config');
+const setupPhpConfig = require('./php-config');
+const setupDatabaseConfig = require('./database-config');
+const setupInspectionToolsConfig = require('./inspection-tools-config');
+const setupExcludedFoldersConfig = require('./exclude-folder-config');
+const setupStylelintConfig = require('./stylelint-config');
+const setupESLintConfig = require('./eslint-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const createPhpStormConfig = () => ({
+    title: 'Setting PHPStorm config',
+    task: (ctx, task) => task.newListr([
+        setupWorkspaceConfig(),
+        setupPhpConfig(),
+        setupDatabaseConfig(),
+        setupInspectionToolsConfig(),
+        setupExcludedFoldersConfig(),
+        setupStylelintConfig(),
+        setupESLintConfig()
+    ], {
+        concurrent: true
+    })
+});
+
+module.exports = createPhpStormConfig;

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

@@ -0,0 +1,29 @@
+const { nameKey, valueKey } = require('../keys');
+const {
+    options: {
+        CODING_STANDARD_OPTION_NAME,
+        CUSTOM_CODING_STANDARD_OPTION_VALUE
+    }
+} = require('./config');
+
+const setupCodingStandardOption = 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]: CUSTOM_CODING_STANDARD_OPTION_VALUE
+        });
+    } else if (codingStandardOption[valueKey] !== CUSTOM_CODING_STANDARD_OPTION_VALUE) {
+        hasChanges = true;
+        codingStandardOption[valueKey] = CUSTOM_CODING_STANDARD_OPTION_VALUE;
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupCodingStandardOption;

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,31 @@
+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
+        });
+    } else if (customRuleSetPathOption && customRuleSetPathOption[valueKey] !== phpCSConfigFormattedPath) {
+        hasChanges = true;
+        customRuleSetPathOption[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'] !== defaultProperties.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,29 @@
+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
+        });
+    } else if (codingStandardOption[valueKey] !== MAGENTO2_CODING_STANDARD_OPTION_VALUE) {
+        hasChanges = true;
+        codingStandardOption[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,145 @@
+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'
+                    });
+                } else if (booleanOption[valueKey] !== 'true') {
+                    hasChanges = true;
+                    booleanOption[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
+};