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
|
import { Tree as NodeGitTree } from "nodegit";
import { Repository } from "./repository";
import { BaseTreeEntry, BlobTreeEntry, createTreeEntry, TreeEntry } from "./tree_entry";
import { createError, ErrorWhere, FailedError, NotFoundError } from "./error";
import { pack, Pack } from "tar-stream";
import { Commit } from "./commit";
/**
* A representation of a git tree
*/
export class Tree {
protected _owner: Repository;
protected _ng_tree: NodeGitTree;
public path: string;
/**
* @param owner The repository which the tree is in
* @param tree An instance of a Nodegit tree
*/
constructor(owner: Repository, tree: NodeGitTree) {
this._owner = owner;
this._ng_tree = tree;
this.path = tree.path();
}
/**
* The tree's entries
*
* @returns An array of tree entry instances
*/
public entries(): BaseTreeEntry[] {
return this._ng_tree.entries().map(entry => createTreeEntry(this._owner, entry));
}
/**
* Returns the entry of a path
*
* @param path - The path of a blob or tree
* @returns An instance of an tree entry
*/
public async find(path: string): Promise<BaseTreeEntry> {
const entry = await this._ng_tree.getEntry(path).catch(err => {
if(err.errno === -3) {
throw(createError(ErrorWhere.Tree, NotFoundError, `Path '${path}'`));
}
throw(createError(ErrorWhere.Tree, FailedError, "get tree path"));
});
return createTreeEntry(this._owner, entry);
}
/**
* Returns if a path exists or not
*
* @param path - The path to look for
* @returns Whether or not there exists an entry for the path
*/
public findExists(path: string): Promise<boolean> {
return this._ng_tree.getEntry(path)
.then(() => true)
.catch(() => false);
}
/**
* Returns an archive made from the tree
*
* @returns An instance of a tar pack
*/
async createArchive(): Promise<Pack> {
const archive = pack();
const repository = this._owner.name.short;
async function addEntries(tree: Tree) {
for(const tree_entry of tree.entries()) {
if(tree_entry instanceof BlobTreeEntry) {
archive.entry({ name: `${repository}/${tree_entry.path}` }, (await (await tree_entry.blob()).content()));
}
else if(tree_entry instanceof TreeEntry) {
await addEntries(await tree_entry.tree());
}
}
}
await addEntries(this);
archive.finalize();
return archive;
}
/**
* Returns the tree of a repository
*
* @param owner The repository which the tree is in
* @returns An instance of a tree
*/
public static async ofRepository(owner: Repository): Promise<Tree> {
const commit = await Commit.branchCommit(owner);
return commit.tree();
}
}
|
