Struct GrepCommand 

pub struct GrepCommand {

    pub executor: CommandExecutor,
    pub pattern: Option<String>,
    pub trees: Vec<String>,
    pub paths: Vec<String>,
    pub ignore_case: bool,
    pub word_regexp: bool,
    pub invert: bool,
    pub line_number: bool,
    pub count: bool,
    pub files_with_matches: bool,
    pub files_without_match: bool,
    pub name_only: bool,
    pub extended_regexp: bool,
    pub fixed_strings: bool,
    pub perl_regexp: bool,
    pub cached: bool,
    pub untracked: bool,
    pub no_index: bool,
    pub recurse_submodules: bool,
}

Builder for git grep.

Fields

executor: CommandExecutor

Shared executor.

pattern: Option<String>

Pattern to search for.

trees: Vec<String>

Tree-ishes to search (defaults to working tree if empty).

paths: Vec<String>

Pathspecs.

ignore_case: bool

-i case-insensitive.

word_regexp: bool

-w match whole word.

invert: bool

-v invert match.

line_number: bool

-n show line numbers.

count: bool

-c count matches per file.

files_with_matches: bool

-l / --files-with-matches.

files_without_match: bool

-L / --files-without-match.

name_only: bool

--name-only.

extended_regexp: bool

-E extended regex.

fixed_strings: bool

-F fixed string.

perl_regexp: bool

-P Perl regex.

cached: bool

--cached.

untracked: bool

--untracked.

no_index: bool

--no-index.

recurse_submodules: bool

--recurse-submodules.

Implementations

impl GrepCommand

pub fn new(pattern: impl Into<String>) -> Self

New grep with the given pattern.

pub fn tree(&mut self, t: impl Into<String>) -> &mut Self

Search a tree-ish (e.g. HEAD, a commit, a branch).

pub fn path(&mut self, p: impl Into<String>) -> &mut Self

Filter by path.

pub fn ignore_case(&mut self) -> &mut Self

-i.

pub fn word_regexp(&mut self) -> &mut Self

-w.

pub fn invert(&mut self) -> &mut Self

-v.

pub fn line_number(&mut self) -> &mut Self

-n.

pub fn count(&mut self) -> &mut Self

-c.

pub fn files_with_matches(&mut self) -> &mut Self

-l.

pub fn files_without_match(&mut self) -> &mut Self

-L.

pub fn name_only(&mut self) -> &mut Self

--name-only.

pub fn extended_regexp(&mut self) -> &mut Self

-E.

pub fn fixed_strings(&mut self) -> &mut Self

-F.

pub fn perl_regexp(&mut self) -> &mut Self

-P.

pub fn cached(&mut self) -> &mut Self

--cached.

pub fn untracked(&mut self) -> &mut Self

--untracked.

pub fn no_index(&mut self) -> &mut Self

--no-index.

pub fn recurse_submodules(&mut self) -> &mut Self

--recurse-submodules.

pub async fn execute_allow_no_match(&self) -> Result<Option<CommandOutput>>

Run the grep, treating “no matches” as success instead of an error.

git grep exits 1 when nothing matched, which execute surfaces as Error::CommandFailed – indistinguishable from a real failure without inspecting the exit code. This method returns Ok(None) for the no-match case and Ok(Some(output)) when there were matches; genuine failures (exit >= 2, e.g. a bad pathspec) still return Err.

Trait Implementations

impl Clone for GrepCommand

fn clone(&self) -> GrepCommand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GrepCommand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GrepCommand

fn default() -> GrepCommand

Returns the “default value” for a type.

impl GitCommand for GrepCommand

type Output = CommandOutput

The typed output produced by this command.

fn get_executor(&self) -> &CommandExecutor

Borrow the shared executor.

fn get_executor_mut(&mut self) -> &mut CommandExecutor

Mutably borrow the shared executor.

fn build_command_args(&self) -> Vec<String>

Build the full argument vector (subcommand + flags + positionals) excluding the leading git program.

fn execute<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CommandOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Run the command and decode its output into Self::Output.

fn execute_raw<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CommandOutput>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Spawn git with the given arguments and return the raw output.

fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self

Append a single raw argument.

fn args<I, S>(&mut self, args: I) -> &mut Self

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Append several raw arguments.

fn flag(&mut self, flag: &str) -> &mut Self

Append a --flag (or -f if a single character).

fn option(&mut self, key: &str, value: &str) -> &mut Self

Append a --key value pair.

fn current_dir<P: Into<PathBuf>>(&mut self, dir: P) -> &mut Self

Run git in the given working directory.

fn env<K: Into<OsString>, V: Into<OsString>>( &mut self, key: K, value: V, ) -> &mut Self

Set an environment variable for this invocation.

fn with_timeout(&mut self, timeout: Duration) -> &mut Self

Cap execution time. On expiry the process is killed and Error::Timeout is returned.

fn with_timeout_secs(&mut self, seconds: u64) -> &mut Self

Convenience: set timeout in whole seconds.