Add rename detection & async filling for file revlog

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]

asyncgit/src/asyncjob/mod.rs

@@ -7,6 +7,7 @@ use crossbeam_channel::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
 /// Passed to `AsyncJob::run` allowing sending intermediate progress notifications
+#[derive(Clone)]
 pub struct RunParams<
 	T: Copy + Send,
 	P: Clone + Send + Sync + PartialEq,

asyncgit/src/file_history.rs

@@ -0,0 +1,299 @@
+use git2::Repository;
+
+use crate::{
+	asyncjob::{AsyncJob, RunParams},
+	error::Result,
+	sync::{
+ self,
+ commit_files::{
+ commit_contains_file, commit_detect_file_rename,
+ },
+ CommitId, CommitInfo, LogWalker, RepoPath,
+ SharedCommitFilterFn,
+	},
+	AsyncGitNotification,
+};
+use std::{
+	sync::{Arc, Mutex, RwLock},
+	time::{Duration, Instant},
+};
+
+///
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FileHistoryEntryDelta {
+	///
+	None,
+	///
+	Added,
+	///
+	Deleted,
+	///
+	Modified,
+	///
+	Renamed,
+	///
+	Copied,
+	///
+	Typechange,
+}
+
+impl From<git2::Delta> for FileHistoryEntryDelta {
+	fn from(value: git2::Delta) -> Self {
+ match value {
+ git2::Delta::Unmodified
+ | git2::Delta::Ignored
+ | git2::Delta::Unreadable
+ | git2::Delta::Conflicted
+ | git2::Delta::Untracked => Self::None,
+ git2::Delta::Added => Self::Added,
+ git2::Delta::Deleted => Self::Deleted,
+ git2::Delta::Modified => Self::Modified,
+ git2::Delta::Renamed => Self::Renamed,
+ git2::Delta::Copied => Self::Copied,
+ git2::Delta::Typechange => Self::Typechange,
+ }
+	}
+}
+
+///
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileHistoryEntry {
+	///
+	pub commit: CommitId,
+	///
+	pub delta: FileHistoryEntryDelta,
+	//TODO: arc and share since most will be the same over the history
+	///
+	pub file_path: String,
+	///
+	pub info: CommitInfo,
+}
+
+///
+pub struct CommitFilterResult {
+	///
+	pub duration: Duration,
+}
+
+enum JobState {
+	Request {
+ file_path: String,
+ repo_path: RepoPath,
+	},
+	Response(Result<CommitFilterResult>),
+}
+
+#[derive(Clone, Default)]
+pub struct AsyncFileHistoryResults(Arc<Mutex<Vec<FileHistoryEntry>>>);
+
+impl PartialEq for AsyncFileHistoryResults {
+	fn eq(&self, other: &Self) -> bool {
+ if Arc::ptr_eq(&self.0, &other.0) {
+ return true;
+ }
+
+ if let Ok(left) = self.0.lock() {
+ if let Ok(right) = other.0.lock() {
+ return *left == *right;
+ }
+ }
+
+ false
+	}
+}
+
+impl AsyncFileHistoryResults {
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ let mut results = self.0.lock()?;
+ log::trace!("pull entries {}", results.len());
+ let results =
+ std::mem::replace(&mut *results, Vec::with_capacity(1));
+ Ok(results)
+	}
+}
+
+///
+#[derive(Clone)]
+pub struct AsyncFileHistoryJob {
+	state: Arc<Mutex<Option<JobState>>>,
+	results: AsyncFileHistoryResults,
+}
+
+///
+impl AsyncFileHistoryJob {
+	///
+	pub fn new(repo_path: RepoPath, file_path: String) -> Self {
+ Self {
+ state: Arc::new(Mutex::new(Some(JobState::Request {
+ repo_path,
+ file_path,
+ }))),
+ results: AsyncFileHistoryResults::default(),
+ }
+	}
+
+	///
+	pub fn result(&self) -> Option<Result<CommitFilterResult>> {
+ if let Ok(mut state) = self.state.lock() {
+ if let Some(state) = state.take() {
+ return match state {
+ JobState::Request { .. } => None,
+ JobState::Response(result) => Some(result),
+ };
+ }
+ }
+
+ None
+	}
+
+	///
+	pub fn extract_results(&self) -> Result<Vec<FileHistoryEntry>> {
+ self.results.extract_results()
+	}
+
+	fn file_history_filter(
+ file_path: Arc<RwLock<String>>,
+ results: Arc<Mutex<Vec<FileHistoryEntry>>>,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> SharedCommitFilterFn {
+ let params = params.clone();
+
+ Arc::new(Box::new(
+ move |repo: &Repository,
+ commit_id: &CommitId|
+ -> Result<bool> {
+ let file_path = file_path.clone();
+
+ if fun_name(&file_path, &results, repo, commit_id)? {
+ params.send(AsyncGitNotification::FileHistory)?;
+ params.set_progress(AsyncFileHistoryResults(
+ results.clone(),
+ ))?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ },
+ ))
+	}
+
+	fn run_request(
+ &self,
+ repo_path: &RepoPath,
+ file_path: String,
+ params: &RunParams<
+ AsyncGitNotification,
+ AsyncFileHistoryResults,
+ >,
+	) -> Result<CommitFilterResult> {
+ let start = Instant::now();
+
+ let file_name = Arc::new(RwLock::new(file_path));
+
+ let filter = Self::file_history_filter(
+ file_name,
+ self.results.0.clone(),
+ params,
+ );
+
+ let repo = sync::repo(repo_path)?;
+ let mut walker =
+ LogWalker::new(&repo, None)?.filter(Some(filter));
+
+ walker.read(None)?;
+
+ let result = CommitFilterResult {
+ duration: start.elapsed(),
+ };
+
+ Ok(result)
+	}
+}
+
+fn fun_name(
+	file_path: &Arc<RwLock<String>>,
+	results: &Arc<Mutex<Vec<FileHistoryEntry>>>,
+	repo: &Repository,
+	commit_id: &CommitId,
+) -> Result<bool> {
+	let current_file_path = file_path.read()?.to_string();
+
+	if let Some(delta) = commit_contains_file(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+	)? {
+ log::info!(
+ "[history] edit: [{}] ({:?}) - {}",
+ commit_id.get_short_string(),
+ delta,
+ &current_file_path
+ );
+
+ let commit_info =
+ sync::get_commit_info_repo(repo, commit_id)?;
+
+ let entry = FileHistoryEntry {
+ commit: *commit_id,
+ delta: delta.into(),
+ info: commit_info,
+ file_path: current_file_path.clone(),
+ };
+
+ //note: only do rename test in case file looks like being added in this commit
+ if matches!(delta, git2::Delta::Added) {
+ let rename = commit_detect_file_rename(
+ repo,
+ *commit_id,
+ current_file_path.as_str(),
+ )?;
+
+ if let Some(old_name) = rename {
+ // log::info!(
+ // "rename: [{}] {:?} <- {:?}",
+ // commit_id.get_short_string(),
+ // current_file_path,
+ // old_name,
+ // );
+
+ (*file_path.write()?) = old_name;
+ }
+ }
+ results.lock()?.push(entry);
+ log::trace!("push entry {}", results.lock()?.len());
+
+ return Ok(true);
+	}
+
+	Ok(false)
+}
+
+impl AsyncJob for AsyncFileHistoryJob {
+	type Notification = AsyncGitNotification;
+	type Progress = AsyncFileHistoryResults;
+
+	fn run(
+ &mut self,
+ params: RunParams<Self::Notification, Self::Progress>,
+	) -> Result<Self::Notification> {
+ if let Ok(mut state) = self.state.lock() {
+ *state = state.take().map(|state| match state {
+ JobState::Request {
+ file_path,
+ repo_path,
+ } => JobState::Response(
+ self.run_request(&repo_path, file_path, &params),
+ ),
+ JobState::Response(result) => {
+ JobState::Response(result)
+ }
+ });
+ }
+
+ Ok(AsyncGitNotification::FileHistory)
+	}
+}

asyncgit/src/lib.rs

@@ -40,6 +40,7 @@ mod commit_files;
 mod diff;
 mod error;
 mod fetch_job;
+mod file_history;
 mod filter_commits;
 mod progress;
 mod pull;
@@ -60,6 +61,9 @@ pub use crate::{
 	diff::{AsyncDiff, DiffParams, DiffType},
 	error::{Error, Result},
 	fetch_job::AsyncFetchJob,
+	file_history::{
+ AsyncFileHistoryJob, FileHistoryEntry, FileHistoryEntryDelta,
+	},
 	filter_commits::{AsyncCommitFilterJob, CommitFilterResult},
 	progress::ProgressPercent,
 	pull::{AsyncPull, FetchRequest},
@@ -117,6 +121,8 @@ pub enum AsyncGitNotification {
 	TreeFiles,
 	///
 	CommitFilter,
+	///
+	FileHistory,
 }
 
 /// helper function to calculate the hash of an arbitrary type that implements the `Hash` trait

asyncgit/src/revlog.rs

@@ -9,6 +9,7 @@ use crate::{
 use crossbeam_channel::Sender;
 use scopetime::scope_time;
 use std::{
+	cell::RefCell,
 	sync::{
  atomic::{AtomicBool, Ordering},
  Arc, Mutex,
@@ -230,19 +231,20 @@ impl AsyncLog {
 	) -> Result<()> {
  let start_time = Instant::now();
 
- let mut entries = vec![CommitId::default(); LIMIT_COUNT];
- entries.resize(0, CommitId::default());
+ let entries =
+ RefCell::new(vec![CommitId::default(); LIMIT_COUNT]);
+ entries.borrow_mut().resize(0, CommitId::default());
 
  let r = repo(repo_path)?;
- let mut walker =
-LogWalker::new(&r, LIMIT_COUNT)?.filter(Some(filter));
+ let mut walker = LogWalker::new(&r, Some(LIMIT_COUNT))?
+ .filter(Some(filter));
 
  loop {
- entries.clear();
- let read = walker.read(&mut entries)?;
+ entries.borrow_mut().clear();
+ let read = walker.read(Some(&entries))?;
 
  let mut current = arc_current.lock()?;
- current.commits.extend(entries.iter());
+ current.commits.extend(entries.borrow().iter());
  current.duration = start_time.elapsed();
 
  if read == 0 {

asyncgit/src/sync/commit.rs

@@ -210,13 +210,14 @@ mod tests {
 	};
 	use commit::{amend, commit_message_prettify, tag_commit};
 	use git2::Repository;
+	use std::cell::RefCell;
 	use std::{fs::File, io::Write, path::Path};
 
 	fn count_commits(repo: &Repository, max: usize) -> usize {
- let mut items = Vec::new();
- let mut walk = LogWalker::new(repo, max).unwrap();
- walk.read(&mut items).unwrap();
- items.len()
+ let items = RefCell::new(Vec::new());
+ let mut walk = LogWalker::new(repo, Some(max)).unwrap();
+ walk.read(Some(&items)).unwrap();
+ items.take().len()
 	}
 
 	#[test]