remove url deps

.github/workflows/rust.yml

@@ -18,5 +18,7 @@ jobs:
     - uses: actions/checkout@v4
     - name: Build
       run: cargo build --verbose
+    - name: Clippy
+      run: cargo clippy --verbose
     - name: Run tests
       run: cargo test --verbose

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "thumbor"
 description = "A Rust client for the Thumbor image service"
-version = "0.0.4"
+version = "0.1.0"
 repository = "https://github.com/SteelAlloy/thumbor-rs"
 documentation = "https://docs.rs/thumbor"
 readme = "README.md"
@@ -20,10 +20,8 @@ cargo = "deny"
 pedantic = "deny"
 
 [dependencies]
-url = "2.5.2"
 strum = { version = "0.26.3", features = ["derive"] }
 thiserror = "1.0.63"
-http = "1.1.0"
 hmac = "0.12.1"
 sha1 = "0.10.6"
 base64ct = { version = "1.6.0", features = ["alloc"] }

README.md

@@ -7,15 +7,29 @@
 
 ## Usage
 
+In short :
+
+```rust
+use thumbor::Server;
+
+let url = Server::new("http://localhost:8888", "my-security-key")
+    .unwrap()
+    .settings_builder()
+    .resize((300, 200))
+    .smart(true)
+    .build()
+    .to_url("path/to/my/image.jpg");
+```
+
 ```rust
 use thumbor::Server;
 
-let server = Server::new_secured("http://localhost:8888", "my-security-key");
+let server = Server::new("http://localhost:8888", "my-security-key").unwrap();
 
-let builder = server.url_builder()
+let settings_builder = server.settings_builder()
     .resize((300, 200))
     .smart(true)
     .build();
 
-let url = builder.build("/path/to/my/image.jpg");
+let url = settings_builder.to_url("path/to/my/image.jpg");
 ```

src/error.rs

@@ -1,7 +1,2 @@
 #[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[error("{0}")]
-    UrlParseError(#[from] url::ParseError),
-    #[error("URL cannot be a base")]
-    UrlCannotBeABase,
-}
+pub enum Error {}

src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(clippy::unwrap_used)]
+
 pub mod error;
 pub mod geometry;
 mod server;

src/server.rs

@@ -1,5 +1,5 @@
 use crate::settings::{Settings, SettingsBuilder};
-use hmac::Hmac;
+use hmac::{digest::InvalidLength, Hmac, Mac};
 use sha1::Sha1;
 
 pub type HmacSha1 = Hmac<Sha1>;
@@ -8,20 +8,22 @@ pub type HmacSha1 = Hmac<Sha1>;
 pub enum Security {
     #[default]
     Unsafe,
-    Hmac(String),
+    Hmac(HmacSha1),
 }
 
-impl From<String> for Security {
-    fn from(value: String) -> Self {
-        Security::Hmac(value)
+impl TryFrom<String> for Security {
+    type Error = InvalidLength;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        let hmac = HmacSha1::new_from_slice(value.as_bytes())?;
+        Ok(Security::Hmac(hmac))
     }
 }
 
 /// ```
 /// use thumbor::Server;
-/// 
-/// let server = Server::new_secured("http://localhost:8888", "my-security-key");
-/// let server = Server::new_unsafe("http://localhost:8888"); // Don't use this in production !
+///
+/// let server = Server::new("http://localhost:8888", "my-security-key").unwrap();
 /// ```
 #[derive(Default, Clone)]
 pub struct Server {
@@ -30,20 +32,34 @@ pub struct Server {
 }
 
 impl Server {
-    pub fn new_unsafe(origin: impl Into<String>) -> Self {
-        Server {
+    pub fn new(origin: impl Into<String>, key: impl Into<String>) -> Result<Self, InvalidLength> {
+        Ok(Server {
             origin: origin.into(),
-            security: Security::Unsafe,
-        }
+            security: key.into().try_into()?,
+        })
     }
-    pub fn new_secured(origin: impl Into<String>, key: impl Into<String>) -> Self {
+
+    /// ```
+    /// use thumbor::Server;
+    ///
+    /// // Don't use this in production !
+    /// let server = Server::new_unsafe("http://localhost:8888");
+    /// ```
+    pub fn new_unsafe(origin: impl Into<String>) -> Self {
         Server {
             origin: origin.into(),
-            security: Security::Hmac(key.into()),
+            security: Security::Unsafe,
         }
     }
 
-    pub fn url_builder(&self) -> SettingsBuilder {
+    /// Create a new SettingsBuilder with the current Server.
+    /// ```
+    /// use thumbor::Server;
+    ///
+    /// let server = Server::new("http://localhost:8888", "my-security-key").unwrap();
+    /// let builder = server.settings_builder();
+    /// ```
+    pub fn settings_builder(&self) -> SettingsBuilder {
         Settings::with_server(self.clone())
     }
 }

src/settings/builder.rs

@@ -1,13 +1,7 @@
+use super::{FitIn, ResponseMode, Settings, Trim};
+use crate::server::Security;
 use base64ct::{Base64Url, Encoding};
 use hmac::Mac;
-use http::Uri;
-
-use crate::{
-    error::Error,
-    server::{HmacSha1, Security},
-};
-
-use super::{FitIn, ResponseMode, Settings, Trim};
 
 impl Settings {
     fn build_path(&self, image_uri: &str) -> String {
@@ -80,36 +74,24 @@ impl Settings {
         path.join("/")
     }
 
-    /// # Errors
-    /// - `Error::UrlParseError`: URL parsing failed.
-    /// - `Error::UrlCannotBeABase`: this URL is cannot-be-a-base.
-    /// # Panics
-    /// TODO: doc
-    pub fn build(&self, image_uri: &str) -> Result<String, Error> {
+    pub fn to_path(&self, image_uri: &str) -> String {
         let path = self.build_path(image_uri);
 
         let security = match &self.server.security {
-            Security::Unsafe => "unsafe".to_owned(),
-            Security::Hmac(secret_key) => {
-                let mut mac = HmacSha1::new_from_slice(secret_key.as_bytes()).unwrap();
-
+            Security::Unsafe => "unsafe",
+            Security::Hmac(hmac) => {
+                let mut mac = hmac.clone();
                 mac.update(path.as_bytes());
 
                 let signature = mac.finalize().into_bytes();
-
-                Base64Url::encode_string(&signature)
+                &Base64Url::encode_string(&signature)
             }
         };
 
-        Ok(format!("{}/{}/{}", self.server.origin, security, path))
+        format!("/{security}/{path}")
     }
 
-    /// # Errors
-    /// - `Error::UrlParseError`: URL parsing failed.
-    /// - `Error::UrlCannotBeABase`: this URL is cannot-be-a-base.
-    /// # Panics
-    /// TODO: doc
-    pub fn build_uri(&self, image_uri: &str) -> Result<Uri, Error> {
-        Ok(self.build(image_uri).unwrap().parse::<Uri>().unwrap())
+    pub fn to_url(&self, image_uri: &str) -> String {
+        format!("{}{}", self.server.origin, self.to_path(image_uri))
     }
 }