IntentOS
/
carto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Great, this works now

This commit is contained in:
Russell 2025-07-28 19:07:04 +02:00
parent d115716d45
commit 57105f17f3
1 changed files with 107 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
src/main.rs
View File

@ -64,6 +64,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let cli = Cli::parse();
let managers = detect_available_managers();
if managers.is_empty() {
eprintln!("Warning: No package managers detected");
}
match cli.command {
Commands::Tree { depth, package, source } => {
handle_tree_command(&managers, depth, package, source)?;
@ -80,7 +84,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
Commands::Find { name, package, size } => {
handle_find_command(&managers, name, package, size)?;
}
Commands::Scan { force, paths , format, detailed, sizes, include_expected } => {
Commands::Scan { force, paths, format, detailed, sizes, include_expected } => {
handle_scan_command(&managers, paths, format, force, detailed, sizes, include_expected)?;
}
}
@ -92,23 +96,54 @@ fn handle_tree_command(
managers: &[Box<dyn PackageManager>],
_depth: Option<usize>,
package_filter: Option<String>,
_source_filter: Option<String>
source_filter: Option<String>
) -> Result<(), Box<dyn std::error::Error>> {
if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
if let Some(package_name) = package_filter {
// Show tree for specific package
cli::tree::print_package_tree(dnf.as_ref(), &package_name)?;
} else {
// Show tree for first few packages as demo
println!("Package file trees (first 5 packages):");
let packages = dnf.get_installed_packages()?;
for package in packages.iter().take(5) {
cli::tree::print_package_tree(dnf.as_ref(), &package.name)?;
println!(); // Empty line between packages
let target_managers: Vec<&Box<dyn PackageManager>> = if let Some(source_name) = source_filter {
// Filter to specific manager
managers.iter().filter(|m| m.name().to_lowercase() == source_name.to_lowercase()).collect()
} else {
// Use all managers
managers.iter().collect()
};
if target_managers.is_empty() {
println!("No suitable package managers found");
return Ok(());
}
if let Some(package_name) = package_filter {
// Show tree for specific package across all managers
let mut found = false;
for manager in &target_managers {
match manager.get_package_info(&package_name) {
Ok(Some(_)) => {
println!("Package '{}' from {}:", package_name, manager.name());
cli::tree::print_package_tree(manager.as_ref(), &package_name)?;
found = true;
println!();
}
Ok(None) => continue,
Err(e) => eprintln!("Error checking {} in {}: {}", package_name, manager.name(), e),
}
}
if !found {
println!("Package '{}' not found in any package manager", package_name);
}
} else {
println!("No DNF package manager found");
// Show tree for first few packages from each manager as demo
for manager in &target_managers {
match manager.get_installed_packages() {
Ok(packages) => {
println!("{} package file trees (first 3 packages):", manager.name());
for package in packages.iter().take(3) {
println!(" Package: {}", package.name);
cli::tree::print_package_tree(manager.as_ref(), &package.name)?;
println!();
}
}
Err(e) => eprintln!("Error getting packages from {}: {}", manager.name(), e),
}
}
}
Ok(())
}
@ -117,10 +152,13 @@ fn handle_package_command(
managers: &[Box<dyn PackageManager>],
name: &str
) -> Result<(), Box<dyn std::error::Error>> {
if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
match dnf.get_package_info(name) {
let mut found = false;
// Search all managers for the package
for manager in managers {
match manager.get_package_info(name) {
Ok(Some(info)) => {
println!("Package: {}", info.name);
println!("Package: {} (from {})", info.name, manager.name());
println!("Version: {}", info.version);
println!("Source: {}", info.source.name());
println!("Install time: {}", info.install_time);
@ -128,18 +166,25 @@ fn handle_package_command(
// Show file tree for this package
println!("\nFiles:");
cli::tree::print_package_tree(dnf.as_ref(), name)?;
cli::tree::print_package_tree(manager.as_ref(), name)?;
found = true;
println!();
}
Ok(None) => println!("Package '{}' not found", name),
Err(e) => println!("Error: {}", e),
Ok(None) => continue,
Err(e) => eprintln!("Error checking {} in {}: {}", name, manager.name(), e),
}
}
if !found {
println!("Package '{}' not found in any package manager", name);
}
Ok(())
}
fn handle_packages_command(
managers: &[Box<dyn PackageManager>],
source_filter: Option<String> // Removed the underscore!
source_filter: Option<String>
) -> Result<(), Box<dyn std::error::Error>> {
if let Some(source_name) = source_filter {
// Filter by specific source
@ -187,13 +232,32 @@ fn handle_file_command(
managers: &[Box<dyn PackageManager>],
path: &str
) -> Result<(), Box<dyn std::error::Error>> {
if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
match dnf.get_file_owner(std::path::Path::new(path)) {
Ok(Some(owner)) => println!("{} is owned by package: {}", path, owner),
Ok(None) => println!("{} is not owned by any package", path),
Err(e) => println!("Error checking {}: {}", path, e),
let path_obj = std::path::Path::new(path);
let mut owners = Vec::new();
// Check all managers for file ownership
for manager in managers {
match manager.get_file_owner(path_obj) {
Ok(Some(owner)) => {
owners.push((manager.name(), owner));
}
Ok(None) => continue,
Err(e) => eprintln!("Warning: Error checking {} in {}: {}", path, manager.name(), e),
}
}
if owners.is_empty() {
println!("{} is not owned by any package", path);
} else if owners.len() == 1 {
let (manager, owner) = &owners[0];
println!("{} is owned by package: {} ({})", path, owner, manager);
} else {
println!("{} is owned by multiple packages:", path);
for (manager, owner) in owners {
println!(" {} ({} package manager)", owner, manager);
}
}
Ok(())
}
@ -204,17 +268,28 @@ fn handle_find_command(
_size: Option<String>
) -> Result<(), Box<dyn std::error::Error>> {
if let Some(package_name) = package {
if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
match dnf.get_package_files(&package_name) {
let mut found = false;
// Search all managers for the package
for manager in managers {
match manager.get_package_files(&package_name) {
Ok(files) => {
println!("Files in package '{}':", package_name);
for file in files {
println!(" {}", file.display());
if !files.is_empty() {
println!("Files in package '{}' from {}:", package_name, manager.name());
for file in files {
println!(" {}", file.display());
}
found = true;
println!();
}
}
Err(e) => println!("Error: {}", e),
Err(e) => eprintln!("Error checking {} in {}: {}", package_name, manager.name(), e),
}
}
if !found {
println!("Package '{}' not found in any package manager", package_name);
}
} else {
println!("Find command needs more specific criteria");
}