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
67
68
69
70
71
72
73
74
75
76
77
78

use std::vec::Vec;

use git2::Oid;
use git2::Repository;

use crate::calver::CalVer;
use crate::calver::ToCalVer;
use crate::repo::RepositoryExt;

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord)]
pub struct Release {
    pub version: CalVer,
    pub commit_id: Oid,
}

impl Release {
    pub fn zero() -> Release {
        Release {
            commit_id: Oid::zero(),
            version: CalVer::zero(),
        }
    }
}

pub trait RepositoryWithRelease {
    fn find_releases(&self) -> Vec<Release>;
    fn find_latest_release(&self) -> Option<Release>;
}

impl RepositoryWithRelease for Repository {
    fn find_releases(&self) -> Vec<Release> {
        let tag_names = self
            .tag_names(None)
            .ok()
            .map(|a| {
                a.iter()
                    .flatten()
                    .map(|s| s.to_string())
                    .collect::<Vec<_>>()
            })
            .unwrap_or_else(|| vec![]);
        let all_releases = tag_names
            .iter()
            .flat_map(|t| t.calver())
            .flat_map(|v| {
                self.resolve_reference_from_short_name(v.to_string().as_str())
                    .ok()
                    .map(|r| r.peel_to_commit().ok())
                    .flatten()
                    .map(|c| Release {
                        commit_id: c.id(),
                        version: v,
                    })
            })
            .collect::<Vec<_>>();
        if let Some(head) = self.head().ok().map(|r| r.peel_to_commit().ok()).flatten() {
            let mut releases = self
                .iter_commit_id(&head)
                .flat_map(|cid| {
                    all_releases
                        .iter()
                        .filter(|r| cid == r.commit_id)
                        .map(|&r| r)
                        .next()
                })
                .collect::<Vec<_>>();
            releases.sort();
            releases.reverse();
            releases
        } else {
            vec![]
        }
    }

    fn find_latest_release(&self) -> Option<Release> {
        self.find_releases().into_iter().next()
    }
}