impr: add support for submodules in workspace

Author: cilki

src/lib.rs

@@ -72,6 +72,19 @@ impl RepoPattern {
     }
 }
 
+/// Represents a git submodule within a repository
+#[derive(Debug, Clone)]
+pub struct SubmoduleInfo {
+    /// The submodule name from .gitmodules
+    pub name: String,
+    /// Relative path within parent repo
+    pub path: PathBuf,
+    /// Clone URL
+    pub url: String,
+    /// Whether submodule is checked out
+    pub initialized: bool,
+}
+
 /// Recursively find "top-level" git repositories.
 /// This function will not traverse into .git directories or nested git repositories.
 /// Find all git repositories in the given path
@@ -115,6 +128,86 @@ pub fn find_git_repositories(path: &str) -> Result<Vec<PathBuf>> {
     Ok(found)
 }
 
+/// Find all submodules in a git repository by parsing the .gitmodules file
+pub fn find_submodules_in_repo(repo_path: &Path) -> Result<Vec<SubmoduleInfo>> {
+    let gitmodules_path = repo_path.join(".gitmodules");
+
+    // If .gitmodules doesn't exist, return empty vec
+    if !gitmodules_path.exists() {
+        return Ok(Vec::new());
+    }
+
+    let content = std::fs::read_to_string(&gitmodules_path)?;
+    let mut submodules = Vec::new();
+
+    // Simple parser for .gitmodules INI format
+    let mut current_name: Option<String> = None;
+    let mut current_path: Option<PathBuf> = None;
+    let mut current_url: Option<String> = None;
+
+    for line in content.lines() {
+        let line = line.trim();
+
+        // Skip empty lines and comments
+        if line.is_empty() || line.starts_with('#') || line.starts_with(';') {
+            continue;
+        }
+
+        // Parse [submodule "name"] section headers
+        if line.starts_with('[') && line.ends_with(']') {
+            // Save previous submodule if we have all required fields
+            if let (Some(name), Some(path), Some(url)) =
+                (current_name.take(), current_path.take(), current_url.take())
+            {
+                // Check if submodule is initialized
+                let initialized = repo_path.join(&path).join(".git").exists();
+
+                submodules.push(SubmoduleInfo {
+                    name: name.clone(),
+                    path,
+                    url,
+                    initialized,
+                });
+            }
+
+            // Extract submodule name from [submodule "name"]
+            if let Some(start) = line.find('"')
+                && let Some(end) = line.rfind('"')
+                && start < end
+            {
+                current_name = Some(line[start + 1..end].to_string());
+            }
+            continue;
+        }
+
+        // Parse key = value lines
+        if let Some(eq_pos) = line.find('=') {
+            let key = line[..eq_pos].trim();
+            let value = line[eq_pos + 1..].trim();
+
+            match key {
+                "path" => current_path = Some(PathBuf::from(value)),
+                "url" => current_url = Some(value.to_string()),
+                _ => {} // Ignore other fields
+            }
+        }
+    }
+
+    // Don't forget the last submodule
+    if let (Some(name), Some(path), Some(url)) = (current_name, current_path, current_url) {
+        let initialized = repo_path.join(&path).join(".git").exists();
+
+        submodules.push(SubmoduleInfo {
+            name,
+            path,
+            url,
+            initialized,
+        });
+    }
+
+    Ok(submodules)
+}
+
 /// Repository status information
 #[derive(Debug)]
 pub enum RepoStatus {

src/tui/mod.rs

@@ -777,10 +777,24 @@ fn ui(f: &mut Frame, app: &mut App) {
 
             // Add status icon for repos only
             if let Some(ref repo) = node.repo_info {
-                if repo.is_clean {
-                    spans.push(Span::styled("✓ ", Style::default().fg(Color::Green)));
+                if repo.is_submodule {
+                    // Submodule indicator
+                    if repo.submodule_initialized {
+                        spans.push(Span::styled("📦 ", Style::default().fg(Color::Magenta)));
+                    } else {
+                        spans.push(Span::styled("📦 ", Style::default().fg(Color::DarkGray)));
+                        spans.push(Span::styled(
+                            "(uninit) ",
+                            Style::default().fg(Color::DarkGray),
+                        ));
+                    }
                 } else {
-                    spans.push(Span::styled("⚠ ", Style::default().fg(Color::Yellow)));
+                    // Regular repo status
+                    if repo.is_clean {
+                        spans.push(Span::styled("✓ ", Style::default().fg(Color::Green)));
+                    } else {
+                        spans.push(Span::styled("⚠ ", Style::default().fg(Color::Yellow)));
+                    }
                 }
             }
 
@@ -1216,38 +1230,66 @@ fn render_highlighted_name<'a>(
 
 /// Collect workspace repositories with metadata
 fn collect_workspace_repos(workspace: &Workspace) -> Vec<RepoInfo> {
-    find_git_repositories(&workspace.path)
-        .unwrap_or_default()
-        .into_iter()
-        .map(|path| {
-            let display_name = path
-                .strip_prefix(&workspace.path)
-                .unwrap_or(&path)
-                .display()
-                .to_string()
-                .trim_start_matches('/')
-                .to_string();
-
-            // Check repo status and get modification time in a single repo open for performance
-            let (status, modification_time) = crate::check_repo_status_and_modification_time(&path)
-                .unwrap_or((crate::RepoStatus::NoCommits, None));
-
-            // A repo is only clean if it has commits, no changes, and no unpushed commits
-            let is_clean = matches!(status, crate::RepoStatus::Clean);
-
-            // Size not computed for workspace repos to save time
-            let size_bytes = None;
+    let repos = find_git_repositories(&workspace.path).unwrap_or_default();
+    let mut repo_infos = Vec::new();
+
+    for path in repos {
+        let display_name = path
+            .strip_prefix(&workspace.path)
+            .unwrap_or(&path)
+            .display()
+            .to_string()
+            .trim_start_matches('/')
+            .to_string();
+
+        // Check repo status and get modification time in a single repo open for performance
+        let (status, modification_time) = crate::check_repo_status_and_modification_time(&path)
+            .unwrap_or((crate::RepoStatus::NoCommits, None));
+
+        // A repo is only clean if it has commits, no changes, and no unpushed commits
+        let is_clean = matches!(status, crate::RepoStatus::Clean);
+
+        // Size not computed for workspace repos to save time
+        let size_bytes = None;
+
+        // Add the main repository
+        repo_infos.push(RepoInfo {
+            path: path.clone(),
+            display_name: display_name.clone(),
+            is_clean,
+            modification_time,
+            size_bytes,
+            operation_status: tree::RepoOperationStatus::None,
+            is_submodule: false,
+            submodule_initialized: false,
+            parent_repo_path: None,
+        });
+
+        // Find and add submodules
+        if let Ok(submodules) = crate::find_submodules_in_repo(&path) {
+            for submodule in submodules {
+                let submodule_display_name = if display_name.is_empty() {
+                    submodule.path.display().to_string()
+                } else {
+                    format!("{}/{}", display_name, submodule.path.display())
+                };
 
-            RepoInfo {
-                path,
-                display_name,
-                is_clean,
-                modification_time,
-                size_bytes,
-                operation_status: tree::RepoOperationStatus::None,
+                repo_infos.push(RepoInfo {
+                    path: path.join(&submodule.path),
+                    display_name: submodule_display_name,
+                    is_clean: true, // Submodule status computed separately
+                    modification_time: None,
+                    size_bytes: None,
+                    operation_status: tree::RepoOperationStatus::None,
+                    is_submodule: true,
+                    submodule_initialized: submodule.initialized,
+                    parent_repo_path: Some(path.clone()),
+                });
             }
-        })
-        .collect()
+        }
+    }
+
+    repo_infos
 }
 
 /// Collect library repositories with metadata
@@ -1270,6 +1312,9 @@ fn collect_library_repos(workspace: &Workspace) -> Vec<RepoInfo> {
                 modification_time,
                 size_bytes,
                 operation_status: tree::RepoOperationStatus::None,
+                is_submodule: false,
+                submodule_initialized: false,
+                parent_repo_path: None,
             }
         })
         .collect()

src/tui/tree.rs

@@ -39,6 +39,12 @@ pub struct RepoInfo {
     pub size_bytes: Option<u64>,
     /// Current operation status
     pub operation_status: RepoOperationStatus,
+    /// Whether this repo is a submodule
+    pub is_submodule: bool,
+    /// Whether this submodule is initialized (checked out)
+    pub submodule_initialized: bool,
+    /// Path to parent repository (for submodules)
+    pub parent_repo_path: Option<PathBuf>,
 }
 
 #[derive(Clone)]
@@ -78,6 +84,30 @@ impl TreeNode {
         }
     }
 
+    pub fn new_submodule(
+        name: String,
+        parent_path: PathBuf,
+        submodule_path: PathBuf,
+        initialized: bool,
+    ) -> Self {
+        Self {
+            name,
+            repo_info: Some(RepoInfo {
+                path: parent_path.join(&submodule_path),
+                display_name: submodule_path.display().to_string(),
+                is_clean: true, // Submodule status computed separately
+                modification_time: None,
+                size_bytes: None,
+                operation_status: RepoOperationStatus::None,
+                is_submodule: true,
+                submodule_initialized: initialized,
+                parent_repo_path: Some(parent_path),
+            }),
+            children: Vec::new(),
+            expanded: false, // Submodules start collapsed
+        }
+    }
+
     /// Flatten the tree into a list of (node, depth, index_path, full_path) tuples
     pub fn flatten(
         &self,
@@ -142,8 +172,13 @@ impl TreeNode {
 
 /// Build a tree structure from a flat list of repos
 pub fn build_tree(mut repos: Vec<RepoInfo>) -> Vec<TreeNode> {
-    // Sort repos by modification time (most recent first)
-    repos.sort_by(|a, b| {
+    // Separate regular repos from submodules
+    let (submodules, regular_repos): (Vec<_>, Vec<_>) =
+        repos.drain(..).partition(|r| r.is_submodule);
+
+    // Sort regular repos by modification time (most recent first)
+    let mut sorted_repos = regular_repos;
+    sorted_repos.sort_by(|a, b| {
         match (a.modification_time, b.modification_time) {
             (Some(a_time), Some(b_time)) => b_time.cmp(&a_time), // Most recent first
             (Some(_), None) => std::cmp::Ordering::Less,         // Items with time come first
@@ -154,7 +189,8 @@ pub fn build_tree(mut repos: Vec<RepoInfo>) -> Vec<TreeNode> {
 
     let mut root_nodes: Vec<TreeNode> = Vec::new();
 
-    for repo in repos {
+    // Build tree from regular repos
+    for repo in sorted_repos {
         let parts: Vec<&str> = repo.display_name.split('/').collect();
 
         if parts.is_empty() {
@@ -189,9 +225,68 @@ pub fn build_tree(mut repos: Vec<RepoInfo>) -> Vec<TreeNode> {
         }
     }
 
+    // Now insert submodules as children of their parent repos
+    for submodule in submodules {
+        insert_submodule_into_tree(&mut root_nodes, submodule);
+    }
+
     root_nodes
 }
 
+/// Helper function to insert a submodule into the tree as a child of its parent repo
+fn insert_submodule_into_tree(root_nodes: &mut Vec<TreeNode>, submodule: RepoInfo) {
+    let parent_path = match &submodule.parent_repo_path {
+        Some(path) => path,
+        None => return, // Shouldn't happen, but skip if no parent
+    };
+
+    // Find the parent repo node
+    if let Some(parent_node) = find_repo_node_by_path(root_nodes, parent_path) {
+        // Create submodule node
+        let submodule_name = submodule
+            .path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or(&submodule.display_name)
+            .to_string();
+
+        let submodule_node = TreeNode::new_submodule(
+            submodule_name,
+            parent_path.clone(),
+            submodule
+                .path
+                .strip_prefix(parent_path)
+                .unwrap_or(&submodule.path)
+                .to_path_buf(),
+            submodule.submodule_initialized,
+        );
+
+        // Add as child of parent
+        parent_node.children.push(submodule_node);
+    }
+}
+
+/// Recursively find a tree node by its repository path
+fn find_repo_node_by_path<'a>(
+    nodes: &'a mut Vec<TreeNode>,
+    path: &PathBuf,
+) -> Option<&'a mut TreeNode> {
+    for node in nodes {
+        // Check if this node matches
+        if let Some(ref repo_info) = node.repo_info
+            && &repo_info.path == path
+        {
+            return Some(node);
+        }
+
+        // Recursively check children
+        if let Some(found) = find_repo_node_by_path(&mut node.children, path) {
+            return Some(found);
+        }
+    }
+    None
+}
+
 /// Build library tree, excluding repos that exist in workspace
 pub fn build_library_tree(
     library_repos: Vec<RepoInfo>,