@@ -17,7 +17,7 @@ pub struct Context<W> {

pub file_stats: bool,

/// Collect how many lines in files have been added, removed and modified (without rename tracking).

pub line_stats: bool,

/// The amount of threads to use. If unset, use all cores, if 0 use al physical cores.

/// The number of threads to use. If unset, use all cores, if 0 use all physical cores.

pub threads: Option<usize>,

/// Omit unifying identities by name and email which can lead to the same author appear multiple times

/// due to using different names or email addresses.

@@ -80,7 +80,7 @@ pub struct Options {

pub format: Format,

/// Given a `path`, originating in the git tree, to place into the archive, put `<prefix>/path` in front of it.

///

/// Note that that `/` should be used as separator, and that a prefix directory has to end with `/`.

/// Note that `/` should be used as separator, and that a prefix directory has to end with `/`.

pub tree_prefix: Option<BString>,

/// The modification time for all entries in the archive as seen since UNIX epoch.

///

@@ -159,7 +159,7 @@ mod prepare {

/// Set the name or path to the shell `program` to use if a shell is to be used, to avoid

/// using the default shell which is `sh`.

///

/// Note that that shells that are not Bourne-style cannot be expected to work correctly,

/// Note that shells that are not Bourne-style cannot be expected to work correctly,

/// because POSIX shell syntax is assumed when searching for and conditionally adding

/// `"$@"` to receive arguments, where applicable (and in the behaviour of

/// [`with_quoted_command()`](Self::with_quoted_command()), if called).

@@ -38,11 +38,11 @@ pub fn build_thread() -> std::thread::Builder {

}

/// Read items from `input` and `consume` them in multiple threads,

/// whose output output is collected by a `reducer`. Its task is to

/// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.

/// whose output is collected by a `reducer`. Its task is to

/// aggregate these outputs into the final result returned by this function, with the benefit of not having to be thread-safe.

///

/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`

/// * if `thread_limit` is `Some`, then the given number of threads will be used. If `None`, all logical cores will be used.

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`

/// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially

/// created by `new_thread_state(…)`.

/// * For `reducer`, see the [`Reduce`] trait

@@ -103,12 +103,12 @@ where

}

/// Read items from `input` and `consume` them in multiple threads,

/// whose output output is collected by a `reducer`. Its task is to

/// whose output is collected by a `reducer`. Its task is to

/// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.

/// Caall `finalize` to finish the computation, once per thread, if there was no error sending results earlier.

/// Call `finalize` to finish the computation, once per thread, if there was no error sending results earlier.

///

/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`

/// * if `thread_limit` is `Some`, then the given number of threads will be used. If `None`, all logical cores will be used.

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`

/// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially

/// created by `new_thread_state(…)`.

/// * `finalize(State) -> Output` is called to potentially process remaining work that was placed in `State`.

@@ -232,7 +232,7 @@ pub trait Reduce {

///

/// If an `Error` is returned, the entire operation will be stopped.

fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error>;

/// Called once once all items where passed to `feed()`, producing the final `Output` of the operation or an `Error`.

/// Called once for all items that were passed to `feed()`, producing the final `Output` of the operation or an `Error`.

fn finalize(self) -> Result<Self::Output, Self::Error>;

}

@@ -116,12 +116,12 @@ mod not_parallel {

pub use not_parallel::{build_thread, in_parallel_with_slice, join, threads, Scope};

/// Read items from `input` and `consume` them in a single thread, producing an output to be collected by a `reducer`,

/// whose task is to aggregate these outputs into the final result returned by this function.

/// whose task it is to aggregate these outputs into the final result returned by this function.

///

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`

/// * `consume(Item, &mut State) -> Output` produces an output given an input along with mutable state.

/// * For `reducer`, see the [`Reduce`] trait

/// * if `thread_limit` has no effect as everything is run on the main thread, but is present to keep the signature

/// * `thread_limit` has no effect as everything is run on the main thread, but is present to keep the signature

/// similar to the parallel version.

///

/// **This serial version performing all calculations on the current thread.**

@@ -143,12 +143,12 @@ where

}

/// Read items from `input` and `consume` them in multiple threads,

/// whose output output is collected by a `reducer`. Its task is to

/// whose output is collected by a `reducer`. Its task is to

/// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.

/// Caall `finalize` to finish the computation, once per thread, if there was no error sending results earlier.

/// Call `finalize` to finish the computation, once per thread, if there was no error sending results earlier.

///

/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`

/// * if `thread_limit` is `Some`, the given number of threads will be used. If `None`, all logical cores will be used.

/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`

/// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially

/// created by `new_thread_state(…)`.

/// * `finalize(State) -> Output` is called to potentially process remaining work that was placed in `State`.

@@ -72,14 +72,14 @@ impl State {

/// Each call to this method will cause the corresponding filter to be invoked unless `driver` indicates a `process` filter,

/// which is only launched once and maintained using this state.

///

/// Note that it's not an error if there is no filter process for `operation` or if a long-running process doesn't supported

/// Note that it's not an error if there is no filter process for `operation` or if a long-running process doesn't support

/// the desired capability.

///

/// ### Deviation

///

/// If a long running process returns the 'abort' status after receiving the data, it will be removed similar to how `git` does it.

/// However, it delivers an unsuccessful error status later, it will not be removed, but reports the error only.

/// If any other non-'error' status is received, the process will be stopped. But that doesn't happen if if such a status is received

/// If a long running process returns the 'abort' status after receiving the data, it will be removed similarly to how `git` does it.

/// However, if it returns an unsuccessful error status later, it will not be removed, but reports the error only.

/// If any other non-'error' status is received, the process will be stopped. But that doesn't happen if such a status is received

/// after reading the filtered result.

pub fn apply<'a>(

&'a mut self,

@@ -96,7 +96,7 @@ pub mod io_err {

}

#[cfg(not(unix))]

/// Returns whether a a file has the executable permission set.

/// Returns whether a file has the executable permission set.

pub fn is_executable(_metadata: &std::fs::Metadata) -> bool {

false

}

@@ -34,7 +34,7 @@ impl hash::Hash for oid {

}

}

/// A utility able to format itself with the given amount of characters in hex.

/// A utility able to format itself with the given number of characters in hex.

#[derive(PartialEq, Eq, Hash, Ord, PartialOrd)]

pub struct HexDisplay<'a> {

inner: &'a oid,

@@ -75,7 +75,7 @@ impl<'a> MessageRef<'a> {

summary(self.title)

}

/// Further parse the body into into non-trailer and trailers, which can be iterated from the returned [`BodyRef`].

/// Further parse the body into non-trailer and trailers, which can be iterated from the returned [`BodyRef`].

pub fn body(&self) -> Option<BodyRef<'a>> {

self.body.map(|b| BodyRef::from_bytes(b))

}