Enum ChangeKind

pub enum ChangeKind {
    Added,
    Modified,
    Deleted,
    Renamed,
}

Variants

Added

Modified

Deleted

Renamed

Implementations

impl ChangeKind

pub const fn letter(self) -> char

Added => 'A'
Modified => 'M'
Deleted => 'D'
Renamed => 'R'

Examples found in repository

examples/example.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = std::env::args().nth(1).unwrap_or_else(|| String::from("."));
    let repo = git_commits::open(&path)?;

    for commit in repo.commits()? {
        let commit = commit?;

        let msg = commit.message_lossy();
        let first_line = msg.trim().lines().next().unwrap_or_default();

        let committer = commit.committer();
        let author = commit.author();

        println!();
        println!("SHA:     {}", commit.sha());
        println!("Time:    {}", committer.time_local().unwrap()); // same as `commit.time_local()`
        println!("Author:  {}", author.name_lossy());
        println!("Message: {first_line}");
        println!();

        for change in commit.changes()? {
            let change = change?;

            // The following `match` can be simplified, by simply doing:
            // println!("  {}", change);

            match change {
                Change::Added(change) => {
                    println!(
                        "  {} {} ({} bytes)",
                        change.kind().letter(),
                        change.path().display(),
                        change.size(),
                    );
                }
                Change::Modified(change) => {
                    println!(
                        "  {} {} ({} -> {} bytes)",
                        change.kind().letter(),
                        change.path().display(),
                        change.old_size(),
                        change.new_size(),
                    );
                }
                Change::Deleted(change) => {
                    println!(
                        "  {} {} ({} bytes)",
                        change.kind().letter(),
                        change.path().display(),
                        change.size(),
                    );
                }
                Change::Renamed(change) => {
                    println!(
                        "  {} {} -> {} ({} bytes)",
                        change.kind().letter(),
                        change.old_path().display(),
                        change.new_path().display(),
                        change.size(),
                    );
                }
            }
        }
    }

    Ok(())
}

pub const fn symbol(self) -> char

`Added => '+'
`Modified => '~'
`Deleted => '-'
`Renamed => '>'

pub const fn is_added(self) -> bool

pub const fn is_modified(self) -> bool

pub const fn is_deleted(self) -> bool

pub const fn is_renamed(self) -> bool

Trait Implementations

impl Clone for ChangeKind

fn clone(&self) -> ChangeKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChangeKind

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

Formats the value using the given formatter.

impl Display for ChangeKind

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

Formats the value using the given formatter.

impl Hash for ChangeKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ChangeKind

fn eq(&self, other: &ChangeKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ChangeKind

impl Eq for ChangeKind

impl StructuralPartialEq for ChangeKind