Is there any way to get last commit of a certain file?

[cathaysia]

I want get a file's last commit date, how do I get it?

[Byron]

gix doesn't provide functionality like this, but ein happens to.

❯ ein t query trace-path README.md
 09:46:32 db cache up to date
 09:46:32 run sql query done 1.0 round in 0.00s (1.2k round/s)
+         | 2023-04-17 | b076fc4 Δ README.md
+++++++++-| 2023-03-06 | bfededa Δ README.md
+         | 2022-11-16 | 7a1cc83 Δ README.md
+         | 2022-11-12 | 52f96fc Δ README.md
+++--     | 2022-11-11 | 98316c4 Δ README.md
+         | 2021-04-18 | 90bc634 Δ README.md
+         | 2020-04-12 | 6765b42 Δ README.md
++-       | 2020-04-12 | aa28a85 Δ README.md
+++--     | 2020-03-08 | ead2494 Δ README.md
+++++     | 2020-03-08 | 9efaee0 Δ README.md
-----     | 2020-02-01 | dfca673 Δ README.md
+         | 2018-02-24 | 4e41d8b Δ README.md
+         | 2015-02-27 | 4696d1a Δ README.md
++        | 2015-02-27 | c2e31d5 Δ README.md

ein t query trace-path PATH shows all commits that alter or rename a given PATH.

[Byron]

The modification date is stored indirectly by commit.committer() or commit.author(), which then implies the modification or creation time of all changes within that commit. To obtain changes, please take a look at this example.

[cathaysia]

thanks, I get the codes :)

use gix::{bstr::ByteSlice, date::Time, ObjectId, Repository, ThreadSafeRepository};

fn get_changed_files_of_info(repo: &Repository, id: ObjectId) -> Vec<String> {
    let tree = repo.find_object(id).unwrap().peel_to_tree().unwrap();
    let a: Vec<String> = tree
        .decode()
        .unwrap()
        .entries
        .into_iter()
        .map(|item| item.filename.to_str().unwrap().to_string())
        .collect();
    a
}
fn get_commit_of_info(repo: &Repository, id: ObjectId) -> Time {
    repo.find_object(id)
        .unwrap()
        .into_commit()
        .committer()
        .unwrap()
        .time
}

fn main() {
    let ins = ThreadSafeRepository::discover("/home/xxx/gix_test/")
        .unwrap()
        .to_thread_local();
    let last_commit_time = ins.head_commit().unwrap().time().unwrap();
    let head_id = ins.head_id().unwrap().ancestors().all().unwrap();
    for pre_id in head_id {
        let id = pre_id.unwrap().id;
        let modify_time = get_commit_of_info(&ins, id);
        let modifyed_files = get_changed_files_of_info(&ins, id);
        println!("{:?}: {:?}", modify_time, modifyed_files);
    }
}

[Byron]

That doesn't look like what's the example is doing though, as get_changed_files_of_info lists all entries in the tree of each commit, not only the changed ones.

[cathaysia]

Yes, because I need to get the last commit time of all files, so I can only traverse commit once, and then store the file name and modification time of each modification. I don't need to get which files were modified by the last commit, what I care about is when the files were last modified.

[cathaysia]

Sorry, I misunderstood you. I'll double check my code.

[cathaysia]

thanks, I'll try it later😃

…

________________________________ From: Sebastian Thiel ***@***.***> Sent: Wednesday, May 24, 2023 7:16:25 PM To: Byron/gitoxide ***@***.***> Cc: DragonBillow ***@***.***>; Author ***@***.***> Subject: Re: [Byron/gitoxide] How do I get commit info by gix? (Discussion #859) One can retrieve the message of a commit with the Commit::message()<https://docs.rs/gix/0.44.1/gix/struct.Commit.html#method.message> method. — Reply to this email directly, view it on GitHub<#859 (reply in thread)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AKBJ6AOFBDJ3XCEUCTJQSMDXHXUYTANCNFSM6AAAAAAYL6454U>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[cathaysia]

thanks to #613 , then I'm able to get all file's last modify time:

   fn new(repo_dir: &str) -> Option<Self> {
        let repo = ThreadSafeRepository::discover(repo_dir)
            .ok()?
            .to_thread_local();
        let rewalk = repo.rev_walk(Some(repo.head_id().unwrap().detach()));
        let mut changes = rewalk.all().ok()?.filter_map(Result::ok);
        let mut mtimes: HashMap<String, u32> = HashMap::new();
        let mut last = Self::id_to_commit(changes.next()?.id())?;
        for next in changes {
            let next_shad = Self::id_to_commit(next.id()).unwrap();
            match Self::change_from_commit(&last, Some(&next_shad)) {
                Some((time, set)) => {
                    set.iter().for_each(|filename| {
                        mtimes.entry(filename.into()).or_insert_with(|| time);
                    });
                }
                None => {}
            }
            last = next_shad;
        }

        let systime = std::time::SystemTime::UNIX_EPOCH
            .checked_add(Duration::new(
                last.time().ok()?.seconds_since_unix_epoch as u64,
                0,
            ))
            .unwrap();
        let default_time: chrono::DateTime<Utc> = systime.into();
    }

    fn id_to_commit(id: Id) -> Option<Commit> {
        let object = id.try_object().ok()?;
        let object = object.expect("empty");
        let commit = object.try_into_commit().ok()?;
        Some(commit)
    }

    fn change_from_commit(last: &Commit, next: Option<&Commit>) -> Option<(u32, HashSet<String>)> {
        let tree = last.tree().ok()?;
        let mut changes = tree.changes().ok()?;
        let changes = changes.track_path();
        let last_tree = next?.tree().ok()?;
        let mut filenames = HashSet::new();
        changes
            .for_each_to_obtain_tree(
                &last_tree,
                |change| -> Result<gix::object::tree::diff::Action, _> {
                    let is_file_change = match change.event {
                        Event::Deletion {
                            entry_mode: _,
                            id: _,
                        } => false,
                        _ => true,
                    };
                    if is_file_change {
                        let path = change.location.to_os_str().unwrap().to_string_lossy();
                        filenames.insert(format!("{}", path));
                    }

                    Ok::<Action, Utf8Error>(Action::Continue)
                },
            )
            .ok()?;

        let time = last.time().ok()?;
        Some((time.seconds_since_unix_epoch, filenames))
    }

But as an interesting result, the original author's code has a big performance problem, I don't quite understand why when I delay id_to_commit, the performance has been greatly improved (before it was about the same speed as fork git, now it is close to libgit2)

just like rust-lang/git2-rs#588 (comment) , This code also has a problem with the first submission, I simply save the time of the first submission, and all files that are not found use this time。