Move protocol types to a separate file

latex-lsp · Dec 11, 2019 · 5ac87b1 · 5ac87b1
1 parent 7347d10
commit 5ac87b1
Show file tree

Hide file tree

Showing 14 changed files with 159 additions and 170 deletions.
diff --git a/src/build.rs b/src/build.rs
@@ -1,14 +1,13 @@
 use crate::capabilities::ClientCapabilitiesExt;
 use crate::client::LspClient;
+use crate::protocol_types::*;
 use crate::workspace::*;
 use futures::future::{AbortHandle, Abortable, Aborted};
 use futures::lock::Mutex;
 use futures::prelude::*;
 use futures::stream;
 use futures_boxed::boxed;
 use lsp_types::*;
-use serde::{Deserialize, Serialize};
-use serde_repr::*;
 use std::collections::HashMap;
 use std::io;
 use std::path::Path;
@@ -18,70 +17,18 @@ use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::process::Command;
 use uuid::Uuid;
 
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BuildParams {
-    pub text_document: TextDocumentIdentifier,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BuildOptions {
-    pub executable: Option<String>,
-    pub args: Option<Vec<String>>,
-    pub on_save: Option<bool>,
-}
-
-impl BuildOptions {
-    pub fn executable(&self) -> String {
-        self.executable
-            .as_ref()
-            .map(Clone::clone)
-            .unwrap_or_else(|| "latexmk".to_owned())
-    }
-
-    pub fn args(&self) -> Vec<String> {
-        self.args.as_ref().map(Clone::clone).unwrap_or_else(|| {
-            vec![
-                "-pdf".to_owned(),
-                "-interaction=nonstopmode".to_owned(),
-                "-synctex=1".to_owned(),
-            ]
-        })
-    }
-
-    pub fn on_save(&self) -> bool {
-        self.on_save.unwrap_or(false)
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize_repr, Deserialize_repr)]
-#[repr(i32)]
-pub enum BuildStatus {
-    Success = 0,
-    Error = 1,
-    Failure = 2,
-    Cancelled = 3,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BuildResult {
-    pub status: BuildStatus,
-}
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct BuildProvider<C> {
     pub client: Arc<C>,
-    pub options: BuildOptions,
+    pub options: LatexBuildOptions,
     pub token: ProgressToken,
 }
 
 impl<C> BuildProvider<C>
 where
     C: LspClient + Send + Sync + 'static,
 {
-    pub fn new(client: Arc<C>, options: BuildOptions) -> Self {
+    pub fn new(client: Arc<C>, options: LatexBuildOptions) -> Self {
         Self {
             client,
             options,
@@ -191,7 +138,7 @@ where
     pub async fn build(
         &self,
         request: FeatureRequest<BuildParams>,
-        options: BuildOptions,
+        options: LatexBuildOptions,
     ) -> BuildResult {
         let provider = BuildProvider::new(Arc::clone(&self.client), options);
         let (handle, reg) = AbortHandle::new_pair();

diff --git a/src/definition/mod.rs b/src/definition/mod.rs
@@ -9,8 +9,7 @@ use self::latex_command::LatexCommandDefinitionProvider;
 use self::latex_label::LatexLabelDefinitionProvider;
 use crate::workspace::*;
 use futures_boxed::boxed;
-use lsp_types::{Location, LocationLink, TextDocumentPositionParams};
-use serde::{Deserialize, Serialize};
+use lsp_types::{LocationLink, TextDocumentPositionParams};
 
 pub struct DefinitionProvider {
     provider: ConcatProvider<TextDocumentPositionParams, LocationLink>,
@@ -44,10 +43,3 @@ impl FeatureProvider for DefinitionProvider {
         self.provider.execute(request).await
     }
 }
-
-#[serde(untagged)]
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-pub enum DefinitionResponse {
-    Locations(Vec<Location>),
-    LocationLinks(Vec<LocationLink>),
-}
diff --git a/src/diagnostics/latex.rs b/src/diagnostics/latex.rs
@@ -3,28 +3,10 @@ use crate::workspace::{Document, Uri};
 use lsp_types::*;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io::{Read, Write};
 use std::process::{Command, Stdio};
 
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct LatexLintOptions {
-    pub on_change: Option<bool>,
-    pub on_save: Option<bool>,
-}
-
-impl LatexLintOptions {
-    pub fn on_change(&self) -> bool {
-        self.on_change.unwrap_or(false)
-    }
-
-    pub fn on_save(&self) -> bool {
-        self.on_save.unwrap_or(false)
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
 pub struct LatexDiagnosticsProvider {
     diagnostics_by_uri: HashMap<Uri, Vec<Diagnostic>>,

diff --git a/src/diagnostics/mod.rs b/src/diagnostics/mod.rs
@@ -2,11 +2,11 @@ mod bibtex;
 mod build;
 mod latex;
 
-use self::bibtex::BibtexDiagnosticsProvider;
 pub use self::bibtex::BibtexErrorCode;
+
+use self::bibtex::BibtexDiagnosticsProvider;
 use self::build::BuildDiagnosticsProvider;
 use self::latex::LatexDiagnosticsProvider;
-pub use self::latex::LatexLintOptions;
 use crate::workspace::Document;
 use lsp_types::Diagnostic;
 

diff --git a/src/formatting/bibtex.rs b/src/formatting/bibtex.rs
@@ -1,14 +1,7 @@
+use crate::protocol_types::BibtexFormattingOptions;
 use crate::syntax::*;
-use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BibtexFormattingOptions {
-    pub line_length: Option<i32>,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct BibtexFormattingParams {
     pub tab_size: usize,
     pub insert_spaces: bool,

diff --git a/src/forward_search.rs b/src/forward_search.rs
@@ -1,36 +1,15 @@
+use crate::protocol_types::*;
 use log::*;
-use serde::{Deserialize, Serialize};
-use serde_repr::*;
 use std::io;
 use std::path::Path;
 use std::process::Stdio;
 use tokio::process::Command;
 
-#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
-pub struct ForwardSearchOptions {
-    pub executable: Option<String>,
-    pub args: Option<Vec<String>>,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize_repr, Deserialize_repr)]
-#[repr(i32)]
-pub enum ForwardSearchStatus {
-    Success = 0,
-    Error = 1,
-    Failure = 2,
-    Unconfigured = 3,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-pub struct ForwardSearchResult {
-    pub status: ForwardSearchStatus,
-}
-
 pub async fn search<'a>(
     tex_file: &'a Path,
     parent: &'a Path,
     line_number: u64,
-    options: ForwardSearchOptions,
+    options: LatexForwardSearchOptions,
 ) -> Option<ForwardSearchResult> {
     if options.executable.is_none() || options.args.is_none() {
         return Some(ForwardSearchResult {

diff --git a/src/lib.rs b/src/lib.rs
@@ -16,6 +16,7 @@ pub mod highlight;
 pub mod hover;
 pub mod link;
 pub mod lsp_kind;
+pub mod protocol_types;
 pub mod range;
 pub mod reference;
 pub mod rename;

diff --git a/src/protocol_types.rs b/src/protocol_types.rs
@@ -0,0 +1,105 @@
+use lsp_types::{Location, LocationLink, TextDocumentIdentifier};
+use serde::{Deserialize, Serialize};
+use serde_repr::*;
+
+#[serde(untagged)]
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub enum DefinitionResponse {
+    Locations(Vec<Location>),
+    LocationLinks(Vec<LocationLink>),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BibtexFormattingOptions {
+    pub line_length: Option<i32>,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
+pub struct LatexForwardSearchOptions {
+    pub executable: Option<String>,
+    pub args: Option<Vec<String>>,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize_repr, Deserialize_repr)]
+#[repr(i32)]
+pub enum ForwardSearchStatus {
+    Success = 0,
+    Error = 1,
+    Failure = 2,
+    Unconfigured = 3,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct ForwardSearchResult {
+    pub status: ForwardSearchStatus,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct LatexLintOptions {
+    pub on_change: Option<bool>,
+    pub on_save: Option<bool>,
+}
+
+impl LatexLintOptions {
+    pub fn on_change(&self) -> bool {
+        self.on_change.unwrap_or(false)
+    }
+
+    pub fn on_save(&self) -> bool {
+        self.on_save.unwrap_or(false)
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildParams {
+    pub text_document: TextDocumentIdentifier,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LatexBuildOptions {
+    pub executable: Option<String>,
+    pub args: Option<Vec<String>>,
+    pub on_save: Option<bool>,
+}
+
+impl LatexBuildOptions {
+    pub fn executable(&self) -> String {
+        self.executable
+            .as_ref()
+            .map(Clone::clone)
+            .unwrap_or_else(|| "latexmk".to_owned())
+    }
+
+    pub fn args(&self) -> Vec<String> {
+        self.args.as_ref().map(Clone::clone).unwrap_or_else(|| {
+            vec![
+                "-pdf".to_owned(),
+                "-interaction=nonstopmode".to_owned(),
+                "-synctex=1".to_owned(),
+            ]
+        })
+    }
+
+    pub fn on_save(&self) -> bool {
+        self.on_save.unwrap_or(false)
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize_repr, Deserialize_repr)]
+#[repr(i32)]
+pub enum BuildStatus {
+    Success = 0,
+    Error = 1,
+    Failure = 2,
+    Cancelled = 3,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildResult {
+    pub status: BuildStatus,
+}
diff --git a/src/server.rs b/src/server.rs
@@ -4,17 +4,18 @@ use crate::capabilities::ClientCapabilitiesExt;
 use crate::citeproc::render_citation;
 use crate::client::LspClient;
 use crate::completion::{CompletionItemData, CompletionProvider, DATABASE};
-use crate::definition::{DefinitionProvider, DefinitionResponse};
-use crate::diagnostics::{DiagnosticsManager, LatexLintOptions};
+use crate::definition::DefinitionProvider;
+use crate::diagnostics::DiagnosticsManager;
 use crate::folding::FoldingProvider;
-use crate::formatting::bibtex::{self, BibtexFormattingOptions, BibtexFormattingParams};
-use crate::forward_search::{self, ForwardSearchOptions, ForwardSearchResult, ForwardSearchStatus};
+use crate::formatting::bibtex::{self, BibtexFormattingParams};
+use crate::forward_search;
 use crate::highlight::HighlightProvider;
 use crate::hover::HoverProvider;
 use crate::link::LinkProvider;
+use crate::protocol_types::*;
 use crate::reference::ReferenceProvider;
 use crate::rename::{PrepareRenameProvider, RenameProvider};
-use crate::symbol::{self, SymbolProvider, SymbolResponse};
+use crate::symbol::{self, SymbolProvider};
 use crate::syntax::*;
 use crate::workspace::*;
 use futures::lock::Mutex;
@@ -309,10 +310,13 @@ impl<C: LspClient + Send + Sync + 'static> LatexLspServer<C> {
     }
 
     #[jsonrpc_method("textDocument/documentSymbol", kind = "request")]
-    pub async fn document_symbol(&self, params: DocumentSymbolParams) -> Result<SymbolResponse> {
+    pub async fn document_symbol(
+        &self,
+        params: DocumentSymbolParams,
+    ) -> Result<DocumentSymbolResponse> {
         let request = self.make_feature_request(params.text_document.as_uri(), params)?;
         let symbols = self.symbol_provider.execute(&request).await;
-        let response = SymbolResponse::new(
+        let response = symbol::document_symbols(
             &self.client_capabilities.get().unwrap(),
             &request.view.workspace,
             &request.document().uri,
@@ -383,7 +387,7 @@ impl<C: LspClient + Send + Sync + 'static> LatexLspServer<C> {
     #[jsonrpc_method("textDocument/build", kind = "request")]
     pub async fn build(&self, params: BuildParams) -> Result<BuildResult> {
         let request = self.make_feature_request(params.text_document.as_uri(), params)?;
-        let options = self.configuration::<BuildOptions>("latex.build").await;
+        let options = self.configuration::<LatexBuildOptions>("latex.build").await;
         let result = self.build_manager.build(request, options).await;
         Ok(result)
     }
@@ -395,7 +399,7 @@ impl<C: LspClient + Send + Sync + 'static> LatexLspServer<C> {
     ) -> Result<ForwardSearchResult> {
         let request = self.make_feature_request(params.text_document.as_uri(), params)?;
         let options = self
-            .configuration::<ForwardSearchOptions>("latex.forwardSearch")
+            .configuration::<LatexForwardSearchOptions>("latex.forwardSearch")
             .await;
 
         match request.document().uri.to_file_path() {
@@ -623,7 +627,7 @@ impl<C: LspClient + Send + Sync + 'static> Middleware for LatexLspServer<C> {
                     }
                 }
                 Action::Build(uri) => {
-                    let config: BuildOptions = self.configuration("latex.build").await;
+                    let config: LatexBuildOptions = self.configuration("latex.build").await;
                     if config.on_save() {
                         let text_document = TextDocumentIdentifier::new(uri.into());
                         self.build(BuildParams { text_document }).await.unwrap();