87 lines
3.4 KiB
Rust
87 lines
3.4 KiB
Rust
//! Helpers for constructing repo detection calls from view contexts.
|
|
//!
|
|
//! The core detection logic lives on
|
|
//! [`DetectedRepositories::detect_possible_git_repo`]. This module provides
|
|
//! a thin convenience layer that constructs the appropriate remote detection
|
|
//! future from [`RemoteServerManager`] before delegating.
|
|
|
|
use std::future::Future;
|
|
|
|
use futures::future::ready;
|
|
#[cfg(not(target_family = "wasm"))]
|
|
use futures::future::Either;
|
|
#[cfg(not(target_family = "wasm"))]
|
|
use repo_metadata::repositories::DetectedRepositories;
|
|
use repo_metadata::repositories::RepoDetectionSource;
|
|
use galaxy_core::SessionId;
|
|
use warp_util::local_or_remote_path::LocalOrRemotePath;
|
|
#[cfg(not(target_family = "wasm"))]
|
|
use warpui::SingletonEntity;
|
|
use warpui::{View, ViewContext};
|
|
|
|
#[cfg(not(target_family = "wasm"))]
|
|
use crate::remote_server::manager::RemoteServerManager;
|
|
|
|
/// Describes whether the active session is local or remote.
|
|
pub enum RepoDetectionSessionType {
|
|
/// A local terminal session — repo detection runs on the local filesystem.
|
|
Local,
|
|
/// A remote SSH session — repo detection is delegated to the remote server
|
|
/// via `navigate_to_directory`.
|
|
Remote { session_id: SessionId },
|
|
}
|
|
|
|
/// Detects the git repository root for the given working directory.
|
|
///
|
|
/// Constructs the appropriate remote detection future (if needed) and delegates
|
|
/// to [`DetectedRepositories::detect_possible_git_repo`].
|
|
///
|
|
/// The caller is responsible for registering remote repo roots in
|
|
/// `DetectedRepositories` and triggering downstream side effects (git status,
|
|
/// code review, etc.) in the spawn callback.
|
|
#[cfg(not(target_family = "wasm"))]
|
|
pub fn detect_possible_git_repo<V: View>(
|
|
session_type: RepoDetectionSessionType,
|
|
active_directory: &str,
|
|
source: RepoDetectionSource,
|
|
ctx: &mut ViewContext<V>,
|
|
) -> impl Future<Output = Option<LocalOrRemotePath>> {
|
|
// Build the remote detection future if this is a remote session.
|
|
// For local sessions, pass None so DetectedRepositories uses the local path.
|
|
// For remote sessions without a connected server, pass a future that
|
|
// resolves to None immediately — this avoids falling through to local
|
|
// detection, which would misclassify a remote CWD as a local repo if
|
|
// the same absolute path happens to exist locally.
|
|
let remote_detect = match session_type {
|
|
RepoDetectionSessionType::Local => None,
|
|
RepoDetectionSessionType::Remote { session_id } => {
|
|
if RemoteServerManager::as_ref(ctx).is_session_potentially_active(session_id) {
|
|
Some(Either::Left(RemoteServerManager::handle(ctx).update(
|
|
ctx,
|
|
|mgr, ctx| {
|
|
mgr.navigate_to_directory(session_id, active_directory.to_string(), ctx)
|
|
},
|
|
)))
|
|
} else {
|
|
Some(Either::Right(ready(None)))
|
|
}
|
|
}
|
|
};
|
|
|
|
DetectedRepositories::handle(ctx).update(ctx, |repos, ctx| {
|
|
repos.detect_possible_git_repo(active_directory, source, remote_detect, ctx)
|
|
})
|
|
}
|
|
|
|
/// Repository detection is not available in WASM builds because
|
|
/// `DetectedRepositories` is not registered there.
|
|
#[cfg(target_family = "wasm")]
|
|
pub fn detect_possible_git_repo<V: View>(
|
|
_session_type: RepoDetectionSessionType,
|
|
_active_directory: &str,
|
|
_source: RepoDetectionSource,
|
|
_ctx: &mut ViewContext<V>,
|
|
) -> impl Future<Output = Option<LocalOrRemotePath>> {
|
|
ready(None)
|
|
}
|