Enhance Composer handling with improved fallbacks and logging

Added fallback to default Composer directories and Windows-specific .bat extension detection for better cross-platform compatibility. Improved error handling, output trimming, and logging in Composer operations. Updated documentation to reflect new behaviors and troubleshooting steps.

Author: AviMoto

CHANGELOG.md

@@ -15,15 +15,23 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0).
 - New ComposerUtil for managing Composer operations
 - Added tests for MoodleSettingsForm and ComposerUtil
 - Added notification for PHP_Codesniffer configuration with automatic path detection and easy setup guidance
+- Added fallback to default Composer directories when command-line detection fails
+- Added Windows compatibility with automatic detection of .bat extensions for executables
 
 ### Changed
 
 - Improved PHP include path management in MoodleSettingsForm
 - Added support for setting the tool_path attribute for phpcs_by_interpreter configuration
+- Updated platform version from 251.23536.39 to 251.23774.350
+- Updated handlebars plugin version from 251.23536.38 to 251.23774.318
+- Enhanced error handling and logging in Composer operations
+- Improved verification of Moodle CS installation
 
 ### Fixed
 
 - Fixed issue in ComposerUtil.getComposerGlobalDir() where it was returning the command instead of the command results
+- Fixed path handling in getPhpcsPath() and getPhpcbfPath() for cross-platform compatibility
+- Fixed output handling in getComposerGlobalDir() by properly trimming whitespace and newlines
 
 
 ## [1.3.3] - 2025-02-28

README.md

@@ -96,12 +96,18 @@ If you need to adjust settings manually:
    - Verify Composer is installed and in PATH
    - Check Composer global installation directory permissions
    - Try running `composer global require moodlehq/moodle-cs` manually
+   - For Windows users, the plugin now automatically detects .bat extensions for executables
 
 3. **Code style not applying**
    - Ensure the plugin is enabled
    - Verify the Moodle project directory is correctly set
    - Try restarting the IDE
 
+4. **Composer operations failing**
+   - The plugin now includes improved error handling and fallback mechanisms
+   - Default Composer directories are checked if the command-line detection fails
+   - More detailed logs are available for troubleshooting
+
 ### Getting Help
 
 - Check the [plugin issues page](https://github.com/SysBind/moodle-dev/issues)

gradle.properties

@@ -12,11 +12,11 @@ pluginUntilBuild = 251.*
 
 # IntelliJ Platform Properties -> https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#configuration-intellij-extension
 platformType = PS
-platformVersion = 251.23536.39
+platformVersion = 251.23774.350
 
 # Plugin Dependencies -> https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
 # Example: platformPlugins = com.jetbrains.php:203.4449.22, org.intellij.scala:2023.3.27@EAP
-platformPlugins = com.dmarcotte.handlebars:251.23536.38
+platformPlugins = com.dmarcotte.handlebars:251.23774.318
 # Example: platformBundledPlugins = com.intellij.java
 platformBundledPlugins = com.jetbrains.php, JavaScript, org.jetbrains.plugins.less, org.jetbrains.plugins.sass
 # Gradle Releases -> https://github.com/gradle/gradle/releases

src/main/kotlin/il/co/sysbind/intellij/moodledev/util/ComposerUtil.kt

@@ -37,21 +37,61 @@ object ComposerUtil {
             processHandler.waitFor()
 
             if (processHandler.exitCode == 0 && output.isNotEmpty()) {
-                composerGlobalDir = output.toString()
+                // Clean up the output - remove any extra whitespace or newlines
+                composerGlobalDir = output.toString().trim()
+                LOG.debug("Found composer global directory: $composerGlobalDir")
                 return composerGlobalDir
+            } else {
+                LOG.warn("Composer command exited with code ${processHandler.exitCode} or empty output")
             }
         } catch (e: Exception) {
             LOG.error("Failed to get composer global directory: ${e.message}", e)
         }
+
+        // Fallback to default locations if composer command fails
+        val userHome = System.getProperty("user.home")
+        val possibleLocations = listOf(
+            "$userHome/.composer",                // Linux/Mac
+            "$userHome/AppData/Roaming/Composer"  // Windows
+        )
+
+        for (location in possibleLocations) {
+            val dir = java.io.File(location)
+            if (dir.exists() && dir.isDirectory) {
+                LOG.debug("Using fallback composer global directory: $location")
+                composerGlobalDir = location
+                return composerGlobalDir
+            }
+        }
+
+        LOG.warn("Could not determine composer global directory")
         return null
     }
 
     fun getPhpcsPath(): String? {
-        return getComposerGlobalDir()?.let { "$it/vendor/bin/phpcs" }
+        return getComposerGlobalDir()?.let { 
+            val path = java.io.File(it, "vendor/bin/phpcs")
+            if (System.getProperty("os.name").lowercase().contains("windows")) {
+                // On Windows, the executable might have a .bat extension
+                if (java.io.File("${path}.bat").exists()) {
+                    return@let "${path}.bat"
+                }
+            }
+            path.absolutePath
+        }
     }
 
     fun getPhpcbfPath(): String? {
-        return getComposerGlobalDir()?.let { "$it/vendor/bin/phpcbf" }
+        return getComposerGlobalDir()?.let { 
+            val path = java.io.File(it, "vendor/bin/phpcbf")
+            if (System.getProperty("os.name").lowercase().contains("windows")) {
+                // On Windows, the executable might have a .bat extension
+                if (java.io.File("${path}.bat").exists()) {
+                    return@let "${path}.bat"
+                }
+            }
+            path.absolutePath
+        }
     }
 
     fun runComposerInstall(project: Project, directory: String): Boolean {
@@ -90,20 +130,82 @@ object ComposerUtil {
     }
 
     fun setupMoodleCs(project: Project): Boolean {
+        LOG.debug("Setting up Moodle CS...")
+
+        // First check if phpcs and phpcbf already exist
+        val phpcsPath = getPhpcsPath()
+        val phpcbfPath = getPhpcbfPath()
+
+        if (phpcsPath != null && phpcbfPath != null) {
+            val phpcsFile = java.io.File(phpcsPath)
+            val phpcbfFile = java.io.File(phpcbfPath)
+
+            if (phpcsFile.exists() && phpcbfFile.exists()) {
+                LOG.debug("PHPCS and PHPCBF already exist, checking if moodle standard is available")
+
+                // Check if moodle standard is available
+                try {
+                    val commandLine = GeneralCommandLine(phpcsPath)
+                    commandLine.addParameters(listOf("-i"))
+
+                    val output = StringBuilder()
+                    val processHandler = OSProcessHandler(commandLine)
+                    processHandler.addProcessListener(object : ProcessAdapter() {
+                        override fun onTextAvailable(event: ProcessEvent, outputType: Key<*>) {
+                            output.append(event.text)
+                        }
+                    })
+
+                    processHandler.startNotify()
+                    processHandler.waitFor()
+
+                    if (processHandler.exitCode == 0 && output.toString().lowercase().contains("moodle")) {
+                        LOG.debug("Moodle standard is already available")
+                        return true
+                    }
+                } catch (e: Exception) {
+                    LOG.warn("Failed to check if moodle standard is available: ${e.message}")
+                    // Continue with setup
+                }
+            }
+        }
+
         try {
             // Set minimum-stability to dev
+            LOG.debug("Setting composer minimum-stability to dev")
             if (!executeComposerCommand(project, listOf("global", "config", "minimum-stability", "dev"))) {
-                LOG.error("Failed to set composer minimum-stability to dev")
-                return false
+                LOG.warn("Failed to set composer minimum-stability to dev, but continuing with installation")
             }
 
             // Install moodlehq/moodle-cs
+            LOG.debug("Installing moodlehq/moodle-cs")
             if (!executeComposerCommand(project, listOf("global", "require", "moodlehq/moodle-cs"))) {
                 LOG.error("Failed to install moodlehq/moodle-cs")
-                return false
+
+                // Try alternative approach - install with --dev flag
+                LOG.debug("Trying alternative approach with --dev flag")
+                if (!executeComposerCommand(project, listOf("global", "require", "--dev", "moodlehq/moodle-cs"))) {
+                    LOG.error("Failed to install moodlehq/moodle-cs with --dev flag")
+                    return false
+                }
             }
 
-            return true
+            // Verify installation
+            val newPhpcsPath = getPhpcsPath()
+            val newPhpcbfPath = getPhpcbfPath()
+
+            if (newPhpcsPath != null && newPhpcbfPath != null) {
+                val newPhpcsFile = java.io.File(newPhpcsPath)
+                val newPhpcbfFile = java.io.File(newPhpcbfPath)
+
+                if (newPhpcsFile.exists() && newPhpcbfFile.exists()) {
+                    LOG.debug("Successfully installed PHPCS and PHPCBF")
+                    return true
+                }
+            }
+
+            LOG.warn("PHPCS or PHPCBF not found after installation")
+            return false
         } catch (e: Exception) {
             LOG.error("Error setting up Moodle CS: ${e.message}", e)
             return false