pub mod setup {
use std::path::Path;
use radicle::git;
use radicle::rad;
use radicle::storage::git::Repository;
use radicle::test::setup::{BranchWith, Node};
/// A node with a repository.
pub struct NodeWithRepo {
pub node: Node,
pub repo: NodeRepo,
}
impl std::ops::Deref for NodeWithRepo {
type Target = Node;
fn deref(&self) -> &Self::Target {
&self.node
}
}
impl std::ops::DerefMut for NodeWithRepo {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.node
}
}
/// A node repository with an optional checkout.
pub struct NodeRepo {
pub repo: Repository,
pub checkout: Option<NodeRepoCheckout>,
}
impl NodeRepo {
#[track_caller]
pub fn checkout(&self) -> &NodeRepoCheckout {
self.checkout.as_ref().unwrap()
}
}
impl std::ops::Deref for NodeRepo {
type Target = Repository;
fn deref(&self) -> &Self::Target {
&self.repo
}
}
impl std::ops::DerefMut for NodeRepo {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.repo
}
}
/// A repository checkout.
pub struct NodeRepoCheckout {
pub checkout: git::raw::Repository,
}
impl NodeRepoCheckout {
pub fn branch_with<S: AsRef<Path>, T: AsRef<[u8]>>(
&self,
blobs: impl IntoIterator<Item = (S, T)>,
) -> BranchWith {
let refname = git::Qualified::from(git::lit::refs_heads(git::refname!("master")));
let base = self.checkout.refname_to_id(refname.as_str()).unwrap();
let parent = self.checkout.find_commit(base).unwrap();
let oid = commit(&self.checkout, &refname, blobs, &[&parent]);
git::push(&self.checkout, &rad::REMOTE_NAME, [(&refname, &refname)]).unwrap();
BranchWith {
base: base.into(),
oid,
}
}
}
impl std::ops::Deref for NodeRepoCheckout {
type Target = git::raw::Repository;
fn deref(&self) -> &Self::Target {
&self.checkout
}
}
pub fn commit<S: AsRef<Path>, T: AsRef<[u8]>>(
repo: &git2::Repository,
refname: &git::Qualified,
blobs: impl IntoIterator<Item = (S, T)>,
parents: &[&git2::Commit<'_>],
) -> git::Oid {
let tree = {
let mut tb = repo.treebuilder(None).unwrap();
for (name, blob) in blobs.into_iter() {
let oid = repo.blob(blob.as_ref()).unwrap();
tb.insert(name.as_ref(), oid, git2::FileMode::Blob.into())
.unwrap();
}
tb.write().unwrap()
};
let tree = repo.find_tree(tree).unwrap();
let author = git2::Signature::now("anonymous", "anonymous@example.com").unwrap();
repo.commit(
Some(refname.as_str()),
&author,
&author,
"Making changes",
&tree,
parents,
)
.unwrap()
.into()
}
}
pub mod fixtures {
use std::path::Path;
use anyhow::Result;
use radicle::cob::cache::NoCache;
use radicle::cob::Title;
use radicle::crypto;
use radicle::crypto::Verified;
use radicle::git;
use radicle::identity::{RepoId, Visibility};
use radicle::node::device::Device;
use radicle::patch::{Cache, MergeTarget, PatchMut, Patches};
use radicle::rad;
use radicle::storage::git::Repository;
use radicle::storage::refs::SignedRefs;
use radicle::storage::ReadStorage;
use radicle::test::setup::{BranchWith, Node};
use radicle::Storage;
use radicle_cli::git::unified_diff::FileHeader;
use radicle_git_ext::Oid;
use radicle_surf::diff::{self, DiffFile, Hunk, Line, Modification};
use crate::git::HunkDiff;
use super::setup::{NodeRepo, NodeRepoCheckout, NodeWithRepo};
/// The birth of the radicle project, January 1st, 2018.
pub const RADICLE_EPOCH: i64 = 1514817556;
pub const MAIN_RS: &str = r#"// This is a comment, and is ignored by the compiler.
// You can test this code by clicking the "Run" button over there ->
// or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
// shortcut.
// This code is editable, feel free to hack it!
// You can always return to the original code by clicking the "Reset" button ->
// This is the main function.
fn main() {
// Statements here are executed when the compiled binary is called.
// Print text to the console.
println!("Hello World!");
}
"#;
pub fn node_with_repo() -> NodeWithRepo {
let node = Node::default();
let (id, _, checkout, _) =
project(node.root.join("working"), &node.storage, &node.signer).unwrap();
let repo = node.storage.repository(id).unwrap();
let checkout = Some(NodeRepoCheckout { checkout });
NodeWithRepo {
node,
repo: NodeRepo { repo, checkout },
}
}
pub fn branch_with_eof_removed(node: &NodeWithRepo) -> BranchWith {
let checkout = node.repo.checkout();
checkout.branch_with([("README", b"Hello World!")])
}
pub fn branch_with_main_changed(node: &NodeWithRepo) -> BranchWith {
let checkout = node.repo.checkout();
let main_rs = r#"// This is a comment, and is ignored by the compiler.
// You can test this code by clicking the "Run" button over there ->
// or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
// shortcut.
// This is a new comment.
// This code is editable, feel free to hack it!
// You can always return to the original code by clicking the "Reset" button ->
// This is the main function.
fn main() {
// Statements here are executed when the compiled binary is called.
// Print text to the console.
println!("Hello World!");
println!("Hello again");
}
"#;
checkout.branch_with([("main.rs", main_rs.as_bytes())])
}
pub fn branch_with_main_emptied(node: &NodeWithRepo) -> BranchWith {
let checkout = node.repo.checkout();
checkout.branch_with([("main.rs", b"")])
}
pub fn branch_with_main_deleted_and_file_added(node: &NodeWithRepo) -> BranchWith {
let checkout = node.repo.checkout();
checkout.branch_with([("CONTRIBUTE", b"TBD\n")])
}
pub fn patch<'a, 'g>(
node: &'a NodeWithRepo,
branch: &BranchWith,
patches: &'a mut Cache<Patches<'a, Repository>, NoCache>,
) -> Result<PatchMut<'a, 'g, Repository, NoCache>> {
let patch = patches.create(
Title::new("My first patch")?,
"Blah blah blah.",
MergeTarget::Delegates,
branch.base,
branch.oid,
&[],
&node.signer,
)?;
Ok(patch)
}
/// Create a new repository at the given path, and initialize it into a project.
pub fn project<P: AsRef<Path>, G>(
path: P,
storage: &Storage,
signer: &Device<G>,
) -> Result<(RepoId, SignedRefs<Verified>, git2::Repository, git2::Oid), rad::InitError>
where
G: crypto::signature::Signer<crypto::Signature>,
{
radicle::storage::git::transport::local::register(storage.clone());
let (working, head) = repository(path);
let (id, _, refs) = rad::init(
&working,
"acme".try_into().unwrap(),
"Acme's repository",
git::refname!("master"),
Visibility::default(),
signer,
storage,
)?;
Ok((id, refs, working, head))
}
/// Creates a regular repository at the given path with a couple of commits.
pub fn repository<P: AsRef<Path>>(path: P) -> (git2::Repository, git2::Oid) {
let repo = git2::Repository::init(path).unwrap();
let sig = git2::Signature::new(
"anonymous",
"anonymous@radicle.xyz",
&git2::Time::new(RADICLE_EPOCH, 0),
)
.unwrap();
let head = git::initial_commit(&repo, &sig).unwrap();
let tree = git::write_tree(Path::new("main.rs"), MAIN_RS.as_bytes(), &repo).unwrap();
let oid = {
let commit = git::commit(
&repo,
&head,
git::refname!("refs/heads/master").as_refstr(),
"Second commit",
&sig,
&tree,
)
.unwrap();
commit.id()
};
repo.set_head("refs/heads/master").unwrap();
repo.checkout_head(None).unwrap();
drop(tree);
drop(head);
(repo, oid)
}
/// @@ -3,8 +3,7 @@
/// 3 3 // or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
/// 4 4 // shortcut.
/// 5 5
/// 6 - // This code is editable, feel free to hack it!
/// 7 - // You can always return to the original code by clicking the "Reset" button ->
/// 6 + // This is still a comment.
/// 8 7
/// 9 8 // This is the main function.
/// 10 9 fn main() {
pub fn simple_modified_hunk_diff(path: &Path, commit: Oid) -> Result<HunkDiff> {
let diff = DiffFile {
oid: commit,
mode: diff::FileMode::Blob,
};
Ok(HunkDiff::Modified {
path: path.to_path_buf(),
header: FileHeader::Modified {
path: path.to_path_buf(),
old: diff.clone(),
new: diff.clone(),
binary: false,
},
old: diff.clone(),
new: diff,
hunk: Some(Hunk {
header: Line::from(b"@@ -3,8 +3,7 @@\n".to_vec()),
lines: vec![
Modification::context(
b"// or if you prefer to use your keyboard, you can use the \"Ctrl + Enter\"\n"
.to_vec(),
3,
3,
),
Modification::context(b"// shortcut.\n".to_vec(), 4, 4),
Modification::context(b"\n".to_vec(), 5, 5),
Modification::deletion(
b"// This code is editable, feel free to hack it!\n".to_vec(),
6,
),
Modification::deletion(
b"// You can always return to the original code by clicking the \"Reset\" button ->\n".to_vec(),
7,
),
Modification::addition(b"// This is still a comment.\n".to_vec(), 6),
Modification::context(b"\n".to_vec(), 8, 7),
Modification::context(b"// This is the main function.\n".to_vec(), 9, 8),
Modification::context(b"fn main() {\n".to_vec(), 10, 9),
],
old: 3..11,
new: 3..10,
}),
_stats: None,
})
}
/// @@ -1,17 +1,15 @@
/// 1 - use radicle::issue::IssueId;
/// 2 - use tui::ui::state::ItemState;
/// 3 - use tui::SelectionExit;
/// 4 1 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
/// 5 2 use tuirealm::event::{Event, Key, KeyEvent};
/// 6 3 use tuirealm::{MockComponent, NoUserEvent};
/// 7 4
/// 8 5 use radicle_tui as tui;
/// 9 6
/// 7 + use tui::ui::state::ItemState;
/// 10 8 use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
/// 11 9 use tui::ui::widget::context::{ContextBar, Shortcuts};
/// 12 10 use tui::ui::widget::list::PropertyList;
/// 13 -
/// 14 11 use tui::ui::widget::Widget;
/// 12 + use tui::{Id, SelectionExit};
/// 15 13
/// 16 14 use super::ui::{IdSelect, OperationSelect};
/// 17 15 use super::{IssueOperation, Message};
pub fn complex_modified_hunk_diff(path: &Path, commit: Oid) -> Result<HunkDiff> {
let diff = DiffFile {
oid: commit,
mode: diff::FileMode::Blob,
};
Ok(HunkDiff::Modified {
path: path.to_path_buf(),
header: FileHeader::Modified {
path: path.to_path_buf(),
old: diff.clone(),
new: diff.clone(),
binary: false,
},
old: diff.clone(),
new: diff,
hunk: Some(Hunk {
header: Line::from(b"@@ -1,17 +1,15 @@\n".to_vec()),
lines: vec![
Modification::deletion(b"use radicle::issue::IssueId;\n".to_vec(), 1),
Modification::deletion(b"use tui::ui::state::ItemState;\n".to_vec(), 2),
Modification::deletion(b"use tui::SelectionExit;\n".to_vec(), 3),
Modification::context(
b"use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};\n"
.to_vec(),
4,
1,
),
Modification::context(
b"use tuirealm::event::{Event, Key, KeyEvent};\n".to_vec(),
5,
2,
),
Modification::context(
b"use tuirealm::{MockComponent, NoUserEvent};\n".to_vec(),
6,
3,
),
Modification::context(b"\n".to_vec(), 7, 4),
Modification::context(b"use radicle_tui as tui;\n".to_vec(), 8, 5),
Modification::context(b"\n".to_vec(), 9, 6),
Modification::addition(b"use tui::ui::state::ItemState;\n".to_vec(), 7),
Modification::context(b"use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};\n"
.to_vec(),
10,
8,
),
Modification::context(
b"use tui::ui::widget::context::{ContextBar, Shortcuts};\n".to_vec(),
11,
9,
),
Modification::context(
b"use tui::ui::widget::list::PropertyList;\n".to_vec(),
12,
10,
),
Modification::deletion(b"\n".to_vec(), 13),
Modification::context(b"use tui::ui::widget::Widget;\n".to_vec(), 14, 11),
Modification::addition(b"use tui::{Id, SelectionExit};\n".to_vec(), 12),
Modification::context(b"\n".to_vec(), 15, 13),
Modification::context(
b"use super::ui::{IdSelect, OperationSelect};\n".to_vec(),
16,
14,
),
Modification::context(
b"use super::{IssueOperation, Message};\n".to_vec(),
17,
15,
),
],
old: 1..18,
new: 1..16,
}),
_stats: None,
})
}
/// @@ -1,1 +0,0 @@
/// - TBD
pub fn deleted_hunk_diff(path: &Path, commit: Oid) -> Result<HunkDiff> {
let diff = DiffFile {
oid: commit,
mode: diff::FileMode::Blob,
};
Ok(HunkDiff::Deleted {
path: path.to_path_buf(),
header: FileHeader::Deleted {
path: path.to_path_buf(),
old: diff.clone(),
binary: false,
},
old: diff.clone(),
hunk: Some(Hunk {
header: Line::from(b"@@ -1,1 +0,0 @@\n".to_vec()),
lines: vec![Modification::deletion(b"TBD\n".to_vec(), 1)],
old: 1..2,
new: 0..0,
}),
_stats: None,
})
}
}