arf-console 0.5.1

A cross-platform R console written 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
107
108
109
110
111
112
113
114
115

//! R_HOME discovery and rig integration.

use crate::config::RSourceStatus;
use crate::external;
use anyhow::{Context, Result};
use std::path::PathBuf;

#[derive(Debug)]
pub(super) struct ResolvedRSource {
    pub(super) status: RSourceStatus,
    pub(super) r_home: Option<PathBuf>,
}

/// Resolve R_HOME from a user-provided path.
///
/// The path can be either:
/// - An installation prefix (e.g., `/opt/R/4.5.2`) containing `bin/R`
/// - The actual R_HOME directory (e.g., `/opt/R/4.5.2/lib/R`)
///
/// If the path contains `bin/R`, we run it with `RHOME` to get the actual R_HOME.
pub(super) fn resolve_r_home_from_path(path: &std::path::Path) -> Result<std::path::PathBuf> {
    // Check if this looks like an installation prefix (has bin/R)
    let r_binary = path.join("bin").join("R");
    if r_binary.exists() {
        // Run `bin/R RHOME` to get the actual R_HOME
        let output = std::process::Command::new(&r_binary)
            .arg("RHOME")
            .output()
            .with_context(|| format!("Failed to run {} RHOME", r_binary.display()))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!("{} RHOME failed: {}", r_binary.display(), stderr);
        }

        let r_home = arf_libr::r_home_from_rhome_output(&String::from_utf8_lossy(&output.stdout))
            .unwrap_or_default();
        if r_home.is_empty() {
            anyhow::bail!("{} RHOME returned empty result", r_binary.display());
        }

        log::debug!(
            "Resolved R_HOME from installation prefix: {} -> {}",
            path.display(),
            r_home
        );
        return Ok(std::path::PathBuf::from(r_home));
    }

    // Assume the path is already R_HOME
    // Validate by checking for etc/Renviron
    let renviron = path.join("etc").join("Renviron");
    if !renviron.exists() {
        log::warn!(
            "Path {} does not look like R_HOME (missing etc/Renviron). \
             Consider providing the installation prefix instead.",
            path.display()
        );
    }

    Ok(path.to_path_buf())
}

/// Resolve R via rig with a specific version (used for CLI --with-r-version).
pub(super) fn setup_r_via_rig(version_spec: &str) -> Result<ResolvedRSource> {
    if let Err(error) = external::rig::rig_available() {
        let context = match &error {
            external::rig::RigError::NotInstalled => {
                "--with-r-version requires rig to be installed.\n\
             Install rig from https://github.com/r-lib/rig"
            }
            external::rig::RigError::CommandFailed(_) => {
                "Failed to run rig while checking whether it is available."
            }
            _ => "Failed to check whether rig is available.",
        };
        return Err(anyhow::Error::new(error).context(context));
    }

    match external::rig::resolve_version(version_spec) {
        Ok(resolved) => resolve_rig_resolution(resolved),
        Err(error) => Err(anyhow::Error::new(error)
            .context(format!("Failed to resolve R version '{version_spec}'"))),
    }
}

/// Set up R from the exact semantic version selected for an override.
///
/// The override resolver has already selected a version from rig's reported
/// version fields. Re-resolving its string would allow a rig name or alias to
/// select a different installation.
pub(super) fn setup_r_via_selected_rig_version(
    selected: &semver::Version,
    versions: &[external::rig::RigVersion],
) -> Result<ResolvedRSource> {
    match external::rig::resolve_selected_version_from_versions(selected, versions) {
        Ok(resolved) => resolve_rig_resolution(resolved),
        Err(error) => anyhow::bail!("Failed to resolve R version '{}': {}", selected, error),
    }
}

fn resolve_rig_resolution(resolved: external::rig::ResolvedVersion) -> Result<ResolvedRSource> {
    log::info!(
        "Using R version {} from {}",
        resolved.version,
        resolved.r_home
    );
    Ok(ResolvedRSource {
        status: RSourceStatus::Rig {
            version: resolved.version,
            override_info: None,
        },
        r_home: Some(PathBuf::from(resolved.r_home)),
    })
}