use std::collections::BTreeMap;
use std::sync::{Arc, Mutex, OnceLock};
use crate::document::Document;
pub type DocumentHandle = Arc<Mutex<Document>>;
pub trait DocumentObserver: Send {
fn on_document_created(&mut self, name: &str) {
let _ = name;
}
fn on_document_deleted(&mut self, name: &str) {
let _ = name;
}
fn on_document_activated(&mut self, name: &str) {
let _ = name;
}
}
#[derive(Default)]
pub struct Application {
documents: BTreeMap<String, DocumentHandle>,
active: Option<String>,
observers: Vec<Box<dyn DocumentObserver>>,
}
impl Application {
pub fn new() -> Self {
Self::default()
}
pub fn add_observer(&mut self, observer: Box<dyn DocumentObserver>) {
self.observers.push(observer);
}
pub fn unique_name(&self, proposed: Option<&str>) -> String {
let base = proposed.unwrap_or("Unnamed");
if !self.documents.contains_key(base) {
return base.to_string();
}
let mut counter = 1;
loop {
let candidate = format!("{base}{counter:03}");
if !self.documents.contains_key(&candidate) {
return candidate;
}
counter += 1;
}
}
pub fn new_document(&mut self, proposed: Option<&str>) -> (String, DocumentHandle) {
self.insert_handle(proposed, Arc::new(Mutex::new(Document::new())))
}
pub fn insert_document(&mut self, proposed: &str, document: Document) -> (String, DocumentHandle) {
self.insert_handle(Some(proposed), Arc::new(Mutex::new(document)))
}
pub fn insert_handle(&mut self, proposed: Option<&str>, handle: DocumentHandle) -> (String, DocumentHandle) {
let name = self.unique_name(proposed);
self.documents.insert(name.clone(), Arc::clone(&handle));
for observer in &mut self.observers {
observer.on_document_created(&name);
}
self.set_active(&name);
(name, handle)
}
pub fn close_document(&mut self, name: &str) -> bool {
if self.documents.remove(name).is_none() {
return false;
}
if self.active.as_deref() == Some(name) {
self.active = None;
}
for observer in &mut self.observers {
observer.on_document_deleted(name);
}
true
}
pub fn get(&self, name: &str) -> Option<DocumentHandle> {
self.documents.get(name).cloned()
}
pub fn contains(&self, name: &str) -> bool {
self.documents.contains_key(name)
}
pub fn names(&self) -> Vec<String> {
self.documents.keys().cloned().collect()
}
pub fn documents(&self) -> Vec<(String, DocumentHandle)> {
self.documents
.iter()
.map(|(name, handle)| (name.clone(), Arc::clone(handle)))
.collect()
}
pub fn len(&self) -> usize {
self.documents.len()
}
pub fn is_empty(&self) -> bool {
self.documents.is_empty()
}
pub fn active(&self) -> Option<&str> {
self.active.as_deref()
}
pub fn set_active(&mut self, name: &str) -> bool {
if !self.documents.contains_key(name) {
return false;
}
if self.active.as_deref() == Some(name) {
return true;
}
self.active = Some(name.to_string());
for observer in &mut self.observers {
observer.on_document_activated(name);
}
true
}
}
static APPLICATION: OnceLock<Mutex<Application>> = OnceLock::new();
pub fn application() -> &'static Mutex<Application> {
APPLICATION.get_or_init(|| Mutex::new(Application::new()))
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Default)]
struct Recorder {
log: Arc<Mutex<Vec<String>>>,
}
impl DocumentObserver for Recorder {
fn on_document_created(&mut self, name: &str) {
self.log.lock().unwrap().push(format!("created:{name}"));
}
fn on_document_deleted(&mut self, name: &str) {
self.log.lock().unwrap().push(format!("deleted:{name}"));
}
fn on_document_activated(&mut self, name: &str) {
self.log.lock().unwrap().push(format!("activated:{name}"));
}
}
#[test]
fn application_is_send() {
fn assert_send<T: Send>() {}
assert_send::<Application>();
}
#[test]
fn new_document_registers_and_activates() {
let mut app = Application::new();
let (name, handle) = app.new_document(Some("Demo"));
assert_eq!(name, "Demo");
assert_eq!(app.active(), Some("Demo"));
assert_eq!(app.len(), 1);
assert!(Arc::ptr_eq(&handle, &app.get("Demo").unwrap()));
}
#[test]
fn names_are_made_unique() {
let mut app = Application::new();
assert_eq!(app.new_document(Some("Doc")).0, "Doc");
assert_eq!(app.new_document(Some("Doc")).0, "Doc001");
assert_eq!(app.new_document(Some("Doc")).0, "Doc002");
assert_eq!(app.new_document(None).0, "Unnamed");
assert_eq!(app.new_document(None).0, "Unnamed001");
}
#[test]
fn closing_clears_active_and_fires_deleted() {
let mut app = Application::new();
let log = Arc::new(Mutex::new(Vec::new()));
app.add_observer(Box::new(Recorder { log: Arc::clone(&log) }));
app.new_document(Some("A"));
let (b, _) = app.new_document(Some("B"));
assert_eq!(app.active(), Some("B"));
assert!(app.close_document(&b));
assert_eq!(app.active(), None);
assert!(!app.close_document("B"));
assert_eq!(
*log.lock().unwrap(),
vec![
"created:A", "activated:A", "created:B", "activated:B", "deleted:B"
]
);
}
#[test]
fn set_active_only_for_open_documents() {
let mut app = Application::new();
app.new_document(Some("A"));
app.new_document(Some("B"));
assert!(app.set_active("A"));
assert_eq!(app.active(), Some("A"));
assert!(!app.set_active("missing"));
assert_eq!(app.active(), Some("A"));
}
#[test]
fn insert_document_takes_a_prebuilt_document() {
let mut app = Application::new();
let (name, _) = app.insert_document("Loaded", Document::new());
assert_eq!(name, "Loaded");
assert!(app.contains("Loaded"));
assert_eq!(app.active(), Some("Loaded"));
}
}