feat(builder): add skipGenerateIfCached parameter to CMakeBuilder (#26)

* feat(builder): add skipGenerateIfCached parameter to CMakeBuilder

Add a new optional parameter `skipGenerateIfCached` to the `CMakeBuilder.run` method. When set to `true`, the builder will skip the CMake generation step if a valid CMakeCache.txt exists and the last generation was successful, improving build performance for repeated builds. The last generation status is persisted to a file in the output directory to track success.

Add a corresponding unit test to verify the caching behavior.

* fix: correct CMake generation skip logic

The previous logic incorrectly skipped generation when skipGenerateIfCached was false. The condition was inverted, causing generation to be skipped when it should run. Now properly track skip state and only skip when both conditions are met.

* fix: correct logic for skipping CMake generation

The condition was inverted, causing generation to be skipped when it should run and vice versa. This prevented CMake projects from being generated when needed.

Author: rainyl

lib/src/builder/builder.dart

@@ -201,8 +201,17 @@ class CMakeBuilder implements Builder {
   /// Runs the CMake genetate and build process.
   ///
   /// Completes with an error if the build fails.
+  ///
+  /// - [skipGenerateIfCached]: Whether to skip generating the CMake project if it is already cached, that is,
+  ///   the `CMakeCache.txt` file exists in the output directory
+  ///   **AND** the last generate exit code is 0.
   @override
-  Future<void> run({required BuildInput input, required BuildOutputBuilder output, Logger? logger}) async {
+  Future<void> run({
+    required BuildInput input,
+    required BuildOutputBuilder output,
+    Logger? logger,
+    bool skipGenerateIfCached = false,
+  }) async {
     // do not override user specified output directory if they also set buildLocal to true
     if (outDir == null && buildLocal) {
       final os = input.config.code.targetOS;
@@ -313,7 +322,7 @@ class CMakeBuilder implements Builder {
       );
     }
 
-    await task.run(environment: envVars);
+    await task.run(environment: envVars, skipGenerateIfCached: skipGenerateIfCached);
   }
 
   /// Get environment variables from vcvarsXXX.bat

lib/src/builder/run_builder.dart

@@ -61,6 +61,9 @@ class RunCMakeBuilder {
   /// log level of CMake
   final LogLevel logLevel;
 
+  /// save the last generate status of native_toolchain_cmake
+  final String lastGenStatusFile;
+
   RunCMakeBuilder({
     required this.input,
     required this.codeConfig,
@@ -74,6 +77,7 @@ class RunCMakeBuilder {
     this.androidArgs = const AndroidBuilderArgs(),
     this.appleArgs = const AppleBuilderArgs(),
     this.logLevel = LogLevel.STATUS,
+    this.lastGenStatusFile = 'ntc_last_generate_status.txt',
     Uri? outputDir,
     UserConfig? userConfig,
   }) : outDir = outputDir ?? input.outputDirectory,
@@ -132,11 +136,30 @@ class RunCMakeBuilder {
 
   Uri androidSysroot(ToolInstance compiler) => compiler.uri.resolve('../sysroot/');
 
-  Future<void> run({Map<String, String>? environment}) async {
-    final result = await _generate(environment: environment);
-    if (result.exitCode != 0) {
-      throw Exception('Failed to generate CMake project: ${result.stderr}');
+  /// Run CMake to generate and build the project.
+  ///
+  /// - [environment] additional environment variables to pass to CMake.
+  /// - [skipGenerateIfCached] whether to skip generating the CMake project.
+  Future<void> run({Map<String, String>? environment, bool skipGenerateIfCached = false}) async {
+    bool skipGenerate = false;
+    if (skipGenerateIfCached) {
+      final cmakeCacheExists = await File.fromUri(outDir.resolve('CMakeCache.txt')).exists();
+      final lastGenExitCode = await getLastGenExitCode();
+      if (cmakeCacheExists && lastGenExitCode == 0) {
+        logger?.warning(
+          'CMake project is already successfully generated '
+          'and skipGenerateIfCached is requested, skip generating.',
+        );
+        skipGenerate = true;
+      }
+    }
+    if (!skipGenerate) {
+      final result = await _generate(environment: environment);
+      if (result.exitCode != 0) {
+        throw Exception('Failed to generate CMake project: ${result.stderr}');
+      }
     }
+
     final result1 = await _build(environment: environment);
     if (result1.exitCode != 0) {
       throw Exception('Failed to build CMake project: ${result1.stderr}');
@@ -168,7 +191,7 @@ class RunCMakeBuilder {
     }
     final _generator = generator.toArgs();
 
-    return runProcess(
+    final results = await runProcess(
       executable: await cmakePath(),
       arguments: [
         '--log-level=${logLevel.name}',
@@ -187,6 +210,17 @@ class RunCMakeBuilder {
       throwOnUnexpectedExitCode: false,
       environment: environment,
     );
+
+    // save the last generate status
+    final msg =
+        "command: ${results.command}\n"
+        "exitCode: ${results.exitCode}\n"
+    // "stdout: ${results.stdout}\n"
+    // "stderr: ${results.stderr}\n"
+    ;
+    await File.fromUri(outDir.resolve(lastGenStatusFile)).writeAsString(msg);
+
+    return results;
   }
 
   Future<RunProcessResult> _build({Map<String, String>? environment}) async {
@@ -306,6 +340,23 @@ class RunCMakeBuilder {
     return defs;
   }
 
+  /// Returns the exit code of the last CMake generate command.
+  ///
+  /// -1: not exist
+  /// 0: success
+  /// other: failed
+  Future<int> getLastGenExitCode() async {
+    final statusFile = File.fromUri(outDir.resolve(lastGenStatusFile));
+    if (!await statusFile.exists()) {
+      return -1;
+    }
+    final content = await statusFile.readAsLines();
+    final exitCode = int.tryParse(
+      content.firstWhere((line) => line.startsWith('exitCode: ')).split('exitCode: ')[1],
+    );
+    return exitCode ?? -1;
+  }
+
   static const androidAbis = {
     Architecture.arm: 'armeabi-v7a',
     Architecture.arm64: 'arm64-v8a',

test/builder/cmake_builder_cache_test.dart

@@ -0,0 +1,73 @@
+@OnPlatform({'mac-os': Timeout.factor(2), 'windows': Timeout.factor(10)})
+import 'dart:io';
+
+import 'package:code_assets/code_assets.dart';
+import 'package:hooks/hooks.dart';
+import 'package:native_toolchain_cmake/native_toolchain_cmake.dart';
+import 'package:test/test.dart';
+
+import '../helpers.dart';
+
+void main() {
+  const name = 'hello_world';
+  const sourceDir = 'test/builder/testfiles/hello_world';
+
+  test('CMakeBuilder skipGenerateIfCached', () async {
+    final tempUri = await tempDirForTest();
+    final tempUri2 = await tempDirForTest();
+
+    final logMessages = <String>[];
+    final logger = createCapturingLogger(logMessages);
+
+    final buildInputBuilder = BuildInputBuilder()
+      ..setupShared(
+        packageName: name,
+        packageRoot: tempUri,
+        outputFile: tempUri.resolve('output.json'),
+        outputDirectoryShared: tempUri2,
+      )
+      ..config.setupBuild(linkingEnabled: false)
+      ..addExtension(
+        CodeAssetExtension(
+          targetOS: OS.current,
+          macOS: OS.current == OS.macOS ? MacOSCodeConfig(targetVersion: defaultMacOSVersion) : null,
+          targetArchitecture: Architecture.current,
+          linkModePreference: LinkModePreference.dynamic,
+          cCompiler: cCompiler,
+        ),
+      );
+
+    final buildInput = BuildInput(buildInputBuilder.json);
+    final buildOutput = BuildOutputBuilder();
+
+    final builder = CMakeBuilder.create(
+      name: name,
+      sourceDir: Directory(sourceDir).absolute.uri,
+      buildMode: BuildMode.release,
+      androidArgs: const AndroidBuilderArgs(),
+      appleArgs: const AppleBuilderArgs(),
+    );
+
+    // First run: Generate and build
+    await builder.run(input: buildInput, output: buildOutput, logger: logger, skipGenerateIfCached: false);
+
+    // Verify first run logs DO NOT contain the skip message
+    expect(logMessages, isNot(contains(contains('CMake project is already successfully generated'))));
+
+    // Clear logs for second run
+    logMessages.clear();
+
+    // Second run: Skip generate if cached
+    await builder.run(input: buildInput, output: buildOutput, logger: logger, skipGenerateIfCached: true);
+
+    // Verify second run logs DO contain the skip message
+    expect(
+      logMessages,
+      contains(
+        contains(
+          'CMake project is already successfully generated and skipGenerateIfCached is requested, skip generating.',
+        ),
+      ),
+    );
+  });
+}