private static int?ParseSwitchArg(IConsoleEnvironment consoleEnvironment, string arg, int valueIndex, ArgInfo switchArg)
{
Contract.Requires(consoleEnvironment != null);
Contract.Requires(arg != null);
Contract.Requires(switchArg != null);
Contract.Requires(valueIndex < 0 || (valueIndex + 1) <= arg.Length);
bool switchValue;
if (valueIndex < 0)
{
switchValue = true;
}
else
{
string settingValueStr = arg.Substring(valueIndex + 1);
if (!bool.TryParse(settingValueStr, out switchValue))
{
consoleEnvironment.ErrWriter.WriteLine(
@"Switch '{0}' has an invalid value ('{1}') - it should either be empty, 'true' or 'false'",
switchArg.ArgName,
settingValueStr);
return(2);
}
}
CommandLineParsingContext context = new CommandLineParsingContext(consoleEnvironment);
context.ArgName = switchArg.ArgName;
switchArg.BoolValueAction(switchValue, context);
return(null);
}
private int?ParsePositionalArg(IConsoleEnvironment consoleEnvironment, int positionalArgsCovered, string arg)
{
Contract.Requires(consoleEnvironment != null);
Contract.Requires(positionalArgsCovered >= 0);
ArgInfo positionalArg = positionalArgs[positionalArgsCovered];
CommandLineParsingContext context = new CommandLineParsingContext(consoleEnvironment);
context.ArgName = positionalArg.ArgName;
if (positionalArg.ArgType == typeof(string))
{
positionalArg.StringValueAction(arg, context);
}
else if (positionalArg.ArgType == typeof(int))
{
int intValue;
if (int.TryParse(arg, out intValue))
{
positionalArg.IntValueAction(intValue, context);
}
else
{
consoleEnvironment.ErrWriter.WriteLine("Argument '{0}' has an invalid value ('{1}') - it should be an integer", positionalArg.ArgName, arg);
return(2);
}
}
else
{
throw new NotImplementedException();
}
return(null);
}
public override int Execute(IConsoleEnvironment env)
{
Contract.Assume(buildDirectory != null);
Contract.Assume(projectSourceDirectory != null);
FreudeProject project = new FreudeProject();
project.SourceDir = projectSourceDirectory;
project.BuildDir = buildDirectory;
CompileTemplate(project);
PrepareBuildDir();
ProcessProjectFiles(project);
WriteBuildMarkerFile();
return(0);
}
private static int?ParseSettingArg(IConsoleEnvironment consoleEnvironment, string arg, int valueIndex, ArgInfo settingArg)
{
Contract.Requires(consoleEnvironment != null);
Contract.Requires(arg != null);
Contract.Requires(settingArg != null);
Contract.Requires(valueIndex == -1 || (valueIndex + 1) >= 0);
Contract.Requires(valueIndex == -1 || (valueIndex + 1) <= arg.Length);
if (valueIndex == -1)
{
consoleEnvironment.ErrWriter.WriteLine("Setting '{0}' is missing the value", settingArg.ArgName);
return(2);
}
string settingValueStr = arg.Substring(valueIndex + 1);
CommandLineParsingContext context = new CommandLineParsingContext(consoleEnvironment);
context.ArgName = settingArg.ArgName;
if (settingArg.ArgType == typeof(string))
{
settingArg.StringValueAction(settingValueStr, context);
}
else if (settingArg.ArgType == typeof(int))
{
int intValue;
if (int.TryParse(settingValueStr, out intValue))
{
settingArg.IntValueAction(intValue, context);
}
else
{
consoleEnvironment.ErrWriter.WriteLine("Setting '{0}' has an invalid value ('{1}') - it should be an integer", settingArg.ArgName, settingValueStr);
return(2);
}
}
else
{
throw new NotImplementedException();
}
return(null);
}
public override int Execute(IConsoleEnvironment env)
{
FreudeProject project = new FreudeProject();
project.BuildDir = buildDirectory;
using (IFtpSession ftpSession = ftpSessionFactory.CreateSession())
{
FtpConnectionData connData = new FtpConnectionData();
connData.Credentials = new NetworkCredential(userName, password);
connData.Host = server;
connData.Port = port;
log.InfoFormat(CultureInfo.InvariantCulture, "Connecting to the FTP server {0}:{1}...", connData.Host, connData.Port);
ftpSession.BeginSession(connData);
PathBuilder buildDirPath = new PathBuilder(buildDirectory);
foreach (string sourceFileName in projectBuilder.ListBuiltFiles(project))
{
PathBuilder sourceFileNameDebasedBuilder = buildDirPath.DebasePath(sourceFileName, false);
PathBuilder destinationFileName;
if (remoteRootDirectory != null)
{
destinationFileName = new PathBuilder(remoteRootDirectory).CombineWith(sourceFileNameDebasedBuilder);
}
else
{
destinationFileName = sourceFileNameDebasedBuilder;
}
string destinationFileNameUnixStyle = destinationFileName.ToUnixPath();
log.InfoFormat(CultureInfo.InvariantCulture, "Uploading file {0} to {1}...", sourceFileName, destinationFileNameUnixStyle);
ftpSession.UploadFile(sourceFileName, destinationFileNameUnixStyle);
}
}
return(0);
}
public virtual int?ParseArgs(IConsoleEnvironment consoleEnvironment, IList <string> args)
{
int positionalArgsCovered = 0;
foreach (string arg in args)
{
int?exitCode;
if (arg.StartsWith("-", StringComparison.OrdinalIgnoreCase))
{
exitCode = ParseNonPositionalArg(consoleEnvironment, arg);
if (exitCode.HasValue)
{
return(exitCode);
}
}
else
{
exitCode = ParsePositionalArg(consoleEnvironment, positionalArgsCovered, arg);
if (exitCode.HasValue)
{
return(exitCode);
}
positionalArgsCovered++;
}
}
for (int i = positionalArgsCovered; i < positionalArgs.Count; i++)
{
ArgInfo arg = positionalArgs[i];
if (arg.IsRequired)
{
consoleEnvironment.ErrWriter.WriteLine("Required argument {0} is missing", arg.ArgName);
return(2);
}
}
return(null);
}
private int?ParseNonPositionalArg(IConsoleEnvironment consoleEnvironment, string arg)
{
Contract.Requires(consoleEnvironment != null);
Contract.Requires(arg != null);
Contract.Requires(arg.Length >= 1);
int valueIndex = arg.IndexOf('=');
string settingName;
if (valueIndex < 0)
{
settingName = arg.Substring(1).ToLowerInvariant();
}
else
{
settingName = arg.Substring(1, valueIndex - 1).ToLowerInvariant();
}
ArgInfo settingArg;
if (!settingsArgs.TryGetValue(settingName, out settingArg))
{
if (!aliases.TryGetValue(settingName, out settingArg))
{
consoleEnvironment.ErrWriter.WriteLine("Unknown setting '{0}' specified", settingName);
return(2);
}
}
Contract.Assume(settingArg != null);
if (!settingArg.IsSwitch)
{
return(ParseSettingArg(consoleEnvironment, arg, valueIndex, settingArg));
}
return(ParseSwitchArg(consoleEnvironment, arg, valueIndex, settingArg));
}
public int Execute(IConsoleEnvironment env)
{
env.OutWriter.WriteLine();
env.OutWriter.WriteLine("USAGE: {0} <command> {{<parameters>}}", consoleShell.CommandExeName);
env.OutWriter.WriteLine();
env.OutWriter.WriteLine("COMMANDS:");
string indentation = " ";
foreach (IConsoleCommand cmd in consoleShell.ListCommands().OrderBy(x => x.CommandId))
{
env.OutWriter.WriteLine("{0}{1} - {2}", indentation, cmd.CommandId, cmd.Description);
string usageHelpText = cmd.ConstructUsageHelpText(indentation);
if (usageHelpText != null)
{
env.OutWriter.WriteLine(usageHelpText);
}
}
return(0);
}
public int Execute(IConsoleEnvironment env)
{
Contract.Requires(env != null);
return(default(int));
}
public int?ParseArgs(IConsoleEnvironment consoleEnvironment, IList <string> args)
{
Contract.Requires(consoleEnvironment != null);
Contract.Requires(args != null);
return(default(int?));
}
public int?ParseArgs(IConsoleEnvironment consoleEnvironment, IList <string> args)
{
return(null);
}
public CommandLineParsingContext(IConsoleEnvironment env)
{
Contract.Requires(env != null);
this.env = env;
}
public abstract int Execute(IConsoleEnvironment env);
public override int Execute(IConsoleEnvironment env)
{
throw new InvalidOperationException("nothing to see here");
}
