Manual bump

buildit-utils/src/lib.rs

@@ -1,15 +1,15 @@
 use crate::github::{find_version_by_packages, print_stdout_and_stderr, update_abbs};
 use abbs_update_checksum_core::{get_new_spec, ParseErrors};
 use anyhow::{bail, Context};
-use github::get_spec;
+use github::{for_each_abbs, get_spec};
 use once_cell::sync::Lazy;
 use std::{
     io::{BufRead, BufReader},
     path::{Path, PathBuf},
     process::Command,
 };
 use tokio::{fs, task::spawn_blocking};
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 pub mod github;
 
@@ -39,27 +39,98 @@ pub struct FindUpdate {
     pub title: String,
 }
 
+fn update_version_manual(spec: &mut String, key: &str, ver: &str) -> Option<()> {
+    let start = spec.find(&key)?;
+    let mut tmp_ref = spec.as_str();
+    tmp_ref = &tmp_ref[start..];
+    let start_delimit = tmp_ref.find("\"")?;
+    tmp_ref = &tmp_ref[start_delimit + 1..];
+    let end_delimit = tmp_ref.find("\"")?;
+
+    debug!(
+        "replace range: {}",
+        &spec[start..start + start_delimit + end_delimit + 2]
+    );
+
+    spec.replace_range(
+        start..start + start_delimit + end_delimit + 2,
+        &format!("{key}=\"{}\"", ver),
+    );
+
+    Some(())
+}
+
 #[tracing::instrument(skip(abbs_path))]
 pub async fn find_update_and_update_checksum(
     pkg: &str,
     abbs_path: &Path,
     coauthor: &str,
+    manual_update: Option<&str>,
 ) -> anyhow::Result<FindUpdate> {
     let _lock = ABBS_REPO_LOCK.lock().await;
 
     // switch to stable branch
     update_abbs("stable", &abbs_path, false).await?;
 
-    info!("Running aosc-findupdate ...");
+    match manual_update {
+        Some(version) => {
+            info!("manual version: {version}");
+            let pkg: Box<str> = Box::from(pkg);
+            let version = Box::from(version);
+            let abbs_path: Box<Path> = Box::from(abbs_path);
+            tokio::task::spawn_blocking(move || {
+                let mut res: anyhow::Result<()> = Ok(());
+                for_each_abbs(&abbs_path, |for_each_pkg, path| {
+                    if *for_each_pkg == *pkg {
+                        let spec = path.join("spec");
+                        let f = std::fs::read_to_string(&spec);
+                        let mut f = match f {
+                            Ok(f) => f,
+                            Err(e) => {
+                                res = Err(e.into());
+                                return;
+                            }
+                        };
+                        let lines: Vec<Box<str>> = f.lines().map(Box::from).collect::<Vec<_>>();
+                        let mut is_upstream_ver = false;
+                        for line in &lines {
+                            if line.starts_with("UPSTREAM_VER") {
+                                update_version_manual(&mut f, "UPSTREAM_VER", &version);
+                                is_upstream_ver = true;
+                            }
+                        }
+
+                        if !is_upstream_ver {
+                            for line in lines {
+                                if line.starts_with("VER") {
+                                    update_version_manual(&mut f, "VER", &version);
+                                }
+                            }
+                        }
+
+                        if let Err(e) = std::fs::write(spec, f) {
+                            res = Err(e.into());
+                        }
+                    }
+                });
 
-    let output = Command::new("aosc-findupdate")
-        .arg("-i")
-        .arg(format!(".*/{pkg}$"))
-        .current_dir(&abbs_path)
-        .output()
-        .context("Running aosc-findupdate")?;
+                res
+            })
+            .await??;
+        }
+        None => {
+            info!("Running aosc-findupdate ...");
 
-    print_stdout_and_stderr(&output);
+            let output = Command::new("aosc-findupdate")
+                .arg("-i")
+                .arg(format!(".*/{pkg}$"))
+                .current_dir(&abbs_path)
+                .output()
+                .context("Running aosc-findupdate")?;
+
+            print_stdout_and_stderr(&output);
+        }
+    }
 
     let status = Command::new("git")
         .arg("status")

server/src/bot.rs

@@ -778,7 +778,7 @@ pub async fn answer(bot: Bot, msg: Message, cmd: Command, pool: DbPool) -> Respo
                     .await?;
             }
         },
-        Command::Bump(package) => {
+        Command::Bump(package_and_version) => {
             let app_private_key = match ARGS.github_app_key.as_ref() {
                 Some(p) => p,
                 None => {
@@ -855,8 +855,20 @@ pub async fn answer(bot: Bot, msg: Message, cmd: Command, pool: DbPool) -> Respo
             }
             let coauthor = coauthor_parts.join(" ");
 
+            let mut split_args = package_and_version.split_ascii_whitespace();
+            let pkg = split_args.next().context("Failed to parse argument");
+            let version = split_args.next();
+
+            let pkg = match pkg {
+                Ok(pkg) => pkg,
+                Err(e) => {
+                    bot.send_message(msg.chat.id, e.to_string()).await?;
+                    return Ok(());
+                }
+            };
+
             match wait_with_send_typing(
-                find_update_and_update_checksum(&package, &ARGS.abbs_path, &coauthor),
+                find_update_and_update_checksum(pkg, &ARGS.abbs_path, &coauthor, version),
                 &bot,
                 msg.chat.id.0,
             )