arf-console 0.7.0-beta.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
116
117
118
119
120
121

//! JSON payloads emitted by `arf headless --json`.

use crate::app::r_source_selection::RSourceSelection;
use crate::app::setup::{RSourceOverrideState, RSourceResolutionReport, RSourceSelectionRoute};
use crate::config::{ConfigLoadProvenance, HistoryLocationSource};
use crate::history::HistoryRuntime;
use crate::ipc::policy::IpcPolicy;
use crate::ipc::session::{SessionInfo, SessionType};
use serde::Serialize;

/// JSON output for `arf headless --json`.
///
/// Contains session connection info and any warnings collected during startup.
/// All keys are always present in the JSON output; `r_version`, `r_home`, `log_file`,
/// and `history_session_id` may be `null` only when history initialization is
/// unavailable. `warnings` is an array that may be empty.
#[derive(Debug, Serialize)]
pub(super) struct HeadlessInfo {
    pid: u32,
    socket_path: String,
    r_version: Option<String>,
    r_home: Option<String>,
    cwd: String,
    started_at: String,
    log_file: Option<String>,
    history_session_id: Option<i64>,
    ipc_policy: IpcPolicy,
    history_runtime: HeadlessHistoryRuntime,
    r_source_override: HeadlessRSourceOverride,
    r_source_selection: RSourceSelection,
    warnings: Vec<String>,
}

#[derive(Debug, Serialize)]
pub(super) struct HeadlessHistoryRuntime {
    state: String,
    source: &'static str,
    path: Option<String>,
    reason: Option<String>,
    detail: Option<String>,
}

impl HeadlessHistoryRuntime {
    pub(super) fn from_runtime(runtime: &HistoryRuntime, source: HistoryLocationSource) -> Self {
        Self {
            state: runtime.state_name().to_string(),
            source: source.as_str(),
            path: runtime
                .requested_path()
                .map(|path| path.display().to_string()),
            reason: runtime.reason_name().map(str::to_string),
            detail: runtime.diagnostic_detail(),
        }
    }
}

#[derive(Debug, Serialize)]
pub(super) struct HeadlessRSourceOverride {
    state: String,
    provider: Option<String>,
    file: Option<String>,
    key: Option<String>,
    requested_version: Option<String>,
    resolved_version: Option<String>,
}

impl HeadlessRSourceOverride {
    pub(super) fn from_report(report: &RSourceResolutionReport) -> Self {
        let applied = report.selection_route == RSourceSelectionRoute::Override;
        let override_state: RSourceOverrideState = report.override_state;
        Self {
            state: override_state.as_str().to_owned(),
            provider: applied.then(|| report.override_provider.clone()).flatten(),
            file: applied
                .then(|| report.file.as_ref().map(|path| path.display().to_string()))
                .flatten(),
            key: applied.then(|| report.key.clone()).flatten(),
            requested_version: applied.then(|| report.requested_version.clone()).flatten(),
            resolved_version: applied.then(|| report.resolved_version.clone()).flatten(),
        }
    }
}

impl HeadlessInfo {
    pub(super) fn from_session(
        session: &SessionInfo,
        history_runtime: &HistoryRuntime,
        history_source: HistoryLocationSource,
        warnings: Vec<String>,
        resolution: &RSourceResolutionReport,
        launch_cwd: &std::path::Path,
        loaded_config: Option<&ConfigLoadProvenance>,
    ) -> Self {
        // Normalize empty/whitespace-only R version to None so JSON shows null
        let r_version = session
            .r_version
            .as_deref()
            .filter(|s| !s.trim().is_empty())
            .map(|s| s.to_string());

        Self {
            pid: session.pid,
            socket_path: session.socket_path.clone(),
            r_version,
            r_home: session.r_home.clone(),
            cwd: session.cwd.clone(),
            started_at: session.started_at.clone(),
            log_file: session.log_file.clone(),
            history_session_id: session.history_session_id,
            ipc_policy: crate::ipc::policy::policy(SessionType::Headless),
            history_runtime: HeadlessHistoryRuntime::from_runtime(history_runtime, history_source),
            r_source_override: HeadlessRSourceOverride::from_report(resolution),
            r_source_selection: RSourceSelection::from_report(
                launch_cwd,
                resolution,
                loaded_config,
            ),
            warnings,
        }
    }
}