public static string SubmoduleSyncCmd(string name)
{
var args = new ArgumentBuilder
{
"submodule sync",
name?.Trim().QuoteNE()
};
return(args.ToString());
}
private static string GetBisectCommand(GitBisectOption bisectOption)
{
var args = new ArgumentBuilder
{
"bisect",
bisectOption
};
return(args.ToString());
}
public static string BranchCmd(string branchName, string revision, bool checkout)
{
var args = new ArgumentBuilder
{
{ checkout, "checkout -b", "branch" },
branchName.Trim().Quote(),
revision?.Trim().QuoteNE()
};
return(args.ToString());
}
public static string ContinueBisectCmd(GitBisectOption bisectOption, params string[] revisions)
{
var args = new ArgumentBuilder
{
"bisect",
bisectOption,
revisions
};
return(args.ToString());
}
public static string ApplyDiffPatchCmd(bool ignoreWhiteSpace, [NotNull] string patchFile)
{
var args = new ArgumentBuilder
{
"apply",
{ ignoreWhiteSpace, "--ignore-whitespace" },
patchFile.ToPosixPath().Quote()
};
return(args.ToString());
}
/// <summary>
/// Split arguments exceeding max length into multiple batches.
/// Windows by default limit arguments length less than 32767 <see cref="short.MaxValue"/>.
/// Implementation by <see cref="System.Diagnostics.Process"/> will have file path included in command line arguments,
/// as well as added quotation and space characters, so we need base length to account for all these added characters
/// <see href="https://referencesource.microsoft.com/#system/services/monitoring/system/diagnosticts/Process.cs,1944"/>
/// </summary>
/// <param name="builder">Argument builder instance.</param>
/// <param name="arguments">Arguments.</param>
/// <param name="baseLength">Base executable file and command line length.</param>
/// <param name="maxLength">Command line max length. Default is 32767 - 1 on Windows.</param>
/// <returns>Array of batch arguments split by max length.</returns>
public static ArgumentString[] BuildBatchArguments(this ArgumentBuilder builder, IEnumerable <string> arguments, int baseLength, int maxLength = short.MaxValue)
{
var baseArgument = builder.ToString();
if (baseLength + baseArgument.Length >= maxLength)
{
throw new ArgumentException($"Git base command \"{baseArgument}\" always reached max length of {maxLength} characters.", nameof(baseArgument));
}
// Clone command as argument builder
var batches = new List <ArgumentString>();
var currentArgumentLength = baseArgument.Length;
var lastBatchBuilder = arguments.Aggregate(builder, (currentBatchBuilder, argument) =>
{
// 1: ' ' space character length will be added
// When enumeration is finished, no need to add ' ' to length calculcation
if (baseLength + currentArgumentLength + 1 + argument.Length >= maxLength)
{
// Handle abnormal case when base command and a single argument exceed max length
if (currentArgumentLength == baseArgument.Length)
{
throw new ArgumentException($"Git command \"{currentBatchBuilder}\" always exceeded max length of {maxLength} characters.", nameof(arguments));
}
// Finish current command line
batches.Add(currentBatchBuilder);
// Return new argument builder
currentArgumentLength = baseArgument.Length + 1 + argument.Length;
return(new ArgumentBuilder()
{
baseArgument, argument
});
}
currentBatchBuilder.Add(argument);
currentArgumentLength += argument.Length + 1;
return(currentBatchBuilder);
});
// Handle rare case when last argument length exceed max length
if (baseLength + currentArgumentLength >= maxLength)
{
throw new ArgumentException($"Git command \"{lastBatchBuilder}\" always exceeded max length of {maxLength} characters.", nameof(arguments));
}
// Add last commandline batch
if (!lastBatchBuilder.IsEmpty)
{
batches.Add(lastBatchBuilder.ToString());
}
return(batches.ToArray());
}
public static string RevertCmd(string commit, bool autoCommit, int parentIndex)
{
var args = new ArgumentBuilder
{
"revert",
{ !autoCommit, "--no-commit" },
{ parentIndex > 0, $"-m {parentIndex}" },
commit
};
return(args.ToString());
}
public static string CherryPickCmd(string cherry, bool commit, string arguments)
{
var args = new ArgumentBuilder
{
"cherry-pick",
{ !commit, "--no-commit" },
arguments,
cherry.Quote()
};
return(args.ToString());
}
public static string CherryPickCmd(ObjectId commitId, bool commit, string arguments)
{
var args = new ArgumentBuilder
{
"cherry-pick",
{ !commit, "--no-commit" },
arguments,
commitId
};
return(args.ToString());
}
public static string GetAllChangedFilesCmd(bool excludeIgnoredFiles, UntrackedFilesMode untrackedFiles, IgnoreSubmodulesMode ignoreSubmodules = IgnoreSubmodulesMode.None)
{
var args = new ArgumentBuilder
{
"status --porcelain -z",
untrackedFiles,
ignoreSubmodules,
{ !excludeIgnoredFiles, "--ignored" }
};
return(args.ToString());
}
public static string CheckoutCmd(string branchOrRevisionName, LocalChangesAction changesAction)
{
var args = new ArgumentBuilder
{
"checkout",
{ changesAction == LocalChangesAction.Merge, "--merge" },
{ changesAction == LocalChangesAction.Reset, "--force" },
branchOrRevisionName.Quote()
};
return(args.ToString());
}
/// <summary>Creates the 'push' command string. <example>"push --progress origin master:master"</example></summary>
public override string ToString()
{
var args = new ArgumentBuilder
{
"push",
{ ReportProgress, "--progress" },
Remote.Quote(),
PushActions.Select(action => action.ToString())
};
return(args.ToString());
}
public static string GetAllChangedFilesCmd(bool excludeIgnoredFiles, UntrackedFilesMode untrackedFiles, IgnoreSubmodulesMode ignoreSubmodules = IgnoreSubmodulesMode.None, bool noLocks = false)
{
var args = new ArgumentBuilder
{
{ noLocks&& VersionInUse.SupportNoOptionalLocks, "--no-optional-locks" },
$"status --porcelain={(VersionInUse.SupportStatusPorcelainV2 ? 2 : 1)} -z",
untrackedFiles,
ignoreSubmodules,
{ !excludeIgnoredFiles, "--ignored" }
};
return(args.ToString());
}
public static string AddSubmoduleCmd(string remotePath, string localPath, string branch, bool force)
{
var args = new ArgumentBuilder
{
"submodule add",
{ force, "-f" },
{ !string.IsNullOrEmpty(branch), $"-b \"{branch?.Trim()}\"" },
remotePath.ToPosixPath().Quote(),
localPath.ToPosixPath().Quote()
};
return(args.ToString());
}
public static string ApplyMailboxPatchCmd(bool ignoreWhiteSpace, string patchFile = null)
{
var args = new ArgumentBuilder
{
"am",
"--3way",
"--signoff",
{ ignoreWhiteSpace, "--ignore-whitespace" },
patchFile?.ToPosixPath().Quote()
};
return(args.ToString());
}
/// <summary>Remove files from the working tree and from the index. <remarks>git rm</remarks></summary>
/// <param name="force">Override the up-to-date check.</param>
/// <param name="isRecursive">Allow recursive removal when a leading directory name is given.</param>
/// <param name="files">Files to remove. Fileglobs can be given to remove matching files.</param>
public static string RemoveCmd(bool force = true, bool isRecursive = true, params string[] files)
{
var args = new ArgumentBuilder
{
"rm",
{ force, "--force" },
{ isRecursive, "-r" },
{ files.Length == 0, "." },
files
};
return(args.ToString());
}
public static string CleanUpCmd(bool dryrun, bool directories, bool nonignored, bool ignored, string paths = null)
{
var args = new ArgumentBuilder
{
"clean",
{ directories, "-d" },
{ !nonignored && !ignored, "-x" },
{ ignored, "-X" },
{ dryrun, "--dry-run" },
{ !dryrun, "-f" },
paths
};
return(args.ToString());
}
public static string StashSaveCmd(bool untracked, bool keepIndex, string message, IReadOnlyList <string> selectedFiles)
{
var isPartialStash = selectedFiles != null && selectedFiles.Any();
var args = new ArgumentBuilder
{
"stash",
{ isPartialStash, "push", "save" },
{ untracked&& VersionInUse.StashUntrackedFilesSupported, "-u" },
{ keepIndex, "--keep-index" },
message.QuoteNE(),
{ isPartialStash, "--" },
{ isPartialStash, selectedFiles }
};
return(args.ToString());
}
public static string MergeBranchCmd(string branch, bool allowFastForward, bool squash, bool noCommit, string strategy, bool allowUnrelatedHistories, string message, int?log)
{
// TODO Quote should escape any " characters, at least for usages like the below
var args = new ArgumentBuilder
{
"merge",
{ !allowFastForward, "--no-ff" },
{ !string.IsNullOrEmpty(strategy), $"--strategy={strategy}" },
{ squash, "--squash" },
{ noCommit, "--no-commit" },
{ allowUnrelatedHistories, "--allow-unrelated-histories" },
{ !string.IsNullOrEmpty(message), $"-m {message.Quote()}" },
{ log != null, $"--log={log}" },
branch
};
return(args.ToString());
}
public static string PushTagCmd(string path, string tag, bool all, ForcePushOptions force = ForcePushOptions.DoNotForce)
{
if (!all && string.IsNullOrWhiteSpace(tag))
{
// TODO this is probably an error
return("");
}
var args = new ArgumentBuilder
{
"push",
force,
{ VersionInUse.PushCanAskForProgress, "--progress" },
path.ToPosixPath().Trim().Quote(),
{ all, "--tags" },
{ !all, $"tag {tag.Replace(" ", "")}" }
};
return(args.ToString());
}
public static string RebaseCmd(string branch, bool interactive, bool preserveMerges, bool autosquash, bool autostash, string from = null, string onto = null)
{
if (from == null ^ onto == null)
{
throw new ArgumentException($"For arguments \"{nameof(from)}\" and \"{nameof(onto)}\", either both must have values, or neither may.");
}
var args = new ArgumentBuilder
{
"rebase",
{ interactive, "-i" },
{ interactive&& autosquash, "--autosquash" },
{ interactive&& !autosquash, "--no-autosquash" },
{ preserveMerges, "--preserve-merges" },
{ autostash, "--autostash" },
from.QuoteNE(),
branch.Quote(),
{ onto != null, $"--onto {onto}" }
};
return(args.ToString());
}
/// <summary>
/// Git Clone.
/// </summary>
/// <param name="central">Makes a bare repo.</param>
/// <param name="branch">
/// <para><c>NULL</c>: do not checkout working copy (--no-checkout).</para>
/// <para><c>""</c> (empty string): checkout remote HEAD (branch param omitted, default behavior for clone).</para>
/// <para>(a non-empty string): checkout the given branch (--branch smth).</para>
/// </param>
/// <param name="depth">An int value for --depth param, or <c>NULL</c> to omit the param.</param>
/// <param name="isSingleBranch">
/// <para><c>True</c>: --single-branch.</para>
/// <para><c>False</c>: --no-single-branch.</para>
/// <para><c>NULL</c>: don't pass any such param to git.</para>
/// </param>
/// <param name="lfs">True to use the <c>git lfs clone</c> command instead of <c>git clone</c>.</param>
public static string CloneCmd(string fromPath, string toPath, bool central = false, bool initSubmodules = false, [CanBeNull] string branch = "", int?depth = null, bool?isSingleBranch = null, bool lfs = false)
{
var from = PathUtil.IsLocalFile(fromPath) ? fromPath.ToPosixPath() : fromPath;
var args = new ArgumentBuilder
{
{ lfs, "lfs" },
"clone",
"-v",
{ central, "--bare" },
{ initSubmodules, "--recurse-submodules" },
{ depth != null, $"--depth {depth}" },
{ isSingleBranch == true, "--single-branch" },
{ isSingleBranch == false, "--no-single-branch" },
"--progress",
{ branch == null, "--no-checkout" },
{ !string.IsNullOrEmpty(branch), $"--branch {branch}" },
from.Trim().Quote(),
toPath.ToPosixPath().Trim().Quote()
};
return(args.ToString());
}
/// <summary>
/// Split arguments exceeding max length into multiple batches.
/// Windows by default limit arguments length less than 32767 <see cref="short.MaxValue"/>.
/// Implementation by <see cref="System.Diagnostics.Process"/> will have file path included in command line arguments,
/// as well as added quotation and space characters, so we need base length to account for all these added characters
/// <see href="https://referencesource.microsoft.com/#system/services/monitoring/system/diagnosticts/Process.cs,1944"/>
/// </summary>
/// <param name="builder">Argument builder instance.</param>
/// <param name="arguments">Arguments.</param>
/// <param name="baseLength">Base executable file and command line length.</param>
/// <param name="maxLength">Command line max length. Default is 32767 - 1 on Windows.</param>
/// <returns>Array of batch arguments split by max length.</returns>
public static List <BatchArgumentItem> BuildBatchArguments(this ArgumentBuilder builder, IEnumerable <string> arguments, int?baseLength = null, int maxLength = short.MaxValue)
{
// 3: double quotes + ' '
// '"git.exe" ' is always included in final command line arguments
if (!baseLength.HasValue)
{
baseLength = AppSettings.GitCommand.Length + 3;
}
var baseArgument = builder.ToString();
if (baseLength + baseArgument.Length >= maxLength)
{
throw new ArgumentException($"Git base command \"{baseArgument}\" always reached max length of {maxLength} characters.", nameof(baseArgument));
}
// Clone command as argument builder
var batches = new List <BatchArgumentItem>();
var currentBatchItemCount = 0;
var currentArgumentLength = baseArgument.Length;
var lastBatchBuilder = arguments.Aggregate(builder, (currentBatchBuilder, argument) =>
{
// 1: ' ' space character length will be added
// When enumeration is finished, no need to add ' ' to length calculcation
if (baseLength + currentArgumentLength + 1 + argument.Length >= maxLength)
{
// Handle abnormal case when base command and a single argument exceed max length
if (currentBatchItemCount == 0)
{
throw new ArgumentException($"Git command \"{currentBatchBuilder}\" always exceeded max length of {maxLength} characters.", nameof(arguments));
}
// Finish current command line
batches.Add(new BatchArgumentItem(currentBatchBuilder, currentBatchItemCount));
// Return new argument builder
currentBatchItemCount = 1;
currentArgumentLength = baseArgument.Length + 1 + argument.Length;
return(new ArgumentBuilder()
{
baseArgument, argument
});
}
currentBatchBuilder.Add(argument);
currentArgumentLength += argument.Length + 1;
currentBatchItemCount++;
return(currentBatchBuilder);
});
// Handle rare case when last argument length exceed max length
if (baseLength + currentArgumentLength >= maxLength)
{
throw new ArgumentException($"Git command \"{lastBatchBuilder}\" always exceeded max length of {maxLength} characters.", nameof(arguments));
}
// Add last commandline batch
if (!lastBatchBuilder.IsEmpty)
{
batches.Add(new BatchArgumentItem(lastBatchBuilder, currentBatchItemCount));
}
return(batches);
}