refactor: couple more of the parsing logic with the config struct

Author: nik-rev

Cargo.lock

@@ -53,6 +53,7 @@ tap = "1.0.1"
 dialoguer = "0.11.0"
 clap_complete_command = { version="0.6.1", features = ["nushell", "fig", "carapace"] }
 clap-verbosity-flag = "3.0.3"
+itertools = "0.14.0"
 
 [dev-dependencies]
 pretty_assertions = "1.4"

Cargo.toml

@@ -1,14 +1,13 @@
 //! Parse the command-line arguments
 
-use std::{path::PathBuf, str::FromStr};
+use std::path::PathBuf;
 
 use clap::{
     CommandFactory as _, Parser, Subcommand,
     builder::styling::{AnsiColor, Effects},
 };
-use tap::Pipe as _;
 
-use crate::{commands, commit::Commit};
+use crate::{commands, config::Commit, config::Remote};
 
 /// A tool which makes it easy to declaratively manage personal forks by automatically merging pull requests
 #[derive(Parser, Debug)]
@@ -134,41 +133,6 @@ pub struct Branch {
     pub commit: Option<Commit>,
 }
 
-/// Example: `helix-editor/helix/master`
-#[derive(Clone, Debug, PartialEq, PartialOrd, Ord, Eq, Default)]
-pub struct Remote {
-    /// Example: `helix-editor`
-    pub owner: String,
-    /// Example: `helix`
-    pub repo: String,
-    /// Example: `master`
-    pub branch: String,
-}
-
-impl Remote {
-    /// Default branch for a remote
-    const DEFAULT_BRANCH: &str = "main";
-}
-
-impl FromStr for Remote {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        s.split_once('/')
-            .ok_or_else(|| "Expected format: `owner/repo`".to_string())?
-            .pipe(|(owner, rest)| {
-                rest.split_once('/')
-                    .unwrap_or((rest, Self::DEFAULT_BRANCH))
-                    .pipe(|(repo, branch)| Self {
-                        owner: owner.to_string(),
-                        repo: repo.to_string(),
-                        branch: branch.to_string(),
-                    })
-            })
-            .pipe(Ok)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -180,15 +144,19 @@ mod test {
             Remote {
                 owner: "helix-editor".to_string(),
                 repo: "helix".to_string(),
-                branch: "main".to_string()
+                branch: "main".to_string(),
+                commit: None
             }
         );
         assert_eq!(
-            "helix-editor/helix/master".parse::<Remote>().unwrap(),
+            "helix-editor/helix/master @ 1a2b3c"
+                .parse::<Remote>()
+                .unwrap(),
             Remote {
                 owner: "helix-editor".to_string(),
                 repo: "helix".to_string(),
-                branch: "master".to_string()
+                branch: "master".to_string(),
+                commit: Some(Commit::try_new("1a2b3c").unwrap())
             }
         );
         "helix-editor".parse::<Remote>().unwrap_err();

src/cli.rs

@@ -2,8 +2,7 @@
 
 use colored::Colorize as _;
 
-use crate::cli::Remote;
-use crate::commit::Commit;
+use crate::config::{Commit, Remote};
 use crate::git::{fetch_branch, git};
 use anyhow::anyhow;
 
@@ -13,7 +12,7 @@ pub async fn branch_fetch(
     commit: Option<Commit>,
     checkout: bool,
 ) -> anyhow::Result<()> {
-    let (_, info) = fetch_branch(&remote, commit.as_ref()).await?;
+    let (_, info) = fetch_branch(&remote).await?;
 
     log::info!(
         "Fetched branch {}/{}/{} available at branch {}{}",

src/commands/branch_fetch.rs

@@ -6,7 +6,7 @@ use std::path::PathBuf;
 use anyhow::bail;
 
 use crate::CONFIG_PATH;
-use crate::commit::Commit;
+use crate::config::Commit;
 use crate::git::git;
 use crate::utils::normalize_commit_msg;
 

src/commands/gen_patch.rs

@@ -3,8 +3,7 @@
 use anyhow::{Context as _, anyhow};
 use colored::Colorize as _;
 
-use crate::cli::Remote;
-use crate::commit::Commit;
+use crate::config::{Commit, Remote};
 use crate::git::{fetch_pull_request, git};
 
 /// Fetch the given `pr` of `remote` at `commit` and store it in local `branch`
@@ -37,6 +36,7 @@ pub async fn pr_fetch(
                     owner: owner.to_string(),
                     repo: repo.to_string(),
                     branch: "main".to_string(),
+                    commit: None,
                 })
             } else {
                 Err(err())

src/commands/pr_fetch.rs

@@ -12,7 +12,7 @@ use colored::Colorize as _;
 use crate::git::{self, GIT_ROOT, git};
 use crate::github_api::{Branch, Remote, RemoteBranch};
 use crate::utils::{display_link, with_uuid};
-use crate::{CONFIG_PATH, CONFIG_ROOT, confirm_prompt};
+use crate::{CONFIG_FILE, CONFIG_FILE_PATH, CONFIG_PATH, CONFIG_ROOT, commands, confirm_prompt};
 
 /// Backup for a file
 struct FileBackup {
@@ -24,11 +24,33 @@ struct FileBackup {
 
 /// Run patchy, if `yes` then there will be no prompt
 pub async fn run(yes: bool) -> anyhow::Result<()> {
-    let Some(config) = Config::read(yes)? else {
-        // if it's Ok(None), we have wrote the default config
+    let root = CONFIG_ROOT.as_str();
+
+    let Ok(config_string) = fs::read_to_string(&*CONFIG_FILE_PATH) else {
+        log::error!("Could not find configuration file at {root}/{CONFIG_FILE}");
+
+        // We don't want to have *any* sort of prompt when using the -y flag since that
+        // would be problematic in scripts
+        if !yes && confirm_prompt!("Would you like us to run `patchy init` to initialize it?",) {
+            commands::init()?;
+        } else if yes {
+            log::info!("You can create it with `patchy init`",);
+        } else {
+            // user said "no" in the prompt, so we don't do any initializing
+        }
+
+        // We don't want to read the default configuration file as config_string. Since
+        // it's empty there's no reason why the user would want to run it.
+
         return Ok(());
     };
 
+    log::trace!("Using configuration file {}", CONFIG_FILE_PATH.display());
+
+    let config = toml::from_str::<Config>(&config_string).map_err(|err| {
+        anyhow!("Could not parse `{root}/{CONFIG_FILE}` configuration file:\n{err}",)
+    })?;
+
     let Ref {
         item: remote_branch,
         commit,
@@ -145,34 +167,14 @@ pub async fn run(yes: bool) -> anyhow::Result<()> {
     }
 
     // Process branches
-    for Ref {
-        item: branch_path,
-        commit: commit_hash,
-    } in &config.branches
-    {
-        // Parse the branch path into owner/repo/branch format
-        let parts: Vec<&str> = branch_path.split('/').collect();
-        if parts.len() < 3 {
-            log::error!("Invalid branch format: {branch_path}. Expected format: owner/repo/branch");
+    for remote in &config.branches {
+        let owner = &remote.owner;
+        let repo = &remote.repo;
+        let branch = &remote.branch;
+        let Ok((_, info)) = git::fetch_branch(remote).await.inspect_err(|err| {
+            log::error!("failed to fetch branch {owner}/{repo}/{branch}: {err}");
+        }) else {
             continue;
-        }
-
-        let owner = parts[0];
-        let repo = parts[1];
-        let branch_name = parts[2..].join("/");
-
-        let remote = crate::cli::Remote {
-            owner: owner.to_string(),
-            repo: repo.to_string(),
-            branch: branch_name.clone(),
-        };
-
-        let info = match git::fetch_branch(&remote, commit_hash.as_ref()).await {
-            Ok((_, info)) => info,
-            Err(err) => {
-                log::error!("Could not fetch branch {owner}/{repo}/{branch_name}: {err}");
-                continue;
-            }
         };
 
         if let Err(err) = git::merge_into_main(
@@ -186,8 +188,9 @@ pub async fn run(yes: bool) -> anyhow::Result<()> {
             "Merged branch {}/{}/{} {}",
             owner.bright_blue(),
             repo.bright_blue(),
-            branch_name.bright_blue(),
-            commit_hash
+            branch.bright_blue(),
+            remote
+                .commit
                 .as_ref()
                 .map(|hash| format!("at commit {}", hash.as_ref().bright_yellow()))
                 .unwrap_or_default()