Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

Merge remote-tracking branch 'upstream/master' into typst-support

Grant Lemons290a08a7bdd2
diff --cc Cargo.lock
index e7558c601,eae3ce581..10bc286d8
--- a/Cargo.lock
+++ b/Cargo.lock
@@@ -594,7 -560,7 +594,8 @@@ dependencies =
"clap",
"harper-comments",
"harper-core",
+ "harper-literate-haskell",
+ "harper-typst",
"serde_json",
]
@@@ -673,7 -650,7 +685,8 @@@ dependencies =
"harper-comments",
"harper-core",
"harper-html",
+ "harper-literate-haskell",
+ "harper-typst",
"itertools 0.14.0",
"once_cell",
"open",
diff --cc Cargo.toml
index 746de49f4,41a57d702..05f7ccd19
--- a/Cargo.toml
+++ b/Cargo.toml
@@@ -1,5 -1,5 +1,5 @@@
[workspace]
- members = [ "harper-cli", "harper-core", "harper-ls", "harper-comments", "harper-wasm", "harper-tree-sitter", "harper-html", "harper-typst"]
-members = [ "harper-cli", "harper-core", "harper-ls", "harper-comments", "harper-wasm", "harper-tree-sitter", "harper-html", "harper-literate-haskell"]
++members = [ "harper-cli", "harper-core", "harper-ls", "harper-comments", "harper-wasm", "harper-tree-sitter", "harper-html", "harper-literate-haskell", "harper-typst" ]
resolver = "2"
[profile.release]
diff --cc harper-cli/Cargo.toml
index 876c42763,d84968403..b1655abac
--- a/harper-cli/Cargo.toml
+++ b/harper-cli/Cargo.toml
@@@ -10,10 -10,7 +10,11 @@@ repository = "https://github.com/automa
anyhow = "1.0.95"
ariadne = "0.4.1"
clap = { version = "4.5.23", features = ["derive"] }
+ harper-literate-haskell = { path = "../harper-literate-haskell", version = "0.15.0" }
harper-core = { path = "../harper-core", version = "0.15.0" }
harper-comments = { path = "../harper-comments", version = "0.15.0" }
+harper-typst = { path = "../harper-typst", version = "0.15.0" }
serde_json = "1.0.133"
+
+[features]
+default = []
diff --cc harper-cli/src/main.rs
index 6740158c6,3a260d0d1..0044ecde3
--- a/harper-cli/src/main.rs
+++ b/harper-cli/src/main.rs
@@@ -168,10 -169,10 +169,11 @@@ fn main() -> anyhow::Result<()>
fn load_file(file: &Path) -> anyhow::Result<(Document, String)> {
let source = std::fs::read_to_string(file)?;
- let mut parser: Box<dyn harper_core::parsers::Parser> =
+ let parser: Box<dyn harper_core::parsers::Parser> =
match file.extension().map(|v| v.to_str().unwrap()) {
Some("md") => Box::new(Markdown),
+ Some("lhs") => Box::new(LiterateHaskellParser),
+ Some("typ") => Box::new(harper_typst::Typst),
_ => Box::new(
CommentParser::new_from_filename(file)
.map(Box::new)
diff --cc harper-literate-haskell/src/lib.rs
index 000000000,f56515a75..903f9c5b3
mode 000000,100644..100644
--- a/harper-literate-haskell/src/lib.rs
+++ b/harper-literate-haskell/src/lib.rs
@@@ -1,0 -1,31 +1,31 @@@
+ use harper_comments::CommentParser;
+ use harper_core::{
+ parsers::{Markdown, Mask, Parser},
+ FullDictionary, Masker, Token,
+ };
+
+ mod masker;
+ use itertools::Itertools;
+ use masker::LiterateHaskellMasker;
+
+ /// Parses a Literate Haskell document by masking out the code and considering text as Markdown.
+ pub struct LiterateHaskellParser;
+
+ impl LiterateHaskellParser {
+ pub fn create_ident_dict(&self, source: &[char]) -> Option<FullDictionary> {
+ let parser = CommentParser::new_from_language_id("haskell").unwrap();
+ let mask = LiterateHaskellMasker::code_only().create_mask(source);
+
+ let code = mask
+ .iter_allowed(source)
+ .flat_map(|(_, src)| src.to_owned())
+ .collect_vec();
+ parser.create_ident_dict(&code)
+ }
+ }
+
+ impl Parser for LiterateHaskellParser {
- fn parse(&mut self, source: &[char]) -> Vec<Token> {
++ fn parse(&self, source: &[char]) -> Vec<Token> {
+ Mask::new(LiterateHaskellMasker::text_only(), Markdown).parse(source)
+ }
+ }
diff --cc harper-literate-haskell/src/masker.rs
index 000000000,bad9556c0..52ebe6ad8
mode 000000,100644..100644
--- a/harper-literate-haskell/src/masker.rs
+++ b/harper-literate-haskell/src/masker.rs
@@@ -1,0 -1,148 +1,148 @@@
+ use harper_core::{CharStringExt, Mask, Masker, Span};
+
+ /// Masker for selecting portions of Literate Haskell documents.
+ ///
+ /// Based on the specifications outlined at https://wiki.haskell.org/Literate_programming.
+ pub struct LiterateHaskellMasker {
+ text: bool,
+ code: bool,
+ }
+
+ impl LiterateHaskellMasker {
+ pub fn text_only() -> Self {
+ Self {
+ text: true,
+ code: false,
+ }
+ }
+
+ pub fn code_only() -> Self {
+ Self {
+ text: false,
+ code: true,
+ }
+ }
+ }
+
+ impl Masker for LiterateHaskellMasker {
- fn create_mask(&mut self, source: &[char]) -> harper_core::Mask {
++ fn create_mask(&self, source: &[char]) -> harper_core::Mask {
+ let mut mask = Mask::new_blank();
+
+ let mut location = 0;
+ let mut in_code_env = false;
+ let mut last_line_blank = false;
+
+ for line in source.split(|c| *c == '\n') {
+ let string_form = line.to_string();
+ let trimmed = string_form.trim();
+ let line_is_bird = line.first().is_some_and(|c| *c == '>');
+
+ // Code fencing
+ let latex_style = matches!(trimmed, r"\begin{code}" | r"\end{code}");
+ let code_start = trimmed == r"\begin{code}" || (last_line_blank && line_is_bird);
+ let code_end = trimmed == r"\end{code}" || trimmed.is_empty();
+
+ // Toggle on fence
+ if (!in_code_env && code_start) || (in_code_env && code_end) {
+ in_code_env = !in_code_env;
+
+ // Exclude latex-style fence
+ if latex_style {
+ location += line.len() + 1; // +1 for the newline split on
+ last_line_blank = trimmed.is_empty();
+ continue;
+ }
+
+ // Exclude newline after code for bird style
+ if trimmed.is_empty() {
+ location += line.len() + 1; // +1 for the newline split on
+ last_line_blank = true;
+ continue;
+ }
+ }
+
+ let end_loc = location + line.len();
+ if (!in_code_env && self.text) || (in_code_env && self.code) {
+ let start_loc = if line_is_bird { location + 2 } else { location };
+ mask.push_allowed(Span::new(start_loc, end_loc));
+ }
+
+ location = end_loc + 1; // +1 for the newline split on
+ last_line_blank = trimmed.is_empty();
+ }
+
+ mask.merge_whitespace_sep(source);
+ mask
+ }
+ }
+
+ #[cfg(test)]
+ mod tests {
+ use harper_core::{Masker, Span};
+ use itertools::Itertools;
+
+ use super::LiterateHaskellMasker;
+
+ #[test]
+ fn bird_format() {
+ let source = r"Text here
+
+ > fact :: Integer -> Integer
+ > fact 0 = 1
+ > fact n = n * fact (n-1)
+
+ Text here
+ "
+ .chars()
+ .collect_vec();
+
+ let text_mask = LiterateHaskellMasker::text_only().create_mask(&source);
+ assert_eq!(
+ text_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(0, 10), Span::new(80, 90)],
+ );
+
+ let code_mask = LiterateHaskellMasker::code_only().create_mask(&source);
+ assert_eq!(
+ code_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(13, 39), Span::new(42, 52), Span::new(55, 78)],
+ );
+ }
+
+ #[test]
+ fn latex_format() {
+ let source = r#"Text here
+ \begin{code}
+ main :: IO ()
+ main = print "just an example"
+ \end{code}
+ Text here
+ "#
+ .chars()
+ .collect_vec();
+
+ let text_mask = LiterateHaskellMasker::text_only().create_mask(&source);
+ assert_eq!(
+ text_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(0, 9), Span::new(79, 89)],
+ );
+
+ let code_mask = LiterateHaskellMasker::code_only().create_mask(&source);
+ assert_eq!(
+ code_mask
+ .iter_allowed(&source)
+ .map(|(s, _)| s)
+ .collect_vec(),
+ vec![Span::new(23, 67)],
+ );
+ }
+ }
diff --cc harper-ls/Cargo.toml
index de1b018cb,3ece4b162..137babfe0
--- a/harper-ls/Cargo.toml
+++ b/harper-ls/Cargo.toml
@@@ -8,9 -8,9 +8,10 @@@ readme = "README.md
repository = "https://github.com/automattic/harper"
[dependencies]
+ harper-literate-haskell = { path = "../harper-literate-haskell", version = "0.15.0" }
harper-core = { path = "../harper-core", version = "0.15.0", features = ["concurrent"] }
harper-comments = { path = "../harper-comments", version = "0.15.0" }
+harper-typst = { path = "../harper-typst", version = "0.15.0" }
harper-html = { path = "../harper-html", version = "0.15.0" }
tower-lsp = "0.20.0"
tokio = { version = "1.42.0", features = ["fs", "rt", "rt-multi-thread", "macros", "io-std", "io-util", "net"] }
diff --cc harper-ls/src/backend.rs
index 02715bf03,35b4e97ae..91acf5ae2
--- a/harper-ls/src/backend.rs
+++ b/harper-ls/src/backend.rs
@@@ -2,7 -2,7 +2,7 @@@ use std::collections::HashMap
use std::path::{Component, PathBuf};
use std::sync::Arc;
--use anyhow::anyhow;
++use anyhow::{anyhow, Result};
use harper_comments::CommentParser;
use harper_core::linting::{LintGroup, Linter};
use harper_core::parsers::{CollapseIdentifiers, IsolateEnglish, Markdown, Parser, PlainEnglish};
@@@ -11,10 -11,11 +11,11 @@@ use harper_core::
WordMetadata,
};
use harper_html::HtmlParser;
+ use harper_literate_haskell::LiterateHaskellParser;
-use itertools::Itertools;
+use harper_typst::Typst;
use serde_json::Value;
use tokio::sync::{Mutex, RwLock};
--use tower_lsp::jsonrpc::Result;
++use tower_lsp::jsonrpc::Result as JsonResult;
use tower_lsp::lsp_types::notification::PublishDiagnostics;
use tower_lsp::lsp_types::{
CodeActionOrCommand, CodeActionParams, CodeActionProviderCapability, CodeActionResponse,
@@@ -83,7 -84,7 +84,7 @@@ impl Backend
}
}
-- async fn save_file_dictionary(&self, url: &Url, dict: impl Dictionary) -> anyhow::Result<()> {
++ async fn save_file_dictionary(&self, url: &Url, dict: impl Dictionary) -> Result<()> {
Ok(save_dict(
self.get_file_dict_path(url)
.await
@@@ -102,13 -103,13 +103,13 @@@
}
}
-- async fn save_user_dictionary(&self, dict: impl Dictionary) -> anyhow::Result<()> {
++ async fn save_user_dictionary(&self, dict: impl Dictionary) -> Result<()> {
let config = self.config.read().await;
Ok(save_dict(&config.user_dict_path, dict).await?)
}
-- async fn generate_global_dictionary(&self) -> anyhow::Result<MergedDictionary> {
++ async fn generate_global_dictionary(&self) -> Result<MergedDictionary> {
let mut dict = MergedDictionary::new();
dict.add_dictionary(FstDictionary::curated());
let user_dict = self.load_user_dictionary().await;
@@@ -116,7 -117,7 +117,7 @@@
Ok(dict)
}
-- async fn generate_file_dictionary(&self, url: &Url) -> anyhow::Result<MergedDictionary> {
++ async fn generate_file_dictionary(&self, url: &Url) -> Result<MergedDictionary> {
let (global_dictionary, file_dictionary) = tokio::join!(
self.generate_global_dictionary(),
self.load_file_dictionary(url)
@@@ -132,11 -133,11 +133,7 @@@
Ok(global_dictionary)
}
-- async fn update_document_from_file(
-- &self,
-- url: &Url,
-- language_id: Option<&str>,
-- ) -> anyhow::Result<()> {
++ async fn update_document_from_file(&self, url: &Url, language_id: Option<&str>) -> Result<()> {
let content = match tokio::fs::read_to_string(
url.to_file_path()
.map_err(|_| anyhow::format_err!("Could not extract file path."))?,
@@@ -158,7 -159,7 +155,7 @@@
url: &Url,
text: &str,
language_id: Option<&str>,
-- ) -> anyhow::Result<()> {
++ ) -> Result<()> {
self.pull_config().await;
let mut doc_lock = self.doc_state.lock().await;
@@@ -183,40 -184,65 +180,79 @@@
return Ok(());
};
- let parser: Option<Box<dyn Parser>> =
- if let Some(ts_parser) = CommentParser::new_from_language_id(language_id) {
- let source = text.chars().collect_vec();
-
- if let Some(new_dict) = ts_parser.create_ident_dict(&source) {
- let new_dict = Arc::new(new_dict);
-
- if doc_state.ident_dict != new_dict {
- doc_state.ident_dict = new_dict.clone();
++ async fn use_ident_dict<'a>(
++ backend: &'a Backend,
++ new_dict: Arc<FullDictionary>,
++ parser: impl Parser + 'static,
++ url: &'a Url,
++ doc_state: &'a mut DocumentState,
++ config_lock: tokio::sync::RwLockReadGuard<'a, Config>,
++ ) -> Result<Box<dyn Parser>> {
++ if doc_state.ident_dict != new_dict {
++ doc_state.ident_dict = new_dict.clone();
++
++ let mut merged = backend.generate_file_dictionary(url).await?;
++ merged.add_dictionary(new_dict);
++ let merged = Arc::new(merged);
++
++ doc_state.linter = LintGroup::new(config_lock.lint_config, merged.clone());
++ doc_state.dict = merged.clone();
++ }
+
- let mut merged = self.generate_file_dictionary(url).await?;
- merged.add_dictionary(new_dict);
- let merged = Arc::new(merged);
++ Ok(Box::new(CollapseIdentifiers::new(
++ Box::new(parser),
++ Box::new(doc_state.dict.clone()),
++ )))
++ }
+
- doc_state.linter = LintGroup::new(config_lock.lint_config, merged.clone());
- doc_state.dict = merged.clone();
- }
- Some(Box::new(CollapseIdentifiers::new(
- Box::new(ts_parser),
- Box::new(doc_state.dict.clone()),
- )))
++ let source: Vec<char> = text.chars().collect();
+ let ts_parser = CommentParser::new_from_language_id(language_id);
+ let parser: Option<Box<dyn Parser>> = match language_id.as_str() {
+ _ if ts_parser.is_some() => {
+ let ts_parser = ts_parser.unwrap();
- let source: Vec<char> = text.chars().collect();
- let source = Arc::new(source);
-
- if let Some(new_dict) = ts_parser.create_ident_dict(source.as_slice()) {
- let new_dict = Arc::new(new_dict);
-
- if doc_state.ident_dict != new_dict {
- doc_state.ident_dict = new_dict.clone();
- let mut merged = self.generate_file_dictionary(url).await?;
- merged.add_dictionary(new_dict);
- let merged = Arc::new(merged);
-
- doc_state.linter = LintGroup::new(config_lock.lint_config, merged.clone());
- doc_state.dict = merged.clone();
- }
- Some(Box::new(CollapseIdentifiers::new(
- Box::new(ts_parser),
- Box::new(doc_state.dict.clone()),
- )))
++
++ if let Some(new_dict) = ts_parser.create_ident_dict(&Arc::new(source)) {
++ Some(
++ use_ident_dict(
++ self,
++ Arc::new(new_dict),
++ ts_parser,
++ url,
++ doc_state,
++ config_lock,
++ )
++ .await?,
++ )
} else {
Some(Box::new(ts_parser))
}
- } else if language_id == "lhaskell" {
- let source = text.chars().collect_vec();
+ }
++ "lhaskell" => {
+ let parser = LiterateHaskellParser;
+
- if let Some(new_dict) = parser.create_ident_dict(&source) {
- let new_dict = Arc::new(new_dict);
-
- if doc_state.ident_dict != new_dict {
- doc_state.ident_dict = new_dict.clone();
-
- let mut merged = self.generate_file_dictionary(url).await?;
- merged.add_dictionary(new_dict);
- let merged = Arc::new(merged);
-
- doc_state.linter = LintGroup::new(config_lock.lint_config, merged.clone());
- doc_state.dict = merged.clone();
- }
- Some(Box::new(CollapseIdentifiers::new(
- Box::new(parser),
- Box::new(doc_state.dict.clone()),
- )))
++ if let Some(new_dict) = parser.create_ident_dict(&Arc::new(source)) {
++ Some(
++ use_ident_dict(
++ self,
++ Arc::new(new_dict),
++ parser,
++ url,
++ doc_state,
++ config_lock,
++ )
++ .await?,
++ )
+ } else {
+ Some(Box::new(parser))
+ }
- } else if language_id == "markdown" {
- Some(Box::new(Markdown))
- } else if language_id == "git-commit" || language_id == "gitcommit" {
- Some(Box::new(GitCommitParser))
- } else if language_id == "html" {
- Some(Box::new(HtmlParser::default()))
- } else if language_id == "mail" || language_id == "plaintext" {
- Some(Box::new(PlainEnglish))
- } else {
- None
- };
++ }
+ "markdown" => Some(Box::new(Markdown)),
+ "git-commit" | "gitcommit" => Some(Box::new(GitCommitParser)),
+ "html" => Some(Box::new(HtmlParser::default())),
+ "mail" | "plaintext" => Some(Box::new(PlainEnglish)),
+ "typst" => Some(Box::new(Typst)),
+ _ => None,
+ };
match parser {
None => {
@@@ -238,7 -264,7 +274,7 @@@
&self,
url: &Url,
range: Range,
-- ) -> Result<Vec<CodeActionOrCommand>> {
++ ) -> JsonResult<Vec<CodeActionOrCommand>> {
let (config, mut doc_states) = tokio::join!(self.config.read(), self.doc_state.lock());
let Some(doc_state) = doc_states.get_mut(url) else {
return Ok(Vec::new());
@@@ -341,7 -367,7 +377,7 @@@
#[tower_lsp::async_trait]
impl LanguageServer for Backend {
-- async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
++ async fn initialize(&self, _: InitializeParams) -> JsonResult<InitializeResult> {
Ok(InitializeResult {
server_info: None,
capabilities: ServerCapabilities {
@@@ -466,7 -492,7 +502,7 @@@
}
}
-- async fn execute_command(&self, params: ExecuteCommandParams) -> Result<Option<Value>> {
++ async fn execute_command(&self, params: ExecuteCommandParams) -> JsonResult<Option<Value>> {
let mut string_args = params
.arguments
.into_iter()
@@@ -554,7 -580,7 +590,10 @@@
}
}
-- async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
++ async fn code_action(
++ &self,
++ params: CodeActionParams,
++ ) -> JsonResult<Option<CodeActionResponse>> {
let actions = self
.generate_code_actions(&params.text_document.uri, params.range)
.await?;
@@@ -562,7 -588,7 +601,7 @@@
Ok(Some(actions))
}
-- async fn shutdown(&self) -> Result<()> {
++ async fn shutdown(&self) -> JsonResult<()> {
let doc_states = self.doc_state.lock().await;
// Clears the diagnostics for open buffers.
diff --cc harper-ls/src/backend.rs:14:1
index 000000000,000000000..873cace99
new file mode 100644
--- /dev/null
+++ b/harper-ls/src/backend.rs:14:1
@@@ -1,0 -1,0 +1,24 @@@
++[?1049h[?1h[?2004h[?2026$p[?u[?12h[?25h[?25l(B]112[1 q[?1002h[?1006h[38:2:0:0:0m
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++