Optimize java

Author: owjs3901

crates/vespera_core/src/openapi.rs

@@ -168,6 +168,63 @@ fn has_any_component_map(components: &Components) -> bool {
         || components.security_schemes.is_some()
 }
 
+/// Merge `other`'s per-method operations into `into` with **self-wins**
+/// semantics: an operation (or path-level field) already present on `into`
+/// is kept; a slot empty on `into` is filled from `other`.
+///
+/// Applied on a path-key conflict so two apps that define the same path
+/// under different methods both keep their operations, instead of the
+/// incoming [`PathItem`] being dropped whole.  Destructuring `other` keeps
+/// this exhaustive — adding a `PathItem` field forces this to be updated.
+fn merge_path_item(into: &mut PathItem, other: PathItem) {
+    let PathItem {
+        get,
+        post,
+        put,
+        patch,
+        delete,
+        head,
+        options,
+        trace,
+        parameters,
+        summary,
+        description,
+    } = other;
+    if into.get.is_none() {
+        into.get = get;
+    }
+    if into.post.is_none() {
+        into.post = post;
+    }
+    if into.put.is_none() {
+        into.put = put;
+    }
+    if into.patch.is_none() {
+        into.patch = patch;
+    }
+    if into.delete.is_none() {
+        into.delete = delete;
+    }
+    if into.head.is_none() {
+        into.head = head;
+    }
+    if into.options.is_none() {
+        into.options = options;
+    }
+    if into.trace.is_none() {
+        into.trace = trace;
+    }
+    if into.parameters.is_none() {
+        into.parameters = parameters;
+    }
+    if into.summary.is_none() {
+        into.summary = summary;
+    }
+    if into.description.is_none() {
+        into.description = description;
+    }
+}
+
 impl OpenApi {
     /// Merge another `OpenAPI` document into this one.
     ///
@@ -177,9 +234,21 @@ impl OpenApi {
     /// and `external_docs` are adopted from `other` only when `self` has
     /// not set its own. On any key/field conflict, `self` takes precedence.
     pub fn merge(&mut self, other: Self) {
-        // Merge paths (self takes precedence on conflict)
+        // Merge paths.  On a path-key conflict, merge per HTTP method
+        // (self-wins per operation) instead of dropping the incoming
+        // `PathItem` wholesale: two merged apps that both define the same
+        // path under DIFFERENT methods (parent `GET /users`, child
+        // `POST /users`) must keep BOTH operations in the generated
+        // document — otherwise the spec under-documents what the merged
+        // router actually serves at runtime.
         for (path, item) in other.paths {
-            self.paths.entry(path).or_insert(item);
+            use std::collections::btree_map::Entry;
+            match self.paths.entry(path) {
+                Entry::Vacant(slot) => {
+                    slot.insert(item);
+                }
+                Entry::Occupied(mut slot) => merge_path_item(slot.get_mut(), item),
+            }
         }
 
         // Merge components (every reusable component kind, self-wins on
@@ -314,6 +383,81 @@ mod tests {
         );
     }
 
+    fn create_post_path_item(summary: &str) -> PathItem {
+        PathItem {
+            post: Some(Operation {
+                summary: Some(summary.to_string()),
+                description: None,
+                operation_id: None,
+                tags: None,
+                parameters: None,
+                request_body: None,
+                responses: BTreeMap::new(),
+                security: None,
+                deprecated: None,
+            }),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn test_merge_same_path_different_methods_are_combined() {
+        // Regression: a path-key conflict must merge per HTTP method, not
+        // drop the incoming PathItem wholesale.  Parent defines GET /users,
+        // child defines POST /users — the merged document must expose BOTH
+        // operations (otherwise the spec under-documents the merged router).
+        let mut base = create_base_openapi();
+        base.paths
+            .insert("/users".to_string(), create_path_item("List users")); // GET
+
+        let mut other = create_base_openapi();
+        other
+            .paths
+            .insert("/users".to_string(), create_post_path_item("Create user")); // POST
+
+        base.merge(other);
+
+        let users = base.paths.get("/users").expect("/users present");
+        // self-wins GET is preserved
+        assert_eq!(
+            users.get.as_ref().unwrap().summary,
+            Some("List users".to_string())
+        );
+        // incoming POST is merged in (previously dropped on the whole-item
+        // `or_insert`)
+        assert_eq!(
+            users.post.as_ref().unwrap().summary,
+            Some("Create user".to_string())
+        );
+    }
+
+    #[test]
+    fn test_merge_same_path_same_method_self_wins() {
+        // Same path AND same method on both sides: self's operation is kept,
+        // the incoming one is discarded.
+        let mut base = create_base_openapi();
+        base.paths
+            .insert("/users".to_string(), create_path_item("Base get"));
+
+        let mut other = create_base_openapi();
+        other
+            .paths
+            .insert("/users".to_string(), create_path_item("Other get"));
+
+        base.merge(other);
+
+        assert_eq!(
+            base.paths
+                .get("/users")
+                .unwrap()
+                .get
+                .as_ref()
+                .unwrap()
+                .summary,
+            Some("Base get".to_string())
+        );
+    }
+
     #[test]
     fn test_merge_schemas() {
         let mut base = create_base_openapi();

crates/vespera_jni/src/streaming_closures.rs

@@ -451,10 +451,16 @@ pub fn close_input_stream(
     env: &mut jni::Env<'_>,
     stream: &Global<JObject<'static>>,
 ) -> jni::errors::Result<()> {
-    env.call_method(stream, jni_str!("close"), jni_sig!("()V"), &[])?;
+    let result = env.call_method(stream, jni_str!("close"), jni_sig!("()V"), &[]);
+    // Scrub a pending exception (e.g. an `IOException` from closing an
+    // already-broken stream) on BOTH success and failure — capturing the
+    // result and clearing BEFORE `?` so a throwing `close()` still leaves the
+    // thread clean, matching `complete_future{,_local}`'s self-contained
+    // contract (the prior `?`-before-clear returned early on a throw).
     if env.exception_check() {
         env.exception_clear();
     }
+    result?;
     Ok(())
 }
 

crates/vespera_macro/src/openapi_generator/paths.rs

@@ -26,7 +26,7 @@ use crate::{
     route_impl::StoredRouteInfo,
 };
 
-type FnIndex<'a> = HashMap<&'a str, HashMap<String, &'a syn::ItemFn>>;
+type FnIndex<'a> = HashMap<String, HashMap<String, &'a syn::ItemFn>>;
 type StorageFnSigs<'a> = HashMap<(Option<String>, &'a str), Option<&'a str>>;
 
 /// Build path items and collect tags from route metadata.
@@ -44,12 +44,23 @@ pub(super) fn build_path_items(
     let mut paths = BTreeMap::new();
     let mut all_tags = BTreeSet::new();
 
+    // Compute once: `cwd` anchors every path normalization below so the
+    // three path sources — `file_cache` keys (collector), route metadata
+    // spans, and ROUTE_STORAGE `#[route]` spans — compare in one canonical
+    // space (separator/relativity/case can differ, especially on Windows).
+    let cwd = std::env::current_dir().unwrap_or_default();
+
     // Build the file-AST function index FIRST so the storage path
     // below can skip any function whose AST is already reachable through
     // `file_cache`.  `collector::collect_metadata` has already walked
     // these files via `syn::parse_file`, so re-parsing `fn_sig_str`
     // from ROUTE_STORAGE for the same function is pure duplicated work.
-    let fn_index: HashMap<&str, HashMap<String, &syn::ItemFn>> = file_cache
+    //
+    // Keyed by the NORMALIZED path so the `already_in_ast` storage check
+    // and the main-loop AST lookup match regardless of path format — a raw
+    // key misses when the `#[route]` span path differs from the collector's
+    // `file_cache` key, needlessly re-parsing the signature on a worker.
+    let fn_index: FnIndex<'_> = file_cache
         .iter()
         .map(|(path, ast)| {
             let fns: HashMap<String, &syn::ItemFn> = ast
@@ -63,7 +74,7 @@ pub(super) fn build_path_items(
                     }
                 })
                 .collect();
-            (path.as_str(), fns)
+            (normalize_path_key(path, &cwd), fns)
         })
         .collect();
 
@@ -73,7 +84,6 @@ pub(super) fn build_path_items(
     // `syn::parse_str` + operation build runs on worker threads below;
     // `syn` ASTs are not `Send`, which is also why fn_index-backed
     // routes stay on this thread.
-    let cwd = std::env::current_dir().unwrap_or_default();
     let storage_fn_sigs = build_storage_fn_sigs(route_storage, &fn_index, &cwd);
 
     // Split routes by signature source. `idx` preserves the original
@@ -96,7 +106,7 @@ 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(route_meta.file_path.as_str())
+        } else if let Some(fns) = fn_index.get(&normalize_path_key(&route_meta.file_path, &cwd))
             && let Some(fn_item) = fns.get(&route_meta.function_name)
         {
             ast_jobs.push((idx, route_meta, &fn_item.sig));
@@ -179,7 +189,8 @@ fn build_storage_fn_sigs<'a>(
         let already_in_ast = s
             .file_path
             .as_deref()
-            .and_then(|fp| fn_index.get(fp))
+            .map(|fp| normalize_path_key(fp, cwd))
+            .and_then(|fp| fn_index.get(&fp))
             .is_some_and(|fns| fns.contains_key(&s.fn_name));
         if already_in_ast {
             continue;

crates/vespera_macro/src/schema_macro/file_lookup/lookup.rs

@@ -260,10 +260,19 @@ pub fn collect_rs_files_recursive(dir: &Path, files: &mut Vec<std::path::PathBuf
     };
 
     for entry in entries.flatten() {
+        // `entry.file_type()` reads the kind from the directory-entry data the
+        // OS already returned for this `read_dir` walk — no extra `metadata`
+        // stat per entry, unlike `path.is_dir()`.  Mirrors the established
+        // `file_utils::collect_with_mtimes_into` pattern (symlinks, which are
+        // neither file nor dir here, are skipped — never present in a `src/`
+        // tree this indexes).
+        let Ok(file_type) = entry.file_type() else {
+            continue;
+        };
         let path = entry.path();
-        if path.is_dir() {
+        if file_type.is_dir() {
             collect_rs_files_recursive(&path, files);
-        } else if path.extension().is_some_and(|ext| ext == "rs") {
+        } else if file_type.is_file() && path.extension().is_some_and(|ext| ext == "rs") {
             files.push(path);
         }
     }