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
|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Text;
using LibGit2Sharp.Core;
using LibGit2Sharp.Core.Handles;
namespace LibGit2Sharp
{
/// <summary>
/// Holds the patch between two trees.
/// <para>The individual patches for each file can be accessed through the indexer of this class.</para>
/// <para>Building a patch is an expensive operation. If you only need to know which files have been added,
/// deleted, modified, ..., then consider using a simpler <see cref="TreeChanges"/>.</para>
/// </summary>
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public class Patch : IEnumerable<ContentChanges>
{
private readonly StringBuilder fullPatchBuilder = new StringBuilder();
private readonly IDictionary<FilePath, ContentChanges> changes = new Dictionary<FilePath, ContentChanges>();
private int linesAdded;
private int linesDeleted;
/// <summary>
/// Needed for mocking purposes.
/// </summary>
protected Patch()
{ }
internal Patch(DiffSafeHandle diff)
{
int count = Proxy.git_diff_num_deltas(diff);
for (int i = 0; i < count; i++)
{
using (var patch = Proxy.git_patch_from_diff(diff, i))
{
var delta = Proxy.git_diff_get_delta(diff, i);
AddFileChange(delta);
Proxy.git_patch_print(patch, PrintCallBack);
}
}
}
private void AddFileChange(GitDiffDelta delta)
{
var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;
var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
changes.Add(newFilePath, new ContentChanges(delta.IsBinary()));
}
private int PrintCallBack(GitDiffDelta delta, GitDiffHunk hunk, GitDiffLine line, IntPtr payload)
{
string patchPart = LaxUtf8Marshaler.FromNative(line.content, (int)line.contentLen);
// Deleted files mean no "new file" path
var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;
var filePath = LaxFilePathMarshaler.FromNative(pathPtr);
ContentChanges currentChange = this[filePath];
string prefix = string.Empty;
switch (line.lineOrigin)
{
case GitDiffLineOrigin.GIT_DIFF_LINE_CONTEXT:
prefix = " ";
break;
case GitDiffLineOrigin.GIT_DIFF_LINE_ADDITION:
linesAdded++;
currentChange.LinesAdded++;
prefix = "+";
break;
case GitDiffLineOrigin.GIT_DIFF_LINE_DELETION:
linesDeleted++;
currentChange.LinesDeleted++;
prefix = "-";
break;
}
string formattedOutput = string.Concat(prefix, patchPart);
fullPatchBuilder.Append(formattedOutput);
currentChange.AppendToPatch(formattedOutput);
return 0;
}
#region IEnumerable<ContentChanges> 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 virtual IEnumerator<ContentChanges> GetEnumerator()
{
return changes.Values.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>
/// Gets the <see cref="ContentChanges"/> corresponding to the specified <paramref name="path"/>.
/// </summary>
public virtual ContentChanges this[string path]
{
get { return this[(FilePath)path]; }
}
private ContentChanges this[FilePath path]
{
get
{
ContentChanges contentChanges;
if (changes.TryGetValue(path, out contentChanges))
{
return contentChanges;
}
return null;
}
}
/// <summary>
/// The total number of lines added in this diff.
/// </summary>
public virtual int LinesAdded
{
get { return linesAdded; }
}
/// <summary>
/// The total number of lines deleted in this diff.
/// </summary>
public virtual int LinesDeleted
{
get { return linesDeleted; }
}
/// <summary>
/// The full patch file of this diff.
/// </summary>
public virtual string Content
{
get { return fullPatchBuilder.ToString(); }
}
/// <summary>
/// Implicit operator for string conversion.
/// </summary>
/// <param name="patch"><see cref="Patch"/>.</param>
/// <returns>The patch content as string.</returns>
public static implicit operator string(Patch patch)
{
return patch.fullPatchBuilder.ToString();
}
private string DebuggerDisplay
{
get
{
return string.Format(CultureInfo.InvariantCulture,
"+{0} -{1}", linesAdded, linesDeleted);
}
}
}
}
|
