How to commit files with gix

[LuckyTurtleDev]

I have write a program, which does clone and check out a repo. After this the files (at storage) will be modified.
The changes (and a new file) should be commit and push now.
How can I commit this change, using gix?
The commit function takes a tree, but I do not see how I can put my changes from disk inside.

[Byron]

Manipulating the index and creating a tree from it for use in a commit isn't implemented yet. Thus it's currently not easy to do that. The timeline for this could be end of this year or early next year - there is a lot of other features waiting.

[kalkin]

You can create an own tree and commit it without using the index. You need to get the old tree from a commit, modify it and commit.

[Byron]

So I guess I will simple call the git binary. It is possible to still use gix to push after I have make the commit with git?

You can do that for now, yes.

[justinrubek]

I ended up implementing this manual tree update in one of my applications. I thought I'd share it here so that someone else could use/improve upon it. I chose to use a recursive function because it made it super easy and shouldn't be a problem for my use-case:

/// Creates a modified git tree with the provided path's entries changed to match their new
/// contents.
///
/// TODO: remove this once `gix` supports a better way to create changes
fn rewrite_tree(
    repo: &gix::Repository,
    tree: &gix::worktree::object::Tree,
    changes: &Vec<PathBuf>,
    tree_path: &mut PathBuf,
) -> Result<gix::worktree::object::Tree> {
    let mut new_entries = vec![];

    for entry in &tree.entries {
        let object: gix::Object = repo.find_object(entry.oid)?;
        match &object.kind {
            gix::object::Kind::Tree => {
                let old_tree = object.clone().into_tree().decode()?.into();
                tree_path.push(entry.filename.to_string());
                let new_tree = rewrite_tree(repo, &old_tree, changes, tree_path)?;
                tree_path.pop();
                let new_id = repo.write_object(&new_tree)?;

                new_entries.push(gix::worktree::object::tree::Entry {
                    filename: entry.filename.clone(),
                    mode: entry.mode,
                    oid: new_id.into(),
                });
            }
            gix::object::Kind::Blob => {
                let file_name = entry.filename.clone().to_string();
                let file_path = tree_path.join(file_name);
                if let Some(new_path) = changes.iter().find(|p| **p == file_path) {
                    let new_id = repo.write_blob_stream(std::fs::File::open(new_path)?)?;

                    new_entries.push(gix::worktree::object::tree::Entry {
                        filename: entry.filename.clone(),
                        mode: entry.mode,
                        oid: new_id.into(),
                    });
                } else {
                    new_entries.push(entry.clone());
                }
            }
            _ => unreachable!(),
        }
    }

    Ok(gix::worktree::object::Tree {
        entries: new_entries,
    })
}

https://github.com/justinrubek/bomper/blob/11cef925f8d1a4c1d75af6adc7299676976fda59/src/bin/bomp/app.rs#L254-L301

[qfel]

Manipulating the index and creating a tree from it for use in a commit isn't implemented yet.

To be clear, if I want to create a commit from the work tree but don't care about the index, it's also not possible yet? I'm not sure if under the hood commit would always have to mean add thing to index and then commit, or the index can be skipped.

[Byron]

Actually, it's a great time to ask that because last time there was no way to (easily) create a tree. But now, in main, there is gix::Repository::edit_tree() which provides an API to do arbitrary edits.
The resulting tree object can then be used in commits.