Split config and rust-version files

Author: Kobzol

README.md

@@ -13,6 +13,8 @@ $ cargo install --locked --git https://github.com/rust-lang/josh-sync
 
 First, create a configuration file for a given subtree repo using `josh-sync init`. The config will be created under the path `josh-sync.toml`. Modify the file to fill in the name of the subtree repository (e.g. `stdarch`) and its relative path in the main `rust-lang/rust` repository (e.g. `library/stdarch`).
 
+The `init` command will also create an empty `rust-version` file that stores the last upstream `rustc` SHA that was synced in the subtree.
+
 ## Performing pull
 
 A pull operation fetches changes to the subtree subdirectory that were performed in `rust-lang/rust` and merges them into the subtree repository. After performing a pull, a pull request is sent against the *subtree repository*. We *pull from rustc*.

josh-sync.example.toml

@@ -1,4 +1,3 @@
 org = "rust-lang"
 repo = "stdarch"
 path = "library/stdarch"
-last_upstream_sha = "abcdef"

src/bin/josh_sync.rs

@@ -1,12 +1,14 @@
 use anyhow::Context;
 use clap::Parser;
+use josh_sync::SyncContext;
 use josh_sync::config::{JoshConfig, load_config};
 use josh_sync::josh::{JoshProxy, try_install_josh};
 use josh_sync::sync::{GitSync, RustcPullError, UPSTREAM_REPO};
 use josh_sync::utils::prompt;
 use std::path::{Path, PathBuf};
 
 const DEFAULT_CONFIG_PATH: &str = "josh-sync.toml";
+const DEFAULT_RUST_VERSION_PATH: &str = "rust-version";
 
 #[derive(clap::Parser)]
 struct Args {
@@ -16,20 +18,24 @@ struct Args {
 
 #[derive(clap::Parser)]
 enum Command {
-    /// Initialize a config file for this repository.
+    /// Initialize a config file and an empty `rust-version` file for this repository.
     Init,
     /// Pull changes from the main `rust-lang/rust` repository.
     /// This creates new commits that should be then merged into this subtree repository.
     Pull {
         #[clap(long, default_value(DEFAULT_CONFIG_PATH))]
-        config: PathBuf,
+        config_path: PathBuf,
+        #[clap(long, default_value(DEFAULT_RUST_VERSION_PATH))]
+        rust_version_path: PathBuf,
     },
     /// Push changes into the main `rust-lang/rust` repository `branch` of a `rustc` fork under
     /// the given GitHub `username`.
     /// The pushed branch should then be merged into the `rustc` repository.
     Push {
         #[clap(long, default_value(DEFAULT_CONFIG_PATH))]
-        config: PathBuf,
+        config_path: PathBuf,
+        #[clap(long, default_value(DEFAULT_RUST_VERSION_PATH))]
+        rust_version_path: PathBuf,
         /// Branch that should be pushed to your remote
         branch: String,
         /// Your GitHub usename where the fork is located
@@ -45,22 +51,26 @@ fn main() -> anyhow::Result<()> {
                 org: "rust-lang".to_string(),
                 repo: "<repository-name>".to_string(),
                 path: "<relative-subtree-path>".to_string(),
-                last_upstream_sha: None,
             };
             config
                 .write(Path::new(DEFAULT_CONFIG_PATH))
                 .context("cannot write config")?;
             println!("Created config file at {DEFAULT_CONFIG_PATH}");
+            std::fs::write(DEFAULT_RUST_VERSION_PATH, "")
+                .context("cannot write rust-version file")?;
+            println!("Created empty rust-version file at {DEFAULT_RUST_VERSION_PATH}");
         }
-        Command::Pull { config } => {
-            let config = load_config(&config)
-                .context("cannot load config. Run the `init` command to initialize it.")?;
+        Command::Pull {
+            config_path,
+            rust_version_path,
+        } => {
+            let ctx = load_context(&config_path, &rust_version_path)?;
             let josh = get_josh_proxy()?;
-            let sync = GitSync::new(config.clone(), josh);
+            let sync = GitSync::new(ctx.clone(), josh);
             match sync.rustc_pull() {
                 Ok(result) => {
                     maybe_create_gh_pr(
-                        &config.config.full_repo_name(),
+                        &ctx.config.full_repo_name(),
                         "Rustc pull update",
                         &result.merge_commit_message,
                     )?;
@@ -78,27 +88,41 @@ fn main() -> anyhow::Result<()> {
         Command::Push {
             username,
             branch,
-            config,
+            config_path,
+            rust_version_path,
         } => {
-            let config = load_config(&config)
-                .context("cannot load config. Run the `init` command to initialize it.")?;
+            let ctx = load_context(&config_path, &rust_version_path)?;
             let josh = get_josh_proxy()?;
-            let sync = GitSync::new(config.clone(), josh);
+            let sync = GitSync::new(ctx.clone(), josh);
             sync.rustc_push(&username, &branch)
                 .context("cannot perform push")?;
 
             // Open PR with `subtree update` title to silence the `no-merges` triagebot check
             println!(
                 r#"You can create the rustc PR using the following URL:
 https://github.com/{UPSTREAM_REPO}/compare/{username}:{branch}?quick_pull=1&title={}+subtree+update&body=r?+@ghost"#,
-                config.config.repo
+                ctx.config.repo
             );
         }
     }
 
     Ok(())
 }
 
+fn load_context(config_path: &Path, rust_version_path: &Path) -> anyhow::Result<SyncContext> {
+    let config = load_config(&config_path)
+        .context("cannot load config. Run the `init` command to initialize it.")?;
+    let rust_version = std::fs::read_to_string(&rust_version_path)
+        .inspect_err(|err| eprintln!("Cannot load rust-version file: {err:?}"))
+        .map(Some)
+        .unwrap_or_default();
+    Ok(SyncContext {
+        config,
+        last_upstream_sha_path: rust_version_path.to_path_buf(),
+        last_upstream_sha: rust_version,
+    })
+}
+
 fn maybe_create_gh_pr(repo: &str, title: &str, description: &str) -> anyhow::Result<bool> {
     let gh_available = which::which("gh").is_ok();
     if !gh_available {

src/config.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 #[derive(serde::Serialize, serde::Deserialize, Clone)]
 pub struct JoshConfig {
@@ -9,9 +9,6 @@ pub struct JoshConfig {
     /// Relative path where the subtree is located in rust-lang/rust.
     /// For example `src/doc/rustc-dev-guide`.
     pub path: String,
-    /// Last SHA of rust-lang/rust that was pulled into this subtree.
-    #[serde(default)]
-    pub last_upstream_sha: Option<String>,
 }
 
 impl JoshConfig {
@@ -26,22 +23,13 @@ impl JoshConfig {
     }
 }
 
-#[derive(Clone)]
-pub struct JoshConfigWithPath {
-    pub config: JoshConfig,
-    pub path: PathBuf,
-}
-
 fn default_org() -> String {
     String::from("rust-lang")
 }
 
-pub fn load_config(path: &Path) -> anyhow::Result<JoshConfigWithPath> {
+pub fn load_config(path: &Path) -> anyhow::Result<JoshConfig> {
     let data = std::fs::read_to_string(path)
         .with_context(|| format!("cannot load config file from {}", path.display()))?;
     let config: JoshConfig = toml::from_str(&data).context("cannot load config as TOML")?;
-    Ok(JoshConfigWithPath {
-        config,
-        path: path.to_path_buf(),
-    })
+    Ok(config)
 }

src/lib.rs

@@ -1,4 +1,17 @@
+use crate::config::JoshConfig;
+use std::path::PathBuf;
+
 pub mod config;
 pub mod josh;
 pub mod sync;
 pub mod utils;
+
+#[derive(Clone)]
+pub struct SyncContext {
+    pub config: JoshConfig,
+    /// The last synced upstream SHA, which should be present
+    /// if a pull was already performed at least once.
+    pub last_upstream_sha: Option<String>,
+    /// Path to a file that stores the last synced upstream SHA.
+    pub last_upstream_sha_path: PathBuf,
+}

src/sync.rs

@@ -1,4 +1,4 @@
-use crate::config::JoshConfigWithPath;
+use crate::SyncContext;
 use crate::josh::JoshProxy;
 use crate::utils::{check_output, check_output_at, ensure_clean_git_state};
 use anyhow::{Context, Error};
@@ -29,13 +29,13 @@ pub struct PullResult {
 }
 
 pub struct GitSync {
-    config: JoshConfigWithPath,
+    context: SyncContext,
     proxy: JoshProxy,
 }
 
 impl GitSync {
-    pub fn new(config: JoshConfigWithPath, proxy: JoshProxy) -> Self {
-        Self { config, proxy }
+    pub fn new(context: SyncContext, proxy: JoshProxy) -> Self {
+        Self { context, proxy }
     }
 
     pub fn rustc_pull(&self) -> Result<PullResult, RustcPullError> {
@@ -59,26 +59,26 @@ impl GitSync {
         // Make sure josh is running.
         let josh = self
             .proxy
-            .start(&self.config.config)
+            .start(&self.context.config)
             .context("cannot start josh-proxy")?;
         let josh_url = josh.git_url(
             UPSTREAM_REPO,
             Some(&upstream_sha),
-            &construct_filter(&self.config.config.path),
+            &construct_filter(&self.context.config.path),
         );
 
         let orig_head = check_output(["git", "rev-parse", "HEAD"])?;
         println!(
             "previous upstream base: {:?}",
-            self.config.config.last_upstream_sha
+            self.context.last_upstream_sha
         );
         println!("new upstream base: {upstream_sha}");
         println!("original local HEAD: {orig_head}");
 
-        /// If the upstream SHA hasn't changed from the latest sync, there is nothing to pull
-        /// We distinguish this situation for tools that might not want to consider this to
-        /// be an error.
-        if let Some(previous_base_commit) = self.config.config.last_upstream_sha.as_ref() {
+        // If the upstream SHA hasn't changed from the latest sync, there is nothing to pull
+        // We distinguish this situation for tools that might not want to consider this to
+        // be an error.
+        if let Some(previous_base_commit) = self.context.last_upstream_sha.as_ref() {
             if *previous_base_commit == upstream_sha {
                 return Err(RustcPullError::NothingToPull);
             }
@@ -89,16 +89,23 @@ impl GitSync {
         // We pass `--no-verify` to avoid running git hooks.
         // We do this before the merge so that if there are merge conflicts, we have
         // the right rust-version file while resolving them.
-        let mut config = self.config.config.clone();
-        config.last_upstream_sha = Some(upstream_sha.clone());
-        config.write(&self.config.path)?;
+        std::fs::write(&self.context.last_upstream_sha_path, &upstream_sha).with_context(|| {
+            anyhow::anyhow!(
+                "cannot write upstream SHA to {}",
+                self.context.last_upstream_sha_path.display()
+            )
+        })?;
 
         let prep_message = format!(
             r#"Update the upstream Rust SHA to {upstream_sha}.
 To prepare for merging from {UPSTREAM_REPO}."#,
         );
 
-        let config_path = self.config.path.to_string_lossy().to_string();
+        let config_path = self
+            .context
+            .last_upstream_sha_path
+            .to_string_lossy()
+            .to_string();
         check_output(&["git", "add", &config_path])?;
         check_output(&[
             "git",
@@ -143,7 +150,7 @@ Upstream ref: {upstream_sha}
 Filtered ref: {incoming_ref}
             "#,
             upstream_head_short = &upstream_sha[..12],
-            filter = construct_filter(&self.config.config.path)
+            filter = construct_filter(&self.context.config.path)
         );
 
         // Merge the fetched commit.
@@ -186,22 +193,17 @@ Filtered ref: {incoming_ref}
     pub fn rustc_push(&self, username: &str, branch: &str) -> anyhow::Result<()> {
         ensure_clean_git_state();
 
-        let base_upstream_sha = self
-            .config
-            .config
-            .last_upstream_sha
-            .clone()
-            .unwrap_or_default();
+        let base_upstream_sha = self.context.last_upstream_sha.clone().unwrap_or_default();
 
         // Make sure josh is running.
         let josh = self
             .proxy
-            .start(&self.config.config)
+            .start(&self.context.config)
             .context("cannot start josh-proxy")?;
         let josh_url = josh.git_url(
             &format!("{username}/rust"),
             None,
-            &construct_filter(&self.config.config.path),
+            &construct_filter(&self.context.config.path),
         );
         let user_upstream_url = format!("https://github.com/{username}/rust");
 
@@ -273,7 +275,7 @@ Filtered ref: {incoming_ref}
         }
         println!(
             "Confirmed that the push round-trips back to {} properly. Please create a rustc PR.",
-            self.config.config.repo
+            self.context.config.repo
         );
 
         Ok(())