arf-console 0.3.3-alpha.2

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
122
123
124
125
126
127
128
129

//! R code completion for reedline.
//!
//! This module re-exports [`MetaCommandCompleter`] from `meta` and provides
//! [`CombinedCompleter`] which dispatches to the appropriate sub-completer.

use super::r_completer::RCompleter;
use reedline::{Completer, Suggestion};

// Re-export so external code can keep using `crate::completion::completer::MetaCommandCompleter`.
pub use super::meta::MetaCommandCompleter;

/// Combined completer that delegates to the appropriate completer.
pub struct CombinedCompleter {
    r_completer: RCompleter,
    meta_completer: MetaCommandCompleter,
}

impl CombinedCompleter {
    /// Create a new CombinedCompleter with default settings (50ms timeout, 100ms debounce, 50 function check limit).
    pub fn new() -> Self {
        Self::with_settings(50, 100, 50)
    }

    /// Create a new CombinedCompleter with custom settings.
    pub fn with_settings(timeout_ms: u64, debounce_ms: u64, auto_paren_limit: usize) -> Self {
        Self::with_settings_and_rig(timeout_ms, debounce_ms, auto_paren_limit, true)
    }

    /// Create a new CombinedCompleter with custom settings and rig availability.
    ///
    /// When `rig_enabled` is false, the `:switch` command is excluded from completion.
    pub fn with_settings_and_rig(
        timeout_ms: u64,
        debounce_ms: u64,
        auto_paren_limit: usize,
        rig_enabled: bool,
    ) -> Self {
        Self::with_settings_full(
            timeout_ms,
            debounce_ms,
            auto_paren_limit,
            rig_enabled,
            false,
            vec!["library".to_string(), "require".to_string()],
        )
    }

    /// Create a new CombinedCompleter with all settings.
    pub fn with_settings_full(
        timeout_ms: u64,
        debounce_ms: u64,
        auto_paren_limit: usize,
        rig_enabled: bool,
        fuzzy_namespace: bool,
        package_functions: Vec<String>,
    ) -> Self {
        // Build exclusion list: always exclude `:r` in R mode
        let mut exclusions: Vec<&'static str> = vec!["r"];

        // Exclude `:switch` when rig is not enabled
        if !rig_enabled {
            exclusions.push("switch");
        }

        CombinedCompleter {
            r_completer: RCompleter::with_settings_full(
                timeout_ms,
                debounce_ms,
                auto_paren_limit,
                fuzzy_namespace,
                package_functions,
            ),
            meta_completer: MetaCommandCompleter::with_exclusions(exclusions),
        }
    }
}

impl Default for CombinedCompleter {
    fn default() -> Self {
        Self::new()
    }
}

impl Completer for CombinedCompleter {
    fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
        if line.trim_start().starts_with(':') {
            self.meta_completer.complete(line, pos)
        } else {
            self.r_completer.complete(line, pos)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_combined_completer_delegates_to_meta() {
        let mut completer = CombinedCompleter::new();
        let suggestions = completer.complete(":rep", 4);
        assert_eq!(suggestions.len(), 1);
        assert_eq!(suggestions[0].value, "reprex");
    }

    #[test]
    fn test_combined_completer_with_leading_whitespace() {
        let mut completer = CombinedCompleter::new();
        let suggestions = completer.complete("  :rep", 6);
        assert_eq!(suggestions.len(), 1);
        assert_eq!(suggestions[0].value, "reprex");
    }

    #[test]
    fn test_combined_completer_excludes_r_command() {
        // CombinedCompleter is used in R mode, so `:r` should be excluded
        let mut completer = CombinedCompleter::new();
        let suggestions = completer.complete(":", 1);
        let values: Vec<&str> = suggestions.iter().map(|s| s.value.as_str()).collect();
        assert!(
            !values.contains(&"r"),
            "`:r` should be excluded in CombinedCompleter (R mode)"
        );
        assert!(
            values.contains(&"shell"),
            "`:shell` should be present in R mode"
        );
    }
}