cargo_e/

e_target.rs

// src/e_target.rs
use anyhow::{Context, Result};
use log::debug;
use std::{
    collections::HashMap,
    ffi::OsString,
    fs,
    path::{Path, PathBuf},
};
use toml::Value;

#[derive(Debug, Clone)]
pub enum TargetOrigin {
    DefaultBinary(PathBuf),
    SingleFile(PathBuf),
    MultiFile(PathBuf),
    SubProject(PathBuf),
    Named(OsString),
}

#[derive(Debug, Clone, PartialEq, Hash, Eq, Copy)]
pub enum TargetKind {
    Unknown,
    Example,
    ExtendedExample,
    Binary,
    ExtendedBinary,
    Bench,
    Test,
    Manifest, // For browsing the entire Cargo.toml or package-level targets.
    ManifestTauri,
    ManifestTauriExample,
    ManifestDioxusExample,
    ManifestDioxus,
}

#[derive(Debug, Clone)]
pub struct CargoTarget {
    pub name: String,
    pub display_name: String,
    pub manifest_path: PathBuf,
    pub kind: TargetKind,
    pub extended: bool,
    pub origin: Option<TargetOrigin>,
}

impl CargoTarget {
    /// Constructs a CargoTarget from a source file.
    ///
    /// Reads the file at `file_path` and determines the target kind based on:
    /// - Tauri configuration (e.g. if the manifest's parent is "src-tauri" or a Tauri config exists),
    /// - Dioxus markers in the file contents,
    /// - And finally, if the file contains "fn main", using its parent directory (examples vs bin) to decide.
    ///
    /// If none of these conditions are met, returns None.
    pub fn from_source_file(
        stem: &std::ffi::OsStr,
        file_path: &Path,
        manifest_path: &Path,
        example: bool,
        extended: bool,
    ) -> Option<Self> {
        let file_path = fs::canonicalize(&file_path).unwrap_or(file_path.to_path_buf());
        let file_contents = std::fs::read_to_string(&file_path).unwrap_or_default();
        let (kind, new_manifest) = crate::e_discovery::determine_target_kind_and_manifest(
            manifest_path,
            &file_path,
            &file_contents,
            example,
            extended,
            None,
        );
        if kind == TargetKind::Unknown {
            return None;
        }
        let name = stem.to_string_lossy().to_string();
        Some(CargoTarget {
            name: name.clone(),
            display_name: name,
            manifest_path: new_manifest.to_path_buf(),
            kind,
            extended,
            origin: Some(TargetOrigin::SingleFile(file_path.to_path_buf())),
        })
    }

    /// Updates the target's name and display_name by interrogating the candidate file and its manifest.
    pub fn figure_main_name(&mut self) {
        // Only operate if we have a candidate file path.
        let candidate = match &self.origin {
            Some(TargetOrigin::SingleFile(path)) | Some(TargetOrigin::DefaultBinary(path)) => path,
            _ => {
                debug!("No candidate file found in target.origin; skipping name determination");
                return;
            }
        };

        // Get the candidate file's stem in lowercase.
        let candidate_stem = candidate
            .file_stem()
            .and_then(|s| s.to_str())
            .map(|s| s.to_lowercase())
            .unwrap_or_default();
        debug!("Candidate stem: {}", candidate_stem);

        // Start with folder-based logic.
        let mut name = if candidate_stem == "main" {
            if let Some(parent_dir) = candidate.parent() {
                if let Some(parent_name) = parent_dir.file_name().and_then(|s| s.to_str()) {
                    debug!("Candidate parent folder: {}", parent_name);
                    if parent_name.eq_ignore_ascii_case("src") {
                        // If candidate is src/main.rs, take the parent of "src".
                        parent_dir
                            .parent()
                            .and_then(|proj_dir| proj_dir.file_name())
                            .and_then(|s| s.to_str())
                            .map(|s| s.to_string())
                            .unwrap_or(candidate_stem.clone())
                    } else if parent_name.eq_ignore_ascii_case("examples") {
                        // If candidate is in an examples folder, use the candidate's parent folder's name.
                        candidate
                            .parent()
                            .and_then(|p| p.file_name())
                            .and_then(|s| s.to_str())
                            .map(|s| s.to_string())
                            .unwrap_or(candidate_stem.clone())
                    } else {
                        candidate_stem.clone()
                    }
                } else {
                    candidate_stem.clone()
                }
            } else {
                candidate_stem.clone()
            }
        } else {
            candidate_stem.clone()
        };
        debug!("Name after folder-based logic: {}", name);

        // If the candidate stem is "main", interrogate the manifest.
        if candidate_stem == "main" {
            let manifest_contents = fs::read_to_string(&self.manifest_path).unwrap_or_default();
            if let Ok(manifest_toml) = manifest_contents.parse::<Value>() {
                // Check for any [[bin]] entries.
                if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
                    debug!("Found {} [[bin]] entries", bins.len());
                    if let Some(bin_name) = bins.iter().find_map(|bin| {
                        if let Some(path_str) = bin.get("path").and_then(|p| p.as_str()) {
                            debug!("Checking bin entry with path: {}", path_str);
                            if path_str == "src/bin/main.rs" {
                                let bn = bin
                                    .get("name")
                                    .and_then(|n| n.as_str())
                                    .map(|s| s.to_string());
                                debug!("Found matching bin with name: {:?}", bn);
                                return bn;
                            }
                        }
                        None
                    }) {
                        debug!("Using bin name from manifest: {}", bin_name);
                        name = bin_name;
                    } else if let Some(pkg) = manifest_toml.get("package") {
                        debug!("No matching [[bin]] entry; checking [package] section");
                        name = pkg
                            .get("name")
                            .and_then(|n| n.as_str())
                            .unwrap_or(&name)
                            .to_string();
                        debug!("Using package name from manifest: {}", name);
                    }
                } else if let Some(pkg) = manifest_toml.get("package") {
                    debug!("No [[bin]] section found; using [package] section");
                    name = pkg
                        .get("name")
                        .and_then(|n| n.as_str())
                        .unwrap_or(&name)
                        .to_string();
                    debug!("Using package name from manifest: {}", name);
                } else {
                    debug!(
                        "Manifest does not contain [[bin]] or [package] sections; keeping name: {}",
                        name
                    );
                }
            } else {
                debug!("Failed to parse manifest TOML; keeping name: {}", name);
            }
        }

        debug!("Final determined name: {}", name);
        if name.eq("main") {
            panic!("Name is main");
        }
        self.name = name.clone();
        self.display_name = name;
    }

    /// Constructs a CargoTarget from a folder by trying to locate a runnable source file.
    ///
    /// The function attempts the following candidate paths in order:
    /// 1. A file named `<folder_name>.rs` in the folder.
    /// 2. `src/main.rs` inside the folder.
    /// 3. `main.rs` at the folder root.
    /// 4. Otherwise, it scans the folder for any `.rs` file containing `"fn main"`.
    ///
    /// Once a candidate is found, it reads its contents and calls `determine_target_kind`
    /// to refine the target kind based on Tauri or Dioxus markers. The `extended` flag
    /// indicates whether the target should be marked as extended (for instance, if the folder
    /// is a subdirectory of the primary "examples" or "bin" folder).
    ///
    /// Returns Some(CargoTarget) if a runnable file is found, or None otherwise.
    pub fn from_folder(
        folder: &Path,
        manifest_path: &Path,
        example: bool,
        _extended: bool,
    ) -> Option<Self> {
        // If the folder contains its own Cargo.toml, treat it as a subproject.
        let sub_manifest = folder.join("Cargo.toml");
        if sub_manifest.exists() {
            // Use the folder's name as the candidate target name.
            let folder_name = folder.file_name()?.to_string_lossy().to_string();
            // Determine the display name from the parent folder.
            let display_name = if let Some(parent) = folder.parent() {
                let parent_name = parent.file_name()?.to_string_lossy();
                if parent_name == folder_name {
                    // If the parent's name equals the folder's name, try using the grandparent.
                    if let Some(grandparent) = parent.parent() {
                        grandparent.file_name()?.to_string_lossy().to_string()
                    } else {
                        folder_name.clone()
                    }
                } else {
                    parent_name.to_string()
                }
            } else {
                folder_name.clone()
            };

            let sub_manifest =
                fs::canonicalize(&sub_manifest).unwrap_or(sub_manifest.to_path_buf());
            debug!("Subproject found: {}", sub_manifest.display());
            debug!("{}", &folder_name);
            return Some(CargoTarget {
                name: folder_name.clone(),
                display_name,
                manifest_path: sub_manifest.clone(),
                // For a subproject, we initially mark it as Manifest;
                // later refinement may resolve it further.
                kind: TargetKind::Manifest,
                extended: true,
                origin: Some(TargetOrigin::SubProject(sub_manifest)),
            });
        }
        // Extract the folder's name.
        let folder_name = folder.file_name()?.to_str()?;

        /// Returns Some(candidate) only if the file exists and its contents contain "fn main".
        fn candidate_with_main(candidate: PathBuf) -> Option<PathBuf> {
            if candidate.exists() {
                let contents = fs::read_to_string(&candidate).unwrap_or_default();
                if contents.contains("fn main") {
                    return Some(candidate);
                }
            }
            None
        }

        // In your from_folder function, for example:
        let candidate = if let Some(candidate) =
            candidate_with_main(folder.join(format!("{}.rs", folder_name)))
        {
            candidate
        } else if let Some(candidate) = candidate_with_main(folder.join("src/main.rs")) {
            candidate
        } else if let Some(candidate) = candidate_with_main(folder.join("main.rs")) {
            candidate
        } else {
            // Otherwise, scan the folder for any .rs file containing "fn main"
            let mut found = None;
            if let Ok(entries) = fs::read_dir(folder) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("rs") {
                        if let Some(candidate) = candidate_with_main(path) {
                            found = Some(candidate);
                            break;
                        }
                    }
                }
            }
            found?
        };

        let candidate = fs::canonicalize(&candidate).unwrap_or(candidate.to_path_buf());
        // Compute the extended flag based on the candidate file location.
        let extended = crate::e_discovery::is_extended_target(manifest_path, &candidate);

        // Read the candidate file's contents.
        let file_contents = std::fs::read_to_string(&candidate).unwrap_or_default();

        // Use our helper to determine if any special configuration applies.
        let (kind, new_manifest) = crate::e_discovery::determine_target_kind_and_manifest(
            manifest_path,
            &candidate,
            &file_contents,
            example,
            extended,
            None,
        );
        if kind == TargetKind::Unknown {
            return None;
        }

        // Determine the candidate file's stem in lowercase.
        let name = candidate.file_stem()?.to_str()?.to_lowercase();
        //         let name = if candidate_stem == "main" {
        //     if let Some(parent_dir) = candidate.parent() {
        //         if let Some(parent_name) = parent_dir.file_name().and_then(|s| s.to_str()) {
        //             if parent_name.eq_ignore_ascii_case("src") {
        //                 // If candidate is src/main.rs, take the parent of "src".
        //                 parent_dir.parent()
        //                     .and_then(|proj_dir| proj_dir.file_name())
        //                     .and_then(|s| s.to_str())
        //                     .map(|s| s.to_string())
        //                     .unwrap_or(candidate_stem.clone())
        //             } else if parent_name.eq_ignore_ascii_case("examples") {
        //                 // If candidate is in the examples folder (e.g. examples/main.rs),
        //                 // use the candidate's parent folder's name.
        //                 candidate.parent()
        //                     .and_then(|p| p.file_name())
        //                     .and_then(|s| s.to_str())
        //                     .map(|s| s.to_string())
        //                     .unwrap_or(candidate_stem.clone())
        //             } else {
        //                 // Fall back to the candidate_stem if no special case matches.
        //                 candidate_stem.clone()
        //             }
        //         } else {
        //             candidate_stem.clone()
        //         }
        //     } else {
        //         candidate_stem.clone()
        //     }
        // } else {
        //     candidate_stem.clone()
        // };
        // let name = if candidate_stem.clone() == "main" {
        //     // Read the manifest contents.
        //     let manifest_contents = fs::read_to_string(manifest_path).unwrap_or_default();
        //     if let Ok(manifest_toml) = manifest_contents.parse::<toml::Value>() {
        //         // Look for any [[bin]] entries.
        //         if let Some(bins) = manifest_toml.get("bin").and_then(|v| v.as_array()) {
        //             if let Some(bin_name) = bins.iter().find_map(|bin| {
        //                 if let Some(path_str) = bin.get("path").and_then(|p| p.as_str()) {
        //                     if path_str == "src/bin/main.rs" {
        //                         return bin.get("name").and_then(|n| n.as_str()).map(|s| s.to_string());
        //                     }
        //                 }
        //                 None
        //             }) {
        //                 // Found a bin with the matching path; use its name.
        //                 bin_name
        //             } else if let Some(pkg) = manifest_toml.get("package") {
        //                 // No matching bin entry, so use the package name.
        //                 pkg.get("name").and_then(|n| n.as_str()).unwrap_or(&candidate_stem).to_string()
        //             } else {
        //                 candidate_stem.to_string()
        //             }
        //         } else if let Some(pkg) = manifest_toml.get("package") {
        //             // No [[bin]] section; use the package name.
        //             pkg.get("name").and_then(|n| n.as_str()).unwrap_or(&candidate_stem).to_string()
        //         } else {
        //             candidate_stem.to_string()
        //         }
        //     } else {
        //         candidate_stem.to_string()
        //     }
        // } else {
        //     candidate_stem.to_string()
        // };
        let mut target = CargoTarget {
            name: name.clone(),
            display_name: name,
            manifest_path: new_manifest.to_path_buf(),
            kind,
            extended,
            origin: Some(TargetOrigin::SingleFile(candidate)),
        };
        // Call the method to update name based on the candidate and manifest.
        target.figure_main_name();
        Some(target)
    }
    /// Returns a refined CargoTarget based on its file contents and location.
    /// This function is pure; it takes an immutable CargoTarget and returns a new one.
    /// If the target's origin is either SingleFile or DefaultBinary, it reads the file and uses
    /// `determine_target_kind` to update the kind accordingly.
    pub fn refined_target(target: &CargoTarget) -> CargoTarget {
        let mut refined = target.clone();

        // Operate only if the target has a file to inspect.
        let file_path = match &refined.origin {
            Some(TargetOrigin::SingleFile(path)) | Some(TargetOrigin::DefaultBinary(path)) => path,
            _ => return refined,
        };

        let file_path = fs::canonicalize(&file_path).unwrap_or(file_path.to_path_buf());
        let file_contents = std::fs::read_to_string(&file_path).unwrap_or_default();

        let (new_kind, new_manifest) = crate::e_discovery::determine_target_kind_and_manifest(
            &refined.manifest_path,
            &file_path,
            &file_contents,
            refined.is_example(),
            refined.extended,
            Some(refined.kind),
        );
        refined.kind = new_kind;
        refined.manifest_path = new_manifest;
        refined.figure_main_name();
        refined
    }

    /// Expands a subproject CargoTarget into multiple runnable targets.
    ///
    /// If the given target's origin is a subproject (i.e. its Cargo.toml is in a subfolder),
    /// this function loads that Cargo.toml and uses `get_runnable_targets` to discover its runnable targets.
    /// It then flattens and returns them as a single `Vec<CargoTarget>`.
    pub fn expand_subproject(target: &CargoTarget) -> Result<Vec<CargoTarget>> {
        // Ensure the target is a subproject.
        if let Some(TargetOrigin::SubProject(sub_manifest)) = &target.origin {
            // Use get_runnable_targets to get targets defined in the subproject.
            let (bins, examples, benches, tests) =
                crate::e_manifest::get_runnable_targets(sub_manifest).with_context(|| {
                    format!(
                        "Failed to get runnable targets from {}",
                        sub_manifest.display()
                    )
                })?;
            let mut sub_targets = Vec::new();
            sub_targets.extend(bins);
            sub_targets.extend(examples);
            sub_targets.extend(benches);
            sub_targets.extend(tests);

            // Optionally mark these targets as extended.
            for t in &mut sub_targets {
                t.extended = true;
                match t.kind {
                    TargetKind::Example => t.kind = TargetKind::ExtendedExample,
                    TargetKind::Binary => t.kind = TargetKind::ExtendedBinary,
                    _ => {} // For other kinds, you may leave them unchanged.
                }
            }
            Ok(sub_targets)
        } else {
            // If the target is not a subproject, return an empty vector.
            Ok(vec![])
        }
    }

    /// Expands subproject targets in the given map.
    /// For every target with a SubProject origin, this function removes the original target,
    /// expands it using `expand_subproject`, and then inserts the expanded targets.
    /// The expanded targets have their display names modified to include the original folder name as a prefix.
    /// This version replaces any existing target with the same key.
    pub fn expand_subprojects_in_place(
        targets_map: &mut HashMap<(String, String), CargoTarget>,
    ) -> Result<()> {
        // Collect keys for targets that are subprojects.
        let sub_keys: Vec<(String, String)> = targets_map
            .iter()
            .filter_map(|(key, target)| {
                if let Some(TargetOrigin::SubProject(_)) = target.origin {
                    Some(key.clone())
                } else {
                    None
                }
            })
            .collect();

        for key in sub_keys {
            if let Some(sub_target) = targets_map.remove(&key) {
                // Expand the subproject target.
                let expanded_targets = Self::expand_subproject(&sub_target)?;
                for mut new_target in expanded_targets {
                    // Update the display name to include the subproject folder name.
                    // For example, if sub_target.display_name was "foo" and new_target.name is "bar",
                    // the new display name becomes "foo > bar".
                    new_target.display_name =
                        format!("{} > {}", sub_target.display_name, new_target.name);
                    // Create a key for the expanded target.
                    let new_key = Self::target_key(&new_target);
                    // Replace any existing target with the same key.
                    targets_map.insert(new_key, new_target);
                }
            }
        }
        Ok(())
    }
    // /// Expands subproject targets in `targets`. Any target whose origin is a SubProject
    // /// is replaced by the targets returned by `expand_subproject`. If the expansion fails,
    // /// you can choose to log the error and keep the original target, or remove it.
    // pub fn expand_subprojects_in_place(
    //     targets_map: &mut HashMap<(String, String), CargoTarget>
    // ) -> anyhow::Result<()> {
    //     // Collect keys for subproject targets.
    //     let sub_keys: Vec<(String, String)> = targets_map
    //         .iter()
    //         .filter_map(|(key, target)| {
    //             if let Some(crate::e_target::TargetOrigin::SubProject(_)) = target.origin {
    //                 Some(key.clone())
    //             } else {
    //                 None
    //             }
    //         })
    //         .collect();

    //     // For each subproject target, remove it from the map, expand it, and insert the new targets.
    //     for key in sub_keys {
    //         if let Some(sub_target) = targets_map.remove(&key) {
    //             let expanded = Self::expand_subproject(&sub_target)?;
    //             for new_target in expanded {
    //                 let new_key = CargoTarget::target_key(&new_target);
    //                 targets_map.entry(new_key).or_insert(new_target);
    //             }
    //         }
    //     }
    //     Ok(())
    // }

    /// Creates a unique key for a target based on its manifest path and name.
    pub fn target_key(target: &CargoTarget) -> (String, String) {
        let manifest = target
            .manifest_path
            .canonicalize()
            .unwrap_or_else(|_| target.manifest_path.clone())
            .to_string_lossy()
            .into_owned();
        let name = target.name.clone();
        (manifest, name)
    }

    /// Expands a subproject target into multiple targets and inserts them into the provided HashMap,
    /// using (manifest, name) as a key to avoid duplicates.
    pub fn expand_subproject_into_map(
        target: &CargoTarget,
        map: &mut std::collections::HashMap<(String, String), CargoTarget>,
    ) -> Result<(), Box<dyn std::error::Error>> {
        // Only operate if the target is a subproject.
        if let Some(crate::e_target::TargetOrigin::SubProject(sub_manifest)) = &target.origin {
            // Discover targets in the subproject.
            let (bins, examples, benches, tests) =
                crate::e_manifest::get_runnable_targets(sub_manifest)?;
            let mut new_targets = Vec::new();
            new_targets.extend(bins);
            new_targets.extend(examples);
            new_targets.extend(benches);
            new_targets.extend(tests);
            // Mark these targets as extended.
            for t in &mut new_targets {
                t.extended = true;
            }
            // Insert each new target if not already present.
            for new in new_targets {
                let key = CargoTarget::target_key(&new);
                map.entry(key).or_insert(new.clone());
            }
        }
        Ok(())
    }

    /// Returns true if the target is an example.
    pub fn is_example(&self) -> bool {
        matches!(
            self.kind,
            TargetKind::Example
                | TargetKind::ExtendedExample
                | TargetKind::ManifestDioxusExample
                | TargetKind::ManifestTauriExample
        )
    }
}

/// Returns the "depth" of a path, i.e. the number of components.
pub fn path_depth(path: &Path) -> usize {
    path.components().count()
}

/// Deduplicates targets that share the same (name, origin key). If duplicates are found,
/// the target with the manifest path of greater depth is kept.
pub fn dedup_targets(targets: Vec<CargoTarget>) -> Vec<CargoTarget> {
    let mut grouped: HashMap<(String, Option<String>), CargoTarget> = HashMap::new();

    for target in targets {
        // We'll group targets by (target.name, origin_key)
        // Create an origin key if available by canonicalizing the origin path.
        let origin_key = target.origin.as_ref().and_then(|origin| match origin {
            TargetOrigin::SingleFile(path)
            | TargetOrigin::DefaultBinary(path)
            | TargetOrigin::SubProject(path) => path
                .canonicalize()
                .ok()
                .map(|p| p.to_string_lossy().into_owned()),
            _ => None,
        });
        let key = (target.name.clone(), origin_key);

        grouped
            .entry(key)
            .and_modify(|existing| {
                let current_depth = path_depth(&target.manifest_path);
                let existing_depth = path_depth(&existing.manifest_path);
                // If the current target's manifest path is deeper, replace the existing target.
                if current_depth > existing_depth {
                    *existing = target.clone();
                }
            })
            .or_insert(target);
    }

    grouped.into_values().collect()
}