codealong 0.1.1

Git analytics
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use git2::{Commit, DiffLine, Repository, Signature};

use crate::error::Error;
use crate::git_blame::GitBlame;
use crate::work_stats::WorkStats;

pub struct LineAnalyzer<'a> {
    repo: &'a Repository,
    commit: &'a Commit<'a>,
    diff_line: &'a DiffLine<'a>,
    blame: Option<&'a GitBlame>,
}

impl<'a> LineAnalyzer<'a> {
    pub fn new(
        repo: &'a Repository,
        commit: &'a Commit,
        diff_line: &'a DiffLine<'a>,
        blame: Option<&'a GitBlame>,
    ) -> LineAnalyzer<'a> {
        LineAnalyzer {
            repo,
            commit,
            diff_line,
            blame,
        }
    }

    pub fn analyze(&self) -> Result<WorkStats, Error> {
        match self.diff_line.origin() {
            '+' => Ok(WorkStats::new_work()),
            ' ' => self.analyze_change(),
            _ => Ok(WorkStats::other()),
        }
    }

    fn analyze_change(&self) -> Result<WorkStats, Error> {
        let blame = self.blame.expect("No blame found for change");
        if let Some(previous_commit_oid) =
            blame.get_line(self.diff_line.old_lineno().unwrap() as usize)?
        {
            let previous_commit = self.repo.find_commit(previous_commit_oid).unwrap();

            let diff_in_seconds = self.commit.committer().when().seconds()
                - previous_commit.committer().when().seconds();
            if diff_in_seconds < 60 * 60 * 24 * 7 * 3 {
                if self.compare_signatures(&previous_commit.author(), &self.commit.author()) {
                    return Ok(WorkStats::churn());
                } else {
                    return Ok(WorkStats::help_others());
                }
            }
        }
        return Ok(WorkStats::legacy_refactor());
    }

    // TODO: incorporate author config
    fn compare_signatures(&self, a: &Signature, b: &Signature) -> bool {
        if let Some(email_a) = a.email() {
            if let Some(email_b) = b.email() {
                return email_a == email_b;
            }
        }
        return false;
    }
}