private static TreeComparisonHandleRetriever WorkdirAndIndexToTree(Repository repo)
{
TreeComparisonHandleRetriever comparisonHandleRetriever = (h, o) =>
{
DiffListSafeHandle diff = null, diff2 = null;
try
{
diff = Proxy.git_diff_tree_to_index(repo.Handle, repo.Index.Handle, h, o);
diff2 = Proxy.git_diff_index_to_workdir(repo.Handle, repo.Index.Handle, o);
Proxy.git_diff_merge(diff, diff2);
}
catch
{
diff.SafeDispose();
throw;
}
finally
{
diff2.SafeDispose();
}
return(diff);
};
return(comparisonHandleRetriever);
}
/// <summary>
/// Show changes between two <see cref = "Tree"/>s.
/// </summary>
/// <param name = "oldTree">The <see cref = "Tree"/> you want to compare from.</param>
/// <param name = "newTree">The <see cref = "Tree"/> you want to compare to.</param>
/// <returns>A <see cref = "TreeChanges"/> containing the changes between the <paramref name = "oldTree"/> and the <paramref name = "newTree"/>.</returns>
public TreeChanges Compare(Tree oldTree, Tree newTree)
{
using (DiffListSafeHandle diff = BuildDiffListFromTrees(oldTree.Id, newTree.Id))
{
return(new TreeChanges(diff));
}
}
internal TreeChanges(DiffListSafeHandle diff, bool skipPatchBuilding = false)
{
Proxy.git_diff_foreach(diff, FileCallback, null, DataCallback);
if (!skipPatchBuilding)
{
Proxy.git_diff_print_patch(diff, PrintCallBack);
}
}
/// <summary>
/// Show changes between a <see cref = "Tree"/> and a selectable target.
/// </summary>
/// <param name = "oldTree">The <see cref = "Tree"/> to compare from.</param>
/// <param name = "diffTarget">The target to compare to.</param>
/// <returns>A <see cref = "TreeChanges"/> containing the changes between the <see cref="Tree"/> and the selected target.</returns>
public TreeChanges Compare(Tree oldTree, DiffTarget diffTarget)
{
var comparer = handleRetrieverDispatcher[diffTarget](repo);
using (DiffListSafeHandle dl = BuildDiffListFromTreeAndComparer(repo, oldTree.Id, comparer))
{
return(new TreeChanges(dl));
}
}
/// <summary>
/// Show changes between the working directory and the index.
/// </summary>
/// <param name = "paths">The list of paths (either files or directories) that should be compared.</param>
/// <param name = "includeUntracked">If true, include untracked files from the working dir as additions. Otherwise ignore them.</param>
/// <returns>A <see cref = "TreeChanges"/> containing the changes between the working directory and the index.</returns>
public virtual TreeChanges Compare(IEnumerable <string> paths = null, bool includeUntracked = false)
{
var comparer = WorkdirToIndex(repo);
using (GitDiffOptions options = BuildOptions(includeUntracked ? DiffOptions.IncludeUntracked : DiffOptions.None, paths))
using (DiffListSafeHandle dl = BuildDiffListFromComparer(null, comparer, options))
{
return(new TreeChanges(dl));
}
}
/// <summary>
/// Show changes between two <see cref = "Tree"/>s.
/// </summary>
/// <param name = "oldTree">The <see cref = "Tree"/> you want to compare from.</param>
/// <param name = "newTree">The <see cref = "Tree"/> you want to compare to.</param>
/// <param name = "paths">The list of paths (either files or directories) that should be compared.</param>
/// <returns>A <see cref = "TreeChanges"/> containing the changes between the <paramref name = "oldTree"/> and the <paramref name = "newTree"/>.</returns>
public virtual TreeChanges Compare(Tree oldTree, Tree newTree, IEnumerable <string> paths = null)
{
using (GitDiffOptions options = BuildOptions(DiffOptions.None, paths))
using (DiffListSafeHandle diff = BuildDiffListFromTrees(
oldTree != null ? oldTree.Id : null,
newTree != null ? newTree.Id : null,
options))
{
return(new TreeChanges(diff));
}
}
/// <summary>
/// Show changes between a <see cref = "Tree"/> and the Index, the Working Directory, or both.
/// </summary>
/// <param name = "oldTree">The <see cref = "Tree"/> to compare from.</param>
/// <param name = "diffTargets">The targets to compare to.</param>
/// <param name = "paths">The list of paths (either files or directories) that should be compared.</param>
/// <returns>A <see cref = "TreeChanges"/> containing the changes between the <see cref="Tree"/> and the selected target.</returns>
public virtual TreeChanges Compare(Tree oldTree, DiffTargets diffTargets, IEnumerable <string> paths = null)
{
var comparer = handleRetrieverDispatcher[diffTargets](repo);
DiffOptions diffOptions = diffTargets.HasFlag(DiffTargets.WorkingDirectory) ?
DiffOptions.IncludeUntracked : DiffOptions.None;
using (GitDiffOptions options = BuildOptions(diffOptions, paths))
using (DiffListSafeHandle dl = BuildDiffListFromTreeAndComparer(
oldTree != null ? oldTree.Id : null,
comparer, options))
{
return(new TreeChanges(dl));
}
}
private TreeChanges BuildTreeChangesFromComparer(
ObjectId oldTreeId, ObjectId newTreeId, TreeComparisonHandleRetriever comparisonHandleRetriever,
DiffOptions diffOptions, IEnumerable <string> paths = null, ExplicitPathsOptions explicitPathsOptions = null, CompareOptions compareOptions = null)
{
var matchedPaths = new MatchedPathsAggregator();
var filePaths = ToFilePaths(repo, paths);
using (GitDiffOptions options = BuildOptions(diffOptions, filePaths, matchedPaths, compareOptions))
using (DiffListSafeHandle diffList = comparisonHandleRetriever(oldTreeId, newTreeId, options))
{
if (explicitPathsOptions != null)
{
DispatchUnmatchedPaths(explicitPathsOptions, filePaths, matchedPaths);
}
return(new TreeChanges(diffList));
}
}
public static extern int git_diff_print_patch(
DiffListSafeHandle diff,
IntPtr data,
git_diff_data_fn printCallback);
public static extern int git_diff_foreach(
DiffListSafeHandle diff,
IntPtr callbackData,
git_diff_file_fn fileCallback,
git_diff_hunk_fn hunkCallback,
git_diff_data_fn lineCallback);
public static extern int git_diff_workdir_to_tree(
RepositorySafeHandle repo,
GitDiffOptions options,
GitObjectSafeHandle oldTree,
out DiffListSafeHandle diff);
public static extern int git_diff_workdir_to_index(
RepositorySafeHandle repo,
GitDiffOptions options,
out DiffListSafeHandle diff);
public static extern int git_diff_merge(
DiffListSafeHandle onto,
DiffListSafeHandle from);
internal TreeChanges(DiffListSafeHandle diff)
{
Proxy.git_diff_foreach(diff, FileCallback, null, DataCallback);
Proxy.git_diff_print_patch(diff, PrintCallBack);
}
internal static extern int git_diff_tree_to_index(
out DiffListSafeHandle diff,
RepositorySafeHandle repo,
GitObjectSafeHandle oldTree,
IndexSafeHandle index,
GitDiffOptions options);
internal static extern int git_diff_index_to_workdir(
out DiffListSafeHandle diff,
RepositorySafeHandle repo,
IndexSafeHandle index,
GitDiffOptions options);
internal static extern int git_diff_print_patch(
DiffListSafeHandle diff,
git_diff_data_cb printCallback,
IntPtr payload);
internal static extern int git_diff_tree_to_workdir(
out DiffListSafeHandle diff,
RepositorySafeHandle repo,
GitObjectSafeHandle oldTree,
GitDiffOptions options);
internal TreeChanges(DiffListSafeHandle diff)
{
Proxy.git_diff_print_patch(diff, PrintCallBack);
}
internal TreeChanges(DiffListSafeHandle diff)
{
Ensure.Success(NativeMethods.git_diff_print_patch(diff, IntPtr.Zero, PrintCallBack));
}
