Cleanup code

Author: owjs3901

crates/vespera_macro/src/openapi_generator/paths.rs

@@ -94,6 +94,14 @@ pub(super) fn build_path_items(
     for (idx, route_meta) in metadata.routes.iter().enumerate() {
         // ROUTE_STORAGE first (avoids file_cache dependency for known
         // routes) — same priority order as the previous sequential code.
+        //
+        // `normalize_path_key` canonicalises the path (allocates + folds
+        // `.`/`..` components + display-renders + Windows case-folds), so
+        // compute it ONCE per route and reuse the owned key: the storage
+        // lookup takes it by reference, and on a storage miss the `fn_index`
+        // fallback MOVES the same `String` out of `storage_key.0` instead of
+        // recomputing it.  The prior code ran the full normalization twice
+        // per route.
         let storage_key = (
             Some(normalize_path_key(&route_meta.file_path, &cwd)),
             route_meta.function_name.as_str(),
@@ -106,7 +114,8 @@ pub(super) fn build_path_items(
             .or_else(|| storage_fn_sigs.get(&legacy_storage_key).copied().flatten())
         {
             parallel_jobs.push((idx, route_meta, fn_sig_str));
-        } else if let Some(fns) = fn_index.get(&normalize_path_key(&route_meta.file_path, &cwd))
+        } else if let Some(norm_key) = storage_key.0
+            && let Some(fns) = fn_index.get(&norm_key)
             && let Some(fn_item) = fns.get(&route_meta.function_name)
         {
             ast_jobs.push((idx, route_meta, &fn_item.sig));
@@ -186,21 +195,19 @@ fn build_storage_fn_sigs<'a>(
 ) -> StorageFnSigs<'a> {
     let mut storage = HashMap::with_capacity(route_storage.len());
     for s in route_storage {
-        let already_in_ast = s
-            .file_path
-            .as_deref()
-            .map(|fp| normalize_path_key(fp, cwd))
-            .and_then(|fp| fn_index.get(&fp))
+        // Canonicalise the stored path ONCE per route (it allocates + folds
+        // path components + display-renders) and reuse it for both the
+        // `already_in_ast` skip check (by reference) and the storage key (by
+        // move) — the prior code ran the full normalization twice per route.
+        let norm_fp = s.file_path.as_deref().map(|fp| normalize_path_key(fp, cwd));
+        let already_in_ast = norm_fp
+            .as_ref()
+            .and_then(|fp| fn_index.get(fp))
             .is_some_and(|fns| fns.contains_key(&s.fn_name));
         if already_in_ast {
             continue;
         }
-        let key = (
-            s.file_path
-                .as_deref()
-                .map(|path| normalize_path_key(path, cwd)),
-            s.fn_name.as_str(),
-        );
+        let key = (norm_fp, s.fn_name.as_str());
         storage
             .entry(key)
             .and_modify(|slot| *slot = None)

libs/vespera-bridge-gradle-plugin/src/main/kotlin/kr/devfive/vespera/VesperaBridgeExtension.kt

@@ -57,4 +57,25 @@ abstract class VesperaBridgeExtension {
      * Java build to invoke cargo implicitly.
      */
     abstract val autoBuildCargo: Property<Boolean>
+
+    /**
+     * Cargo build profile selecting both the output subdirectory and the
+     * build flag. `"release"` (default) → `cargo build --release` →
+     * `target/release/`; `"dev"` (or `"debug"`) → plain `cargo build` →
+     * `target/debug/`; any other `"<p>"` → `cargo build --profile <p>` →
+     * `target/<p>/`. Lets debug or custom-profile cdylibs be bundled
+     * without hand-editing the plugin (the previous hardcoded `--release`
+     * forced every consumer onto the release profile).
+     */
+    abstract val cargoProfile: Property<String>
+
+    /**
+     * Base Cargo target directory that holds the per-profile output
+     * subdirectory. Defaults to `<cargoRoot>/target`. Set this when the
+     * workspace redirects Cargo output via `CARGO_TARGET_DIR` or a
+     * `.cargo/config.toml` `build.target-dir`, so the plugin locates the
+     * cdylib (and, when `autoBuildCargo` is on, directs cargo's output)
+     * at the right place instead of failing on the default `target/`.
+     */
+    abstract val targetDir: DirectoryProperty
 }

libs/vespera-bridge-gradle-plugin/src/main/kotlin/kr/devfive/vespera/VesperaBridgePlugin.kt

@@ -42,18 +42,24 @@ class VesperaBridgePlugin : Plugin<Project> {
             .create("vespera", VesperaBridgeExtension::class.java)
         ext.autoBuildCargo.convention(false)
         ext.cargoSourceRoots.convention(listOf("src", "crates", "examples"))
+        ext.cargoProfile.convention("release")
 
         // Compute platform-derived values eagerly (host machine info).
         val os = detectOs()
         val arch = detectArch()
         val generatedResourcesDir = project.layout.buildDirectory.dir("generated/vesperaNativeResources")
         val targetSubdir = "native/$os-$arch"
 
-        // Lazy file references — evaluated at task execution.
+        // Lazy file references — evaluated at task execution.  The cdylib
+        // lives under `<targetDir|cargoRoot/target>/<profileDir>/`, so a
+        // debug / custom-profile build or a redirected CARGO_TARGET_DIR is
+        // located correctly instead of being hardcoded to `target/release/`.
         val cdylibFile = project.provider {
-            val root = ext.cargoRoot.get().asFile
             val name = ext.crateName.get()
-            File(root, "target/release/" + mapLibraryName(os, name))
+            val targetBase =
+                if (ext.targetDir.isPresent) ext.targetDir.get().asFile
+                else File(ext.cargoRoot.get().asFile, "target")
+            File(targetBase, profileDir(ext.cargoProfile.get()) + "/" + mapLibraryName(os, name))
         }
 
         val cargoBuildTask = project.tasks.register(
@@ -64,7 +70,24 @@ class VesperaBridgePlugin : Plugin<Project> {
                     t.group = "vespera"
                     t.description = "Build the Rust cdylib via `cargo build --release`."
                     t.workingDir = ext.cargoRoot.get().asFile
-                    t.commandLine("cargo", "build", "-p", ext.crateName.get(), "--release")
+                    // Profile-aware command: `release` → `--release`, `dev`/
+                    // `debug` → default build, any other → `--profile <p>`.
+                    val profile = ext.cargoProfile.get()
+                    val cmd = mutableListOf("cargo", "build", "-p", ext.crateName.get())
+                    when (profile) {
+                        "release" -> cmd.add("--release")
+                        "dev", "debug" -> {} // default profile → target/debug
+                        else -> { cmd.add("--profile"); cmd.add(profile) }
+                    }
+                    t.commandLine(cmd)
+                    // Honour a redirected target dir so cargo writes where
+                    // `bundleNativeLib` later looks for the cdylib.
+                    if (ext.targetDir.isPresent) {
+                        t.environment(
+                            "CARGO_TARGET_DIR",
+                            ext.targetDir.get().asFile.absolutePath,
+                        )
+                    }
                     // Up-to-date check: re-run on workspace manifests, Cargo.lock,
                     // and Rust sources in configured roots. This repository keeps
                     // Rust code under crates/* and examples/*, not only src/.
@@ -97,8 +120,12 @@ class VesperaBridgePlugin : Plugin<Project> {
                             val src = cdylibFile.get()
                             require(src.exists()) {
                                 "Native library not found: $src\n" +
-                                    "Run: cargo build -p ${ext.crateName.get()} --release " +
-                                    "(or set vespera.autoBuildCargo = true)"
+                                    "Build the '${ext.crateName.get()}' cdylib for the " +
+                                    "'${ext.cargoProfile.get()}' profile (or set " +
+                                    "vespera.autoBuildCargo = true). If the workspace " +
+                                    "redirects Cargo output (CARGO_TARGET_DIR / " +
+                                    ".cargo/config.toml build.target-dir), set " +
+                                    "vespera.targetDir to that directory."
                             }
                         }
                     })
@@ -167,4 +194,14 @@ class VesperaBridgePlugin : Plugin<Project> {
         "macos" -> "lib$name.dylib"
         else -> "lib$name.so"
     }
+
+    /**
+     * Map a Cargo profile name to its `target/` output subdirectory.
+     * Cargo's built-in `dev` profile emits to `debug`; every other profile
+     * (`release`, or a custom `[profile.X]`) uses its own name verbatim.
+     */
+    private fun profileDir(profile: String): String = when (profile) {
+        "dev", "debug" -> "debug"
+        else -> profile
+    }
 }

libs/vespera-bridge/src/main/java/com/devfive/vespera/bridge/WireHeaderReader.java

@@ -502,17 +502,15 @@ String readString() {
         // decode loop below.
         int simpleLen = simpleAsciiRun();
         if (simpleLen >= 0) {
-            String s;
-            if (buf.hasArray()) {
-                // Heap-backed buffer (ByteBuffer.wrap on the SYNC / streaming
-                // / async paths): build the String straight from the backing
-                // array — one copy, no intermediate byte[].  Direct buffers
-                // (the DIRECT dispatch path) have no accessible array and keep
-                // the absolute bulk-get copy below.
-                s = WireHeaderStringSupport.readAsciiString(buf, pos, simpleLen);
-            } else {
-                s = WireHeaderStringSupport.readAsciiString(buf, pos, simpleLen);
-            }
+            // `readAsciiString` already branches on `buf.hasArray()` itself:
+            // heap-backed buffers (SYNC / streaming / async, ByteBuffer.wrap)
+            // build the String straight from the backing array (one copy, no
+            // intermediate byte[]), while direct buffers (the DIRECT dispatch
+            // path) fall back to a pooled-scratch bulk-get — so this single
+            // call is already optimal for both buffer kinds. The previous outer
+            // `if (buf.hasArray()) ... else ...` invoked the identical call in
+            // both arms (dead branch); collapsed here.
+            String s = WireHeaderStringSupport.readAsciiString(buf, pos, simpleLen);
             pos += simpleLen + 1; // consume the run + the closing quote
             return s;
         }