Merge remote-tracking branch 'origin/master' into feature/relative_sequence_number

# Conflicts:
#	crunchy-cli-core/src/utils/format.rs

Cargo.lock

@@ -401,7 +401,6 @@ dependencies = [
  "regex",
  "reqwest",
  "rustls-native-certs",
- "sanitize-filename",
  "serde",
  "serde_json",
  "serde_plain",
@@ -1517,16 +1516,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
 
-[[package]]
-name = "sanitize-filename"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ed72fbaf78e6f2d41744923916966c4fbe3d7c74e3037a8ee482f1115572603"
-dependencies = [
- "lazy_static",
- "regex",
-]
-
 [[package]]
 name = "schannel"
 version = "0.1.22"

crunchy-cli-core/Cargo.toml

@@ -28,7 +28,6 @@ log = { version = "0.4", features = ["std"] }
 num_cpus = "1.16"
 regex = "1.9"
 reqwest = { version = "0.11", default-features = false, features = ["socks"] }
-sanitize-filename = "0.5"
 serde = "1.0"
 serde_json = "1.0"
 serde_plain = "1.0"

crunchy-cli-core/src/archive/command.rs

@@ -100,6 +100,10 @@ pub struct Archive {
     #[arg(short, long, default_value_t = false)]
     pub(crate) yes: bool,
 
+    #[arg(help = "The number of threads used to download")]
+    #[arg(short, long, default_value_t = num_cpus::get())]
+    pub(crate) threads: usize,
+
     #[arg(help = "Crunchyroll series url(s)")]
     #[arg(required = true)]
     pub(crate) urls: Vec<String>,
@@ -160,7 +164,8 @@ impl Execute for Archive {
                 .ffmpeg_preset(self.ffmpeg_preset.clone().unwrap_or_default())
                 .output_format(Some("matroska".to_string()))
                 .audio_sort(Some(self.audio.clone()))
-                .subtitle_sort(Some(self.subtitle.clone()));
+                .subtitle_sort(Some(self.subtitle.clone()))
+                .threads(self.threads);
 
             for single_formats in single_format_collection.into_iter() {
                 let (download_formats, mut format) = get_format(&self, &single_formats).await?;
@@ -170,7 +175,7 @@ impl Execute for Archive {
                     downloader.add_format(download_format)
                 }
 
-                let formatted_path = format.format_path((&self.output).into(), true);
+                let formatted_path = format.format_path((&self.output).into());
                 let (path, changed) = free_file(formatted_path.clone());
 
                 if changed && self.skip_existing {

crunchy-cli-core/src/download/command.rs

@@ -82,6 +82,10 @@ pub struct Download {
     #[arg(long, default_value_t = false)]
     pub(crate) force_hardsub: bool,
 
+    #[arg(help = "The number of threads used to download")]
+    #[arg(short, long, default_value_t = num_cpus::get())]
+    pub(crate) threads: usize,
+
     #[arg(help = "Url(s) to Crunchyroll episodes or series")]
     #[arg(required = true)]
     pub(crate) urls: Vec<String>,
@@ -151,7 +155,8 @@ impl Execute for Download {
                 } else {
                     None
                 })
-                .ffmpeg_preset(self.ffmpeg_preset.clone().unwrap_or_default());
+                .ffmpeg_preset(self.ffmpeg_preset.clone().unwrap_or_default())
+                .threads(self.threads);
 
             for mut single_formats in single_format_collection.into_iter() {
                 // the vec contains always only one item
@@ -162,7 +167,7 @@ impl Execute for Download {
                 let mut downloader = download_builder.clone().build();
                 downloader.add_format(download_format);
 
-                let formatted_path = format.format_path((&self.output).into(), true);
+                let formatted_path = format.format_path((&self.output).into());
                 let (path, changed) = free_file(formatted_path.clone());
 
                 if changed && self.skip_existing {

crunchy-cli-core/src/utils/download.rs

@@ -50,6 +50,7 @@ pub struct DownloadBuilder {
     audio_sort: Option<Vec<Locale>>,
     subtitle_sort: Option<Vec<Locale>>,
     force_hardsub: bool,
+    threads: usize,
 }
 
 impl DownloadBuilder {
@@ -61,6 +62,7 @@ impl DownloadBuilder {
             audio_sort: None,
             subtitle_sort: None,
             force_hardsub: false,
+            threads: num_cpus::get(),
         }
     }
 
@@ -73,6 +75,7 @@ impl DownloadBuilder {
             subtitle_sort: self.subtitle_sort,
 
             force_hardsub: self.force_hardsub,
+            threads: self.threads,
 
             formats: vec![],
         }
@@ -99,6 +102,7 @@ pub struct Downloader {
     subtitle_sort: Option<Vec<Locale>>,
 
     force_hardsub: bool,
+    threads: usize,
 
     formats: Vec<DownloadFormat>,
 }
@@ -502,7 +506,8 @@ impl Downloader {
         let tempfile = tempfile(".mp4")?;
         let (mut file, path) = tempfile.into_parts();
 
-        download_segments(ctx, &mut file, message, variant_data).await?;
+        self.download_segments(ctx, &mut file, message, variant_data)
+            .await?;
 
         Ok(path)
     }
@@ -516,7 +521,8 @@ impl Downloader {
         let tempfile = tempfile(".m4a")?;
         let (mut file, path) = tempfile.into_parts();
 
-        download_segments(ctx, &mut file, message, variant_data).await?;
+        self.download_segments(ctx, &mut file, message, variant_data)
+            .await?;
 
         Ok(path)
     }
@@ -537,9 +543,9 @@ impl Downloader {
 
         Ok(path)
     }
-}
 
-pub async fn download_segments(
+    async fn download_segments(
+        &self,
         ctx: &Context,
         writer: &mut impl Write,
         message: String,
@@ -569,7 +575,7 @@ pub async fn download_segments(
             None
         };
 
-    let cpus = num_cpus::get();
+        let cpus = self.threads;
         let mut segs: Vec<Vec<VariantSegment>> = Vec::with_capacity(cpus);
         for _ in 0..cpus {
             segs.push(vec![])
@@ -673,8 +679,8 @@ pub async fn download_segments(
 
             if let Some(p) = &progress {
                 let progress_len = p.length().unwrap();
-            let estimated_segment_len =
+                let estimated_segment_len = (variant_data.bandwidth / 8)
-                (variant_data.bandwidth / 8) * segments.get(pos as usize).unwrap().length.as_secs();
+                    * segments.get(pos as usize).unwrap().length.as_secs();
                 let bytes_len = bytes.len() as u64;
 
                 p.set_length(progress_len - estimated_segment_len + bytes_len);
@@ -720,6 +726,7 @@ pub async fn download_segments(
 
         Ok(())
     }
+}
 
 fn estimate_variant_file_size(variant_data: &VariantData, segments: &Vec<VariantSegment>) -> u64 {
     (variant_data.bandwidth / 8) * segments.iter().map(|s| s.length.as_secs()).sum::<u64>()

crunchy-cli-core/src/utils/format.rs

@@ -1,6 +1,6 @@
 use crate::utils::filter::real_dedup_vec;
 use crate::utils::log::tab_info;
-use crate::utils::os::is_special_file;
+use crate::utils::os::{is_special_file, sanitize};
 use anyhow::Result;
 use chrono::Duration;
 use crunchyroll_rs::media::{Resolution, Stream, Subtitle, VariantData};
@@ -376,55 +376,59 @@ impl Format {
         }
     }
 
-    /// Formats the given string if it has specific pattern in it. It's possible to sanitize it which
+    /// Formats the given string if it has specific pattern in it. It also sanitizes the filename.
-    /// removes characters which can cause failures if the output string is used as a file name.
+    pub fn format_path(&self, path: PathBuf) -> PathBuf {
-    pub fn format_path(&self, path: PathBuf, sanitize: bool) -> PathBuf {
+        let mut path = sanitize(path.to_string_lossy(), false);
-        let path = path
+        path = path
-            .to_string_lossy()
+            .replace("{title}", &sanitize(&self.title, true))
-            .to_string()
-            .replace("{title}", &self.title)
             .replace(
                 "{audio}",
-                &self
+                &sanitize(
-                    .locales
+                    self.locales
                         .iter()
                         .map(|(a, _)| a.to_string())
                         .collect::<Vec<String>>()
                         .join("|"),
+                    true,
+                ),
             )
-            .replace("{resolution}", &self.resolution.to_string())
+            .replace("{resolution}", &sanitize(self.resolution.to_string(), true))
-            .replace("{series_id}", &self.series_id)
+            .replace("{series_id}", &sanitize(&self.series_id, true))
-            .replace("{series_name}", &self.series_name)
+            .replace("{series_name}", &sanitize(&self.series_name, true))
-            .replace("{season_id}", &self.season_id)
+            .replace("{season_id}", &sanitize(&self.season_id, true))
-            .replace("{season_name}", &self.season_title)
+            .replace("{season_name}", &sanitize(&self.season_title, true))
             .replace(
                 "{season_number}",
-                &format!("{:0>2}", self.season_number.to_string()),
+                &format!("{:0>2}", sanitize(self.season_number.to_string(), true)),
             )
-            .replace("{episode_id}", &self.episode_id)
+            .replace("{episode_id}", &sanitize(&self.episode_id, true))
             .replace(
                 "{episode_number}",
-                &format!("{:0>2}", self.episode_number.to_string()),
+                &format!("{:0>2}", sanitize(&self.episode_number, true)),
             )
             .replace(
                 "{relative_episode_number}",
-                &self.relative_episode_number.unwrap_or_default().to_string(),
+                &sanitize(
+                    self.relative_episode_number.unwrap_or_default().to_string(),
+                    true,
+                ),
+            )
+            .replace(
+                "{sequence_number}",
+                &sanitize(self.sequence_number.to_string(), true),
             )
-            .replace("{sequence_number}", &self.sequence_number.to_string())
             .replace(
                 "{relative_sequence_number}",
-                &self
+                &sanitize(
-                    .relative_sequence_number
+                    self.relative_sequence_number
                         .unwrap_or_default()
                         .to_string(),
+                    true,
+                ),
             );
 
-        if sanitize {
-            PathBuf::from(sanitize_filename::sanitize(path))
-        } else {
         PathBuf::from(path)
     }
-    }
 
     pub fn visual_output(&self, dst: &Path) {
         info!(

crunchy-cli-core/src/utils/os.rs

@@ -1,4 +1,6 @@
 use log::debug;
+use regex::{Regex, RegexBuilder};
+use std::borrow::Cow;
 use std::io::ErrorKind;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -78,3 +80,49 @@ pub fn free_file(mut path: PathBuf) -> (PathBuf, bool) {
 pub fn is_special_file<P: AsRef<Path>>(path: P) -> bool {
     path.as_ref().exists() && !path.as_ref().is_file() && !path.as_ref().is_dir()
 }
+
+lazy_static::lazy_static! {
+    static ref ILLEGAL_RE: Regex = Regex::new(r#"[\?<>:\*\|":]"#).unwrap();
+    static ref CONTROL_RE: Regex = Regex::new(r"[\x00-\x1f\x80-\x9f]").unwrap();
+    static ref RESERVED_RE: Regex = Regex::new(r"^\.+$").unwrap();
+    static ref WINDOWS_RESERVED_RE: Regex = RegexBuilder::new(r"(?i)^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$")
+        .case_insensitive(true)
+        .build()
+        .unwrap();
+    static ref WINDOWS_TRAILING_RE: Regex = Regex::new(r"[\. ]+$").unwrap();
+}
+
+/// Sanitizes a filename with the option to include/exclude the path separator from sanitizing. This
+/// is based of the implementation of the
+/// [`sanitize-filename`](https://crates.io/crates/sanitize-filename) crate.
+pub fn sanitize<S: AsRef<str>>(path: S, include_path_separator: bool) -> String {
+    let path = Cow::from(path.as_ref());
+
+    let path = ILLEGAL_RE.replace_all(&path, "");
+    let path = CONTROL_RE.replace_all(&path, "");
+    let path = RESERVED_RE.replace(&path, "");
+
+    let collect = |name: String| {
+        if name.len() > 255 {
+            name[..255].to_string()
+        } else {
+            name
+        }
+    };
+
+    if cfg!(windows) {
+        let path = WINDOWS_RESERVED_RE.replace(&path, "");
+        let path = WINDOWS_TRAILING_RE.replace(&path, "");
+        let mut path = path.to_string();
+        if include_path_separator {
+            path = path.replace(['\\', '/'], "");
+        }
+        collect(path)
+    } else {
+        let mut path = path.to_string();
+        if include_path_separator {
+            path = path.replace('/', "");
+        }
+        collect(path)
+    }
+}