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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use clap::Parser;
use crossterm::style::Stylize;
use std::path::PathBuf;

use crate::Result;

/// Create a new Scoop bucket or manifest template
#[derive(Debug, Parser)]
#[clap(arg_required_else_help = true)]
pub struct Args {
    /// The name of the bucket to create
    name: String,

    /// Create a manifest template instead of a bucket
    #[arg(short = 'm', long, action = clap::ArgAction::SetTrue)]
    manifest: bool,

    /// Directory where to create the bucket (default: scoop root)
    #[arg(short = 'd', long)]
    directory: Option<String>,
}

pub fn execute(args: Args, session: &scoop_rs::Session) -> Result<()> {
    let config = session.config();
    let root_path = PathBuf::from(config.root_path());

    if args.manifest {
        create_manifest_template(&args.name, &root_path)?;
    } else {
        let dir = args
            .directory
            .map(PathBuf::from)
            .unwrap_or_else(|| root_path.join("buckets"));
        create_bucket(&args.name, &dir)?;
    }

    Ok(())
}

fn create_bucket(name: &str, dir: &std::path::Path) -> Result<()> {
    let bucket_dir = dir.join(name);

    if bucket_dir.exists() {
        eprintln!("Bucket directory already exists: {}", bucket_dir.display());
        return Ok(());
    }

    std::fs::create_dir_all(&bucket_dir)?;

    // Create a minimal bucket structure (manifests live in `bucket/`,
    // which is where enumeration looks for them).
    let bucket_subdir = bucket_dir.join("bucket");
    std::fs::create_dir_all(&bucket_subdir)?;

    let gitignore = bucket_dir.join(".gitignore");
    std::fs::write(&gitignore, "*.json\n")?;

    let readme = bucket_dir.join("README.md");
    std::fs::write(&readme, format!("# {}\n\n", name))?;

    let manifest = bucket_subdir.join(format!("{}.json", name));
    std::fs::write(&manifest, SAMPLE_MANIFEST)?;

    println!(
        "Created bucket '{}' at {}",
        name.green(),
        bucket_dir.display()
    );
    println!("\nTo add this bucket, run: bagger bucket add {}", name);

    Ok(())
}

fn create_manifest_template(name: &str, dir: &std::path::Path) -> Result<()> {
    let manifest_path = dir.join(format!("{}.json", name));

    if manifest_path.exists() {
        eprintln!("Manifest file already exists: {}", manifest_path.display());
        return Ok(());
    }

    std::fs::write(&manifest_path, SAMPLE_MANIFEST)?;

    println!(
        "Created manifest template at {}",
        manifest_path.display().to_string().green()
    );

    Ok(())
}

const SAMPLE_MANIFEST: &str = r#"{
  "version": "1.0.0",
  "description": "Example application",
  "homepage": "https://example.com",
  "license": "MIT",
  "url": "https://example.com/app-1.0.0.zip",
  "hash": "sha256:0000000000000000000000000000000000000000000000000000000000000000",
  "bin": "app.exe",
  "shortcuts": [
    [
      "app.exe",
      "App"
    ]
  ]
}"#;