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

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)
         ]);
 

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/mess-detector-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME = 'MessDetectorProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupMessDetectorProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const messDetectorProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (messDetectorProjectConfigurationComponent) {
+        if (messDetectorProjectConfigurationComponent.option && !Array.isArray(messDetectorProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            messDetectorProjectConfigurationComponent.option = [messDetectorProjectConfigurationComponent.option];
+        } else if (!messDetectorProjectConfigurationComponent.option) {
+            hasChanges = true;
+            messDetectorProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            messDetectorProjectConfigurationComponent.option.length > 0
+            && !messDetectorProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            messDetectorProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMessDetectorProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-code-sniffer-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PHPCodeSnifferProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCodeSnifferProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpCodeSnifferProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpCodeSnifferProjectConfigurationComponent) {
+        if (phpCodeSnifferProjectConfigurationComponent.option && !Array.isArray(phpCodeSnifferProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpCodeSnifferProjectConfigurationComponent.option = [phpCodeSnifferProjectConfigurationComponent.option];
+        } else if (!phpCodeSnifferProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpCodeSnifferProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpCodeSnifferProjectConfigurationComponent.option.length > 0
+            && !phpCodeSnifferProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpCodeSnifferProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCodeSnifferProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-cs-fixer-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PHPCSFixerProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCSFixerProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpCSFixeProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpCSFixeProjectConfigurationComponent) {
+        if (phpCSFixeProjectConfigurationComponent.option && !Array.isArray(phpCSFixeProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpCSFixeProjectConfigurationComponent.option = [phpCSFixeProjectConfigurationComponent.option];
+        } else if (!phpCSFixeProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpCSFixeProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpCSFixeProjectConfigurationComponent.option.length > 0
+            && !phpCSFixeProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpCSFixeProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCSFixerProjectConfiguration;