rpkg 0.3.1

A lightweight CLI wrapper around Rscript for installing R packages from CRAN or elsewhere
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

mod cli;
mod cran;

use crate::cli::*;
use crate::cran::*;

use clap::Parser;
use std::process::Command;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Cli::parse();
    let cran_repo = resolve_cran_repo(&args)?;
    let Cli {
        packages,
        library,
        github,
        gitlab,
        bitbucket,
        codeberg,
        url,
        update,
        ..
    } = args;

    let mut expr_parts = Vec::new();

    if library.is_none() {
        expr_parts.push(
            r#"local({
    lib <- .libPaths()[1]
    if (file.access(lib, 2) != 0) {
        user_lib <- Sys.getenv("R_LIBS_USER")
        if (!nzchar(user_lib)) stop("R_LIBS_USER is not set and default library is not writable")
        user_lib <- normalizePath(user_lib, mustWork = FALSE)
        if (!dir.exists(user_lib)) {
            message(sprintf("Creating personal library: %s", user_lib))
            dir.create(user_lib, recursive = TRUE)
        }
        .libPaths(c(user_lib, .libPaths()))
    }
})"#
            .to_string(),
        );
    }

    if update {
        let mut urls: Vec<String> = Vec::new();
        if let Some(additional_url) = &url {
            urls.push(format!("\"{}\"", escape_r_string(additional_url)));
        }
        urls.push(format!("\"{}\"", escape_r_string(&cran_repo)));

        let repos_expr = urls.join(", ");

        let mut update_expr = format!("update.packages(ask = FALSE, repos = c({}))", repos_expr);

        if let Some(lib) = &library {
            update_expr = format!(
                "update.packages(ask = FALSE, lib.loc = \"{}\", repos = c({}))",
                escape_r_string(lib),
                repos_expr
            );
        }

        expr_parts.push(update_expr);
    }

    if !packages.is_empty() {
        let pkg_list = packages
            .iter()
            .map(|p| format!("\"{}\"", escape_r_string(p)))
            .collect::<Vec<_>>()
            .join(", ");

        let mut urls: Vec<String> = Vec::new();
        if let Some(additional_url) = &url {
            urls.push(format!("\"{}\"", escape_r_string(additional_url)));
        }

        urls.push(format!("\"{}\"", escape_r_string(&cran_repo)));

        let repos_expr = urls.join(", ");

        let mut cran_expr = format!(
            "install.packages(c({}), repos = c({})",
            pkg_list, repos_expr
        );

        if let Some(lib) = &library {
            cran_expr.push_str(&format!(", lib = \"{}\"", escape_r_string(lib)));
        }
        cran_expr.push(')');
        expr_parts.push(cran_expr);
    }

    let mut git_repos: Vec<(&str, &String)> = Vec::new();
    for repo in &github {
        git_repos.push(("github", repo));
    }
    for repo in &gitlab {
        git_repos.push(("gitlab", repo));
    }
    for repo in &bitbucket {
        git_repos.push(("bitbucket", repo));
    }
    for repo in &codeberg {
        git_repos.push(("codeberg", repo));
    }

    if !git_repos.is_empty() {
        let mut remotes_bootstrap = format!(
            "if (!requireNamespace(\"remotes\", quietly = TRUE)) install.packages(\"remotes\", repos = \"{}\"",
            escape_r_string(&cran_repo)
        );
        if let Some(lib) = &library {
            remotes_bootstrap.push_str(&format!(", lib = \"{}\"", escape_r_string(lib)));
        }
        remotes_bootstrap.push(')');
        expr_parts.push(remotes_bootstrap);

        for (source, repo) in git_repos {
            let git_url = build_git_url(source, repo);
            let mut install_expr =
                format!("remotes::install_git(\"{}\"", escape_r_string(&git_url));
            if let Some(lib) = &library {
                install_expr.push_str(&format!(", lib = \"{}\"", escape_r_string(lib)));
            }
            install_expr.push_str(", upgrade = \"never\")");
            expr_parts.push(install_expr);
        }
    }

    if expr_parts.is_empty() {
        return Err("no packages or git sources provided".into());
    }

    let expr = expr_parts.join("; ");

    let status = Command::new("Rscript").arg("-e").arg(&expr).status()?;
    if !status.success() {
        std::process::exit(status.code().unwrap_or(1));
    }
    Ok(())
}