Struct DiffOptions 

pub struct DiffOptions { /* private fields */ }

Structure describing options about how the diff should be executed.

Implementations

impl DiffOptions

pub fn new() -> DiffOptions

Creates a new set of empty diff options.

All flags and other options are defaulted to false or their otherwise zero equivalents.

Examples found in repository

examples/git-log.rs (line 120)

fn run(args: &Args) -> Result<(), Error> {
    let path = args.flag_git_dir.as_ref().map(|s| &s[..]).unwrap_or(".");
    let repo = Repository::open(path)?;
    let mut revwalk = repo.revwalk()?;

    // Prepare the revwalk based on CLI parameters
    let base = if args.flag_reverse { git2::Sort::REVERSE } else { git2::Sort::NONE };
    revwalk.set_sorting(
        base | if args.flag_topo_order {
            git2::Sort::TOPOLOGICAL
        } else if args.flag_date_order {
            git2::Sort::TIME
        } else {
            git2::Sort::NONE
        },
    )?;
    for commit in &args.arg_commit {
        if commit.starts_with('^') {
            let obj = repo.revparse_single(&commit[1..])?;
            revwalk.hide(obj.id())?;
            continue;
        }
        let revspec = repo.revparse(commit)?;
        if revspec.mode().contains(git2::RevparseMode::SINGLE) {
            revwalk.push(revspec.from().unwrap().id())?;
        } else {
            let from = revspec.from().unwrap().id();
            let to = revspec.to().unwrap().id();
            revwalk.push(to)?;
            if revspec.mode().contains(git2::RevparseMode::MERGE_BASE) {
                let base = repo.merge_base(from, to)?;
                let o = repo.find_object(base, Some(ObjectType::Commit))?;
                revwalk.push(o.id())?;
            }
            revwalk.hide(from)?;
        }
    }
    if args.arg_commit.is_empty() {
        revwalk.push_head()?;
    }

    // Prepare our diff options and pathspec matcher
    let (mut diffopts, mut diffopts2) = (DiffOptions::new(), DiffOptions::new());
    for spec in &args.arg_spec {
        diffopts.pathspec(spec);
        diffopts2.pathspec(spec);
    }
    let ps = Pathspec::new(args.arg_spec.iter())?;

    // Filter our revwalk based on the CLI parameters
    macro_rules! filter_try {
        ($e:expr) => {
            match $e {
                Ok(t) => t,
                Err(e) => return Some(Err(e)),
            }
        };
    }
    let revwalk = revwalk
        .filter_map(|id| {
            let id = filter_try!(id);
            let commit = filter_try!(repo.find_commit(id));
            let parents = commit.parents().len();
            if parents < args.min_parents() {
                return None;
            }
            if let Some(n) = args.max_parents() {
                if parents >= n {
                    return None;
                }
            }
            if !args.arg_spec.is_empty() {
                match commit.parents().len() {
                    0 => {
                        let tree = filter_try!(commit.tree());
                        let flags = git2::PathspecFlags::NO_MATCH_ERROR;
                        if ps.match_tree(&tree, flags).is_err() {
                            return None;
                        }
                    }
                    _ => {
                        let m = commit
                            .parents()
                            .all(|parent| match_with_parent(&repo, &commit, &parent, &mut diffopts).unwrap_or(false));
                        if !m {
                            return None;
                        }
                    }
                }
            }
            if !sig_matches(&commit.author(), &args.flag_author) {
                return None;
            }
            if !sig_matches(&commit.committer(), &args.flag_committer) {
                return None;
            }
            if !log_message_matches(commit.message(), &args.flag_grep) {
                return None;
            }
            Some(Ok(commit))
        })
        .skip(args.flag_skip.unwrap_or(0))
        .take(args.flag_max_count.unwrap_or(!0));

    // print!
    for commit in revwalk {
        let commit = commit?;
        print_commit(&commit);
        if !args.flag_patch || commit.parents().len() > 1 {
            continue;
        }
        let a = if commit.parents().len() == 1 {
            let parent = commit.parent(0)?;
            Some(parent.tree()?)
        } else {
            None
        };
        let b = commit.tree()?;
        let diff = repo.diff_tree_to_tree(a.as_ref(), Some(&b), Some(&mut diffopts2))?;
        diff.print(DiffFormat::Patch, |_delta, _hunk, line| {
            match line.origin() {
                ' ' | '+' | '-' => print!("{}", line.origin()),
                _ => {}
            }
            print!("{}", str::from_utf8(line.content()).unwrap());
            true
        })?;
    }

    Ok(())
}

pub fn reverse(&mut self, reverse: bool) -> &mut DiffOptions

Flag indicating whether the sides of the diff will be reversed.

pub fn include_ignored(&mut self, include: bool) -> &mut DiffOptions

Flag indicating whether ignored files are included.

pub fn recurse_ignored_dirs(&mut self, recurse: bool) -> &mut DiffOptions

Flag indicating whether ignored directories are traversed deeply or not.

pub fn include_untracked(&mut self, include: bool) -> &mut DiffOptions

Flag indicating whether untracked files are in the diff

pub fn recurse_untracked_dirs(&mut self, recurse: bool) -> &mut DiffOptions

Flag indicating whether untracked directories are traversed deeply or not.

pub fn include_unmodified(&mut self, include: bool) -> &mut DiffOptions

Flag indicating whether unmodified files are in the diff.

pub fn include_typechange(&mut self, include: bool) -> &mut DiffOptions

If enabled, then Typechange delta records are generated.

pub fn include_typechange_trees(&mut self, include: bool) -> &mut DiffOptions

Event with include_typechange, the tree returned generally shows a deleted blob. This flag correctly labels the tree transitions as a typechange record with the new_file’s mode set to tree.

Note that the tree SHA will not be available.

pub fn ignore_filemode(&mut self, ignore: bool) -> &mut DiffOptions

Flag indicating whether file mode changes are ignored.

pub fn ignore_submodules(&mut self, ignore: bool) -> &mut DiffOptions

Flag indicating whether all submodules should be treated as unmodified.

pub fn ignore_case(&mut self, ignore: bool) -> &mut DiffOptions

Flag indicating whether case insensitive filenames should be used.

pub fn disable_pathspec_match(&mut self, disable: bool) -> &mut DiffOptions

If pathspecs are specified, this flag means that they should be applied as an exact match instead of a fnmatch pattern.

pub fn skip_binary_check(&mut self, skip: bool) -> &mut DiffOptions

Disable updating the binary flag in delta records. This is useful when iterating over a diff if you don’t need hunk and data callbacks and want to avoid having to load a file completely.

pub fn enable_fast_untracked_dirs(&mut self, enable: bool) -> &mut DiffOptions

When diff finds an untracked directory, to match the behavior of core Git, it scans the contents for ignored and untracked files. If all contents are ignored, then the directory is ignored; if any contents are not ignored, then the directory is untracked. This is extra work that may not matter in many cases.

This flag turns off that scan and immediately labels an untracked directory as untracked (changing the behavior to not match core git).

pub fn update_index(&mut self, update: bool) -> &mut DiffOptions

When diff finds a file in the working directory with stat information different from the index, but the OID ends up being the same, write the correct stat information into the index. Note: without this flag, diff will always leave the index untouched.

pub fn include_unreadable(&mut self, include: bool) -> &mut DiffOptions

Include unreadable files in the diff

pub fn include_unreadable_as_untracked( &mut self, include: bool, ) -> &mut DiffOptions

Include unreadable files in the diff as untracked files

pub fn force_text(&mut self, force: bool) -> &mut DiffOptions

Treat all files as text, disabling binary attributes and detection.

pub fn force_binary(&mut self, force: bool) -> &mut DiffOptions

Treat all files as binary, disabling text diffs

pub fn ignore_whitespace(&mut self, ignore: bool) -> &mut DiffOptions

Ignore all whitespace

pub fn ignore_whitespace_change(&mut self, ignore: bool) -> &mut DiffOptions

Ignore changes in the amount of whitespace

pub fn ignore_whitespace_eol(&mut self, ignore: bool) -> &mut DiffOptions

Ignore whitespace at the end of line

pub fn ignore_blank_lines(&mut self, ignore: bool) -> &mut DiffOptions

Ignore blank lines

pub fn show_untracked_content(&mut self, show: bool) -> &mut DiffOptions

When generating patch text, include the content of untracked files.

This automatically turns on include_untracked but it does not turn on recurse_untracked_dirs. Add that flag if you want the content of every single untracked file.

pub fn show_unmodified(&mut self, show: bool) -> &mut DiffOptions

When generating output, include the names of unmodified files if they are included in the Diff. Normally these are skipped in the formats that list files (e.g. name-only, name-status, raw). Even with this these will not be included in the patch format.

pub fn patience(&mut self, patience: bool) -> &mut DiffOptions

Use the “patience diff” algorithm

pub fn minimal(&mut self, minimal: bool) -> &mut DiffOptions

Take extra time to find the minimal diff

pub fn show_binary(&mut self, show: bool) -> &mut DiffOptions

Include the necessary deflate/delta information so that git-apply can apply given diff information to binary files.

pub fn indent_heuristic(&mut self, heuristic: bool) -> &mut DiffOptions

Use a heuristic that takes indentation and whitespace into account which generally can produce better diffs when dealing with ambiguous diff hunks.

pub fn context_lines(&mut self, lines: u32) -> &mut DiffOptions

Set the number of unchanged lines that define the boundary of a hunk (and to display before and after).

The default value for this is 3.

pub fn interhunk_lines(&mut self, lines: u32) -> &mut DiffOptions

Set the maximum number of unchanged lines between hunk boundaries before the hunks will be merged into one.

The default value for this is 0.

pub fn id_abbrev(&mut self, abbrev: u16) -> &mut DiffOptions

The default value for this is core.abbrev or 7 if unset.

pub fn max_size(&mut self, size: i64) -> &mut DiffOptions

Maximum size (in bytes) above which a blob will be marked as binary automatically.

A negative value will disable this entirely.

The default value for this is 512MB.

pub fn old_prefix<T>(&mut self, t: T) -> &mut DiffOptions

where T: IntoCString,

The virtual “directory” to prefix old file names with in hunk headers.

The default value for this is “a”.

pub fn new_prefix<T>(&mut self, t: T) -> &mut DiffOptions

where T: IntoCString,

The virtual “directory” to prefix new file names with in hunk headers.

The default value for this is “b”.

pub fn pathspec<T>(&mut self, pathspec: T) -> &mut DiffOptions

where T: IntoCString,

Add to the array of paths/fnmatch patterns to constrain the diff.

Examples found in repository

examples/git-log.rs (line 122)

fn run(args: &Args) -> Result<(), Error> {
    let path = args.flag_git_dir.as_ref().map(|s| &s[..]).unwrap_or(".");
    let repo = Repository::open(path)?;
    let mut revwalk = repo.revwalk()?;

    // Prepare the revwalk based on CLI parameters
    let base = if args.flag_reverse { git2::Sort::REVERSE } else { git2::Sort::NONE };
    revwalk.set_sorting(
        base | if args.flag_topo_order {
            git2::Sort::TOPOLOGICAL
        } else if args.flag_date_order {
            git2::Sort::TIME
        } else {
            git2::Sort::NONE
        },
    )?;
    for commit in &args.arg_commit {
        if commit.starts_with('^') {
            let obj = repo.revparse_single(&commit[1..])?;
            revwalk.hide(obj.id())?;
            continue;
        }
        let revspec = repo.revparse(commit)?;
        if revspec.mode().contains(git2::RevparseMode::SINGLE) {
            revwalk.push(revspec.from().unwrap().id())?;
        } else {
            let from = revspec.from().unwrap().id();
            let to = revspec.to().unwrap().id();
            revwalk.push(to)?;
            if revspec.mode().contains(git2::RevparseMode::MERGE_BASE) {
                let base = repo.merge_base(from, to)?;
                let o = repo.find_object(base, Some(ObjectType::Commit))?;
                revwalk.push(o.id())?;
            }
            revwalk.hide(from)?;
        }
    }
    if args.arg_commit.is_empty() {
        revwalk.push_head()?;
    }

    // Prepare our diff options and pathspec matcher
    let (mut diffopts, mut diffopts2) = (DiffOptions::new(), DiffOptions::new());
    for spec in &args.arg_spec {
        diffopts.pathspec(spec);
        diffopts2.pathspec(spec);
    }
    let ps = Pathspec::new(args.arg_spec.iter())?;

    // Filter our revwalk based on the CLI parameters
    macro_rules! filter_try {
        ($e:expr) => {
            match $e {
                Ok(t) => t,
                Err(e) => return Some(Err(e)),
            }
        };
    }
    let revwalk = revwalk
        .filter_map(|id| {
            let id = filter_try!(id);
            let commit = filter_try!(repo.find_commit(id));
            let parents = commit.parents().len();
            if parents < args.min_parents() {
                return None;
            }
            if let Some(n) = args.max_parents() {
                if parents >= n {
                    return None;
                }
            }
            if !args.arg_spec.is_empty() {
                match commit.parents().len() {
                    0 => {
                        let tree = filter_try!(commit.tree());
                        let flags = git2::PathspecFlags::NO_MATCH_ERROR;
                        if ps.match_tree(&tree, flags).is_err() {
                            return None;
                        }
                    }
                    _ => {
                        let m = commit
                            .parents()
                            .all(|parent| match_with_parent(&repo, &commit, &parent, &mut diffopts).unwrap_or(false));
                        if !m {
                            return None;
                        }
                    }
                }
            }
            if !sig_matches(&commit.author(), &args.flag_author) {
                return None;
            }
            if !sig_matches(&commit.committer(), &args.flag_committer) {
                return None;
            }
            if !log_message_matches(commit.message(), &args.flag_grep) {
                return None;
            }
            Some(Ok(commit))
        })
        .skip(args.flag_skip.unwrap_or(0))
        .take(args.flag_max_count.unwrap_or(!0));

    // print!
    for commit in revwalk {
        let commit = commit?;
        print_commit(&commit);
        if !args.flag_patch || commit.parents().len() > 1 {
            continue;
        }
        let a = if commit.parents().len() == 1 {
            let parent = commit.parent(0)?;
            Some(parent.tree()?)
        } else {
            None
        };
        let b = commit.tree()?;
        let diff = repo.diff_tree_to_tree(a.as_ref(), Some(&b), Some(&mut diffopts2))?;
        diff.print(DiffFormat::Patch, |_delta, _hunk, line| {
            match line.origin() {
                ' ' | '+' | '-' => print!("{}", line.origin()),
                _ => {}
            }
            print!("{}", str::from_utf8(line.content()).unwrap());
            true
        })?;
    }

    Ok(())
}

pub unsafe fn raw(&mut self) -> *const git_diff_options

Acquire a pointer to the underlying raw options.

This function is unsafe as the pointer is only valid so long as this structure is not moved, modified, or used elsewhere.

Trait Implementations

impl Default for DiffOptions

fn default() -> DiffOptions

Returns the “default value” for a type.