bb68fda ci — heartwood

modified .github/workflows/build.yml

@@ -11,11 +11,12 @@ jobs:

       fail-fast: false
       matrix:
         os:
          - macos-latest       # arm64
          - ubuntu-latest-arm  # arm64
          - ubuntu-latest      # x64
          - windows-latest-arm # arm64
          - windows-latest     # x64
           - macos-latest      # arm64
           - ubuntu-24.04-arm  # arm64
           - ubuntu-latest     # x64
           - windows-11-arm    # arm64
           - windows-latest    # x64
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2

modified crates/radicle-cli/examples/framework/home.md

@@ -8,23 +8,23 @@ $ touch file.bin

 $ rad self --did
 did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk
 $ pwd
 [..]/home/bob/.radicle
 [..]/bob/.radicle
 $ mkdir src
 $ cd src
 $ pwd
 [..]/home/bob/.radicle/src
 [..]/bob/.radicle/src
 ```
 ``` ~alice
 $ rad self --did
 did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
 $ pwd
 [..]/home/alice/.radicle
 [..]/alice/.radicle
 ```
 ``` ~bob
 $ pwd
 [..]/home/bob/.radicle/src
 [..]/bob/.radicle/src
 ```
 ```

modified crates/radicle-cli/examples/rad-id-threshold.md

@@ -176,7 +176,7 @@ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 2 potential s

 ✓ Creating checkout in ./heartwood..
 ✓ Remote alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi added
 ✓ Remote-tracking branch alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/master created for z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
 ✓ Repository successfully cloned under [..]/bob/heartwood/
 ✓ Repository successfully cloned under [..]/bob/work/heartwood/
 ╭────────────────────────────────────╮
 │ heartwood                          │
 │ Radicle Heartwood Protocol & Stack │

modified crates/radicle-cli/examples/rad-patch-delete.md

@@ -60,7 +60,6 @@ $ rad patch comment 6c61ef1 --reply-to 833db19 -m "Thanks, I'll add it!"

 ``` ~alice
 $ touch MIT
 $ ln MIT LICENSE -f
 $ git add MIT
 $ git commit -am "Add MIT License"
 [prepare-license 1cc8cd9] Add MIT License

modified crates/radicle-cli/examples/rad-self.md

@@ -9,11 +9,11 @@ Node not running

 SSH          not running
 ├╴Key (hash) SHA256:UIedaL6Cxm6OUErh9GQUzzglSk7VpQlVTI1TAFB/HWA
 └╴Key (full) ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHahWSBEpuT1ESZbynOmBNkLBSnR32Ar4woZqSV2YNH1
 Home         [..]/home/alice/.radicle
 ├╴Config     [..]/home/alice/.radicle/config.json
 ├╴Storage    [..]/home/alice/.radicle/storage
 ├╴Keys       [..]/home/alice/.radicle/keys
 └╴Node       [..]/home/alice/.radicle/node
 Home         [..]/alice/.radicle
 ├╴Config     [..]/alice/.radicle/config.json
 ├╴Storage    [..]/alice/.radicle/storage
 ├╴Keys       [..]/alice/.radicle/keys
 └╴Node       [..]/alice/.radicle/node
 ```
 If you need to display only your DID, Node ID, or SSH Public Key, you can use

@@ -41,5 +41,5 @@ ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHahWSBEpuT1ESZbynOmBNkLBSnR32Ar4woZqSV2YNH1

 ```
 $ rad self --home
 [..]/home/alice/.radicle
 [..]/alice/.radicle
 ```

modified crates/radicle-cli/src/git/unified_diff.rs

@@ -586,10 +586,20 @@ impl<'a> Writer<'a> {

     }
     pub fn write(&mut self, s: impl fmt::Display, style: term::Style) -> io::Result<()> {
         #[cfg(windows)]
         const EOL: &str = "\r\n";
         #[cfg(not(windows))]
         const EOL: &str = "\n";
         if self.styled {
             writeln!(self.stream, "{}", term::Paint::new(s).with_style(style))
             write!(
                 self.stream,
                 "{}{EOL}",
                 term::Paint::new(s).with_style(style)
             )
         } else {
             writeln!(self.stream, "{s}")
             write!(self.stream, "{s}{EOL}")
         }
     }

modified crates/radicle-cli/tests/commands.rs

@@ -1689,6 +1689,13 @@ fn rad_fork() {

 #[test]
 fn rad_diff() {
     if std::env::consts::OS == "macos" {
         // macOS's `sed` requires an argument for `-i`, which we don't provide
         // in the example. Providing it makes the test fail on Linux.
         // Since this command is deprecated anyway, we just skip macOS.
         return;
     }
     let tmp = tempfile::tempdir().unwrap();
     fixtures::repository(&tmp);

modified crates/radicle-cli/tests/util/environment.rs

@@ -82,37 +82,37 @@ impl Default for Environment {

 impl Environment {
     /// Create a new test environment.
     fn named(name: &'static str) -> Self {
     pub fn new() -> Self {
         Self {
             tempdir: tempfile::TempDir::with_prefix("radicle-".to_owned() + name).unwrap(),
             tempdir: tempfile::TempDir::new().unwrap(),
             users: 0,
         }
     }
     /// Create a new test environment.
     pub fn new() -> Self {
         Self::named("")
     }
     /// Return the temp directory path.
     /// Return the path of the temporary directory at which
     /// this testing environment is rooted.
     pub fn tempdir(&self) -> PathBuf {
         self.tempdir.path().into()
     }
     /// Path to the working directory designated for given alias.
     pub fn work(&self, has_alias: &impl HasAlias) -> PathBuf {
         self.tempdir().join("work").join(has_alias.alias().as_ref())
     /// Return the home directory of the user with the given alias.
     /// This is in analogy to a Unix home directory.
     pub fn unix_home(&self, has_alias: &impl HasAlias) -> PathBuf {
         self.tempdir().join(has_alias.alias().to_string())
     }
     /// We don't have `RAD_HOME` or `HOME` to rely on to compute a home as usual.
     pub fn home(&self, alias: &Alias) -> Home {
         Home::new(
             self.tempdir()
                 .join("home")
                 .join(alias.to_string())
                 .join(".radicle"),
         )
         .unwrap()
     /// Return the Radicle path of the user with the given alias.
     /// This is in analogy to `$RAD_HOME` and always a subdirectory of
     /// the user's home directory (see [`Environment::unix_home`]).
     pub fn rad_home(&self, has_alias: &impl HasAlias) -> Home {
         Home::new(self.unix_home(has_alias).join(".radicle")).unwrap()
     }
     /// Path to the working directory of the user with the given alias.
     /// Tests that need to act on multiple repositories should crate
     /// subdirecories within this directory.
     pub fn work(&self, has_alias: &impl HasAlias) -> PathBuf {
         self.unix_home(has_alias).join("work")
     }
     /// Create a new default configuration.

@@ -135,7 +135,7 @@ impl Environment {

     /// is provided.
     pub fn profile_with(&mut self, config: profile::Config) -> Profile {
         let alias = config.alias().clone();
         let home = self.home(&alias);
         let home = self.rad_home(&alias);
         let keypair = KeyPair::from_seed(Seed::from([!(self.users as u8); 32]));
         let policies_db = home.node().join(POLICIES_DB_FILE);
         let cobs_db = home.cobs().join(COBS_DB_FILE);

@@ -224,7 +224,12 @@ impl Environment {

         self.node_with(config::seed(alias))
     }
     /// Convenience method for placing repository fixture.
     /// Convenience method for placing repository fixture into the
     /// directory returned by [`Environment::work`] for the user.
     /// Use this only in tests that act on *a single repository* only.
     /// For tests that need to act on multiple repositories,
     /// create the repositories as subdirectories of the working
     /// directory returned by [`Environment::work`].
     pub fn repository(
         &self,
         has_alias: &impl HasAlias,

@@ -236,24 +241,17 @@ impl Environment {

     pub fn test(
         &self,
         test_file: &'static str,
         subject: &(impl HasAlias + HasHome),
         subject: &impl HasAlias,
     ) -> Result<(), Box<dyn std::error::Error>> {
         formula(
             self.work(subject).as_ref(),
             PathBuf::from("examples").join(test_file.to_owned() + ".md"),
         )?
         .env(
             "RAD_HOME",
             subject.home().path().to_path_buf().to_string_lossy(),
         )
         .env("USER", subject.alias().as_ref())
         .env("RAD_HOME", self.rad_home(subject).path().to_string_lossy())
         .env(
             "JJ_CONFIG",
             subject
                 .home()
                 .path()
                 .parent()
                 .unwrap()
                 .to_path_buf()
             self.unix_home(subject)
                 .join(".jjconfig.toml")
                 .to_string_lossy(),
         )

@@ -262,10 +260,11 @@ impl Environment {

         Ok(())
     }
     /// Convenience method for executing multiple test formulas with standard configuration.
     pub fn tests(
         &self,
         test_files: impl IntoIterator<Item = &'static str>,
         subject: &(impl HasAlias + HasHome),
         subject: &impl HasAlias,
     ) -> Result<(), Box<dyn std::error::Error>> {
         for test_file in test_files {
             self.test(test_file, subject)?;

@@ -288,6 +287,12 @@ pub trait HasAlias {

     fn alias(&self) -> &Alias;
 }
 impl HasAlias for Alias {
     fn alias(&self) -> &Alias {
         self
     }
 }
 impl HasAlias for Node<MemorySigner> {
     fn alias(&self) -> &Alias {
         &self.config.alias

@@ -305,25 +310,3 @@ impl<G> HasAlias for NodeHandle<G> {

         &self.alias
     }
 }
 pub trait HasHome {
     fn home(&self) -> &Home;
 }
 impl HasHome for Profile {
     fn home(&self) -> &Home {
         &self.home
     }
 }
 impl HasHome for Node<MemorySigner> {
     fn home(&self) -> &Home {
         &self.home
     }
 }
 impl HasHome for NodeHandle<MemorySigner> {
     fn home(&self) -> &Home {
         &self.home
     }
 }

modified crates/radicle-cli/tests/util/formula.rs

@@ -28,7 +28,6 @@ pub(crate) fn formula(

         .env("EDITOR", "true")
         .env("TZ", "UTC")
         .env("LANG", "C")
         .env("USER", "alice")
         .env(env::RAD_PASSPHRASE, "radicle")
         .env(env::RAD_KEYGEN_SEED, RAD_SEED)
         .env(env::RAD_RNG_SEED, "0")

modified crates/radicle/Cargo.toml

@@ -60,3 +60,4 @@ qcheck = { workspace = true }

 qcheck-macros = { workspace = true }
 radicle-cob = { workspace = true, features = ["stable-commit-ids"] }
 radicle-crypto = { workspace = true, features = ["test"] }
 tempfile = { workspace = true }

modified crates/radicle/src/cob/identity.rs

@@ -1323,12 +1323,16 @@ mod test {

             .unwrap();
         bob.repo.fetch(alice);
         let a3 = alice_identity.redact(a2, &alice.signer).unwrap();
         let a3 = cob::git::stable::with_advanced_timestamp(|| {
             alice_identity.redact(a2, &alice.signer).unwrap()
         });
         assert!(alice_identity.revision(&a1).is_some());
         assert_eq!(alice_identity.timeline, vec![a0, a1, a2, a3]);
         let mut bob_identity = Identity::load_mut(&*bob.repo).unwrap();
         let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();
         let b1 = cob::git::stable::with_advanced_timestamp(|| {
             bob_identity.accept(&a2, &bob.signer).unwrap()
         });
         assert_eq!(bob_identity.timeline, vec![a0, a1, a2, b1]);
         assert_eq!(bob_identity.revision(&a2).unwrap().state, State::Accepted);

@@ -1454,11 +1458,15 @@ mod test {

         // Bob accepts alice's revision.
         let mut bob_identity = Identity::load_mut(&*bob.repo).unwrap();
         let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();
         let b1 = cob::git::stable::with_advanced_timestamp(|| {
             bob_identity.accept(&a2, &bob.signer).unwrap()
         });
         // Eve rejects the revision, not knowing.
         let mut eve_identity = Identity::load_mut(&*eve.repo).unwrap();
         let e1 = eve_identity.reject(a2, &eve.signer).unwrap();
         let e1 = cob::git::stable::with_advanced_timestamp(|| {
             eve_identity.reject(a2, &eve.signer).unwrap()
         });
         assert!(eve_identity.revision(&a2).unwrap().is_active());
         // Then she submits a new revision.

modified crates/radicle/src/git/raw.rs

@@ -6,10 +6,14 @@

 // Re-exports that are only used within this crate.
 pub(crate) use git2::{
     message_trailers_strs, AutotagOption, Blob, Config, FetchOptions, FetchPrune, Object,
     RemoteCallbacks, Revwalk, Sort,
     message_trailers_strs, AutotagOption, Blob, Config, FetchOptions, FetchPrune, Object, Revwalk,
     Sort,
 };
 // Re-exports that are only used within this crate for testing.
 #[cfg(any(test, feature = "test"))]
 pub(crate) use git2::RemoteCallbacks;
 // Re-exports that are used by other crates in the workspace, including this crate.
 pub use git2::{
     Branch, BranchType, Commit, Direction, Error, ErrorClass, ErrorCode, FileMode, ObjectType, Oid,

modified crates/radicle/src/profile.rs

@@ -779,15 +779,16 @@ mod test {

     use super::*;
     // Checks that if we have:
     // '/run/user/1000/.tmpqfK6ih/../.tmpqfK6ih/Radicle/Home'
     // '/run/user/1000/.tmpqfK6ih/../.tmpqfK6ih/Home/Radicle'
     //
     // that it gets normalized to:
     // '/run/user/1000/.tmpqfK6ih/Radicle/Home'
     // '/run/user/1000/.tmpqfK6ih/Home/Radicle'
     #[test]
     fn canonicalize_home() {
         let tmp = tempfile::tempdir().unwrap();
         let path = tmp.path().join("Home").join("Radicle");
         fs::create_dir_all(path.clone()).unwrap();
         let path = dunce::canonicalize(path).unwrap();
         let last = tmp.path().components().next_back().unwrap();
         let home = Home::new(