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

use std::{fmt::Display, fs::exists};

use clap::{Args, ValueEnum};

use self::ecosystem::Ecosystem;

use super::ecosystem;

#[derive(Args, Debug)]
pub(crate) struct PackageManagerArgs {
    #[clap(long)]
    pub(crate) package_manager: Option<PackageManager>,
}

#[derive(Debug, Clone, ValueEnum, PartialEq, Eq)]
pub(crate) enum PackageManager {
    Npm,
    Bun,
    Yarn,
    Pnpm,
    Cargo,
}

impl Display for PackageManager {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                Self::Npm => "npm",
                Self::Bun => "bun",
                Self::Yarn => "yarn",
                Self::Pnpm => "pnpm",
                Self::Cargo => "cargo",
            }
        )
    }
}

pub(crate) const PACKAGE_JSON_PATH: &str = "./package.json";
pub(crate) const PACKAGE_LOCK_JSON_PATH: &str = "./package-lock.json";
pub(crate) const YARN_LOCK_PATH: &str = "./yarn.lock";
pub(crate) const YARN_PNPM_LOCK_YAML_PATH: &str = "./pnpm-lock.yaml";
const BUN_LOCK_PATH: &str = "./bun.lock";
const BUN_LOCKB_PATH: &str = "./bun.lockb";
const CARGO_TOML: &str = "./Cargo.toml";

impl PackageManager {
    pub(crate) fn auto_detect_preferred_package_manager_for_ecosystem(
        ecosystem: Ecosystem,
    ) -> Option<Self> {
        match ecosystem {
            Ecosystem::JavaScript => {
                if exists(BUN_LOCK_PATH).unwrap() || exists(BUN_LOCKB_PATH).unwrap() {
                    Some(Self::Bun)
                } else if exists(YARN_LOCK_PATH).unwrap() {
                    Some(Self::Yarn)
                } else if exists(YARN_PNPM_LOCK_YAML_PATH).unwrap() {
                    Some(Self::Pnpm)
                } else if exists(PACKAGE_JSON_PATH).unwrap() {
                    Some(Self::Npm)
                } else {
                    None
                }
            }
            Ecosystem::Rust => {
                if exists(CARGO_TOML).unwrap() {
                    Some(Self::Cargo)
                } else {
                    None
                }
            }
        }
    }

    // pub(crate) fn ecosystem(&self) -> Ecosystem {
    //     match self {
    //         PackageManager::Npm => Ecosystem::JavaScript,
    //         PackageManager::Bun => Ecosystem::JavaScript,
    //         PackageManager::Yarn => Ecosystem::JavaScript,
    //         PackageManager::Pnpm => Ecosystem::JavaScript,
    //         PackageManager::Cargo => Ecosystem::Rust,
    //     }
    // }
}