public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
string VariableStart = "";
if ( Arguments.Length > 1 )
{
VariableStart = ( (string) Arguments[1].GetArgument() ).ToLower();
}
IDictionary EnvironmentVariables = Environment.GetEnvironmentVariables();
SortedList AlphaList = new SortedList( EnvironmentVariables );
foreach ( DictionaryEntry Entry in AlphaList )
{
string VariableName = (string) Entry.Key;
VariableName = VariableName.ToLower();
if ( VariableName.StartsWith( VariableStart ) )
{
string VariableValue = (string) Entry.Value;
TermUtil.WriteText( _Terminal, VariableName + "=" + VariableValue + Environment.NewLine );
}
}
return 0;
}
private void RunHelp(ICommandArgument arg = null)
{
this.Context.Information("\n");
if (arg != null)
{
this.Context.Information(arg.Description);
}
else
{
var desc = this.ScriptDescription + "\n";
desc += "Typical Usage:\n";
desc += " Windows:\n";
desc += " build.ps1 <--longAction | -shortAction>=<action option>\n";
desc += " Linux:\n";
desc += " build.sh <--longAction | -shortAction>=<action option>\n";
desc += "\n";
desc += "Available Actions:\n";
foreach (var a in this.Arguments)
{
desc += $" --{a.Name}|-{a.Shortname}\n";
}
desc += "\n";
desc += this.HelpArgument.Description;
this.Context.Information(desc);
}
this.Context.Information("\n");
}
public static RemoteCommand FormatAddCommand(string name, string url, string master, string[] branches, bool mirror, bool fetch, bool tags)
{
var args = new ICommandArgument[1+2+(master!=null?1:0)+(branches!=null?branches.Length:0)+(mirror?1:0)+(fetch?(tags?2:1):0)];
int id = 0;
args[id++] = Add();
if(branches != null && branches.Length != 0)
{
foreach(var b in branches)
{
args[id++] = TrackBranch(b);
}
}
if(!string.IsNullOrEmpty(master))
{
args[id++] = Master(master);
}
if(fetch)
{
args[id++] = Fetch();
if(tags) args[id++] = Tags();
}
if(mirror)
{
args[id++] = Mirror();
}
args[id++] = new CommandParameter(name);
args[id++] = new CommandParameter(url);
return new RemoteCommand(args);
}
public static RemoteCommand FormatAddCommand(string name, string url, string master, string[] branches, bool mirror, bool fetch, bool tags)
{
var args = new ICommandArgument[1 + 2 + (master != null?1:0) + (branches != null?branches.Length:0) + (mirror?1:0) + (fetch?(tags?2:1):0)];
int id = 0;
args[id++] = Add();
if (branches != null && branches.Length != 0)
{
foreach (var b in branches)
{
args[id++] = TrackBranch(b);
}
}
if (!string.IsNullOrEmpty(master))
{
args[id++] = Master(master);
}
if (fetch)
{
args[id++] = Fetch();
if (tags)
{
args[id++] = Tags();
}
}
if (mirror)
{
args[id++] = Mirror();
}
args[id++] = new CommandParameter(name);
args[id++] = new CommandParameter(url);
return(new RemoteCommand(args));
}
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
if ( Arguments.Length < 2 )
{
throw new CommandException();
}
System.Uri targetUri = new System.Uri( (string) Arguments[1].GetArgument() );
_Terminal.WriteTo( new StringBuilder( "Creating request\n" ),
OutputType.StandardOutput );
WebRequest searchRequest = WebRequest.Create(
targetUri );
_Terminal.WriteTo( new StringBuilder( "Getting request\n" ),
OutputType.StandardOutput );
WebResponse searchResult = searchRequest.GetResponse();
Stream searchStream = searchResult.GetResponseStream();
ICommandArgument[] showArguments = new ICommandArgument[2];
showArguments[0] = Arguments[0];
showArguments[1] = new FileInputArgument( searchStream );
ShowpageCommand showCommand = new ShowpageCommand( _CommandProcessor, _Terminal );
return showCommand.PerformCommand( showArguments, out CommandResult );
}
internal Command(CommandType commandType, ICommandArgument argument, Guid?tempId)
{
CommandType = commandType;
Argument = argument;
TempId = tempId;
Uid = Guid.NewGuid();
}
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
if ( Arguments.Length < 2 )
{
throw new CommandException();
}
Stream sourceStream = null;
if ( Arguments[1].GetArgument() is string )
{
sourceStream = (Stream) new FileStream( (string) Arguments[1].GetArgument(), FileMode.Open, FileAccess.Read );
}
else
{
sourceStream = (Stream) Arguments[1].GetArgument();
}
string resultString = GetHtml( sourceStream );
_Terminal.WriteTo(
new StringBuilder( resultString ),
ConsoleProcessRedirection.OutputType.StandardOutput );
TextCommandResult result = new TextCommandResult( new StringBuilder( resultString ) );
CommandResult = result;
return 0;
}
public void ApplyArguments(TCommand command, string[] args)
{
for (int i = 0; i < _commandArgs.Length; i++)
{
ICommandArgument <TCommand> arg = _commandArgs[i];
arg.ModifyCommand(command, enabled: args.Any(c => arg.IsValidArgString(c)));
}
}
public void AddArgument(ICommandArgument argument)
{
if (_args == null)
{
_args = new List <ICommandArgument>();
}
_args.Add(argument);
}
public void AddOption(ICommandArgument option)
{
if (_options == null)
{
_options = new List <ICommandArgument>();
}
_options.Add(option);
}
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
_CommandProcessor.Close();
return 0;
}
public override int PerformCommand( ICommandArgument [] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
if ( Arguments.Length > 1 )
{
Directory.SetCurrentDirectory( (string) Arguments[1].GetArgument() );
}
return 0;
}
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
System.UriBuilder searchBinding = new System.UriBuilder();
searchBinding.Scheme = "http";
searchBinding.Host = searchServer;
searchBinding.Path = searchRoot;
string searchQuery = searchQueryPrefix;
for ( int currentArgument = 1; currentArgument < Arguments.Length; currentArgument++ )
{
if ( currentArgument > 1 )
{
searchQuery += "%20";
}
searchQuery += Arguments[currentArgument].GetArgument();
}
searchBinding.Query = searchQuery;
_Terminal.WriteTo(
new StringBuilder( searchBinding.ToString() + "\n\n" ),
ConsoleProcessRedirection.OutputType.StandardOutput );
PageCommand pageRetriever = new PageCommand(
_CommandProcessor,
new NullTerminal() );
ICommandArgument[] showArguments = new ICommandArgument[2];
showArguments[0] = Arguments[0];
showArguments[1] = new CommandArgument( searchBinding.ToString() );
pageRetriever.PerformCommand(
showArguments,
out CommandResult );
string resultString = ( (StringBuilder) CommandResult.GetArgument() ).ToString();
string[] links = FindLinks( resultString );
foreach ( string link in links )
{
_Terminal.WriteTo(
new StringBuilder( link + "\n\n" ),
ConsoleProcessRedirection.OutputType.StandardOutput );
}
return 0;
}
public IBackloadStorageProviderFile Add(ICommandArgument args)
{
var f = this.Files.Add(new File(args.FileContext));
if (args.SaveChanges)
{
this.SaveChanges();
}
return(f);
}
private ArgumentValues ConstructDefaultArgument(ICommandArgument argument, bool isImplicit = false)
{
var argumentName = argument.ShortName == '\0'
? Settings.PrefixShort + argument.ShortName
: Settings.PrefixLong + argument.Name;
return(argument.ValueType.IsArray
? new ArgumentValues(
argumentName, (argument.DefaultValue as IEnumerable)?.Cast <object>(), isImplicit: isImplicit
)
: new ArgumentValues(argumentName, isImplicit: isImplicit, values: argument.DefaultValue));
}
/// <summary>
/// Tries to find a player, if found then <paramref name="callback"/> will be called
/// </summary>
/// <param name="cmdArg"></param>
/// <param name="callback"></param>
public static bool TryGet(ICommandArgument cmdArg, Action <UPlayer> callback)
{
var player = From(cmdArg.ToString());
if (player != null)
{
callback(player);
return(true);
}
return(false);
}
public static bool TryConvertToByte(this ICommandArgument src, out byte?value, out CommandResult error)
{
byte result;
if (src.TryConvertToByte(out result, out error))
{
value = result;
return(true);
}
value = null;
return(false);
}
public CommandArgs(string[] rawArgs)
{
RawArguments = rawArgs;
var arguments = new ICommandArgument[Length];
for (var i = 0; i < RawArguments.Length; i++)
{
arguments[i] = new CommandArgument(i, RawArguments[i]);
}
Arguments = arguments;
}
public bool TryGetArgument(string optionLabel, out ICommandArgument result)
{
if (this.argumentsAsDictionary.TryGetValue(optionLabel, out var found))
{
result = new CommandArgument(this.Command, optionLabel, found);
return(true);
}
else
{
result = default;
return(false);
}
}
/// <summary>
/// Try to convert the argument to byte.
/// </summary>
/// <param name="value">the converted value</param>
/// <param name="error">
/// CommandResult.LangError("NUMBER_BETWEEN", byte.MinValue, byte.MaxValue) if out of range;
// CommandResult.LangError("INVALID_NUMBER", src.ToString()) if invalid.
/// </param>
/// <returns>true if sucessfull, otherwise false</returns>
public static bool TryConvertToByte(this ICommandArgument src, out byte value, out CommandResult error)
{
value = 0;
error = null;
try {
value = byte.Parse(src.ToString());
return(true);
} catch (OverflowException) {
error = CommandResult.LangError("NUMBER_BETWEEN", byte.MinValue, byte.MaxValue);
} catch (FormatException) {
error = CommandResult.LangError("INVALID_NUMBER", src.ToString());
}
return(false);
}
public IBackloadStorageProviderFile Remove(ICommandArgument args)
{
var file = this.Files.Find(args.FileId);
if (file != null)
{
this.Files.Remove(file);
if (args.SaveChanges)
{
this.SaveChanges();
}
}
return(file);
}
public static BranchCommand FormatCreateBranchCommand(string name, string startingRevision, bool specifyTracking, bool track, bool reflog)
{
var args = new ICommandArgument[2 + (specifyTracking?1:0) + (reflog?1:0)];
int id = 0;
if (specifyTracking)
{
args[id++] = track ? Track() : NoTrack();
}
if (reflog)
{
args[id++] = RefLog();
}
args[id + 0] = new CommandParameter(name);
args[id + 1] = new CommandParameter(startingRevision);
return(new BranchCommand(args));
}
/// <summary>
/// Gets if argument defined in Cake commandline
/// </summary>
/// <param name="arg">Command Argument</param>
/// <param name="context">Cake Context</param>
/// <returns>True if it exists, false otherwise</returns>
/// <example>
/// <code>
/// var newArg = CommandHelper.AddArgument("test", "t", "Testing stuff");
/// var hasArg = newArg.HasArgument(Context)
/// </code>
/// </example>
public static bool HasArgument(this ICommandArgument arg, ICakeContext context)
{
if (arg == null)
{
throw new ArgumentNullException(nameof(arg));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var hasArg = context.HasArgument(arg.Name);
hasArg |= context.HasArgument(arg.Shortname);
return(hasArg);
}
private static bool?GetToggleValue(ICommandArgument arg)
{
switch (arg.RawValue.ToLowerInvariant())
{
case "true":
case "on":
case "1":
return(true);
case "false":
case "off":
case "0":
return(false);
default:
return(null);
}
}
public static void DropKit(ICommandSource src, ICommandArgument kitArg, Vector3 pos)
{
var kitManager = KitModule.Instance.KitManager;
var kitName = kitArg.ToString();
if (!kitManager.Contains(kitName))
{
EssLang.Send(src, "KIT_NOT_EXIST", kitName);
}
else
{
var kitItems = kitManager.GetByName(kitName).Items;
kitItems.Where(i => i is KitItem).Cast <KitItem>().ForEach(i =>
ItemManager.dropItem(i.UnturnedItem, pos, true, true, true)
);
}
}
public Parser(IParserService parserService, IEnumerable <IOspCommand> commands, IOptions <OspToolOptions> options)
{
_parserService = parserService;
_commands = commands;
Options = options;
_commandArg = _parserService.AddCommandArgument("c", "command",
new[]
{
"Command that has to be executed:"
}, true);
foreach (var ospCommand in _commands)
{
ospCommand.AddCommand(_commandArg);
}
CreateSamples();
}
public IBackloadStorageProviderFile Update(ICommandArgument args)
{
File f = this.Files.Find(args.FileId);
// Update or add file to context
if (f != null)
{
f.Update(args.FileContext);
}
else
{
f = this.Files.Add(new File(args.FileContext));
}
if (args.SaveChanges)
{
this.SaveChanges();
}
return(f);
}
public static PushCommand FormatPushCommand(string remote, ICollection<string> branches, bool force, bool thin, bool tags)
{
var args = new ICommandArgument[branches.Count + 3 + (force?1:0) + (tags?1:0)];
int arg = 0;
if(tags)
{
args[arg++] = Tags();
}
if(force)
{
args[arg++] = Force();
}
args[arg++] = thin ? Thin() : NoThin();
args[arg++] = Porcelain();
args[arg++] = new CommandParameter(remote);
foreach(var branch in branches)
{
args[arg++] = new CommandParameter(branch);
}
return new PushCommand(args);
}
public static PushCommand FormatPushCommand(string remote, ICollection <string> branches, bool force, bool thin, bool tags)
{
var args = new ICommandArgument[branches.Count + 3 + (force?1:0) + (tags?1:0)];
int arg = 0;
if (tags)
{
args[arg++] = Tags();
}
if (force)
{
args[arg++] = Force();
}
args[arg++] = thin ? Thin() : NoThin();
args[arg++] = Porcelain();
args[arg++] = new CommandParameter(remote);
foreach (var branch in branches)
{
args[arg++] = new CommandParameter(branch);
}
return(new PushCommand(args));
}
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
Assembly ThisAssembly = Assembly.GetCallingAssembly();
string AppTitle = "Shango";
string AppCompany = "Afrosoft";
Version AppVersion = new Version("0.1.0.10");
object[] Attributes = ThisAssembly.GetCustomAttributes( false );
foreach ( object Attr in Attributes )
{
if ( Attr is AssemblyTitleAttribute )
{
AppTitle = ( ( AssemblyTitleAttribute ) Attr ).Title;
}
if ( Attr is AssemblyCompanyAttribute )
{
AppCompany = ( ( AssemblyCompanyAttribute ) Attr ).Company;
}
if ( Attr is AssemblyName )
{
AppVersion = ( ( AssemblyName ) Attr ).Version;
}
}
string AppDescription = AppCompany + " " + AppTitle;
AppDescription += " [Version " + AppVersion.Major + "." + AppVersion.Minor + "." + AppVersion.Revision + "." + AppVersion.Build + "]";
TermUtil.WriteText( _Terminal, AppDescription + Environment.NewLine );
return 0;
}
/// <summary>
/// Gets argument value from Cake commandline.
/// </summary>
/// <param name="arg">Command Argument</param>
/// <param name="context">Cake Context</param>
/// <returns>Value as string if defined. Empty string if not defined.</returns>
/// <example>
/// <code>
/// var newArg = CommandHelper.AddArgument("test", "t", "Testing stuff");
/// var argVal = newArg.GetArgumentValue(Context)
/// </code>
/// </example>
public static string GetArgumentValue(this ICommandArgument arg, ICakeContext context)
{
if (arg == null)
{
throw new ArgumentNullException(nameof(arg));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var longArgValue = context.Argument(arg.Name, string.Empty);
if (!string.IsNullOrWhiteSpace(longArgValue))
{
return(longArgValue);
}
var shortArgValue = context.Argument(arg.Shortname, string.Empty);
return(shortArgValue);
}
public static void DropKit(ICommandSource src, ICommandArgument kitArg, Vector3 pos)
{
var kitManager = KitModule.Instance.KitManager;
var kitName = kitArg.ToString();
if (!kitManager.Contains(kitName))
{
context.User.SendLocalizedMessage(Translations, "KIT_NOT_EXIST", kitName);
return;
}
foreach (var item in kitManager.GetByName(kitName).Items)
{
if (item is KitItem kitItem)
{
ItemManager.dropItem(kitItem.UnturnedItem, pos, true, true, true);
}
if (item is KitItemVehicle vehicleItem)
{
VehicleManager.spawnVehicle(vehicleItem.Id, pos + (Vector3.up * 16), Quaternion.identity);
}
}
}
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult )
{
CommandResult = null;
string CommandName = (string) Arguments[0].GetArgument();
string CommandArguments = null;
if ( Arguments.Length > 1 )
{
CommandArguments = (string) Arguments[1].GetArgument();
}
for ( int Argument = 2; Argument < Arguments.Length; Argument++ )
{
CommandArguments += " " + Arguments[Argument].GetArgument();
}
_Process = new RedirectedProcess( _Terminal, this );
_Process.Start( CommandName, CommandArguments );
return 0;
}
/// <summary>
/// </summary>
/// <param name="src"></param>
/// <param name="minInclusive">Maximum value</param>
/// <param name="maxInclusive">Minimum value</param>
/// <returns></returns>
public static bool IsInRange(this ICommandArgument src, int minInclusive, int maxInclusive)
{
var val = src.ToInt;
return(val >= minInclusive && val <= maxInclusive);
}
internal Command(CommandType commandType, ICommandArgument argument)
// ReSharper disable once IntroduceOptionalParameters.Global
: this(commandType, argument, null)
{
}
private static void GiveItem( ICommandSource src, UPlayer target, ICommandArgument itemArg,
ICommandArgument amountArg, bool allPlayers = false )
{
ItemAsset asset;
if ( itemArg.IsUshort )
{
var id = itemArg.ToUshort;
asset = (ItemAsset) Assets.find( EAssetType.ITEM, id );
}
else
{
asset = UnturnedItems.GetItemAssetByName( itemArg.ToLowerString );
}
if ( asset == null )
{
src.SendMessage( $"Could not find an item with this name or id: {itemArg}" );
return;
}
ushort amt = 1;
if ( amountArg != null )
{
if ( !amountArg.IsShort )
{
EssLang.INVALID_NUMBER.SendTo( src, amountArg );
}
else if ( amountArg.ToUshort <= 0 )
{
EssLang.MUST_POSITIVE.SendTo( src );
}
else
{
amt = amountArg.ToUshort;
goto give;
}
return;
}
give:
var playersToReceive = new List<UPlayer>();
var item = new Item( asset.id, true );
if ( allPlayers )
{
UServer.Players.ForEach( playersToReceive.Add );
EssLang.GIVEN_ITEM_ALL.SendTo( src, amt, asset.Name );
}
else
{
playersToReceive.Add( target );
if ( !src.IsConsole && src.ToPlayer() != target )
{
EssLang.GIVEN_ITEM.SendTo( src, amt, asset.Name, target.CharacterName );
}
}
playersToReceive.ForEach( p =>
{
var success = p.GiveItem( item, amt, true );
EssLang.RECEIVED_ITEM.SendTo( p, amt, asset.Name );
if ( !success )
{
EssLang.INVENTORY_FULL.SendTo( p );
}
} );
}
private static void GiveItem(ICommandSource src, UPlayer target, ICommandArgument itemArg,
ICommandArgument amountArg, bool allPlayers = false)
{
if (!src.HasPermission("essentials.command.item.other") && target != src)
{
EssLang.Send(src, "COMMAND_NO_PERMISSION");
return;
}
var optAsset = ItemUtil.GetItem(itemArg.ToString());
if (optAsset.IsAbsent)
{
EssLang.Send(src, "ITEM_NOT_FOUND", itemArg);
return;
}
if (UEssentials.Config.GiveItemBlacklist.Contains(optAsset.Value.id) &&
!src.HasPermission("essentials.bypass.blacklist.item"))
{
EssLang.Send(src, "BLACKLISTED_ITEM", $"{optAsset.Value.itemName} ({optAsset.Value.id})");
return;
}
ushort amt = 1;
if (amountArg != null)
{
if (!amountArg.IsShort)
{
EssLang.Send(src, "INVALID_NUMBER", amountArg);
}
else if (amountArg.ToShort <= 0)
{
EssLang.Send(src, "MUST_POSITIVE");
}
else
{
amt = amountArg.ToUShort;
goto give;
}
return;
}
give:
var asset = optAsset.Value;
var playersToReceive = new List <UPlayer>();
var item = new Item(asset.id, true);
if (asset is ItemFuelAsset)
{
ItemUtil.Refuel(item);
}
if (!src.HasPermission("essentials.bypass.itemlimit") && amt > UEssentials.Config.ItemSpawnLimit)
{
amt = UEssentials.Config.ItemSpawnLimit;
EssLang.Send(src, "ITEM_LIMIT", amt);
}
if (allPlayers)
{
UServer.Players.ForEach(playersToReceive.Add);
EssLang.Send(src, "GIVEN_ITEM_ALL", amt, asset.itemName, asset.id);
}
else
{
playersToReceive.Add(target);
if (!src.IsConsole && src.ToPlayer() == target)
{
goto give2;
}
EssLang.Send(src, "GIVEN_ITEM", amt, asset.itemName, asset.id, target.CharacterName);
}
give2:
playersToReceive.ForEach(p => {
var success = p.GiveItem(item, amt, true);
EssLang.Send(p, "RECEIVED_ITEM", amt, asset.itemName, asset.id);
if (!success)
{
EssLang.Send(p, "INVENTORY_FULL");
}
});
}
public bool Equals(ICommandArgument other)
{
return(other.RawValue == this.RawValue);
}
public int SqlExecute(ICommandArgument args)
{
return(this.Database.ExecuteSqlCommand(args.SqlCommand, args.SqlParameter));
}
public CommandArgs( string rawArgs )
{
RawArguments = new string[0];
if ( rawArgs.Length < 0 )
return;
var args = new List<string>();
var argBuilder = new StringBuilder();
var inQuot = false;
var chars = rawArgs.ToCharArray();
var charLen = chars.Length;
for ( var i = 0; i < charLen; i++ )
{
var ch = chars[i];
if ( (ch == '\'' || ch == '"') )
{
if ( i != 0 && chars[i - 1] == '\\' )
{
argBuilder.Length = argBuilder.Length - 1;
goto append;
}
inQuot = !inQuot;
goto appendAll;
}
if ( ch == ' ' )
{
if ( inQuot )
goto append;
goto appendAll;
}
append:
argBuilder.Append( ch );
if ( i == (charLen - 1) )
goto appendAll;
continue;
appendAll:
if ( argBuilder.Length > 0 )
{
args.Add( argBuilder.ToString() );
argBuilder.Length = 0;
}
}
RawArguments = args.ToArray();
var arguments = new ICommandArgument[ Length ];
for ( var i = 0; i < RawArguments.Length; i++ )
{
arguments[i] = new CommandArgument( i, RawArguments[i] );
}
Arguments = arguments;
}
public CommandArgs(string[] rawArgs)
{
/*RawArguments = new string[0];
*
* if ( rawArgs.Length < 0 )
* return;
*
* var args = new List<string>();
* var argBuilder = new StringBuilder();
* var inQuot = false;
*
* var chars = rawArgs.ToCharArray();
* var charLen = chars.Length;
*
* for ( var i = 0; i < charLen; i++ )
* {
* var ch = chars[i];
*
* if ( (ch == '\'' || ch == '"') )
* {
* if ( i != 0 && chars[i - 1] == '\\' )
* {
* argBuilder.Length = argBuilder.Length - 1;
* goto append;
* }
*
* inQuot = !inQuot;
* goto appendAll;
* }
*
* if ( ch == ' ' )
* {
* if ( inQuot )
* goto append;
* goto appendAll;
* }
*
* append:
* argBuilder.Append( ch );
* if ( i == (charLen - 1) )
* goto appendAll;
* continue;
*
* appendAll:
* if ( argBuilder.Length > 0 )
* {
* args.Add( argBuilder.ToString() );
* argBuilder.Length = 0;
* }
* }*/
RawArguments = rawArgs;
var arguments = new ICommandArgument[Length];
for (var i = 0; i < RawArguments.Length; i++)
{
arguments[i] = new CommandArgument(i, RawArguments[i]);
}
Arguments = arguments;
}
public void SetNext(ICommandArgument icommand)
{
nextCommandArgument = icommand;
}
private static void InsertQueryRevisionsParameters(QueryRevisionsParameters parameters, IList<ICommandArgument> args, ICommandArgument format)
{
#region Commit Limiting
if(parameters.MaxCount != 0)
{
args.Add(LogCommand.MaxCount(parameters.MaxCount));
}
if(parameters.Skip != 0)
{
args.Add(LogCommand.Skip(parameters.Skip));
}
if(parameters.SinceDate.HasValue)
{
args.Add(LogCommand.Since(parameters.SinceDate.Value));
}
if(parameters.UntilDate.HasValue)
{
args.Add(LogCommand.Until(parameters.UntilDate.Value));
}
if(parameters.AuthorPattern != null)
{
args.Add(LogCommand.Author(parameters.AuthorPattern));
}
if(parameters.CommitterPattern != null)
{
args.Add(LogCommand.Committer(parameters.CommitterPattern));
}
if(parameters.MessagePattern != null)
{
args.Add(LogCommand.Grep(parameters.MessagePattern));
}
if(parameters.AllMatch)
{
args.Add(LogCommand.AllMatch());
}
if(parameters.RegexpIgnoreCase)
{
args.Add(LogCommand.RegexpIgnoreCase());
}
if(parameters.RegexpExtended)
{
args.Add(LogCommand.ExtendedRegexp());
}
if(parameters.RegexpFixedStrings)
{
args.Add(LogCommand.FixedStrings());
}
if(parameters.RemoveEmpty)
{
args.Add(LogCommand.RemoveEmpty());
}
switch(parameters.MergesMode)
{
case RevisionMergesQueryMode.MergesOnly:
args.Add(LogCommand.Merges());
break;
case RevisionMergesQueryMode.NoMerges:
args.Add(LogCommand.NoMerges());
break;
}
if(parameters.Follow)
{
args.Add(LogCommand.Follow());
}
if(parameters.Not)
{
args.Add(LogCommand.Not());
}
if(parameters.All)
{
args.Add(LogCommand.All());
}
if(parameters.ReferencesGlob != null)
{
args.Add(LogCommand.Glob(parameters.ReferencesGlob));
}
if(parameters.Branches != null)
{
args.Add(LogCommand.Branches(parameters.Branches));
}
if(parameters.Tags != null)
{
args.Add(LogCommand.Tags(parameters.Tags));
}
if(parameters.Remotes != null)
{
args.Add(LogCommand.Remotes(parameters.Remotes));
}
#endregion
#region History Simplification
if(parameters.FirstParent)
{
args.Add(LogCommand.FirstParent());
}
if(parameters.SimplifyByDecoration)
{
args.Add(LogCommand.SimplifyByDecoration());
}
if(parameters.EnableParentsRewriting)
{
args.Add(LogCommand.Parents());
}
#endregion
#region Ordering
switch(parameters.Order)
{
case RevisionQueryOrder.DateOrder:
args.Add(LogCommand.DateOrder());
break;
case RevisionQueryOrder.TopoOrder:
args.Add(LogCommand.TopoOrder());
break;
}
if(parameters.Reverse)
{
args.Add(LogCommand.Reverse());
}
#endregion
#region Formatting
args.Add(LogCommand.NullTerminate());
if(format != null)
{
args.Add(format);
}
#endregion
if(parameters.Since != null && parameters.Until != null)
{
args.Add(new CommandParameter(parameters.Since + ".." + parameters.Until));
}
if(parameters.References != null)
{
foreach(var reference in parameters.References)
{
args.Add(new CommandParameter(reference));
}
}
if(parameters.Paths != null && parameters.Paths.Count != 0)
{
args.Add(CommandFlag.NoMoreOptions());
foreach(var path in parameters.Paths)
{
args.Add(new PathCommandArgument(path));
}
}
}
public void AddCommand(ICommandArgument commandArgument)
{
CommandArgumentValue = commandArgument.AddCommandValue(CommandValue, _commandDescription);
AddArguments();
}
public abstract int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult );
