Add --preserve-encoding option to keep response body encoding

src/cli.rs

@@ -159,6 +159,12 @@ Defaults to \"format\" if the NO_COLOR env is set and to \"none\" if stdout is n
     #[clap(short = 'd', long)]
     pub download: bool,
 
+    /// During download, keep the raw encoding of the body. Requires --download.
+    ///
+    /// For example, set Accept-Encoding: gzip and use --preserve-encoding to skip decompression.
+    #[clap(long, requires = "download")]
+    pub preserve_encoding: bool,
+
     /// Resume an interrupted download. Requires --download and --output.
     #[clap(
         short = 'c',

src/download.rs

@@ -160,6 +160,7 @@ const UNCOLORED_SPINNER_TEMPLATE: &str = "{spinner} {bytes} {bytes_per_sec} {wid
 
 pub fn download_file(
     mut response: Response,
+    preserve_encoding: bool,
     file_name: Option<PathBuf>,
     // If we fall back on taking the filename from the URL it has to be the
     // original URL, before redirects. That's less surprising and matches
@@ -244,9 +245,13 @@ pub fn download_file(
         pb.reset_eta();
     }
 
+    let compression_type = if !preserve_encoding {
+        get_compression_type(response.headers())
+    } else {
+        None
+    };
     match pb {
         Some(ref pb) => {
-            let compression_type = get_compression_type(response.headers());
             copy_largebuf(
                 &mut decompress(&mut pb.wrap_read(response), compression_type),
                 &mut buffer,
@@ -267,7 +272,6 @@ pub fn download_file(
             }
         }
         None => {
-            let compression_type = get_compression_type(response.headers());
             copy_largebuf(
                 &mut decompress(&mut response, compression_type),
                 &mut buffer,

src/main.rs

@@ -353,11 +353,25 @@ fn run(args: Cli) -> Result<i32> {
     let mut request = {
         let mut request_builder = client
             .request(method, args.url.clone())
-            .header(
+            .header(USER_AGENT, get_user_agent());
+
+        if args.download {
+            if let Some(encoding) = headers.get(ACCEPT_ENCODING) {
+                if args.resume && encoding != HeaderValue::from_static("identity") {
+                    return Err(anyhow!(
+                            "Cannot use --continue with --download, when the encoding is not 'identity'"
+                        ));
+                }
+            } else {
+                request_builder =
+                    request_builder.header(ACCEPT_ENCODING, HeaderValue::from_static("identity"));
+            }
+        } else {
+            request_builder = request_builder.header(
                 ACCEPT_ENCODING,
                 HeaderValue::from_static("gzip, deflate, br"),
-            )
-            .header(USER_AGENT, get_user_agent());
+            );
+        }
 
         if matches!(
             args.http_version,
@@ -464,12 +478,6 @@ fn run(args: Cli) -> Result<i32> {
         request
     };
 
-    if args.download {
-        request
-            .headers_mut()
-            .insert(ACCEPT_ENCODING, HeaderValue::from_static("identity"));
-    }
-
     let buffer = Buffer::new(
         args.download,
         args.output.as_deref(),
@@ -555,6 +563,7 @@ fn run(args: Cli) -> Result<i32> {
             if exit_code == 0 {
                 download_file(
                     response,
+                    args.preserve_encoding,
                     args.output,
                     &args.url,
                     resume,

tests/cli.rs

@@ -413,9 +413,9 @@ fn download() {
 }
 
 #[test]
-fn accept_encoding_not_modifiable_in_download_mode() {
+fn accept_encoding_modifiable_in_download_mode() {
     let server = server::http(|req| async move {
-        assert_eq!(req.headers()["accept-encoding"], "identity");
+        assert_eq!(req.headers()["accept-encoding"], "gzip");
         hyper::Response::builder()
             .body(r#"{"ids":[1,2,3]}"#.into())
             .unwrap()
@@ -429,6 +429,64 @@ fn accept_encoding_not_modifiable_in_download_mode() {
         .success();
 }
 
+#[test]
+fn accept_encoding_identity_default_in_download_mode() {
+    let server = server::http(|req| async move {
+        assert_eq!(req.headers()["accept-encoding"], "identity");
+        hyper::Response::builder()
+            .body(r#"{"ids":[1,2,3]}"#.into())
+            .unwrap()
+    });
+
+    let dir = tempdir().unwrap();
+    get_command()
+        .current_dir(&dir)
+        .args([&server.base_url(), "--download"])
+        .assert()
+        .success();
+}
+
+#[test]
+fn accept_encoding_identity_in_resumable_download_mode() {
+    let server = server::http(|req| async move {
+        assert_eq!(req.headers()["accept-encoding"], "identity");
+        hyper::Response::builder()
+            .body(r#"{"ids":[1,2,3]}"#.into())
+            .unwrap()
+    });
+
+    let dir = tempdir().unwrap();
+    get_command()
+        .current_dir(&dir)
+        .args([
+            &server.base_url(),
+            "--download",
+            "--output",
+            "foo",
+            "--continue",
+            "accept-encoding:identity",
+        ])
+        .assert()
+        .success();
+}
+
+#[test]
+fn accept_encoding_not_modifiable_in_resumable_download_mode() {
+    let dir = tempdir().unwrap();
+    get_command()
+        .current_dir(&dir)
+        .args([
+            ":",
+            "--download",
+            "--output",
+            "foo",
+            "--continue",
+            "accept-encoding:gzip",
+        ])
+        .assert()
+        .failure();
+}
+
 #[test]
 fn download_generated_filename() {
     let dir = tempdir().unwrap();