bagger 0.1.0-beta.11

Bagger is a CLI implementation of Scoop in Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use clap::Parser;
use scoop_rs::{operation, Session};

use crate::Result;

/// Show package(s) basic information
#[derive(Debug, Parser)]
#[clap(arg_required_else_help = true)]
pub struct Args {
    /// The query string (regex supported)
    query: String,
}

pub fn execute(args: Args, session: &Session) -> Result<()> {
    let query = args.query;

    let queries = vec![query.as_str()];
    let options = vec![];
    let packages = operation::package_query(session, queries, options, false)?;
    let length = packages.len();
    match length {
        0 => eprintln!("Could not find package for query '{}'.", query),
        _ => {
            if length == 1 {
                println!("Found 1 package for query '{}':", query);
            } else {
                println!("Found {} package(s) for query '{}':", length, query);
            }

            for (idx, pkg) in packages.iter().enumerate() {
                // Ident
                println!("Identity: {}", pkg.ident());
                // Name
                println!("Name: {}", pkg.name());
                // Bucket
                println!("Bucket: {}", pkg.bucket());
                // Description
                println!(
                    "Description: {}",
                    pkg.description().unwrap_or("<no description>")
                );
                // Version
                println!("Version: {}", pkg.version());
                // Homepage
                println!("Homepage: {}", pkg.homepage());
                // License
                println!("License: {}", pkg.license());
                // Binaries
                println!(
                    "Shims: {}",
                    pkg.shims()
                        .map(|v| v.join(","))
                        .unwrap_or("<no shims>".to_owned())
                );
                // Dependencies (includes runtime deps)
                let deps = pkg.dependencies();
                println!(
                    "Dependencies: {}",
                    if deps.is_empty() {
                        "<none>".to_owned()
                    } else {
                        deps.join(", ")
                    }
                );
                // Explicit runtime deps
                if let Some(runtime) = pkg.manifest().runtime() {
                    if !runtime.is_empty() {
                        println!("Runtime: {}", runtime.join(", "));
                    }
                }

                if idx != (length - 1) {
                    println!();
                }
            }
        }
    }
    Ok(())
}