git_rs 0.1.0

A (work in progress) pure rust git implementation.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::collections::HashSet;
use std::io::Cursor;
use std::io::Write;

use crate::walk::commits::CommitIterator;
use crate::walk::tree::TreeIterator;
use crate::objects::{Type, Object};
use crate::errors::Result;
use crate::id::Id;

pub mod loose;
pub mod pack;
pub mod fs;

pub trait Queryable {
    fn get<W: Write, S: Queryable>(&self, id: &Id, output: &mut W, backends: &StorageSet<S>) -> Result<Option<Type>>;
}

impl Queryable for () {
    fn get<W: Write, S: Queryable>(&self, id: &Id, _output: &mut W, _backends: &StorageSet<S>) -> Result<Option<Type>> {
        Ok(None)
    }
}

impl<Q: Queryable> Queryable for (Q,) {
    fn get<W: Write, S: Queryable>(&self, id: &Id, output: &mut W, backends: &StorageSet<S>) -> Result<Option<Type>> {
        self.0.get(id, output, backends)
    }
}

impl<H: Queryable, T: Queryable> Queryable for (H, T) {
    fn get<W: Write, S: Queryable>(&self, id: &Id, output: &mut W, backends: &StorageSet<S>) -> Result<Option<Type>> {
        let opt = self.0.get(id, output, backends)?;
        if opt.is_some() {
            return Ok(opt)
        }

        self.1.get(id, output, backends)
    }
}

impl<Q: Queryable> Queryable for Vec<Q> {
    fn get<W: Write, S: Queryable>(&self, id: &Id, output: &mut W, backends: &StorageSet<S>) -> Result<Option<Type>> {
        for queryable in self {
            let opt = queryable.get(id, output, backends)?;
            if opt.is_some() {
                return Ok(opt)
            }
        }

        Ok(None)
    }
}

pub struct StorageSet<Q: Queryable> {
    backend: Q
}

impl<Q: Queryable> StorageSet<Q> {
    pub fn new(backend: Q) -> StorageSet<Q> {
        StorageSet {
            backend
        }
    }

    pub fn get<W: Write>(&self, id: &Id, output: &mut W) -> Result<Option<Type>> {
        self.backend.get(id, output, &self)
    }

    pub fn commits(&self, id: &Id, seen: Option<HashSet<Id>>) -> CommitIterator<Q> {
        CommitIterator::new(&self, id, seen)
    }

    pub fn tree(&self, id: &Id) -> TreeIterator<Q> {
        let result = match self.get_and_load(id) {
            Ok(xs) => xs,
            Err(_) => return TreeIterator::new(&self, vec![])
        };

        if result.is_none() {
            return TreeIterator::new(&self, vec![])
        }

        match result.unwrap() {
            Object::Commit(commit) => {
                match commit.tree() {
                    Some(tree) => self.tree(&tree),
                    None => TreeIterator::new(&self, vec![])
                }
            },
            Object::Tree(tree) => {
                TreeIterator::new(&self, vec![tree.into_iter()])
            },
            _ => {
                TreeIterator::new(&self, vec![])
            }
        }
    }

    pub fn get_and_load(&self, id: &Id) -> Result<Option<Object>> {
        let mut data = Vec::new();
        match self.get(id, &mut data)? {
            Some(typ) => Ok(Some(typ.load(&mut Cursor::new(&data))?)),
            None => Ok(None)
        }
    }
}