Struct Blame 

pub struct Blame {

    pub commit: String,
    pub original_line_no: usize,
    pub final_line_no: usize,
    pub filename: String,
    pub summary: String,
    pub content: String,
    pub previous_commit: Option<String>,
    pub previous_filepath: Option<String>,
    pub boundary: bool,
    pub author: String,
    pub author_mail: String,
    pub author_time: u64,
    pub author_tz: String,
    pub committer: String,
    pub committer_mail: String,
    pub committer_time: u64,
    pub committer_tz: String,
}

The blame information

This struct stores the git blame output in PORCELAIN format.

The Porcelain Format

The porcelain format is the output format produced by git blame when the --porcelain option is used.

Note that the --porcelain option generally suppresses commit information that has already been seen.

The --line-porcelain option can be used to outputs the full commit information for each line, use this when parsing. so use this for parsing.

More information about the porcelain format can be For more information, see git doc.

time

author_time and committer_time are UNIX times (seconds).

boundary

boundary is a metadata indicating the commit where the history tracking is stopped in git blame. This line means that the history will not be followed this point.

It is output only when necessary, and in that case, it is set to true.

Fields

commit: String

original_line_no: usize

final_line_no: usize

filename: String

summary: String

content: String

The contents of the actual line

previous_commit: Option<String>

previous_filepath: Option<String>

boundary: bool

Set to true when blame output contains boundary.

author: String

author_mail: String

author_time: u64

author_tz: String

committer: String

committer_mail: String

committer_time: u64

committer_tz: String

Implementations

impl Blame

pub fn short_commit(&self) -> String

Returns the abbreviated (short-hand) version of the commit hash.

Examples found in repository

examples/demo.rs (line 42)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 {
        eprintln!("Error: missing args <FILE_PATH>");
        std::process::exit(1);
    }

    let filepath = std::path::PathBuf::from(args[1].clone());
    if !filepath.is_file() {
        eprintln!("Error: invalid file path");
        std::process::exit(1);
    }

    let output = std::process::Command::new("git")
        .args(["blame", "--line-porcelain"])
        .arg(filepath)
        .output()
        .unwrap();

    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr);
        eprintln!("Error: {err}");
        std::process::exit(1);
    }

    let raw_blame = String::from_utf8_lossy(&output.stdout);
    let blames = match git_blame_parser::parse(&raw_blame) {
        Ok(blames) => blames,
        Err(e) => {
            eprintln!("Error: {e}");
            std::process::exit(1);
        }
    };

    for blame in blames.iter() {
        println!(
            "* {}: {:0>4} by {} {}",
            blame.short_commit(),
            blame.original_line_no,
            blame.author,
            blame.author_mail
        );
        println!("summary: {}", blame.summary);
        println!("content: `{}`", blame.content);
        println!();
    }
}

Trait Implementations

impl Debug for Blame

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

Formats the value using the given formatter.

impl Default for Blame

fn default() -> Blame

Returns the “default value” for a type.