Allow formatting via latexindent for BibTeX files

latex-lsp · Apr 11, 2020 · 8b2d3a6 · 8b2d3a6
1 parent d030edf
commit 8b2d3a6
Show file tree

Hide file tree

Showing 9 changed files with 83 additions and 51 deletions.
diff --git a/src/citeproc/mod.rs b/src/citeproc/mod.rs
@@ -50,7 +50,10 @@ pub fn render_citation(tree: &bibtex::Tree, key: &str) -> Option<MarkupContent>
 }
 
 fn convert_to_ris(tree: &bibtex::Tree, key: &str) -> Option<RisReference> {
-    let options = BibtexFormattingOptions { line_length: None };
+    let options = BibtexFormattingOptions {
+        line_length: None,
+        formatter: None,
+    };
     let params = bibtex::FormattingParams {
         insert_spaces: true,
         tab_size: 4,

diff --git a/src/hover/bibtex/string_reference.rs b/src/hover/bibtex/string_reference.rs
@@ -56,7 +56,7 @@ impl BibtexStringReferenceHoverProvider {
             return None;
         }
 
-        let options = BibtexFormattingOptions { line_length: None };
+        let options = BibtexFormattingOptions { line_length: None, formatter: None };
         let text = bibtex::format(
             tree,
             tree.children(string_node).next()?,

diff --git a/src/protocol/options.rs b/src/protocol/options.rs
@@ -1,10 +1,24 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum BibtexFormatter {
+    Texlab,
+    Latexindent,
+}
+
+impl Default for BibtexFormatter {
+    fn default() -> Self {
+        Self::Texlab
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BibtexFormattingOptions {
     pub line_length: Option<i32>,
+    pub formatter: Option<BibtexFormatter>,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]

diff --git a/src/server.rs b/src/server.rs
@@ -17,7 +17,7 @@ use crate::{
     reference::ReferenceProvider,
     rename::{PrepareRenameProvider, RenameProvider},
     symbol::{document_symbols, workspace_symbols, SymbolProvider},
-    syntax::{bibtex, latex, CharStream, SyntaxNode},
+    syntax::{bibtex, latexindent, CharStream, SyntaxNode},
     tex::{DistributionKind, DynamicDistribution, KpsewhichError},
     workspace::{DocumentContent, Workspace},
 };
@@ -378,17 +378,9 @@ impl<C: LspClient + Send + Sync + 'static> LatexLspServer<C> {
             .await?;
         let mut edits = Vec::new();
         match &req.current().content {
-            DocumentContent::Latex(_) => match latex::format(&req.current().text).await {
-                Ok(text) => {
-                    let mut stream = CharStream::new(&text);
-                    while stream.next().is_some() {}
-                    let range = Range::new(Position::new(0, 0), stream.current_position);
-                    edits.push(TextEdit::new(range, text));
-                }
-                Err(why) => {
-                    debug!("Failed to run latexindent.pl: {}", why);
-                }
-            },
+            DocumentContent::Latex(_) => {
+                Self::run_latexindent(&req.current().text, "tex", &mut edits).await;
+            }
             DocumentContent::Bibtex(tree) => {
                 let options = req
                     .options
@@ -397,28 +389,49 @@ impl<C: LspClient + Send + Sync + 'static> LatexLspServer<C> {
                     .and_then(|opts| opts.formatting)
                     .unwrap_or_default();
 
-                let params = bibtex::FormattingParams {
-                    tab_size: req.params.options.tab_size as usize,
-                    insert_spaces: req.params.options.insert_spaces,
-                    options: &options,
-                };
-
-                for node in tree.children(tree.root) {
-                    let should_format = match &tree.graph[node] {
-                        bibtex::Node::Preamble(_) | bibtex::Node::String(_) => true,
-                        bibtex::Node::Entry(entry) => !entry.is_comment(),
-                        _ => false,
-                    };
-                    if should_format {
-                        let text = bibtex::format(&tree, node, params);
-                        edits.push(TextEdit::new(tree.graph[node].range(), text));
+                match options.formatter.unwrap_or_default() {
+                    BibtexFormatter::Texlab => {
+                        let params = bibtex::FormattingParams {
+                            tab_size: req.params.options.tab_size as usize,
+                            insert_spaces: req.params.options.insert_spaces,
+                            options: &options,
+                        };
+
+                        for node in tree.children(tree.root) {
+                            let should_format = match &tree.graph[node] {
+                                bibtex::Node::Preamble(_) | bibtex::Node::String(_) => true,
+                                bibtex::Node::Entry(entry) => !entry.is_comment(),
+                                _ => false,
+                            };
+                            if should_format {
+                                let text = bibtex::format(&tree, node, params);
+                                edits.push(TextEdit::new(tree.graph[node].range(), text));
+                            }
+                        }
+                    }
+                    BibtexFormatter::Latexindent => {
+                        Self::run_latexindent(&req.current().text, "bib", &mut edits).await;
                     }
                 }
             }
         }
         Ok(edits)
     }
 
+    async fn run_latexindent(old_text: &str, extension: &str, edits: &mut Vec<TextEdit>) {
+        match latexindent::format(old_text, extension).await {
+            Ok(new_text) => {
+                let mut stream = CharStream::new(&old_text);
+                while stream.next().is_some() {}
+                let range = Range::new(Position::new(0, 0), stream.current_position);
+                edits.push(TextEdit::new(range, new_text));
+            }
+            Err(why) => {
+                debug!("Failed to run latexindent.pl: {}", why);
+            }
+        }
+    }
+
     #[jsonrpc_method("textDocument/prepareRename", kind = "request")]
     pub async fn prepare_rename(
         &self,

diff --git a/src/syntax/bibtex/formatter.rs b/src/syntax/bibtex/formatter.rs
@@ -207,6 +207,7 @@ mod tests {
         let tree = bibtex::open(source);
         let options = BibtexFormattingOptions {
             line_length: Some(line_length),
+            formatter: None,
         };
 
         let mut children = tree.children(tree.root);

diff --git a/src/syntax/latex/formatter.rs b/src/syntax/latex/formatter.rs
diff --git a/src/syntax/latex/mod.rs b/src/syntax/latex/mod.rs
@@ -1,10 +1,9 @@
 mod analysis;
 mod ast;
-mod formatter;
 mod lexer;
 mod parser;
 
-pub use self::{analysis::*, ast::*, formatter::*};
+pub use self::{analysis::*, ast::*};
 
 use self::{lexer::Lexer, parser::Parser};
 use crate::{

diff --git a/src/syntax/latexindent.rs b/src/syntax/latexindent.rs
@@ -0,0 +1,21 @@
+use std::{io, process::Stdio};
+use tempfile::tempdir;
+use tokio::{fs, process::Command};
+
+pub async fn format(text: &str, extension: &str) -> io::Result<String> {
+    let dir = tempdir()?;
+    let input = format!("input.{}", extension);
+    let output = format!("output.{}", extension);
+    fs::write(dir.path().join(&input), text).await?;
+
+    Command::new("latexindent")
+        .args(&["-o", &output, &input])
+        .current_dir(dir.path())
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()?
+        .await?;
+
+    fs::read_to_string(dir.path().join(&output)).await
+}
diff --git a/src/syntax/mod.rs b/src/syntax/mod.rs
@@ -1,6 +1,7 @@
 pub mod bibtex;
 mod lang_data;
 pub mod latex;
+pub mod latexindent;
 mod lsp_kind;
 mod text;