Fetch prune not working

[darakeon]

I tried to call fetch with prune, but it does not delete the branch that was deleted remotely.

The lib.rs enum is
https://github.com/rust-lang/git2-rs/blob/master/libgit2-sys/lib.rs#L393

And this is the one exposed:
https://github.com/rust-lang/git2-rs/blob/master/src/lib.rs#L1311

Is there anything missing? I'm new to Rust, so I couldn't find what is the problem.

[alexcrichton]

Is this perhaps a bug with libgit2 itself? Or with the bindings?

[ehuss]

@darakeon It seems to work for me. Can you put together a sample reproduction, something like this:

use git2::*;
use std::fs;
use std::path::Path;

fn main() {
    // Create two branches in "otherrepo", and fetch them into "repo".
    let other_path = Path::new("otherrepo");
    if other_path.exists() {
        fs::remove_dir_all(other_path).unwrap();
    }
    let repo_path = Path::new("repo");
    if repo_path.exists() {
        fs::remove_dir_all(repo_path).unwrap();
    }
    let otherrepo = Repository::init(other_path).unwrap();
    add_file(&otherrepo, "foo");

    let head = otherrepo.head().unwrap().target().unwrap();
    let head = otherrepo.find_commit(head).unwrap();
    otherrepo.branch("somebranch", &head, true).unwrap();
    otherrepo.set_head("refs/heads/somebranch").unwrap();
    add_file(&otherrepo, "bar");

    let repo = Repository::init(repo_path).unwrap();

    let mut remote = repo.remote("otherrepo", "otherrepo").unwrap();
    remote.fetch(&[] as &[&str], None, None).unwrap();

    let otherbranch = repo
        .resolve_reference_from_short_name("otherrepo/somebranch")
        .unwrap();
    eprintln!("branch={:?}", otherbranch.peel_to_commit());

    // Remove "somebranch".
    otherrepo.set_head("refs/heads/master").unwrap();
    let mut somebranch = otherrepo
        .find_branch("somebranch", BranchType::Local)
        .unwrap();
    somebranch.delete().unwrap();

    // Fetch with prune.
    let mut fo = FetchOptions::new();
    fo.prune(FetchPrune::On);
    remote.fetch(&[] as &[&str], Some(&mut fo), None).unwrap();

    // Verify that the branch was pruned.
    assert!(repo
        .resolve_reference_from_short_name("otherrepo/somebranch")
        .is_err());
}

fn add_file(repo: &Repository, name: &str) {
    let mut index = repo.index().unwrap();
    fs::write(repo.workdir().unwrap().join(name), "test").unwrap();
    index.add_path(std::path::Path::new(name)).unwrap();
    index.write().unwrap();
    let id = index.write_tree().unwrap();
    let tree = repo.find_tree(id).unwrap();
    let sig = repo.signature().unwrap();
    let mut parents = Vec::new();
    if let Some(parent) = repo.head().ok().map(|h| h.target().unwrap()) {
        parents.push(repo.find_commit(parent).unwrap());
    }
    let parents = parents.iter().collect::<Vec<_>>();

    repo.commit(Some("HEAD"), &sig, &sig, "test", &tree, &parents)
        .unwrap();
}

[darakeon]

My code is a little bit different at fetch
https://github.com/darakeon/dfm/blob/main/version/src/git.rs#L100

I'm passing the branch names and a reflog message. Could one of those things be a problem?

EDIT: I'm using a callback too, to make authentication part.

[ehuss]

It's hard to say without seeing a minimal reproduction.

This library just provides a thin wrapper around the libgit2 library. I think it is unlikely that there is an issue with the bindings, considering the example above seems to work. If something is not working correctly, I would suggest making a minimal C example and filing an issue on the libgit2 tracker, or trying one of their help options.

[darakeon]

Sorry for the delay, I'll test it as soon as I can

[darakeon]

Discovered the problem.

I was using this to fetch:

remote.fetch(
	&["main", branch_name],
	Some(&mut options),
	Some("updating local")
).unwrap();

But the correct was:

remote.fetch(
	&[] as &[&str],
	Some(&mut options),
	Some("updating local")
).unwrap();

Passing the branch name probably made my script update just the local branch I pointed (and main local).

Thanks, @ehuss !!! Closing!