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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using LibGit2Sharp.Core;
namespace LibGit2Sharp
{
/// <summary>
/// The Collection of references in a <see cref = "Repository" />
/// </summary>
public class ReferenceCollection : IEnumerable<Reference>
{
private readonly Repository repo;
/// <summary>
/// Initializes a new instance of the <see cref = "ReferenceCollection" /> class.
/// </summary>
/// <param name = "repo">The repo.</param>
internal ReferenceCollection(Repository repo)
{
this.repo = repo;
}
/// <summary>
/// Gets the <see cref = "LibGit2Sharp.Reference" /> with the specified name.
/// </summary>
/// <param name = "name">The canonical name of the reference to resolve.</param>
/// <returns>The resolved <see cref = "LibGit2Sharp.Reference" /> if it has been found, null otherwise.</returns>
public Reference this[string name]
{
get { return Resolve<Reference>(name); }
}
#region IEnumerable<Reference> Members
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>An <see cref="IEnumerator{T}"/> object that can be used to iterate through the collection.</returns>
public IEnumerator<Reference> GetEnumerator()
{
return Libgit2UnsafeHelper
.ListAllReferenceNames(repo.Handle, GitReferenceType.ListAll)
.Select(n => this[n])
.GetEnumerator();
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>An <see cref="IEnumerator"/> object that can be used to iterate through the collection.</returns>
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
/// <summary>
/// Creates a direct or symbolic reference with the specified name and target
/// </summary>
/// <param name = "name">The name of the reference to create.</param>
/// <param name = "target">The target which can be either a sha or the canonical name of another reference.</param>
/// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
/// <returns>A new <see cref = "Reference" />.</returns>
public Reference Create(string name, string target, bool allowOverwrite = false)
{
Ensure.ArgumentNotNullOrEmptyString(name, "name");
Ensure.ArgumentNotNullOrEmptyString(target, "target");
ObjectId id;
IntPtr reference;
int res;
if (ObjectId.TryParse(target, out id))
{
res = CreateDirectReference(name, id, allowOverwrite, out reference);
}
else
{
res = CreateSymbolicReference(name, target, allowOverwrite, out reference);
}
Ensure.Success(res);
return Reference.BuildFromPtr<Reference>(reference, repo);
}
private int CreateSymbolicReference(string name, string target, bool allowOverwrite, out IntPtr reference)
{
if (allowOverwrite)
{
return NativeMethods.git_reference_create_symbolic_f(out reference, repo.Handle, name, target);
}
return NativeMethods.git_reference_create_symbolic(out reference, repo.Handle, name, target);
}
private int CreateDirectReference(string name, ObjectId targetOid, bool allowOverwrite, out IntPtr reference)
{
if (targetOid is AbbreviatedObjectId) //TODO: This is hacky... :-/
{
var obj = repo.Lookup(targetOid);
if (obj == null)
{
Ensure.Success((int) GitErrorCode.GIT_ENOTFOUND);
}
targetOid = obj.Id;
}
GitOid oid = targetOid.Oid;
if (allowOverwrite)
{
return NativeMethods.git_reference_create_oid_f(out reference, repo.Handle, name, ref oid);
}
return NativeMethods.git_reference_create_oid(out reference, repo.Handle, name, ref oid);
}
/// <summary>
/// Delete a reference with the specified name
/// </summary>
/// <param name="name">The name of the reference to delete.</param>
public void Delete(string name)
{
Ensure.ArgumentNotNullOrEmptyString(name, "name");
IntPtr reference = RetrieveReferencePtr(name);
int res = NativeMethods.git_reference_delete(reference);
Ensure.Success(res);
}
/// <summary>
/// Rename an existing reference with a new name
/// </summary>
/// <param name="currentName">The canonical name of the reference to rename.</param>
/// <param name="newName">The new canonical name.</param>
/// <param name="allowOverwrite">True to allow silent overwriting a potentially existing reference, false otherwise.</param>
/// <returns></returns>
public Reference Move(string currentName, string newName, bool allowOverwrite = false)
{
Ensure.ArgumentNotNullOrEmptyString(currentName, "currentName");
Ensure.ArgumentNotNullOrEmptyString(newName, "newName");
IntPtr referencePtr = RetrieveReferencePtr(currentName);
int res;
if (allowOverwrite)
{
res = NativeMethods.git_reference_rename_f(referencePtr, newName);
}
else
{
res = NativeMethods.git_reference_rename(referencePtr, newName);
}
Ensure.Success(res);
return Reference.BuildFromPtr<Reference>(referencePtr, repo);
}
internal T Resolve<T>(string name) where T : class
{
Ensure.ArgumentNotNullOrEmptyString(name, "name");
IntPtr reference = RetrieveReferencePtr(name, false);
return Reference.BuildFromPtr<T>(reference, repo);
}
/// <summary>
/// Updates the target on a reference.
/// </summary>
/// <param name = "name">The name of the reference.</param>
/// <param name = "target">The target which can be either a sha or the name of another reference.</param>
public Reference UpdateTarget(string name, string target)
{
Ensure.ArgumentNotNullOrEmptyString(name, "name");
Ensure.ArgumentNotNullOrEmptyString(target, "target");
IntPtr reference = RetrieveReferencePtr(name);
int res;
ObjectId id;
bool isObjectIdentifier = ObjectId.TryParse(target, out id);
var type = NativeMethods.git_reference_type(reference);
switch (type)
{
case GitReferenceType.Oid:
if (!isObjectIdentifier) throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, "The reference specified by {0} is an Oid reference, you must provide a sha as the target.", name), "target");
var oid = id.Oid;
res = NativeMethods.git_reference_set_oid(reference, ref oid);
break;
case GitReferenceType.Symbolic:
if (isObjectIdentifier) throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, "The reference specified by {0} is an Symbolic reference, you must provide a symbol as the target.", name), "target");
res = NativeMethods.git_reference_set_target(reference, target);
break;
default:
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Reference '{0}' has an un unexpected type ('{1}').", name, Enum.GetName(typeof(GitReferenceType), type)));
}
Ensure.Success(res);
return Reference.BuildFromPtr<Reference>(reference, repo);
}
private IntPtr RetrieveReferencePtr(string referenceName, bool shouldThrow = true)
{
IntPtr reference;
var res = NativeMethods.git_reference_lookup(out reference, repo.Handle, referenceName);
if (!shouldThrow && res == (int)GitErrorCode.GIT_ENOTFOUND)
{
return IntPtr.Zero;
}
Ensure.Success(res);
return reference;
}
}
}
|
