repo 0.14.13

An opinionated tool for repo management.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use std::{fs::exists, process::Stdio};

use clap::{Args, Subcommand};
use printable_shell_command::PrintableShellCommand;

use crate::common::{
    debug::DebugPrintable,
    ecosystem::Ecosystem,
    package_manager::{PackageManager, PackageManagerArgs, PACKAGE_LOCK_JSON_PATH},
};

#[derive(Args, Debug)]
pub(crate) struct SetupArgs {
    /// Run a specific setup command, or infer the ssetup command to run.
    #[command(subcommand)]
    command: Option<SetupCommand>,
}

#[derive(Debug, Subcommand)]
enum SetupCommand {
    /// Install dependencies
    Dependencies(PackageManagerArgs),
}

// TODO: skip empty deps?
fn npm_install() {
    println!("Installing dependencies using: `npm`");
    let install_commmand = match exists(PACKAGE_LOCK_JSON_PATH).unwrap() {
        true => "ci",
        false => {
            println!(
                "Using `npm install` instead of `npm ci` because the lockfile was not found at: {}\nThis may create a new lockfile.",
                PACKAGE_LOCK_JSON_PATH
            );
            "install"
        }
    };
    PrintableShellCommand::new("npm")
        .arg_each([install_commmand])
        .debug_print()
        .status()
        .expect("Could not install dependencies using `npm`");
}

fn bun_install() {
    println!("Installing dependencies using: `bun`");
    PrintableShellCommand::new("bun")
        .arg_each(["install", "--frozen-lockfile"])
        .debug_print()
        .status()
        .expect("Could not install dependencies using `bun`");
}

fn yarn_install() {
    println!("Installing dependencies using: `npx yarn`");
    PrintableShellCommand::new("npx")
        .arg_each(["yarn", "install", "--frozen-lockfile"])
        .debug_print()
        .status()
        .expect("Could not install dependencies using `npx yarn`");
}

fn pnpm_install() {
    println!("Installing dependencies using: `npx pnpm`");
    PrintableShellCommand::new("npx")
        .arg_each(["pnpm", "install", "--frozen-lockfile"])
        .debug_print()
        .status()
        .expect("Could not install dependencies using `npx pnpm`");
}

fn cargo_install() {
    println!("Installing dependencies using: `cargo`");
    println!("Installing dependencies by building the default target. For more information, see: https://github.com/rust-lang/cargo/issues/2644");
    // TODO: https://github.com/rust-lang/cargo/issues/2644
    PrintableShellCommand::new("cargo")
        .arg("build")
        .debug_print()
        .status()
        .expect("Could not install dependencies using `cargo`");
}

// TODO: multiple package managers in a single repo
fn setup_dependencies(package_manager_args: PackageManagerArgs) {
    // TODO: multiple ecosystems
    let package_manager = package_manager_args.package_manager;
    match package_manager {
        Some(PackageManager::Npm) => npm_install(),
        Some(PackageManager::Bun) => bun_install(),
        Some(PackageManager::Yarn) => yarn_install(),
        Some(PackageManager::Pnpm) => pnpm_install(),
        Some(PackageManager::Cargo) => cargo_install(),
        None => {
            if let Some(package_manager) =
                PackageManager::auto_detect_preferred_package_manager_for_ecosystem(
                    Ecosystem::JavaScript,
                )
            {
                // TODO: encode this in the type system
                match package_manager {
                    PackageManager::Npm => npm_install(),
                    PackageManager::Bun => bun_install(),
                    PackageManager::Yarn => yarn_install(),
                    PackageManager::Pnpm => pnpm_install(),
                    PackageManager::Cargo => panic!("unrechachable"),
                }
            }
            if let Some(package_manager) =
                PackageManager::auto_detect_preferred_package_manager_for_ecosystem(Ecosystem::Rust)
            {
                // TODO: encode this in the type system
                match package_manager {
                    PackageManager::Npm => panic!("unrechachable"),
                    PackageManager::Bun => panic!("unrechachable"),
                    PackageManager::Yarn => panic!("unrechachable"),
                    PackageManager::Pnpm => panic!("unrechachable"),
                    PackageManager::Cargo => cargo_install(),
                }
            }
        }
    }
}

pub(crate) fn make_setup_exists() -> bool {
    PrintableShellCommand::new("make")
        .arg_each(["-n", "setup"])
        .debug_print()
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .status()
        .expect("Could not detect whether `make setup` exists")
        .success()
}

pub(crate) fn make_setup() {
    PrintableShellCommand::new("make")
        .arg("setup")
        .debug_print()
        .status()
        .expect("Could not run `make setup` exists`");
}

pub(crate) fn setup_command(setup_args: SetupArgs) {
    match setup_args.command {
        None => {
            if make_setup_exists() {
                eprintln!("Running: make setup");
                make_setup();
            } else {
                setup_dependencies(PackageManagerArgs {
                    package_manager: None,
                });
            }
        }
        Some(SetupCommand::Dependencies(package_manager_args)) => {
            setup_dependencies(package_manager_args);
        }
    };
}