oo-ide 0.0.4

∞ is a terminal IDE focused on low distraction, high usability.
Documentation 
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
145
146
147
148
149
150
151

//! IDE-internal logging system.
//!
//! `ooLogger` hooks into the `log` crate and fans each record out to:
//!   1. A fixed-capacity in-memory ring buffer (`LogBuffer`).
//!   2. A `tokio::sync::broadcast` channel so the log view receives live entries.
//!
//! The file sink is handled by `simplelog::WriteLogger` via
//! `simplelog::CombinedLogger`; this module only manages the in-process buffer.

use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::time::SystemTime;

use log::{Level, LevelFilter, Metadata, Record};
use simplelog::{Config, SharedLogger};
use tokio::sync::broadcast;

// ---------------------------------------------------------------------------
// Public types
// ---------------------------------------------------------------------------

/// One captured log record.
#[derive(Clone, Debug)]
pub struct LogEntry {
    pub time: SystemTime,
    pub level: Level,
    /// Target reported by the `log` macro (e.g. `oo::lsp`).
    pub target: String,
    pub message: String,
}

/// Fixed-capacity FIFO that keeps the most recent N entries.
pub struct LogBuffer {
    capacity: usize,
    entries: VecDeque<LogEntry>,
}

impl LogBuffer {
    fn new(capacity: usize) -> Self {
        Self {
            capacity,
            entries: VecDeque::with_capacity(capacity),
        }
    }

    fn push(&mut self, entry: LogEntry) {
        if self.entries.len() == self.capacity {
            self.entries.pop_front();
        }
        self.entries.push_back(entry);
    }

    /// Snapshot for the log view to display on open.
    pub fn snapshot(&self) -> Vec<LogEntry> {
        self.entries.iter().cloned().collect()
    }
}

/// Shared state between the custom logger and any subscribers (e.g. `LogView`).
pub struct LogState {
    pub buffer: Mutex<LogBuffer>,
    pub tx: broadcast::Sender<LogEntry>,
}

impl LogState {
    fn new(capacity: usize) -> Arc<Self> {
        let (tx, _) = broadcast::channel(4096);
        Arc::new(Self {
            buffer: Mutex::new(LogBuffer::new(capacity)),
            tx,
        })
    }

    /// Subscribe to live log entries.
    pub fn subscribe(&self) -> broadcast::Receiver<LogEntry> {
        self.tx.subscribe()
    }
}

// ---------------------------------------------------------------------------
// In-memory logger — implements simplelog::SharedLogger
// ---------------------------------------------------------------------------

pub struct InMemoryLogger {
    state: Arc<LogState>,
    level: LevelFilter,
}

impl log::Log for InMemoryLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= self.level
    }

    fn log(&self, record: &Record) {
        if !self.enabled(record.metadata()) {
            return;
        }
        let entry = LogEntry {
            time: SystemTime::now(),
            level: record.level(),
            target: record.target().to_owned(),
            message: record.args().to_string(),
        };
        if let Ok(mut buf) = self.state.buffer.lock() {
            buf.push(entry.clone());
        }
        // Ignore send errors — no subscribers is fine.
        let _ = self.state.tx.send(entry);
    }

    fn flush(&self) {}
}

impl SharedLogger for InMemoryLogger {
    fn level(&self) -> LevelFilter {
        self.level
    }

    fn config(&self) -> Option<&Config> {
        None
    }

    fn as_log(self: Box<Self>) -> Box<dyn log::Log> {
        self
    }
}

// ---------------------------------------------------------------------------
// Initialisation
// ---------------------------------------------------------------------------

/// Initialise a combined logger: `simplelog::WriteLogger` to `log_file` plus
/// the in-memory logger.  Returns the `LogState` handle to thread into the app.
///
/// # Panics
/// Panics if a global logger has already been set.
pub fn init_combined_logger(log_file: std::fs::File, level: LevelFilter) -> Arc<LogState> {
    let state = LogState::new(10_000);

    let file_logger = simplelog::WriteLogger::new(level, Config::default(), log_file);

    let mem_logger = Box::new(InMemoryLogger {
        state: state.clone(),
        level,
    });

    simplelog::CombinedLogger::init(vec![file_logger, mem_logger])
        .expect("logger already initialised");

    state
}