@scandipwa/magento-scripts 1.16.1 → 2.0.0-alpha.10

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

@@ -1,17 +1,26 @@
 const path = require('path');
 const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
 const pathExists = require('../../../util/path-exists');
+const {
+    urlKey, typeKey, versionKey, nameKey
+} = require('./keys');
 const { formatPathForPHPStormConfig } = require('./xml-utils');
 
 const pathToModulesConfig = path.join(process.cwd(), '.idea', 'modules.xml');
 const excludeFoldersPaths = [
     'bin',
     'dev',
-    'pub',
-    'setup',
+    'pub/static',
     'var/cache',
     'var/page_cache',
-    'var/log'
+    'var/log',
+    'var/composer_home',
+    'var/view_preprocessed'
+].map((p) => `file://$MODULE_DIR$/${p}`);
+
+const mustBeIncludedPaths = [
+    'pub',
+    'setup'
 ].map((p) => `file://$MODULE_DIR$/${p}`);
 
 /**
@@ -24,26 +33,23 @@ const getProjectConfigFilePath = async () => {
     return modulesConfigData.project.component.modules.module['@_filepath'].replace('$PROJECT_DIR$', process.cwd());
 };
 
-/**
- * @returns {Array<{'@_url': string}>}
- */
-const getExcludedFoldersConfig = (projectConfigData) => {
+const setupDefaultsForExcludedFoldersConfig = (projectConfigData) => {
     if (!projectConfigData.module) {
         projectConfigData.module = {
-            '@_type': 'WEB_MODULE',
-            '@_version': '4'
+            [typeKey]: 'WEB_MODULE',
+            [versionKey]: '4'
         };
     }
 
     if (!projectConfigData.module.component) {
         projectConfigData.module.component = {
-            '@_name': 'NewModuleRootManager',
+            [nameKey]: 'NewModuleRootManager',
             orderEntry: [
                 {
-                    '@_type': 'inheritedJdk'
+                    [typeKey]: 'inheritedJdk'
                 },
                 {
-                    '@_type': 'sourceFolder',
+                    [typeKey]: 'sourceFolder',
                     '@_forTest': 'false'
                 }
             ]
@@ -52,37 +58,42 @@ const getExcludedFoldersConfig = (projectConfigData) => {
 
     if (!projectConfigData.module.component.content) {
         projectConfigData.module.component.content = {
-            '@_url': 'file://$MODULE_DIR$'
+            [urlKey]: 'file://$MODULE_DIR$'
         };
     }
 
     if (!projectConfigData.module.component.content.excludeFolder) {
         projectConfigData.module.component.content.excludeFolder = [];
     }
-
-    return projectConfigData
-        .module.component.content.excludeFolder;
 };
 
-const setupExcludedFolders = (excludedFoldersConfig) => {
+const setupExcludedFolders = (projectConfigData) => {
+    const { excludeFolder } = projectConfigData.module.component.content;
     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
+            (excludeFoldersPath) => !excludeFolder.some(
+                (config) => config[urlKey] === excludeFoldersPath
             )
         );
 
     if (missingExcludedFolders.length > 0) {
         hasChanges = true;
         missingExcludedFolders.forEach((missingExcludedFolder) => {
-            excludedFoldersConfig.unshift({
-                '@_url': missingExcludedFolder
+            projectConfigData.module.component.content.excludeFolder.unshift({
+                [urlKey]: missingExcludedFolder
             });
         });
     }
 
+    const hasSomePathsThatMustBeFiltered = excludeFolder.some((config) => mustBeIncludedPaths.includes(config[urlKey]));
+
+    if (hasSomePathsThatMustBeFiltered) {
+        projectConfigData.module.component.content.excludeFolder = excludeFolder.filter((config) => !mustBeIncludedPaths.includes(config[urlKey]));
+        hasChanges = true;
+    }
+
     return hasChanges;
 };
 
@@ -94,13 +105,13 @@ const getIMLFilePath = async () => {
 
         const modulesConfig = {
             '?xml': {
-                '@_version': '1.0',
+                [versionKey]: '1.0',
                 '@_encoding': 'UTF-8'
             },
             project: {
-                '@_version': '4',
+                [versionKey]: '4',
                 component: {
-                    '@_name': 'ProjectModuleManager',
+                    [nameKey]: 'ProjectModuleManager',
                     modules: [
                         {
                             module: {
@@ -129,8 +140,8 @@ const setupExcludedFoldersConfig = () => ({
             const projectFilePath = await getProjectConfigFilePath();
             if (await pathExists(projectFilePath)) {
                 const projectConfigData = await loadXmlFile(projectFilePath);
-                const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
-                const hasChanges = setupExcludedFolders(excludedFoldersConfig);
+                setupDefaultsForExcludedFoldersConfig(projectConfigData);
+                const hasChanges = setupExcludedFolders(projectConfigData);
                 if (hasChanges) {
                     await buildXmlFile(projectFilePath, projectConfigData);
                 } else {
@@ -144,12 +155,13 @@ const setupExcludedFoldersConfig = () => ({
         const projectFilePath = await getIMLFilePath();
         const projectConfigData = {
             '?xml': {
-                '@_version': '1.0',
+                [versionKey]: '1.0',
                 '@_encoding': 'UTF-8'
             }
         };
-        const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
-        setupExcludedFolders(excludedFoldersConfig);
+
+        setupDefaultsForExcludedFoldersConfig(projectConfigData);
+        setupExcludedFolders(projectConfigData);
 
         await buildXmlFile(projectFilePath, projectConfigData);
     }

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

@@ -5,6 +5,7 @@ const setupInspectionToolsConfig = require('./inspection-tools-config');
 const setupExcludedFoldersConfig = require('./exclude-folder-config');
 const setupStylelintConfig = require('./stylelint-config');
 const setupESLintConfig = require('./eslint-config');
+const setupPhpDockerSettingsConfig = require('./php-docker-settings-config');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -14,6 +15,7 @@ const createPhpStormConfig = () => ({
     task: (ctx, task) => task.newListr([
         setupWorkspaceConfig(),
         setupPhpConfig(),
+        setupPhpDockerSettingsConfig(),
         setupDatabaseConfig(),
         setupInspectionToolsConfig(),
         setupExcludedFoldersConfig(),

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

@@ -4,11 +4,25 @@ const nameKey = '@_name';
 const valueKey = '@_value';
 const toolPathKey = '@_tool_path';
 const standardsKey = '@_standards';
+const urlKey = '@_url';
+const typeKey = '@_type';
+const versionKey = '@_version';
+
+/**
+ * Makes a xml property key
+ * @param {string} key
+ * @returns {string}
+ */
+const propertyKey = (key) => `@_${key}`;
 
 module.exports = {
     classKey,
     nameKey,
     valueKey,
     toolPathKey,
-    standardsKey
+    standardsKey,
+    urlKey,
+    typeKey,
+    versionKey,
+    propertyKey
 };

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

@@ -5,6 +5,7 @@ const setupMessDetector = require('./mess-detector-config');
 const setupPHPCodeSniffer = require('./php-code-sniffer-config');
 const { getPhpConfig } = require('./php-config');
 const setupPHPCSFixer = require('./php-cs-fixer-config');
+const setupPHPInterpreters = require('./php-interpreters-config');
 const setupPHPProjectSharedConfiguration = require('./php-project-shared-configuration-config');
 
 /**
@@ -13,7 +14,7 @@ const setupPHPProjectSharedConfiguration = require('./php-project-shared-configu
 const setupPhpConfig = () => ({
     title: 'Set up PHP configuration',
     task: async (ctx, task) => {
-        const phpConfig = getPhpConfig(ctx.config.overridenConfiguration);
+        const phpConfig = getPhpConfig(ctx);
 
         if (await pathExists(phpConfig.path)) {
             const phpConfigContent = setupXMLStructure(await loadXmlFile(phpConfig.path));
@@ -22,6 +23,7 @@ const setupPhpConfig = () => ({
                 setupMessDetector(phpConfigs),
                 setupPHPCodeSniffer(phpConfigs),
                 setupPHPCSFixer(phpConfigs),
+                setupPHPInterpreters(phpConfigs, ctx),
                 setupPHPProjectSharedConfiguration(phpConfigs, phpConfig.phpLanguageLevel)
             ]);
 
@@ -41,6 +43,7 @@ const setupPhpConfig = () => ({
             setupMessDetector(phpConfigs),
             setupPHPCodeSniffer(phpConfigs),
             setupPHPCSFixer(phpConfigs),
+            setupPHPInterpreters(phpConfigs, ctx),
             setupPHPProjectSharedConfiguration(phpConfigs, phpConfig.phpLanguageLevel)
         ]);
 

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

@@ -2,10 +2,10 @@ const path = require('path');
 const { baseConfig } = require('../../../../config');
 
 /**
- * @param {import('../../../../../typings/index').CMAConfiguration} app
+ * @param {import('../../../../../typings/context').ListrContext} ctx
  */
-const getPhpConfig = (app) => {
-    const [majorPHPVersion, minorPHPVersion] = app.configuration.php.version.split('.');
+const getPhpConfig = (ctx) => {
+    const [majorPHPVersion, minorPHPVersion] = ctx.phpVersion.split('.');
     const phpLanguageLevel = `${ majorPHPVersion }.${ minorPHPVersion }`;
 
     return {

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

@@ -0,0 +1,81 @@
+const { nameKey, propertyKey } = require('../keys');
+
+const PHP_INTERPRETERS_COMPONENT_NAME = 'PhpInterpreters';
+
+/**
+ * @param {Array} phpConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPInterpreters = async (phpConfigs, ctx) => {
+    let hasChanges = false;
+    const phpInterpretersComponent = phpConfigs.find(
+        (phpConfig) => phpConfig[nameKey] === PHP_INTERPRETERS_COMPONENT_NAME
+    );
+
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const currentInterpreterImage = ctx.debug ? php.debugImage : php.image;
+
+    const defaultPhpInterpreterConfiguration = {
+        [nameKey]: currentInterpreterImage,
+        [propertyKey('id')]: '2fbe75d5-bc8f-4adb-8e62-ddb0ccee6428',
+        [propertyKey('home')]: 'docker://DATA',
+        [propertyKey('debugger_id')]: 'php.debugger.XDebug',
+        remote_data: {
+            [propertyKey('INTERPRETER_PATH')]: 'php',
+            [propertyKey('HELPERS_PATH')]: '/opt/.phpstorm_helpers',
+            [propertyKey('VALID')]: 'true',
+            [propertyKey('RUN_AS_ROOT_VIA_SUDO')]: 'false',
+            [propertyKey('DOCKER_ACCOUNT_NAME')]: 'Docker',
+            [propertyKey('DOCKER_IMAGE_NAME')]: currentInterpreterImage,
+            [propertyKey('DOCKER_REMOTE_PROJECT_PATH')]: ctx.config.baseConfig.containerMagentoDir
+        }
+    };
+
+    if (phpInterpretersComponent) {
+        if (!phpInterpretersComponent.interpreters) {
+            hasChanges = true;
+            phpInterpretersComponent.interpreters = {};
+        }
+
+        if (!Array.isArray(phpInterpretersComponent.interpreters.interpreter)) {
+            hasChanges = true;
+            phpInterpretersComponent.interpreters.interpreter = [phpInterpretersComponent.interpreters.interpreter];
+        }
+
+        const phpInterpreterConfiguration = phpInterpretersComponent.interpreters.interpreter.find(
+            (interpreter) => interpreter[nameKey] === php.image || interpreter[nameKey] === php.debugImage
+        );
+
+        if (!phpInterpreterConfiguration) {
+            hasChanges = true;
+            phpInterpretersComponent.interpreters.interpreter.push(defaultPhpInterpreterConfiguration);
+        } else {
+            if (phpInterpreterConfiguration[nameKey] !== currentInterpreterImage) {
+                hasChanges = true;
+                phpInterpreterConfiguration[nameKey] = currentInterpreterImage;
+            }
+            if (phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_IMAGE_NAME')] !== currentInterpreterImage) {
+                hasChanges = true;
+                phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_IMAGE_NAME')] = currentInterpreterImage;
+            }
+
+            if (phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_REMOTE_PROJECT_PATH')] !== ctx.config.baseConfig.containerMagentoDir) {
+                hasChanges = true;
+                phpInterpreterConfiguration.remote_data[propertyKey('DOCKER_REMOTE_PROJECT_PATH')] = ctx.config.baseConfig.containerMagentoDir;
+            }
+        }
+    } else {
+        hasChanges = true;
+        phpConfigs.push({
+            [nameKey]: PHP_INTERPRETERS_COMPONENT_NAME,
+            interpreters: {
+                interpreter: defaultPhpInterpreterConfiguration
+            }
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPInterpreters;

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

@@ -0,0 +1,42 @@
+const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
+const pathExists = require('../../../../util/path-exists');
+const { setupXMLStructure } = require('../setup-xml-structure');
+const { getPhpDockerSettingsConfig } = require('./php-docker-settings-config');
+const setupPHPDockerContainerSettingsConfig = require('./setup-php-docker-container-settings-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ */
+const setupPhpDockerSettingsConfig = () => ({
+    title: 'Set up PHP Docker Settings configuration',
+    task: async (ctx, task) => {
+        const phpDockerSettingsConfig = getPhpDockerSettingsConfig();
+
+        if (await pathExists(phpDockerSettingsConfig.path)) {
+            const phpDockerSettingsConfigContent = setupXMLStructure(await loadXmlFile(phpDockerSettingsConfig.path));
+            const phpDockerSettingsConfigs = phpDockerSettingsConfigContent.project.component;
+            const hasChanges = await Promise.all([
+                setupPHPDockerContainerSettingsConfig(phpDockerSettingsConfigs, ctx)
+            ]);
+
+            if (hasChanges.includes(true)) {
+                await buildXmlFile(phpDockerSettingsConfig.path, phpDockerSettingsConfigContent);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const phpDockerSettingsConfigContent = setupXMLStructure({});
+        const phpDockerSettingsConfigs = phpDockerSettingsConfigContent.project.component;
+
+        await Promise.all([
+            setupPHPDockerContainerSettingsConfig(phpDockerSettingsConfigs, ctx)
+        ]);
+
+        await buildXmlFile(phpDockerSettingsConfig.path, phpDockerSettingsConfigContent);
+    }
+});
+
+module.exports = setupPhpDockerSettingsConfig;

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

@@ -0,0 +1,9 @@
+const path = require('path');
+
+const getPhpDockerSettingsConfig = () => ({
+    path: path.join(process.cwd(), '.idea', 'php-docker-settings.xml')
+});
+
+module.exports = {
+    getPhpDockerSettingsConfig
+};

package/lib/tasks/file-system/create-phpstorm-config/php-docker-settings-config/setup-php-docker-container-settings-config.js

@@ -0,0 +1,66 @@
+const { propertyKey } = require('../keys');
+
+const PHP_DOCKER_CONTAINER_SETTINGS_COMPONENT_NAME = 'PhpDockerContainerSettings';
+
+/**
+ * @param {Array} phpDockerSettingsConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPDockerContainerSettingsConfig = async (phpDockerSettingsConfigs, ctx) => {
+    let hasChanges = false;
+    const phpDockerContainerSettingsComponent = phpDockerSettingsConfigs.find(
+        (phpDockerSettingsConfig) => phpDockerSettingsConfig[propertyKey('name')] === PHP_DOCKER_CONTAINER_SETTINGS_COMPONENT_NAME
+    );
+
+    const defaultList = {
+        map: {
+            entry: {
+                [propertyKey('key')]: '2fbe75d5-bc8f-4adb-8e62-ddb0ccee6428',
+                value: {
+                    DockerContainerSettings: {
+                        option: [
+                            {
+                                [propertyKey('name')]: 'runCliOptions',
+                                [propertyKey('value')]: ''
+                            },
+                            {
+                                [propertyKey('name')]: 'version',
+                                [propertyKey('value')]: '1'
+                            },
+                            {
+                                [propertyKey('name')]: 'volumeBindings',
+                                list: {
+                                    DockerVolumeBindingImpl: {
+                                        option: [
+                                            {
+                                                [propertyKey('name')]: 'containerPath',
+                                                [propertyKey('value')]: ctx.config.baseConfig.containerMagentoDir
+                                            },
+                                            {
+                                                [propertyKey('name')]: 'hostPath',
+                                                [propertyKey('value')]: '$PROJECT_DIR$'
+                                            }
+                                        ]
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    };
+
+    if (!phpDockerContainerSettingsComponent) {
+        hasChanges = true;
+        phpDockerSettingsConfigs.push({
+            [propertyKey('name')]: PHP_DOCKER_CONTAINER_SETTINGS_COMPONENT_NAME,
+            list: defaultList
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPDockerContainerSettingsConfig;

package/lib/tasks/file-system/create-phpstorm-config/setup-xml-structure.js

@@ -1,29 +1,31 @@
-const xmlConfiguration = {
+const { propertyKey } = require('./keys');
+
+const xmlConfiguration = () => ({
     '?xml': {
-        '@_version': '1.0',
-        '@_encoding': 'UTF-8'
+        [propertyKey('version')]: '1.0',
+        [propertyKey('encoding')]: 'UTF-8'
     },
     project: {
-        '@_version': '4',
+        [propertyKey('version')]: '4',
         component: []
     }
-};
+});
 
 const setupXMLStructure = (data) => {
     if (!data) {
-        data = xmlConfiguration;
+        data = xmlConfiguration();
     }
 
     if (data['?xml'] === undefined) {
-        data['?xml'] = xmlConfiguration['?xml'];
+        data['?xml'] = xmlConfiguration()['?xml'];
     }
 
     if (data.project === undefined) {
-        data.project = xmlConfiguration.project;
+        data.project = xmlConfiguration().project;
     }
 
     if (data.project.component === undefined) {
-        data.project.component = xmlConfiguration.project.component;
+        data.project.component = [];
     }
 
     if (!Array.isArray(data.project.component) && Boolean(data.project.component)) {

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

@@ -3,6 +3,7 @@ const fs = require('fs');
 const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
 const pathExists = require('../../../util/path-exists');
 const { valueKey, nameKey } = require('./keys');
+const { setupXMLStructure } = require('./setup-xml-structure');
 
 const STYLELINT_CONFIGURATION_COMPONENT_NAME = 'StylelintConfiguration';
 
@@ -26,7 +27,7 @@ const setupStylelintConfig = () => ({
     task: async (ctx, task) => {
         if (await pathExists(pathToStylelintConfig)) {
             let hasChanges = false;
-            const styleLintConfigurationData = await loadXmlFile(pathToStylelintConfig);
+            const styleLintConfigurationData = setupXMLStructure(await loadXmlFile(pathToStylelintConfig));
 
             if (styleLintConfigurationData.project.component && !Array.isArray(styleLintConfigurationData.project.component)) {
                 hasChanges = true;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/composer-settings-config.js

@@ -1,50 +1,39 @@
 const path = require('path');
-const { baseConfig } = require('../../../../config');
 const pathExists = require('../../../../util/path-exists');
 const { nameKey } = require('../keys');
 const { formatPathForPHPStormConfig } = require('../xml-utils');
 
 const COMPOSER_SETTINGS_COMPONENT_NAME = 'ComposerSettings';
 
-const pharPathKey = '@_pharPath';
+const composerKey = '@_composer';
 const doNotAskKey = '@_doNotAsk';
 const synchronizationStateKey = '@_synchronizationState';
 
 const composerJsonPath = path.join(process.cwd(), 'composer.json');
 const composerJsonFormattedPath = formatPathForPHPStormConfig(composerJsonPath);
-const composerPharPath = path.join(baseConfig.cacheDir, 'composer', 'composer.phar');
-const composerPharFormattedPath = formatPathForPHPStormConfig(composerPharPath);
 
 const defaultComposerSettingsProperties = {
     [doNotAskKey]: 'true',
     [synchronizationStateKey]: 'SYNCHRONIZE'
 };
 
-// TODO Ideally, we want to setup interpreter for compose.phar
-
-// It should look like this:
-// <component name="ComposerSettings" synchronizationState="DONT_SYNCHRONIZE">
-//     <pharConfigPath>$PROJECT_DIR$/composer.json</pharConfigPath>
-//     <execution>
-//         <phar
-//             pharPath="$PROJECT_DIR$/node_modules/.create-magento-app-cache/composer/composer.phar"
-//             interpreterId="f19b09e2-16e7-491f-9056-3299df58e578"
-//         />
-//     </execution>
-// </component>
-
 /**
  * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
-const setupComposerSettings = async (workspaceConfigs) => {
+const setupComposerSettings = async (workspaceConfigs, ctx) => {
     let hasChanges = false;
     const composerSettingsComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === COMPOSER_SETTINGS_COMPONENT_NAME
     );
 
     const isComposerJsonExists = await pathExists(composerJsonPath);
-    const isComposerPharExists = await pathExists(composerPharPath);
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const defaultInterpreterConfig = {
+        [nameKey]: ctx.debug ? php.debugImage : php.image,
+        [composerKey]: 'composer'
+    };
 
     if (composerSettingsComponent) {
         if (
@@ -55,17 +44,15 @@ const setupComposerSettings = async (workspaceConfigs) => {
             composerSettingsComponent.pharConfigPath = composerJsonFormattedPath;
         }
 
-        const pharConfig = composerSettingsComponent.execution && composerSettingsComponent.execution.phar;
+        const interpreterConfig = composerSettingsComponent.execution && composerSettingsComponent.execution.interpreter;
 
-        if (pharConfig && isComposerPharExists && !(pharPathKey in pharConfig)) {
-            hasChanges = true;
-            pharConfig[pharPathKey] = composerPharFormattedPath;
-        } else if (!pharConfig && isComposerPharExists) {
+        if (!interpreterConfig) {
             hasChanges = true;
             composerSettingsComponent.execution = composerSettingsComponent.execution || {};
-            composerSettingsComponent.execution.phar = {
-                [pharPathKey]: composerPharFormattedPath
-            };
+            composerSettingsComponent.execution.interpreter = defaultInterpreterConfig;
+        } else if (interpreterConfig[nameKey] !== defaultInterpreterConfig[nameKey]) {
+            hasChanges = true;
+            composerSettingsComponent.execution.interpreter[nameKey] = defaultInterpreterConfig[nameKey];
         }
     } else {
         hasChanges = true;
@@ -74,9 +61,7 @@ const setupComposerSettings = async (workspaceConfigs) => {
             ...defaultComposerSettingsProperties,
             pharConfigPath: composerJsonFormattedPath,
             execution: {
-                phar: {
-                    [pharPathKey]: composerPharFormattedPath
-                }
+                interpreter: defaultInterpreterConfig
             }
         });
     }

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

@@ -3,9 +3,15 @@ const pathExists = require('../../../../util/path-exists');
 const { setupXMLStructure } = require('../setup-xml-structure');
 const setupComposerSettings = require('./composer-settings-config');
 const setupFormatOnSave = require('./format-setting-config');
+const setupMessDetectorProjectConfiguration = require('./mess-detector-project-configuration-config');
+const setupPHPCodeSnifferProjectConfiguration = require('./php-code-sniffer-project-configuration-config');
+const setupPHPCSFixerProjectConfiguration = require('./php-cs-fixer-project-configuration-config');
 const setupPHPDebugGeneral = require('./php-debug-general-config');
 const setupPHPServers = require('./php-server-config');
+const setupPHPStanProjectConfiguration = require('./php-stan-project-configuration-config.js');
+const setupPHPWorkspaceProjectConfiguration = require('./php-workspace-project-configuration-config');
 const setupPropertiesComponent = require('./properties-component-config');
+const setupPSalmProjectConfiguration = require('./psalm-project-configuration-config.js');
 const setupRunManager = require('./run-manager-config');
 const { getWorkspaceConfig } = require('./workspace-config');
 
@@ -20,8 +26,15 @@ const setupWorkspaceConfig = () => ({
             const workspaceConfiguration = setupXMLStructure(await loadXmlFile(workspaceConfig.path));
             const workspaceConfigs = workspaceConfiguration.project.component;
             const hasChanges = await Promise.all([
-                setupPHPDebugGeneral(workspaceConfigs, workspaceConfig),
-                setupPHPServers(workspaceConfigs, workspaceConfig),
+                setupMessDetectorProjectConfiguration(workspaceConfigs),
+                setupPHPCSFixerProjectConfiguration(workspaceConfigs),
+                setupPHPCodeSnifferProjectConfiguration(workspaceConfigs),
+                setupPHPStanProjectConfiguration(workspaceConfigs),
+                setupPSalmProjectConfiguration(workspaceConfigs),
+                setupPHPWorkspaceProjectConfiguration(workspaceConfigs, ctx),
+                setupPHPDebugGeneral(workspaceConfigs),
+                setupPHPServers(workspaceConfigs, workspaceConfig, ctx),
+                setupComposerSettings(workspaceConfigs, ctx),
                 setupRunManager(workspaceConfigs, workspaceConfig),
                 setupPropertiesComponent(workspaceConfigs)
             ]);
@@ -39,11 +52,17 @@ const setupWorkspaceConfig = () => ({
         const workspaceConfigs = workspaceConfiguration.project.component;
 
         await Promise.all([
-            setupPHPDebugGeneral(workspaceConfigs, workspaceConfig),
-            setupPHPServers(workspaceConfigs, workspaceConfig),
+            setupMessDetectorProjectConfiguration(workspaceConfigs),
+            setupPHPCSFixerProjectConfiguration(workspaceConfigs),
+            setupPHPCodeSnifferProjectConfiguration(workspaceConfigs),
+            setupPHPStanProjectConfiguration(workspaceConfigs),
+            setupPSalmProjectConfiguration(workspaceConfigs),
+            setupPHPDebugGeneral(workspaceConfigs),
+            setupPHPServers(workspaceConfigs, workspaceConfig, ctx),
+            setupPHPWorkspaceProjectConfiguration(workspaceConfigs, ctx),
             setupRunManager(workspaceConfigs, workspaceConfig),
             setupPropertiesComponent(workspaceConfigs),
-            setupComposerSettings(workspaceConfigs),
+            setupComposerSettings(workspaceConfigs, ctx),
             setupFormatOnSave(workspaceConfigs)
         ]);