@nx/gradle 21.5.0-canary.20250821-4ba2085 → 21.5.0-canary.20250823-a93e74e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/gradle",
-  "version": "21.5.0-canary.20250821-4ba2085",
+  "version": "21.5.0-canary.20250823-a93e74e",
   "private": false,
   "description": "The Nx Plugin for Gradle allows Gradle tasks to be run through Nx",
   "repository": {
@@ -35,9 +35,9 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "21.5.0-canary.20250821-4ba2085",
-    "nx": "21.5.0-canary.20250821-4ba2085",
-    "smol-toml": "^1.4.1"
+    "@nx/devkit": "21.5.0-canary.20250823-a93e74e",
+    "nx": "21.5.0-canary.20250823-a93e74e",
+    "toml-eslint-parser": "^0.10.0"
   },
   "publishConfig": {
     "access": "public"

package/src/migrations/21-4-0/change-plugin-version-0-1-5.js

@@ -4,7 +4,7 @@ exports.default = update;
 const devkit_1 = require("@nx/devkit");
 const has_gradle_plugin_1 = require("../../utils/has-gradle-plugin");
 const gradle_project_graph_plugin_utils_1 = require("../../generators/init/gradle-project-graph-plugin-utils");
-const version_catalog_utils_1 = require("../../utils/version-catalog-utils");
+const version_catalog_ast_utils_1 = require("../../utils/version-catalog-ast-utils");
 /* Change the plugin version to 0.1.5
  */
 async function update(tree) {
@@ -16,8 +16,8 @@ async function update(tree) {
         return;
     }
     const gradlePluginVersionToUpdate = '0.1.5';
-    // Update version in version catalogs first
-    await (0, version_catalog_utils_1.updateNxPluginVersionInCatalogs)(tree, gradlePluginVersionToUpdate);
+    // Update version in version catalogs using AST-based approach to preserve formatting
+    await (0, version_catalog_ast_utils_1.updateNxPluginVersionInCatalogsAst)(tree, gradlePluginVersionToUpdate);
     // Then update in build.gradle(.kts) files
     await (0, gradle_project_graph_plugin_utils_1.addNxProjectGraphPlugin)(tree, gradlePluginVersionToUpdate);
 }

package/src/utils/version-catalog-ast-utils.d.ts

@@ -0,0 +1,15 @@
+import { Tree } from '@nx/devkit';
+export declare function findVersionCatalogFiles(tree: Tree): Promise<string[]>;
+/**
+ * Updates a plugin version in a TOML catalog while preserving formatting
+ */
+export declare function updatePluginVersionInCatalogAst(sourceText: string, pluginName: string, newVersion: string): string | null;
+/**
+ * Extracts plugin version from catalog using AST parsing
+ */
+export declare function extractPluginVersionFromCatalogAst(sourceText: string, pluginName: string): string | null;
+/**
+ * Updates Nx plugin version in all catalog files using AST-based approach
+ */
+export declare function updateNxPluginVersionInCatalogsAst(tree: Tree, expectedVersion: string): Promise<boolean>;
+//# sourceMappingURL=version-catalog-ast-utils.d.ts.map

package/src/utils/version-catalog-ast-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-catalog-ast-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/gradle/src/utils/version-catalog-ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,IAAI,EAAE,MAAM,YAAY,CAAC;AAI7C,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAW3E;AAiKD;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,IAAI,CA6Gf;AAED;;GAEG;AACH,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,IAAI,CA4Df;AAED;;GAEG;AACH,wBAAsB,kCAAkC,CACtD,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAkClB"}

package/src/utils/version-catalog-ast-utils.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findVersionCatalogFiles = findVersionCatalogFiles;
+exports.updatePluginVersionInCatalogAst = updatePluginVersionInCatalogAst;
+exports.extractPluginVersionFromCatalogAst = extractPluginVersionFromCatalogAst;
+exports.updateNxPluginVersionInCatalogsAst = updateNxPluginVersionInCatalogsAst;
+const devkit_1 = require("@nx/devkit");
+const toml_eslint_parser_1 = require("toml-eslint-parser");
+const versions_1 = require("./versions");
+async function findVersionCatalogFiles(tree) {
+    const versionCatalogPaths = [];
+    const globFiles = await (0, devkit_1.globAsync)(tree, ['**/gradle/*.versions.toml']);
+    for (const filePath of globFiles) {
+        if (!versionCatalogPaths.includes(filePath)) {
+            versionCatalogPaths.push(filePath);
+        }
+    }
+    return versionCatalogPaths;
+}
+/**
+ * Reconstructs TOML content from source text with selective replacements
+ * based on AST node ranges. This preserves all original formatting.
+ */
+function reconstructTomlWithUpdates(sourceText, updates) {
+    // Sort updates by start position in reverse order to apply from end to beginning
+    const sortedUpdates = updates.sort((a, b) => b.start - a.start);
+    let result = sourceText;
+    for (const update of sortedUpdates) {
+        result =
+            result.slice(0, update.start) +
+                update.replacement +
+                result.slice(update.end);
+    }
+    return result;
+}
+/**
+ * Finds a key-value pair in a TOML table by key name
+ */
+function findKeyValueInTable(table, keyName) {
+    if (!table.body)
+        return null;
+    for (const item of table.body) {
+        if (item.type === 'TOMLKeyValue') {
+            if (getKeyName(item.key) === keyName) {
+                return item;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Gets the string representation of a TOML key
+ */
+function getKeyName(key) {
+    if (key.type === 'TOMLKey' && key.keys && key.keys.length > 0) {
+        // Handle TOMLKey type which contains an array of keys (for dotted keys like version.ref)
+        return key.keys
+            .map((k) => {
+            if (k.type === 'TOMLBare') {
+                return k.name;
+            }
+            else if (k.type === 'TOMLQuoted') {
+                return k.value;
+            }
+            return '';
+        })
+            .join('.');
+    }
+    else if (key.type === 'TOMLBare') {
+        return key.name;
+    }
+    else if (key.type === 'TOMLQuoted') {
+        return key.value;
+    }
+    return '';
+}
+/**
+ * Gets the string value from a TOML value node
+ */
+function getStringValue(value) {
+    if (value.type === 'TOMLValue' && value.kind === 'string') {
+        return value.value;
+    }
+    return null;
+}
+/**
+ * Finds plugin configuration in the plugins table
+ */
+function findPluginConfig(pluginsTable, pluginName) {
+    if (!pluginsTable.body)
+        return null;
+    for (const item of pluginsTable.body) {
+        if (item.type === 'TOMLKeyValue') {
+            const value = item.value;
+            if (value.type === 'TOMLValue' && value.kind === 'string') {
+                // Simple format: plugin = "id:version"
+                const stringValue = value.value;
+                if (stringValue.startsWith(`${pluginName}:`)) {
+                    return { keyValue: item, format: 'simple' };
+                }
+            }
+            else if (value.type === 'TOMLInlineTable') {
+                // Object format: { id = "plugin.name", version = "1.0.0" }
+                const idKeyValue = findKeyValueInTable(value, 'id');
+                if (idKeyValue) {
+                    const idValue = getStringValue(idKeyValue.value);
+                    if (idValue === pluginName) {
+                        return { keyValue: item, format: 'object' };
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Finds the plugins table in the AST
+ */
+function findPluginsTable(ast) {
+    // Look through all top-level elements
+    for (const topLevel of ast.body) {
+        if (topLevel.type === 'TOMLTopLevelTable') {
+            // Look through the body of the top-level table for [plugins] table
+            for (const item of topLevel.body) {
+                if (item.type === 'TOMLTable' && item.key && item.key.keys) {
+                    const tableName = item.key.keys
+                        .map((key) => getKeyName(key))
+                        .join('.');
+                    if (tableName === 'plugins') {
+                        return item;
+                    }
+                }
+            }
+            // If no [plugins] table found, check if there's a plugins key in the root table
+            const pluginsKeyValue = findKeyValueInTable(topLevel, 'plugins');
+            if (pluginsKeyValue?.value.type === 'TOMLInlineTable') {
+                return pluginsKeyValue.value;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Finds the versions table in the AST
+ */
+function findVersionsTable(ast) {
+    // Look through all top-level elements
+    for (const topLevel of ast.body) {
+        if (topLevel.type === 'TOMLTopLevelTable') {
+            // Look through the body of the top-level table for [versions] table
+            for (const item of topLevel.body) {
+                if (item.type === 'TOMLTable' && item.key && item.key.keys) {
+                    const tableName = item.key.keys
+                        .map((key) => getKeyName(key))
+                        .join('.');
+                    if (tableName === 'versions') {
+                        return item;
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Updates a plugin version in a TOML catalog while preserving formatting
+ */
+function updatePluginVersionInCatalogAst(sourceText, pluginName, newVersion) {
+    try {
+        const ast = (0, toml_eslint_parser_1.parseTOML)(sourceText);
+        const updates = [];
+        const pluginsTable = findPluginsTable(ast);
+        if (!pluginsTable) {
+            return null; // No plugins table found
+        }
+        const pluginConfig = findPluginConfig(pluginsTable, pluginName);
+        if (!pluginConfig) {
+            return null; // Plugin not found
+        }
+        const { keyValue, format } = pluginConfig;
+        if (format === 'simple') {
+            // Update simple format: "plugin:version" -> "plugin:newVersion"
+            const value = keyValue.value;
+            const newValue = `${pluginName}:${newVersion}`;
+            // Preserve the quote style
+            const quote = value.style === 'basic' ? '"' : "'";
+            const replacement = `${quote}${newValue}${quote}`;
+            updates.push({
+                start: value.range[0],
+                end: value.range[1],
+                replacement,
+            });
+        }
+        else if (format === 'object') {
+            // Handle object format
+            const inlineTable = keyValue.value;
+            // First, try to find direct version
+            const versionKeyValue = findKeyValueInTable(inlineTable, 'version');
+            if (versionKeyValue) {
+                const versionValue = versionKeyValue.value;
+                if (versionValue.type === 'TOMLValue' &&
+                    versionValue.kind === 'string') {
+                    // Direct version update
+                    const quote = versionValue.style === 'basic' ? '"' : "'";
+                    const replacement = `${quote}${newVersion}${quote}`;
+                    updates.push({
+                        start: versionValue.range[0],
+                        end: versionValue.range[1],
+                        replacement,
+                    });
+                }
+            }
+            else {
+                // Check for version.ref pattern - look for either quoted or unquoted key
+                let versionRefKeyValue = findKeyValueInTable(inlineTable, 'version.ref');
+                if (!versionRefKeyValue) {
+                    // Try with quotes since TOML inline tables may require quoted keys for dotted keys
+                    versionRefKeyValue = findKeyValueInTable(inlineTable, '"version.ref"');
+                }
+                if (versionRefKeyValue) {
+                    // This means we need to update the referenced version in the [versions] table
+                    const refValue = getStringValue(versionRefKeyValue.value);
+                    if (refValue) {
+                        const versionsTable = findVersionsTable(ast);
+                        if (versionsTable) {
+                            const referencedVersion = findKeyValueInTable(versionsTable, refValue);
+                            if (referencedVersion) {
+                                const refVersionValue = referencedVersion.value;
+                                if (refVersionValue.type === 'TOMLValue' &&
+                                    refVersionValue.kind === 'string') {
+                                    const quote = refVersionValue.style === 'basic' ? '"' : "'";
+                                    const replacement = `${quote}${newVersion}${quote}`;
+                                    updates.push({
+                                        start: refVersionValue.range[0],
+                                        end: refVersionValue.range[1],
+                                        replacement,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (updates.length === 0) {
+            return null;
+        }
+        return reconstructTomlWithUpdates(sourceText, updates);
+    }
+    catch (error) {
+        console.error('Error parsing TOML with AST:', error);
+        return null;
+    }
+}
+/**
+ * Extracts plugin version from catalog using AST parsing
+ */
+function extractPluginVersionFromCatalogAst(sourceText, pluginName) {
+    try {
+        const ast = (0, toml_eslint_parser_1.parseTOML)(sourceText);
+        const pluginsTable = findPluginsTable(ast);
+        if (!pluginsTable) {
+            return null;
+        }
+        const pluginConfig = findPluginConfig(pluginsTable, pluginName);
+        if (!pluginConfig) {
+            return null;
+        }
+        const { keyValue, format } = pluginConfig;
+        if (format === 'simple') {
+            // Extract from simple format: "plugin:version"
+            const value = keyValue.value;
+            const stringValue = value.value;
+            return stringValue.split(':')[1] || null;
+        }
+        else if (format === 'object') {
+            // Extract from object format
+            const inlineTable = keyValue.value;
+            // First, try to find direct version
+            const versionKeyValue = findKeyValueInTable(inlineTable, 'version');
+            if (versionKeyValue) {
+                return getStringValue(versionKeyValue.value);
+            }
+            // Check for version.ref pattern - look for either quoted or unquoted key
+            let versionRefKeyValue = findKeyValueInTable(inlineTable, 'version.ref');
+            if (!versionRefKeyValue) {
+                // Try with quotes since TOML inline tables may require quoted keys for dotted keys
+                versionRefKeyValue = findKeyValueInTable(inlineTable, '"version.ref"');
+            }
+            if (versionRefKeyValue) {
+                const refValue = getStringValue(versionRefKeyValue.value);
+                if (refValue) {
+                    const versionsTable = findVersionsTable(ast);
+                    if (versionsTable) {
+                        const referencedVersion = findKeyValueInTable(versionsTable, refValue);
+                        if (referencedVersion) {
+                            return getStringValue(referencedVersion.value);
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('Error parsing TOML with AST:', error);
+        return null;
+    }
+}
+/**
+ * Updates Nx plugin version in all catalog files using AST-based approach
+ */
+async function updateNxPluginVersionInCatalogsAst(tree, expectedVersion) {
+    const catalogFiles = await findVersionCatalogFiles(tree);
+    let updated = false;
+    for (const catalogPath of catalogFiles) {
+        if (!tree.exists(catalogPath)) {
+            continue;
+        }
+        const content = tree.read(catalogPath, 'utf-8');
+        if (!content) {
+            continue;
+        }
+        const currentVersion = extractPluginVersionFromCatalogAst(content, versions_1.gradleProjectGraphPluginName);
+        if (currentVersion && currentVersion !== expectedVersion) {
+            const updatedContent = updatePluginVersionInCatalogAst(content, versions_1.gradleProjectGraphPluginName, expectedVersion);
+            if (updatedContent) {
+                tree.write(catalogPath, updatedContent);
+                updated = true;
+            }
+        }
+    }
+    return updated;
+}

package/src/utils/version-catalog-utils.d.ts

@@ -1,7 +0,0 @@
-import { Tree } from '@nx/devkit';
-import { TomlTable } from 'smol-toml';
-export declare function findVersionCatalogFiles(tree: Tree): Promise<string[]>;
-export declare function updatePluginVersionInCatalog(catalogContent: TomlTable, pluginName: string, newVersion: string): string;
-export declare function extractPluginVersionFromCatalog(catalogContent: TomlTable, pluginName: string): string | null;
-export declare function updateNxPluginVersionInCatalogs(tree: Tree, expectedVersion: string): Promise<boolean>;
-//# sourceMappingURL=version-catalog-utils.d.ts.map

package/src/utils/version-catalog-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version-catalog-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/gradle/src/utils/version-catalog-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAa,MAAM,YAAY,CAAC;AAG7C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAW3E;AAED,wBAAgB,4BAA4B,CAC1C,cAAc,EAAE,SAAS,EACzB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CA8CR;AAED,wBAAgB,+BAA+B,CAC7C,cAAc,EAAE,SAAS,EACzB,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,IAAI,CAwCf;AAED,wBAAsB,+BAA+B,CACnD,IAAI,EAAE,IAAI,EACV,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAoClB"}

package/src/utils/version-catalog-utils.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findVersionCatalogFiles = findVersionCatalogFiles;
-exports.updatePluginVersionInCatalog = updatePluginVersionInCatalog;
-exports.extractPluginVersionFromCatalog = extractPluginVersionFromCatalog;
-exports.updateNxPluginVersionInCatalogs = updateNxPluginVersionInCatalogs;
-const devkit_1 = require("@nx/devkit");
-const TOML = require("smol-toml");
-const versions_1 = require("./versions");
-async function findVersionCatalogFiles(tree) {
-    const versionCatalogPaths = [];
-    const globFiles = await (0, devkit_1.globAsync)(tree, ['**/gradle/*.versions.toml']);
-    for (const filePath of globFiles) {
-        if (!versionCatalogPaths.includes(filePath)) {
-            versionCatalogPaths.push(filePath);
-        }
-    }
-    return versionCatalogPaths;
-}
-function updatePluginVersionInCatalog(catalogContent, pluginName, newVersion) {
-    if (catalogContent.plugins) {
-        for (const [pluginAlias, pluginConfig] of Object.entries(catalogContent.plugins)) {
-            if (typeof pluginConfig === 'string') {
-                // Handle simple format: plugin = "id:version"
-                if (pluginConfig.startsWith(`${pluginName}:`)) {
-                    catalogContent.plugins[pluginAlias] = `${pluginName}:${newVersion}`;
-                    break;
-                }
-            }
-            else if (typeof pluginConfig === 'object' && pluginConfig !== null) {
-                // Handle object format: { id = "plugin.name", version = "1.0.0" }
-                const config = pluginConfig;
-                if (config.id === pluginName) {
-                    if (config.version && typeof config.version === 'string') {
-                        // Direct version
-                        config.version = newVersion;
-                    }
-                    else if (config.version &&
-                        typeof config.version === 'object' &&
-                        config.version.ref &&
-                        catalogContent.versions) {
-                        // Version reference in object form: version = { ref = "nx-version" }
-                        const versionRef = config.version.ref;
-                        if (catalogContent.versions[versionRef]) {
-                            catalogContent.versions[versionRef] = newVersion;
-                        }
-                    }
-                    else if (config['version.ref'] && catalogContent.versions) {
-                        let versionRef = config['version.ref'];
-                        // Handle the case where version.ref might be an object with ref property
-                        if (typeof versionRef === 'object' && versionRef.ref) {
-                            versionRef = versionRef.ref;
-                        }
-                        if (catalogContent.versions[versionRef]) {
-                            catalogContent.versions[versionRef] = newVersion;
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    return TOML.stringify(catalogContent);
-}
-function extractPluginVersionFromCatalog(catalogContent, pluginName) {
-    if (!catalogContent.plugins) {
-        return null;
-    }
-    for (const pluginConfig of Object.values(catalogContent.plugins)) {
-        if (typeof pluginConfig === 'string') {
-            // Handle simple format: plugin = "id:version"
-            if (pluginConfig.startsWith(`${pluginName}:`)) {
-                return pluginConfig.split(':')[1];
-            }
-        }
-        else if (typeof pluginConfig === 'object' && pluginConfig !== null) {
-            // Handle object format: { id = "plugin.name", version = "1.0.0" }
-            const config = pluginConfig;
-            if (config.id === pluginName) {
-                if (config.version && typeof config.version === 'string') {
-                    // Direct version
-                    return config.version;
-                }
-                else if (config.version &&
-                    typeof config.version === 'object' &&
-                    config.version.ref &&
-                    catalogContent.versions) {
-                    // Version reference in object form: version = { ref = "nx-version" }
-                    return catalogContent.versions[config.version.ref] || null;
-                }
-                else if (config['version.ref'] && catalogContent.versions) {
-                    // Version reference - look up the referenced version
-                    let versionRef = config['version.ref'];
-                    // Handle the case where version.ref might be an object with ref property
-                    if (typeof versionRef === 'object' && versionRef.ref) {
-                        versionRef = versionRef.ref;
-                    }
-                    return catalogContent.versions[versionRef] || null;
-                }
-            }
-        }
-    }
-    return null;
-}
-async function updateNxPluginVersionInCatalogs(tree, expectedVersion) {
-    const catalogFiles = await findVersionCatalogFiles(tree);
-    let updated = false;
-    for (const catalogPath of catalogFiles) {
-        if (!tree.exists(catalogPath)) {
-            continue;
-        }
-        const content = tree.read(catalogPath, 'utf-8');
-        if (!content) {
-            continue;
-        }
-        const parsedToml = TOML.parse(content);
-        if (!parsedToml.plugins) {
-            continue;
-        }
-        const currentVersion = extractPluginVersionFromCatalog(parsedToml, versions_1.gradleProjectGraphPluginName);
-        if (currentVersion && currentVersion !== expectedVersion) {
-            const updatedContent = updatePluginVersionInCatalog(parsedToml, versions_1.gradleProjectGraphPluginName, expectedVersion);
-            tree.write(catalogPath, updatedContent);
-            updated = true;
-        }
-    }
-    return updated;
-}