Apply some clippy::pedantic lints

rq-cli/src/components/response_panel.rs

@@ -78,7 +78,7 @@ impl ResponsePanel {
     }
 
     pub fn set_response(&mut self, value: Response) {
-        self.state = State::Received(value)
+        self.state = State::Received(value);
     }
 }
 
@@ -126,13 +126,13 @@ impl ResponsePanel {
         match self.body() {
             Ok(body) => match body {
                 Payload::Text(t) => iter::once(format!("decoded with encoding '{}':", t.charset))
-                    .chain(t.text.lines().map(|s| s.to_string()))
+                    .chain(t.text.lines().map(str::to_string))
                     .collect(),
                 Payload::Bytes(b) if self.show_raw => iter::once("lossy utf-8 decode:".to_string())
                     .chain(
                         String::from_utf8_lossy(&b.bytes)
                             .lines()
-                            .map(|s| s.to_string()),
+                            .map(str::to_string),
                     )
                     .collect(),
                 Payload::Bytes(_) => vec!["raw bytes".into()],

rq-core/src/request.rs

@@ -24,8 +24,8 @@ static CLIENT: Lazy<Client> = Lazy::new(|| {
 pub struct Response {
     pub status: StatusCode,
     pub version: String,
-    pub payload: Payload,
     pub headers: HeaderMap,
+    pub payload: Payload,
 }
 
 impl Response {

rq-core/src/request/decode.rs

@@ -1,12 +1,9 @@
 use bytes::Bytes;
 use encoding_rs::{Encoding, UTF_8};
 
-pub async fn decode_with_encoding(
-    bytes: Bytes,
-    encoding_name: &str,
-) -> (String, &'static Encoding) {
+pub fn decode_with_encoding(bytes: &Bytes, encoding_name: &str) -> (String, &'static Encoding) {
     let encoding = Encoding::for_label(encoding_name.as_bytes()).unwrap_or(UTF_8);
 
-    let (text, encoding, _) = encoding.decode(&bytes);
+    let (text, encoding, _) = encoding.decode(bytes);
     (text.into_owned(), encoding)
 }

rq-core/src/request/mime.rs

@@ -39,10 +39,9 @@ impl Payload {
                     (mime::TEXT, _) | (_, mime::JSON) => {
                         let charset = mime
                             .get_param("charset")
-                            .map(|charset| charset.to_string())
-                            .unwrap_or("utf-8".into());
+                            .map_or("utf-8".into(), |charset| charset.to_string());
                         let (text, encoding) =
-                            decode_with_encoding(response.bytes().await.unwrap(), &charset).await;
+                            decode_with_encoding(&response.bytes().await.unwrap(), &charset);
                         Payload::Text(TextPayload {
                             charset: encoding.name().to_owned(),
                             text,
@@ -81,5 +80,5 @@ fn parse_extension(name: Name) -> Option<String> {
         mime::XML => Some("xml"),
         _ => None,
     }
-    .map(|extension| extension.to_string())
+    .map(str::to_string)
 }