squash: feat/new-from-files

pl4nty · pl4nty · commit 0e502c561a63 · 2026-02-02T01:19:21.000Z
diff --git a/src/commands/new_version.rs b/src/commands/new_version.rs
@@ -5,9 +5,10 @@ use std::{
 };
 
 use anstream::println;
-use camino::Utf8PathBuf;
+use camino::{Utf8Path, Utf8PathBuf};
 use clap::Parser;
 use color_eyre::eyre::Result;
+use color_eyre::eyre::ensure;
 use indicatif::ProgressBar;
 use inquire::CustomType;
 use ordinal::Ordinal;
@@ -34,7 +35,7 @@ use crate::{
     commands::utils::{
         SPINNER_TICK_RATE, SubmitOption, prompt_existing_pull_request, write_changes_to_dir,
     },
-    download::Downloader,
+    download::{DownloadedFile, Downloader},
     download_file::process_files,
     github::{
         GITHUB_HOST, WINGET_PKGS_FULL_NAME,
@@ -67,6 +68,10 @@ pub struct NewVersion {
     #[arg(short, long, num_args = 1.., value_hint = clap::ValueHint::Url)]
     urls: Vec<Url>,
 
+    /// The list of files to use instead of downloading urls
+    #[arg(short, long, num_args = 1.., value_hint = clap::ValueHint::FilePath, requires = "urls", value_parser = is_valid_file)]
+    files: Vec<Utf8PathBuf>,
+
     #[arg(long)]
     package_locale: Option<LanguageTag>,
 
@@ -155,6 +160,15 @@ pub struct NewVersion {
 
 impl NewVersion {
     pub async fn run(self) -> Result<()> {
+        if !self.files.is_empty() {
+            ensure!(
+                self.urls.len() == self.files.len(),
+                "Number of URLs ({}) must match number of files ({})",
+                self.urls.len(),
+                self.files.len()
+            );
+        }
+
         let token = TokenManager::handle(self.token).await?;
         let github = GitHub::new(&token)?;
 
@@ -219,20 +233,27 @@ impl NewVersion {
             }
         });
 
-        let downloader = Downloader::new_with_concurrent(self.concurrent_downloads)?;
-        let mut files = downloader.download(urls.iter().cloned()).await?;
+        let mut files = if self.files.is_empty() {
+            let downloader = Downloader::new_with_concurrent(self.concurrent_downloads)?;
+            downloader.download(urls.iter().cloned()).await?
+        } else {
+            self.files
+                .iter()
+                .zip(urls.iter().cloned())
+                .map(|(path, url)| DownloadedFile::from_local(path, url))
+                .collect::<Result<Vec<_>>>()?
+        };
+
         let mut download_results = process_files(&mut files).await?;
 
         let mut installers = Vec::new();
         for analyser in &mut download_results.values_mut() {
             let mut silent = None;
             let mut silent_with_progress = None;
             let mut custom = None;
-            if analyser
-                .installers
-                .iter()
-                .any(|installer| installer.r#type == Some(InstallerType::Exe))
-            {
+            if analyser.installers.iter().any(|installer| {
+                installer.r#type == Some(InstallerType::Exe) && installer.switches.is_empty()
+            }) {
                 if confirm_prompt(&format!("Is {} a portable exe?", analyser.file_name))? {
                     for installer in &mut analyser.installers {
                         installer.r#type = Some(InstallerType::Portable);
@@ -480,3 +501,10 @@ impl NewVersion {
         Ok(())
     }
 }
+
+fn is_valid_file(path: &str) -> Result<Utf8PathBuf> {
+    let path = Utf8Path::new(path);
+    ensure!(path.exists(), "{path} does not exist");
+    ensure!(path.is_file(), "{path} is not a file");
+    Ok(path.to_path_buf())
+}
diff --git a/src/commands/update_version.rs b/src/commands/update_version.rs
@@ -6,9 +6,9 @@ use std::{
 };
 
 use anstream::println;
-use camino::Utf8PathBuf;
+use camino::{Utf8Path, Utf8PathBuf};
 use clap::Parser;
-use color_eyre::eyre::{Error, Result, bail};
+use color_eyre::eyre::{Error, Result, bail, ensure};
 use futures_util::TryFutureExt;
 use indicatif::ProgressBar;
 use owo_colors::OwoColorize;
@@ -25,7 +25,7 @@ use crate::{
     commands::utils::{
         SPINNER_TICK_RATE, SubmitOption, prompt_existing_pull_request, write_changes_to_dir,
     },
-    download::Downloader,
+    download::{DownloadedFile, Downloader},
     download_file::process_files,
     github::{
         GITHUB_HOST, GitHubError, WINGET_PKGS_FULL_NAME,
@@ -56,6 +56,10 @@ pub struct UpdateVersion {
     #[arg(short, long, num_args = 1.., required = true, value_hint = clap::ValueHint::Url)]
     urls: Vec<Url>,
 
+    /// The list of files to use instead of downloading urls
+    #[arg(short, long, num_args = 1.., requires = "urls", value_parser = is_valid_file, value_hint = clap::ValueHint::FilePath)]
+    files: Vec<Utf8PathBuf>,
+
     /// Number of installers to download at the same time
     #[arg(long, default_value_t = NonZeroUsize::new(num_cpus::get()).unwrap())]
     concurrent_downloads: NonZeroUsize,
@@ -107,6 +111,15 @@ pub struct UpdateVersion {
 
 impl UpdateVersion {
     pub async fn run(self) -> Result<()> {
+        if !self.files.is_empty() {
+            ensure!(
+                self.urls.len() == self.files.len(),
+                "Number of URLs ({}) must match number of files ({})",
+                self.urls.len(),
+                self.files.len()
+            );
+        }
+
         let token = TokenManager::handle(self.token.as_deref()).await?;
         let github = GitHub::new(&token)?;
 
@@ -127,13 +140,23 @@ impl UpdateVersion {
             return Ok(());
         }
 
-        let downloader = Downloader::new_with_concurrent(self.concurrent_downloads)?;
         let (mut manifests, mut github_values, mut files) = try_join!(
             github
                 .get_manifests(&self.package_identifier, latest_version)
                 .map_err(Error::new),
             self.fetch_github_values(&github).map_err(Error::new),
-            downloader.download(self.urls.iter().cloned()),
+            async {
+                if self.files.is_empty() {
+                    let downloader = Downloader::new_with_concurrent(self.concurrent_downloads)?;
+                    downloader.download(self.urls.iter().cloned()).await
+                } else {
+                    self.files
+                        .iter()
+                        .zip(self.urls.iter().cloned())
+                        .map(|(path, url)| DownloadedFile::from_local(path, url))
+                        .collect::<Result<Vec<_>>>()
+                }
+            },
         )?;
 
         let mut download_results = process_files(&mut files).await?;
@@ -385,3 +408,10 @@ fn fix_relative_paths<R: Read + Seek>(
         })
         .collect::<BTreeSet<_>>()
 }
+
+fn is_valid_file(path: &str) -> Result<Utf8PathBuf> {
+    let path = Utf8Path::new(path);
+    ensure!(path.exists(), "{path} does not exist");
+    ensure!(path.is_file(), "{path} is not a file");
+    Ok(path.to_path_buf())
+}
diff --git a/src/download/file.rs b/src/download/file.rs
@@ -1,7 +1,10 @@
 use std::fs::File;
 
+use camino::Utf8Path;
 use chrono::NaiveDate;
+use color_eyre::eyre::Result;
 use memmap2::Mmap;
+use sha2::{Digest, Sha256};
 use winget_types::Sha256String;
 
 use crate::manifests::Url;
@@ -18,3 +21,20 @@ pub struct DownloadedFile {
     pub file_name: String,
     pub last_modified: Option<NaiveDate>,
 }
+
+impl DownloadedFile {
+    pub fn from_local(path: &Utf8Path, url: Url) -> Result<Self> {
+        let file = File::open(path)?;
+        let mmap = unsafe { Mmap::map(&file) }?;
+        let sha_256 = Sha256String::from_digest(&Sha256::digest(&mmap));
+        let file_name = path.file_name().unwrap_or_else(|| path.as_str()).to_owned();
+        Ok(Self {
+            file,
+            url,
+            mmap,
+            sha_256,
+            file_name,
+            last_modified: None,
+        })
+    }
+}
