Offline, privacy-first grammar checker. Fast, open-source, Rust-powered
use crate::config::Config;
use harper_core::{DictWordMetadata, spell::Dictionary};
use std::sync::Arc;
use tokio::io::{AsyncBufReadExt, AsyncRead, AsyncWrite, BufReader};
use tokio::sync::Mutex;
use super::error::ProtocolError;
use super::framing::write_message;
use super::message::{Request, Response};
/// Tauri-side protocol endpoint that owns shared state and responds to highlighter requests.
pub struct Server<R, W> {
reader: BufReader<R>,
writer: W,
config: Arc<Mutex<Config>>,
}
impl<R, W> Server<R, W>
where
R: AsyncRead + Unpin,
W: AsyncWrite + Unpin,
{
pub fn new(reader: R, writer: W, config: Arc<Mutex<Config>>) -> Self {
Self {
reader: BufReader::new(reader),
writer,
config,
}
}
pub async fn receive_request(&mut self) -> Result<Option<Request>, ProtocolError> {
let mut line = String::new();
if self.reader.read_line(&mut line).await? == 0 {
return Ok(None);
}
let request = serde_json::from_str(&line)?;
let response = self.handle_request(&request).await;
write_message(&mut self.writer, &response).await?;
Ok(Some(request))
}
async fn handle_request(&self, request: &Request) -> Response {
match request {
Request::OpenSettings => Response::Ack,
Request::GetLintConfig => Response::GetLintConfig {
config: self.config.lock().await.lint_config.clone(),
},
Request::GetDictionary => Response::GetDictionary {
words: self
.config
.lock()
.await
.mutable_dictionary
.words_iter()
.map(|word| word.iter().collect())
.collect(),
},
Request::GetDialect => Response::GetDialect {
dialect: self.config.lock().await.dialect,
},
Request::GetDebounceMs => Response::GetDebounceMs {
debounce_ms: self.config.lock().await.debounce_ms,
},
Request::GetIgnoredLints => Response::GetIgnoredLints {
ignored_lints: self.config.lock().await.ignored_lints.clone(),
},
Request::GetIntegrations => Response::GetIntegrations {
integrations: self.config.lock().await.integrations.clone(),
},
Request::GetAutoEnableNewApps => Response::GetAutoEnableNewApps {
enabled: self.config.lock().await.auto_enable_new_apps,
},
Request::ResolveIntegration { bundle_id } => {
let mut config = self.config.lock().await;
let previous_len = config.integrations.len();
let enabled = config.resolve_integration(bundle_id);
if config.integrations.len() != previous_len
&& let Err(error) = config.save_to_system().await
{
config.remove_integration(bundle_id.trim());
eprintln!("failed to save discovered integration: {error}");
return Response::ResolveIntegration { enabled: false };
}
Response::ResolveIntegration { enabled }
}
Request::SetLintConfig { config } => {
let mut stored_config = self.config.lock().await;
stored_config.lint_config = config.clone();
if let Err(error) = stored_config.save_to_system().await {
eprintln!("failed to save config: {error}");
}
Response::Ack
}
Request::IgnoreLint { ignored_lints } => {
let mut config = self.config.lock().await;
config.ignored_lints.append(ignored_lints.clone());
if let Err(error) = config.save_to_system().await {
eprintln!("failed to save config: {error}");
}
Response::Ack
}
Request::AddToDictionary { word } => {
let mut config = self.config.lock().await;
config
.mutable_dictionary
.append_word_str(word, DictWordMetadata::default());
if let Err(error) = config.save_to_system().await {
eprintln!("failed to save config: {error}");
}
Response::Ack
}
Request::AddIntegration { bundle_id } => {
let mut config = self.config.lock().await;
config.add_integration(bundle_id.clone());
if let Err(error) = config.save_to_system().await {
eprintln!("failed to save config: {error}");
}
Response::Ack
}
Request::RemoveIntegration { bundle_id } => {
let mut config = self.config.lock().await;
config.remove_integration(bundle_id);
if let Err(error) = config.save_to_system().await {
eprintln!("failed to save config: {error}");
}
Response::Ack
}
Request::SetIntegrationEnabled { bundle_id, enabled } => {
let mut config = self.config.lock().await;
config.set_integration_enabled(bundle_id, *enabled);
if let Err(error) = config.save_to_system().await {
eprintln!("failed to save config: {error}");
}
Response::Ack
}
}
}
}