chore(lib): continuation of v3 refactor (see #117)

CHANGELOG.md

@@ -7,14 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [3.0.0](https://github.com/jeertmans/languagetool-rust/compare/v2.1.4...v2.1.5)
 
-- Added support for Mardown and Typst files.
+- Added support for Markdown and Typst files.
   [#117](https://github.com/jeertmans/languagetool-rust/pull/117)
 
-### Chore
+### Breaking
 
-- **Breaking** Stopped (de)serializing structs that did not need.
+- **Breaking** Stopped (de)serializing structs that did not need it.
   [#117](https://github.com/jeertmans/languagetool-rust/pull/117)
-- **Breaking** Completly reorganized the crate.
+- **Breaking** Completely reorganized the crate.
   [#117](https://github.com/jeertmans/languagetool-rust/pull/117)
 
 ## [2.1.4](https://github.com/jeertmans/languagetool-rust/compare/v2.1.3...v2.1.4)
@@ -182,7 +182,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   [#6](https://github.com/jeertmans/languagetool-rust/pull/6)
 - Add compare links to release tags in CHANGELOG.
   [#9](https://github.com/jeertmans/languagetool-rust/pull/9)
-- Add action to check if can publish.
+- Add action to check if crate is publishable.
   [#11](https://github.com/jeertmans/languagetool-rust/pull/11)
 
 ### Added

Cargo.toml

@@ -60,7 +60,7 @@ license = "MIT"
 name = "languagetool-rust"
 readme = "README.md"
 repository = "https://github.com/jeertmans/languagetool-rust"
-rust-version = "1.64.0"
+rust-version = "1.70.0"
 version = "2.1.4"
 
 [package.metadata.docs.rs]

README.md

@@ -153,14 +153,14 @@ languagetool_rust = "^2.1"
 ### Example
 
 ```rust
-use languagetool_rust::{check::CheckRequest, server::ServerClient};
+use languagetool_rust::api::{check::CheckRequest, server::ServerClient};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client = ServerClient::from_env_or_default();
 
     let req = CheckRequest::default()
-        .with_text("Some phrase with a smal mistake".to_string());  # codespell:ignore smal
+        .with_text("Some phrase with a smal mistake".to_string());  //# codespell:ignore smal
 
     println!(
         "{}",

benches/benchmarks/check_texts.rs

@@ -1,9 +1,11 @@
 use criterion::{criterion_group, Criterion, Throughput};
 use futures::future::join_all;
 use languagetool_rust::{
-    check::{CheckRequest, CheckResponse, CheckResponseWithContext},
+    api::{
+        check::{CheckRequest, CheckResponse, CheckResponseWithContext},
+        server::ServerClient,
+    },
     error::Error,
-    server::ServerClient,
 };
 
 static FILES: [(&str, &str); 3] = [
@@ -44,12 +46,10 @@ async fn check_text_split(text: &str) -> CheckResponse {
     );
     let lines = text.lines();
 
-    let resps = join_all(lines.map(|line| {
-        async {
-            let req = CheckRequest::default().with_text(line.to_string());
-            let resp = request_until_success(&req, &client).await;
-            CheckResponseWithContext::new(req.get_text(), resp)
-        }
+    let resps = join_all(lines.map(|line| async {
+        let req = CheckRequest::default().with_text(line.to_string());
+        let resp = request_until_success(&req, &client).await;
+        CheckResponseWithContext::new(req.get_text(), resp)
     }))
     .await;
 

src/api/check.rs

@@ -12,7 +12,7 @@ use annotate_snippets::{
 use clap::{Args, Parser, ValueEnum};
 use serde::{Deserialize, Serialize, Serializer};
 
-use super::error::{Error, Result};
+use crate::error::{Error, Result};
 
 /// Requests
 
@@ -23,7 +23,7 @@ use super::error::{Error, Result};
 /// - a five character string matching pattern `[a-z]{2}-[A-Z]{2}
 /// - or some more complex ascii string (see below)
 ///
-/// Language code is case insensitive.
+/// Language code is case-insensitive.
 ///
 /// Therefore, a valid language code must match the following:
 ///
@@ -38,7 +38,7 @@ use super::error::{Error, Result};
 /// # Examples
 ///
 /// ```
-/// # use languagetool_rust::check::parse_language_code;
+/// # use languagetool_rust::api::check::parse_language_code;
 /// assert!(parse_language_code("en").is_ok());
 ///
 /// assert!(parse_language_code("en-US").is_ok());
@@ -187,7 +187,7 @@ impl DataAnnotation {
 #[cfg(test)]
 mod data_annotation_tests {
 
-    use crate::check::DataAnnotation;
+    use super::DataAnnotation;
 
     #[test]
     fn test_text() {
@@ -277,7 +277,7 @@ impl Level {
     /// # Examples
     ///
     /// ```
-    /// # use languagetool_rust::check::Level;
+    /// # use languagetool_rust::api::check::Level;
     ///
     /// let level: Level = Default::default();
     ///
@@ -296,7 +296,7 @@ impl Level {
 /// # Examples
 ///
 /// ```
-/// # use languagetool_rust::check::split_len;
+/// # use languagetool_rust::api::check::split_len;
 /// let s = "I have so many friends.
 /// They are very funny.
 /// I think I am very lucky to have them.
@@ -696,7 +696,7 @@ pub struct CheckCommand {
     /// Specify the files type to use the correct parser.
     ///
     /// If set to auto, the type is guessed from the filename extension.
-    #[clap(long, default_value = "default", ignore_case = true, value_enum)]
+    #[clap(long, value_enum, default_value_t = FileType::default(), ignore_case = true)]
     pub r#type: FileType,
     /// Optional filenames from which input is read.
     #[arg(conflicts_with_all(["text", "data"]), value_parser = parse_filename)]
@@ -709,7 +709,7 @@ pub struct CheckCommand {
 #[cfg(test)]
 mod request_tests {
 
-    use crate::CheckRequest;
+    use super::CheckRequest;
 
     #[test]
     fn test_with_text() {
@@ -845,7 +845,7 @@ pub struct Rule {
     pub urls: Option<Vec<Url>>,
 }
 
-/// Type of a given match.
+/// Type of given match.
 #[derive(PartialEq, Eq, Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 #[non_exhaustive]
@@ -876,7 +876,7 @@ pub struct Match {
     /// More context to match, post-processed using original text.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub more_context: Option<MoreContext>,
-    /// Char index at which the match start.
+    /// Char index at which the match starts.
     pub offset: usize,
     /// List of possible replacements (if applies).
     pub replacements: Vec<Replacement>,
@@ -959,7 +959,7 @@ impl CheckResponse {
     #[must_use]
     pub fn annotate(&self, text: &str, origin: Option<&str>, color: bool) -> String {
         if self.matches.is_empty() {
-            return "No error were found in provided text".to_string();
+            return "No errors were found in provided text".to_string();
         }
         let replacements: Vec<_> = self
             .matches
@@ -975,8 +975,11 @@ impl CheckResponse {
             })
             .collect();
 
-        let snippets = self.matches.iter().zip(replacements.iter()).map(|(m, r)| {
-            Snippet {
+        let snippets = self
+            .matches
+            .iter()
+            .zip(replacements.iter())
+            .map(|(m, r)| Snippet {
                 title: Some(Annotation {
                     label: Some(&m.message),
                     id: Some(&m.rule.id),
@@ -1005,8 +1008,7 @@ impl CheckResponse {
                     color,
                     ..Default::default()
                 },
-            }
-        });
+            });
 
         let mut annotation = String::new();
 

src/api/languages.rs

@@ -2,9 +2,6 @@
 
 use serde::{Deserialize, Serialize};
 
-/// LanguageTool GET languages request.
-pub struct Request;
-
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 #[non_exhaustive]

src/api/mod.rs

@@ -1,64 +1,71 @@
-/// Raw bindings to the LanguageTool API v1.1.2.
-///
-/// The current bindings were generated using the
-/// [HTTP API documentation](https://languagetool.org/http-api/).
-///
-/// Unfortunately, the LanguageTool API is not as documented as we could
-/// hope, and resquests might return undocumented fields. Those are deserialized
-/// to the `undocumented` field.
+//! Raw bindings to the LanguageTool API v1.1.2.
+//!
+//! The current bindings were generated using the
+//! [HTTP API documentation](https://languagetool.org/http-api/).
+//!
+//! Unfortunately, the LanguageTool API is not as documented as we could
+//! hope, and requests might return undocumented fields. Those are de-serialized
+//! to the `undocumented` field.
 pub mod check;
 pub mod languages;
 pub mod server;
 pub mod words;
 
-/// A HTTP client for making requests to some LanguageTool server.
+/// A HTTP client for making requests to a LanguageTool server.
+#[derive(Debug)]
 pub struct Client {
     /// Server's hostname.
     hostname: String,
     /// Server's port.
     port: Option<String>,
-    /// Inner client to perform HTTP requets.
+    /// Inner client to perform HTTP requests.
     client: reqwest::Client,
 }
 
 impl Default for Client {
     fn default() -> Self {
         Self {
             hostname: "https://api.languagetoolplus.com".to_string(),
-            ..Default::default()
+            port: None,
+            client: Default::default(),
         }
     }
 }
 
 impl Client {
-    /// Construct a HTTP url base on the current hostname, optional port,
+    /// Construct an HTTP URL base on the current hostname, optional port,
     /// and provided endpoint.
     #[inline]
+    #[must_use]
     pub fn url(&self, endpoint: &str) -> String {
-        let hostname = self.hostname;
-        match self.port {
+        let hostname = &self.hostname;
+        match &self.port {
             Some(p) => format!("{hostname}:{p}/v2{endpoint}"),
             None => format!("{hostname}/v2{endpoint}"),
         }
     }
 
     /// Send a check request to the server and await for the response.
-    pub async fn check(&self, request: &check::Request) -> Result<check::Response> {
+    pub async fn check(
+        &self,
+        request: &check::CheckRequest,
+    ) -> reqwest::Result<check::CheckResponse> {
         self.client
             .post(self.url("/check"))
             .query(request)
             .send()
             .await?
-            .json::<check::Response>()
+            .json::<check::CheckResponse>()
+            .await
     }
 
-    /// Send a words request to the server and await for the response.
-    pub async fn languages(&self, request: &languages::Request) -> Result<languages::Response> {
+    /// Send a request for the list of supported languages to the server and await for the response.
+    pub async fn languages(&self) -> reqwest::Result<languages::Response> {
         self.client
             .get(self.url("/languages"))
-            .query(request)
             .send()
             .await?
-            .json::<check::Response>()
+            .json::<languages::Response>()
+            .await
     }
 }