public ProgramOutput(CommandLineParameters parameters)
{
if (!parameters.Quiet)
{
_outputs.Add(new ConsoleOutput());
}
}
public void RequiredValueShouldThrowIfNotParsedYet()
{
var parms = new CommandLineParameters();
var version = parms.Required <string>("version");
Assert.That(() => version.Value, Throws.Exception);
}
public ProgramOutput(CommandLineParameters parameters)
{
if (!parameters.Quiet)
{
_outputs.Add(new ConsoleOutput());
}
}
public void DefaultValueShouldReturnIfNotParsed()
{
var parms = new CommandLineParameters();
var version = parms.Default("version", "0.2");
Assert.That(version.Value, Is.EqualTo("0.2"));
}
public void AllCommandsFound()
{
var types = LoadTypes();
var io = InputControl.Default();
Assert.AreEqual(6, types.Count());
foreach (var type in types)
{
var attr = type.GetCustomAttribute <CommandLineCommandAttribute>();
Assert.IsNotNull(attr);
Assert.IsNotNull(attr.Command);
Assert.IsNotNull(attr.Description);
var commandLine = CommandLineParameters.Parse(attr.Command);
Assert.IsNotNull(commandLine);
io.Writer = new StringWriter();
var command = commandLine.CreateCommandExecutor(io);
Assert.IsNotNull(command);
command.DisplayHelp();
Assert.IsTrue(!string.IsNullOrWhiteSpace(io.Writer.ToString()));
Assert.IsTrue(io.Writer.ToString().Contains(attr.Command));
}
}
/// <summary>
/// Initializes a new instance of the <b>BaseOperation</b> class.
/// </summary>
/// <param name="parameters"></param>
/// <exception cref="ArgumentNullException">If <paramref name="parameters"/> is null.</exception>
protected BaseOperation(CommandLineParameters parameters)
{
if (parameters == null) {
throw new ArgumentNullException("parameters");
}
_parameters = parameters;
}
public async Task DestroyExecutes()
{
using (var tmpCacheFile = new TemporaryFile())
{
var parameters = CommandLineParameters.Parse($"kdestroy --cache {tmpCacheFile.File}");
var io = new InputControl
{
Clear = () => { },
HookCtrlC = hook => { },
Writer = new StringWriter()
};
var command = (KerberosDestroyCommand)parameters.CreateCommandExecutor(io);
Assert.IsNotNull(command);
await command.Execute();
var result = io.Writer.ToString();
Assert.IsTrue(result.Contains("Cache file has been deleted."));
var exists = File.Exists(tmpCacheFile.File);
Assert.IsFalse(exists);
}
}
public void Run(string[] args, MethodInfo getTargetsMethod)
{
var parameters = new CommandLineParameters();
try {
Dictionary<string, ITask> targets = GetTargetsFromAssembly(getTargetsMethod, parameters);
var parsedParameters = ParseCommandLineArguments(args);
string[] buildArguments = parsedParameters.RemainingArguments;
if (buildArguments.Length >= 2) {
InterpretParameters(parameters, parsedParameters, _bounce);
string command = buildArguments[0];
IEnumerable<string> targetsToBuild = TargetsToBuild(buildArguments);
BuildTargets(command, targetsToBuild, targets);
}
else
{
System.Console.WriteLine("usage: bounce build|clean target-name");
PrintAvailableTargets(targets);
PrintAvailableParameters(parameters);
Environment.Exit(1);
}
} catch (BounceException ce) {
ce.Explain(System.Console.Error);
Environment.Exit(1);
}
}
public void RequiredShouldThrowExceptionIfNoValueGiven()
{
var parms = new CommandLineParameters();
var version = parms.Required<string>("version");
Assert.That(() => parms.ParseCommandLineArguments(new List<ParsedCommandLineParameter>()), Throws.InstanceOf(typeof(CommandLineParametersException)));
}
public void TestBadNumericArgument()
{
var argv = new[] { "--boolean", "--string", "astring", "--numeric", "nineteen eighty-four" };
var parameters = new CommandLineParameters(argv, _typeOptions);
Assert.IsFalse(parameters.IsValid);
}
public void VersionRange_must_be_a_valid_version_range_if_parameter_is_set(string version)
{
// ARRANGE
using var repositoryDirectory = new TemporaryDirectory();
var parameters = new CommandLineParameters()
{
RepositoryPath = repositoryDirectory,
VersionRange = version
};
var validator = new CommandLineParametersValidator();
// ACT
var result = validator.Validate(parameters);
// ASSERT
Assert.False(result.IsValid);
var error = Assert.Single(result.Errors);
Assert.Equal(nameof(CommandLineParameters.VersionRange), error.PropertyName);
// error message should contain commandline parameter name (specified using the Option attribute) instead of the property name
Assert.Contains("'versionRange'", error.ErrorMessage);
}
public void RequiredValueShouldThrowIfNotParsedYet()
{
var parms = new CommandLineParameters();
var version = parms.Required<string>("version");
Assert.That(() => version.Value, Throws.Exception);
}
public void ConfigurationFilePath_must_exists_if_parameter_is_set()
{
// ARRANGE
using var repositoryDirectory = new TemporaryDirectory();
var configurationFilePath = Path.Combine(repositoryDirectory, "config.json");
var parameters = new CommandLineParameters()
{
RepositoryPath = repositoryDirectory,
ConfigurationFilePath = configurationFilePath
};
var validator = new CommandLineParametersValidator();
// ACT
var result = validator.Validate(parameters);
// ASSERT
Assert.False(result.IsValid);
var error = Assert.Single(result.Errors);
Assert.Equal(nameof(CommandLineParameters.ConfigurationFilePath), error.PropertyName);
// error message should contain commandline parameter name (specified using the Option attribute) instead of the property name
Assert.Contains("'configurationFilePath'", error.ErrorMessage);
}
public void RepositoryPath_must_exists()
{
// ARRANGE
using var temporaryDirectory = new TemporaryDirectory();
var nonExistingDirectory = Path.Combine(temporaryDirectory, "someDir");
var parameters = new CommandLineParameters()
{
RepositoryPath = nonExistingDirectory
};
var validator = new CommandLineParametersValidator();
// ACT
var result = validator.Validate(parameters);
// ASSERT
Assert.False(result.IsValid);
var error = Assert.Single(result.Errors);
Assert.Equal(nameof(CommandLineParameters.RepositoryPath), error.PropertyName);
// error message should contain commandline parameter name (specified using the Option attribute) instead of the property name
Assert.Contains("'repository'", error.ErrorMessage);
}
public void ReportResult(List <CommandLineParameters.OptionInfo> options, CommandLineParameters parameters, bool expectedValidity, string message, bool showParameters)
{
Expect(parameters.IsValid == expectedValidity, "FAILED: " + message);
if (showParameters)
{
foreach (CommandLineParameters.OptionInfo option in options)
{
if (option.Type == typeof(bool))
{
Console.WriteLine(option.Name + ": {0}", (bool)parameters[option.Name]);
}
if (option.Type == typeof(string))
{
Console.WriteLine(option.Name + ": {0}", (string)parameters[option.Name]);
}
if (option.Type == typeof(int))
{
Console.WriteLine(option.Name + ": {0}", (int)parameters[option.Name]);
}
}
}
Console.Write("PASSED ");
Console.WriteLine(message);
Console.WriteLine();
}
public void DefaultValueShouldReturnIfNotParsed()
{
var parms = new CommandLineParameters();
var version = parms.Default("version", "0.2");
Assert.That(version.Value, Is.EqualTo("0.2"));
}
public void TestQuietValueIsParsed()
{
var options = new CommandLineParameters();
var args = new[] {"-q"};
Parser.Default.ParseArguments(args, options);
Assert.IsTrue(options.Quiet);
}
public void TestSingleRunValueIsParsed()
{
var options = new CommandLineParameters();
var args = new[] { "-s" };
Parser.Default.ParseArguments(args, options);
Assert.IsTrue(options.SingleRun);
}
public void ShouldThrowIfParameterGivenButNoneRegistered()
{
var parms = new CommandLineParameters();
var parsedCommandLineParameters = new List<ParsedCommandLineParameter>();
parsedCommandLineParameters.Add(new ParsedCommandLineParameter {Name = "provided", Value = "value"});
Assert.That(() => parms.ParseCommandLineArguments(parsedCommandLineParameters), Throws.InstanceOf(typeof(CommandLineParametersException)));
}
/* *******************************************************************
* Constructors
* *******************************************************************/
#region protected BaseOperation(CommandLineParameters parameters)
/// <summary>
/// Initializes a new instance of the <b>BaseOperation</b> class.
/// </summary>
/// <param name="parameters"></param>
/// <exception cref="ArgumentNullException">If <paramref name="parameters"/> is null.</exception>
protected BaseOperation(CommandLineParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
_parameters = parameters;
}
public void MakeParameters_InvalidValues_Test(string startPath, string action, string file)
{
string[] args = { startPath, action, file };
var result = CommandLineParameters.MakeParameters(args);
Assert.IsNull(result);
}
protected override void OnStart(string[] arguments)
{
var parser = new CommandLineParser(new CommandLineParserSettings());
var commandLineParameters = new CommandLineParameters();
parser.ParseArguments(arguments, commandLineParameters);
bottomShelfHost.Start(commandLineParameters);
}
public void TestQuietValueIsParsed()
{
var options = new CommandLineParameters();
var args = new[] { "-q" };
Parser.Default.ParseArguments(args, options);
Assert.IsTrue(options.Quiet);
}
public void TestSingleRunValueIsParsed()
{
var options = new CommandLineParameters();
var args = new[] { "-s" };
Parser.Default.ParseArguments(args, options);
Assert.IsTrue(options.SingleRun);
}
static void InitializeContainer(CommandLineParameters parameters)
{
var builder = new ContainerBuilder();
builder.RegisterType <StrPathCalculator>().As <IPathCalculator>().SingleInstance();
builder.RegisterType <ConsolePrinter>().As <IPrinter>().SingleInstance();
builder.Register(
ctx => parameters.IsConsole() ? (IResultWriter)(new ConsoleWriter()) : (new FileWriter(parameters.ResultFile, ctx.Resolve <IPrinter>()))
).SingleInstance();
builder.Register(
ctx =>
{
IFileHandler result = null;
IResultWriter writer = ctx.Resolve <IResultWriter>();
IPathCalculator calculator = ctx.Resolve <IPathCalculator>();
IPrinter printer = ctx.Resolve <IPrinter>();
switch (parameters.GetAction())
{
case Core.Action.All:
result = new SimpleFileHandler(printer);
break;
case Core.Action.Cs:
result = new CsFileHandler(printer);
break;
case Core.Action.ReversedOne:
result = new ReverseOneFileHandler(printer);
break;
case Core.Action.ReversedTwo:
result = new ReverseTwoFileHandler(printer);
break;
default:
throw new Exception($"Invalid action: [{parameters.ActionStr}]");
}
return(result);
}
).InstancePerLifetimeScope();
builder.Register <IDirectoryHandler>(
ctx => new DirectoryHandler(parameters.StartDirectory,
ctx.Resolve <IFileHandler>(),
ctx.Resolve <IResultWriter>(),
ctx.Resolve <IPathCalculator>(),
ctx.Resolve <IPrinter>())
).InstancePerLifetimeScope();
builder.RegisterType <Scanner>().As <IScanner>().InstancePerLifetimeScope();
_container = builder.Build();
}
public void ParserGeneratesCommand()
{
var parameters = CommandLineParameters.Parse(KInitParameters);
var command = parameters.CreateCommandExecutor(InputControl.Default());
Assert.IsNotNull(command);
Assert.IsInstanceOfType(command, typeof(KerberosInitCommand));
}
public void GetAction_ConvertFromString_Test(string action, Action result)
{
string[] args = { $"-s {_tempPath}", $"-a {action}" };
var options = CommandLineParameters.MakeParameters(args);
Assert.IsNotNull(options);
Assert.IsTrue(options.GetAction() == result);
}
public void TestCommandlineParametersArguments()
{
var argv = new[] { "--boolean", "--string", "astring", "--numeric", "1984", "42", "foo" };
var parameters = new CommandLineParameters(argv, _typeOptions);
Assert.AreEqual(2, parameters.Arguments.Count);
Assert.Contains("42", parameters.Arguments);
Assert.Contains("foo", parameters.Arguments);
}
public static void Start(CommandLineParameters opts, IListener listener = null)
{
if (listener != null)
{
AppListener = listener;
}
RunServer(opts);
}
public void IsConsole_Fail_Test(string console)
{
string[] args = { $"-s {_tempPath}", $"-a {console}" };
var options = CommandLineParameters.MakeParameters(args);
Assert.IsNotNull(options);
Assert.IsFalse(options.IsConsole());
}
public void IsValid_Action_Fail_Test(string action)
{
string[] args = { $"-s {_tempPath}", $"-a {action}" };
var options = CommandLineParameters.MakeParameters(args);
Assert.IsNotNull(options);
Assert.IsFalse(options.IsValid());
}
public void RequiredShouldReturnValueWhenGiven()
{
var parms = new CommandLineParameters();
var version = parms.Required<string>("version");
parms.ParseCommandLineArguments(new List<ParsedCommandLineParameter> {new ParsedCommandLineParameter {Name = "version", Value = "0.2"}});
Assert.That(version.Value, Is.EqualTo("0.2"));
}
private static CommandLineParameters GetCommandline(string[] args)
{
CommandLineParameters commandLineParameters = CommandLineParameters.FromFile(args);
if (commandLineParameters == null)
{
commandLineParameters = CommandLineParameters.FromArguments(args);
}
// Checks
if (commandLineParameters.Result.HasErrors)
{
ErrorHandler.Log($"Error in parameters: {commandLineParameters.Result.ErrorText}");
}
commandLineParameters.FileForVersion = Path.GetFullPath(commandLineParameters.FileForVersion);
if (!File.Exists(commandLineParameters.FileForVersion))
{
ErrorHandler.Log($"File not exists: {commandLineParameters.FileForVersion}");
}
var extension = Path.GetExtension(commandLineParameters.FileForVersion)?.ToLower();
if (extension != ".dll" &&
extension != ".exe")
{
ErrorHandler.Log($"File type not supported: {extension}");
}
if (commandLineParameters.ReleaseAttachments != null)
{
for (var index = 0; index < commandLineParameters.ReleaseAttachments.Count; index++)
{
commandLineParameters.ReleaseAttachments[index] =
Path.GetFullPath(commandLineParameters.ReleaseAttachments[index]);
var attachment = commandLineParameters.ReleaseAttachments[index];
if (!File.Exists(attachment))
{
ErrorHandler.Log($"Attachment file not found: {attachment}");
}
}
}
LogParameter(nameof(commandLineParameters.GitHubRepo), commandLineParameters.GitHubRepo);
LogParameter(nameof(commandLineParameters.GitHubToken), commandLineParameters.GitHubToken);
LogParameter(nameof(commandLineParameters.FileForVersion), commandLineParameters.FileForVersion);
LogParameter(nameof(commandLineParameters.IsChangelogFileCreationEnabled),
commandLineParameters.IsChangelogFileCreationEnabled);
LogParameter(nameof(commandLineParameters.IsPreRelease), commandLineParameters.IsPreRelease);
LogParameter(nameof(commandLineParameters.IsUpdateOnly), commandLineParameters.IsUpdateOnly);
LogParameter(nameof(commandLineParameters.IssueFilterLabel), commandLineParameters.IssueFilterLabel);
LogParameter(nameof(commandLineParameters.IssueLabels), commandLineParameters.IssueLabels);
LogParameter(nameof(commandLineParameters.ReleaseAttachments), commandLineParameters.ReleaseAttachments);
return(commandLineParameters);
}
public void StringAsInteger()
{
var parameters = new CommandLineParameters(_typeStrings, _typeOptions);
Expect(parameters.IsValid);
#pragma warning disable 168
int test = parameters["string"];
#pragma warning restore 168
Expect(false, "FAILED type test: string as integer didn't throw exception.");
}
public void MakeParameters_DefaultValues_Test(string startPath)
{
string[] args = { startPath };
var result = CommandLineParameters.MakeParameters(args);
Assert.IsNotNull(result);
Assert.AreEqual("all", result.ActionStr);
Assert.AreEqual("results.txt", result.ResultFile);
}
public void BoolAsString()
{
var parameters = new CommandLineParameters(_typeStrings, _typeOptions);
Expect(parameters.IsValid);
#pragma warning disable 168
string test = parameters["boolean"];
#pragma warning restore 168
Expect(false, "FAILED type test: boolean as string didn't throw exception.");
}
public MainService(
IHostApplicationLifetime appLifetime,
IOptions <CommandLineParameters> cmdParams,
IOptions <AppSetting> appSettings
)
{
this.appLifetime = appLifetime;
this.cmdParams = cmdParams.Value;
this.appSettings = appSettings.Value;
}
public void IntegerAsBool()
{
var parameters = new CommandLineParameters(_typeStrings, _typeOptions);
Expect(parameters.IsValid);
#pragma warning disable 168
bool test = parameters["numeric"];
#pragma warning restore 168
Expect(false, "FAILED type test: integer as boolean didn't throw exception.");
}
private static void RunServer(CommandLineParameters opts)
{
CheckFirewall(opts.Port);
Key = CryptoService.Encrypt(opts.Password);
KeyMaster.Action.Application = opts.Application;
string baseAddress = "http://" + "*" + ":" + opts.Port + "/";
host = CreateHostBuilder(baseAddress).Build();
host.Run();
}
public void MakeParameters_ValidValues_Test(string startPath, string action, string file)
{
string[] args = { startPath, action, file };
var result = CommandLineParameters.MakeParameters(args);
Assert.IsNotNull(result);
StringAssert.EndsWith(startPath, result.StartDirectory);
StringAssert.EndsWith(action, result.ActionStr);
StringAssert.EndsWith(file, result.ResultFile);
}
public void ShouldThrowIfParameterGivenButNoneRegistered()
{
var parms = new CommandLineParameters();
var parsedCommandLineParameters = new List <ParsedCommandLineParameter>();
parsedCommandLineParameters.Add(new ParsedCommandLineParameter {
Name = "provided", Value = "value"
});
Assert.That(() => parms.ParseCommandLineArguments(parsedCommandLineParameters), Throws.InstanceOf(typeof(CommandLineParametersException)));
}
public void RequiredShouldThrowExceptionIfNoValueGiven()
{
var parms = new CommandLineParameters();
var param1 = (IParameter) parms.Required<string>("provided");
var param2 = (IParameter) parms.Required<int>("notprovided");
var parsedCommandLineParameters = new List<ParsedCommandLineParameter>();
parsedCommandLineParameters.Add(new ParsedCommandLineParameter {Name = "provided", Value = "value"});
parms.ParseCommandLineArguments(parsedCommandLineParameters);
Assert.That(() => parms.EnsureAllRequiredParametersHaveValues(new [] {param1, param2}), Throws.InstanceOf(typeof(CommandLineParametersException)));
}
public void AbleToUseBounceFromOutside()
{
// arrange
var bounce = new BounceFactory().GetBounce();
var targetsRetriever = new TargetsRetriever();
var parameters = new CommandLineParameters();
var targets = targetsRetriever.GetTargetsFromObject(GetTargets(parameters)).ToTargets();
var command = BounceCommandFactory.GetCommandByName("build");
var builder = new TargetsBuilder();
// act
builder.BuildTargets(bounce, targets, command);
// assert
Assert.That(Directory.Exists(GitCheckoutDirectory), Is.True);
}
public void Run(string[] args, MethodInfo getTargetsMethod)
{
TargetsPath = new Uri(getTargetsMethod.Module.Assembly.CodeBase).LocalPath;
var parameters = new CommandLineParameters();
try {
IDictionary<string, IObsoleteTask> targets = GetTargetsFromAssembly(getTargetsMethod, parameters);
ParsedCommandLineParameters parsedParameters = ParseCommandLineArguments(args);
string[] buildArguments = parsedParameters.RemainingArguments;
CommandAndTargets commandAndTargets = CommandAndTargetParser.ParseCommandAndTargetNames(buildArguments, targets);
if (commandAndTargets.Targets.Count() >= 1) {
var bounce = new Bounce();
InterpretParameters(parameters, parsedParameters, bounce);
try
{
EnsureAllRequiredParametersAreSet(parameters, commandAndTargets.Targets);
BuildTargets(bounce, commandAndTargets);
}
catch (BounceException ce)
{
ce.Explain(bounce.LogOptions.StdErr);
Environment.Exit(1);
}
}
else
{
System.Console.WriteLine("usage: bounce build|clean target-name");
PrintAvailableTargets(targets);
Environment.Exit(1);
}
} catch (BounceException ce) {
ce.Explain(System.Console.Error);
Environment.Exit(1);
}
}
public static void Run(CommandLineParameters options)
{
var installUtilArguments = new List<string>();
installUtilArguments.Add(Assembly.GetExecutingAssembly().Location);
installUtilArguments.Add("/LogToConsole=true");
DelayedAutoStart = options.DelayedAutoStart;
ServiceAccount serviceAccount;
Enum.TryParse(options.ServiceAccount, true, out serviceAccount);
Account = serviceAccount;
ServiceStartMode startType;
Enum.TryParse(options.StartType, true, out startType);
StartType = startType;
if(options.UninstallWindowsService)
installUtilArguments.Add("/u");
ManagedInstallerClass.InstallHelper(installUtilArguments.ToArray());
}
private Dictionary<string, ITask> GetTargetsFromAssembly(MethodInfo getTargetsMethod, CommandLineParameters parameters)
{
object targetsObject = GetTargetsObjectFromAssembly(getTargetsMethod, parameters);
Dictionary<string, ITask> targets = new Dictionary<string, ITask>();
foreach (PropertyInfo property in targetsObject.GetType().GetProperties()) {
targets[property.Name] = (ITask) property.GetValue(targetsObject, new object[0]);
}
return targets;
}
private IDictionary<string, IObsoleteTask> GetTargetsFromAssembly(MethodInfo getTargetsMethod, CommandLineParameters parameters)
{
return TargetsRetriever.GetTargetsFromAssembly(getTargetsMethod, parameters);
}
private void EnsureAllRequiredParametersAreSet(CommandLineParameters parameters, IEnumerable<Target> targetsToBuild)
{
var tasks = targetsToBuild.Select(t => t.Task);
foreach (IObsoleteTask task in tasks) {
IEnumerable<IParameter> parametersForTask = ParameterFinder.FindParametersInTask(task);
parameters.EnsureAllRequiredParametersHaveValues(parametersForTask);
}
}
/// <summary>
/// Generate usage text for the script with given ID and descriptions
/// </summary>
/// <param name="context">Script context</param>
/// <param name="description">Script description</param>
/// <param name="id">Script ID</param>
/// <param name="width">Console width</param>
/// <param name="items">Command line parameters</param>
/// <returns></returns>
public string GetUsage(ScriptContext context, string description, string id, int width, CommandLineParameters items)
{
width = CorrectWidth(width);
StringWriter sw = new StringWriter();
// Write description
if (!string.IsNullOrEmpty(description))
{
Utils.Wrap(sw, description, width, string.Empty);
sw.WriteLine();
}
if ((Options & UsageOptions.UsageLine) != 0)
{
string prefix = LinePrefix + id;
StringBuilder line = new StringBuilder(prefix);
bool optional = false;
foreach (CommandLineParameter p in items)
{
string text = p.GetTransformedValue(context);
string vardescr = p.GetDescription(context);
if (p.Required)
{
if (!string.IsNullOrEmpty(p.Switch))
line.Append(" " + items.GetSwitchPrefixesArray()[0] + p.Switch);
if (p.Count != CommandLineValueCount.None)
line.Append(" " + p.GetDescription(context));
}
else if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(p.Switch))
optional = true;
else if (p.Count != CommandLineValueCount.None && string.IsNullOrEmpty(p.Switch) && !string.IsNullOrEmpty(vardescr))
line.Append(" [" + vardescr + "]");
}
if (optional && LineSuffix == null)
line.Append(" [parameters]");
line.Append(LineSuffix);
Utils.Wrap(sw, line.ToString(), width, new string(' ', prefix.Length + 1));
}
foreach (CommandLineParameter p in items)
{
string text = p.GetTransformedValue(context);
if (!string.IsNullOrEmpty(text) &&
((p.Switch ?? string.Empty).Trim().Length != 0 ||
(!string.IsNullOrEmpty(p.Var) && !string.IsNullOrEmpty(p.Value))))
{
if ((Options & UsageOptions.UsageLine) != 0)
sw.WriteLine();
break;
}
}
sw.Write(getArgsUsage(context, width, items));
return sw.ToString();
}
/// Get script usage, not exceeding the given width (-1 = autodetect width)
public string GetAutoUsage(Script s, int width)
{
string id = s.Id;
if (string.IsNullOrEmpty(id))
id=Path.GetFileNameWithoutExtension(s.Location).ToUpperInvariant();
StringWriter sw = new StringWriter();
string desc = null;
if ((s.Usage.Options & UsageOptions.UseVersionInfo)!=0)
desc=s.VersionInfo.GenerateInfo(this, true);
CommandLineParameters c=new CommandLineParameters(s.Parameters,s.SwitchPrefixes,s.UnknownSwitches);
sw.Write(s.Usage.GetUsage(this,desc, id, width, c));
return sw.ToString();
}
static void ShowUsage(CommandLineParameters clps)
{
Console.WriteLine("Usage :\n\n\tConsoleRunner [wildcard or filename for story file][...] [parameters]");
Console.WriteLine("\nWhere parameters can be one of the following :" );
foreach(var clp in clps)
{
var typedesc = " ";
if (clp.Type != ParameterType.Flag)
typedesc += "XXXX";
if (clp.Type == ParameterType.Multiple)
typedesc+="[, ...]*";
Console.WriteLine("\n\t -"+string.Join(",-",clp.Names) + typedesc);
Console.WriteLine("\t\t" + clp.Description);
}
}
/// <summary>
/// Execute script against the current Context.
///
/// This method is not intended to be called directly.
/// </summary>
/// <returns>Script return value</returns>
public virtual object ExecuteScript()
{
//
CommandLineParameters c = new CommandLineParameters(Parameters, SwitchPrefixes, UnknownSwitches);
c.ApplyDefaultValues(Context);
c.CheckRequiredValues(Context);
return ReturnValue.Unwrap(base.Execute());
}
private static CommandLineParameters getXsParams()
{
CommandLineParameters args = new CommandLineParameters(
new[]
{
new CommandLineParameter {Value = "Syntax: XSharper [<script>] [//engine parameters] [<script parameters>]"},
new CommandLineParameter {},
new CommandLineParameter {Value = "Parameters may be specified as /name value, or as /name=value, or as /name:value. Parameter names are case insensitive."},
new CommandLineParameter {},
new CommandLineParameter(xs.script, null, CommandLineValueCount.Single, null, null) {Description = "script.xsh", Value = "XML file to execute. If . (dot) is specified, <xsharper> section from the configuration file is loaded."},
new CommandLineParameter(xs.scriptargs, null, CommandLineValueCount.Multiple, null, null) {Description = "<script parameters>"},
new CommandLineParameter {},
new CommandLineParameter {Value = " --- basic parameters ---"},
new CommandLineParameter(xs.config, CommandLineValueCount.None, null, "true") {Value = "Use an alternative configuration file", Description = "app.config"},
new CommandLineParameter(xs.quiet, CommandLineValueCount.None, null, "true") {Value = "Don't display informational messages"},
new CommandLineParameter(xs.debug, CommandLineValueCount.None, "0", "true") {Value = "Turn on additional debug output (visible with dbgview)"},
new CommandLineParameter(xs.debugc, CommandLineValueCount.None, "0", "true") {Value = "Turn on additional debug output (written to console)"},
new CommandLineParameter(xs.verbose, CommandLineValueCount.None, "0", "true") {Value = "Turn on script engine debug output"},
new CommandLineParameter(xs.trace, CommandLineValueCount.None, null, "true") {Value = "Trace script progress"},
new CommandLineParameter(xs.wait, CommandLineValueCount.None, null, "true") {Value = "Display execution time and wait for user input before terminating"},
new CommandLineParameter(xs.nocolors, CommandLineValueCount.None, null, "true") {Value = "Output to console in the same color"},
new CommandLineParameter(xs.path, CommandLineValueCount.Single, null, "") {Value = "; separated list of directories to search for scripts", Description = "directories", Default = Environment.GetEnvironmentVariable("XSH_PATH")},
new CommandLineParameter(xs.@ref, CommandLineValueCount.Single, null, "") {Value = "; separated list of assemblies or assembly filenames to load", Description = "references", Default = Environment.GetEnvironmentVariable("XSH_REF")},
new CommandLineParameter(xs.log, CommandLineValueCount.Single, null, "xsharper.log") {Value = "Copy all output to the specified file", Description = "log.txt"},
new CommandLineParameter(xs.requireAdmin, CommandLineValueCount.None, null, "Admin") {Value = "Force process elevation to obtain admin privileges (RunAs)"},
new CommandLineParameter(xs.validate, CommandLineValueCount.None, null, "true") {Value = "Validate script signature"},
new CommandLineParameter(xs.utf8, CommandLineValueCount.None, "false", "true") {Value = "Force UTF8 console output. ANSI is used if not specified."},
new CommandLineParameter(xs.last, CommandLineValueCount.None, null, "true") {Last = true, Value = "Stop looking for //* parameters after this"},
new CommandLineParameter {},
new CommandLineParameter {Value = " --- code & schema generation ---"},
new CommandLineParameter(xs.save, CommandLineValueCount.Single, null, "xsharper_save.xsh") {Value = "Save script to the specified xml file", Description = "x.xsh"},
new CommandLineParameter(xs.gensample, CommandLineValueCount.Single, null, "sample.xsh") {Value = "Generate a sample script file x.xsh", Description = "x.xsh"},
new CommandLineParameter(xs.genconfig, CommandLineValueCount.Single, null, "app.config") {Value = "Generate a sample config file", Description = "app.config"},
new CommandLineParameter(xs.genxsd, CommandLineValueCount.Single, null, "*") {Value = "Generate and save XML schema", Description = "schema.xsd"},
new CommandLineParameter(xs.gencs, CommandLineValueCount.Single, null, "*") {Value = "Generate C# source code into file x.cs", Description = "x.cs"},
new CommandLineParameter(xs.forcenet20, CommandLineValueCount.None, null, "true") {Value = "Generate C# source code using .NET 2.0 syntax"},
new CommandLineParameter(xs.@namespace, CommandLineValueCount.Single, null, null) {Value = "Namespace for generated C# code (GUID if not specified)", Description = "namespace"},
new CommandLineParameter(xs.@class, CommandLineValueCount.Single, null, null) {Value = "Class name of the generated C# code"},
new CommandLineParameter(xs.main, CommandLineValueCount.None, null, "true") {Value = "Create Program.Main entry point"},
new CommandLineParameter {},
new CommandLineParameter {Value = " --- executable generation ---"},
new CommandLineParameter(xs.genexe, CommandLineValueCount.Single, null, "*") {Value = "Generate standalone console executable", Description = "x.exe"},
new CommandLineParameter(xs.genwinexe, CommandLineValueCount.Single, null, "*") {Value = "Generate standalone Windows executable", Description = "x.exe"},
new CommandLineParameter(xs.genlibrary, CommandLineValueCount.Single, null, "*") {Value = "Generate standalone assembly", Description = "x.dll"},
new CommandLineParameter(xs.icon, CommandLineValueCount.Single) {Value = "Icon file for the produced executable (requires .NET 3.5 compiler)", Description = "x.ico"},
new CommandLineParameter(xs.compilerOptions, CommandLineValueCount.Single, null, null) {Value = "Extra C# compiler options", Description = "options"},
new CommandLineParameter(xs.noSrc, CommandLineValueCount.None, null, "true") {Value = "Do not include C# source code into the executable"},
new CommandLineParameter(xs.codeout, CommandLineValueCount.Single, null, null) {Value = "Save temporary .cs files in this directory", Description = "directory"},
new CommandLineParameter {},
new CommandLineParameter {Value = " --- inline scripts ---"},
new CommandLineParameter(xs.execRest, "/", CommandLineValueCount.Multiple, null, "true") {Last = true, Value = "Execute a piece of xml or C# code until the end of the line, replacing ` with \"", Description = "code"},
new CommandLineParameter(xs.execRestD, "/#", CommandLineValueCount.Multiple, null, "true") {Synonyms = "/#?", Last = true, Value = "Same as above, but evaluate and dump the result", Description = "code"},
new CommandLineParameter(xs.execRestP, "/p", CommandLineValueCount.Multiple, null, "true") {Last = true, Value = "Same as above, but evaluate and print the result", Description = "code"},
new CommandLineParameter {},
new CommandLineParameter {Value = " --- built-in scripts (use /" + xs.save.Replace("xs.", "/") + " to save instead of executing) ---"},
new CommandLineParameter(xs.download, CommandLineValueCount.Multiple, null, null) {Unspecified = "/?", Description = "uri", Value = "Download from url, and save to file"},
new CommandLineParameter(xs.zip, CommandLineValueCount.Multiple, null, null) {Unspecified = "/?", Value = "Archive directory to a .zip file", Description = "archive.zip"},
new CommandLineParameter(xs.unzip, CommandLineValueCount.Multiple, null, null) {Unspecified = "/?", Value = "Extract a .zip file to directory", Description = "archive.zip",},
new CommandLineParameter(xs.version, CommandLineValueCount.None, null, "true") {Value = "Display XSharper version"},
new CommandLineParameter {},
new CommandLineParameter {Value = " --- utilitites ---"},
new CommandLineParameter(xs.upgrade, CommandLineValueCount.None, null, "true") {Value = "Upgrade this executable to the latest XSharper version"},
new CommandLineParameter(xs.help, CommandLineValueCount.Single, null, "") {Value = "If action or class name is not specified, display this text. If action is *, display the list of actions. Otherwise display specific action/class help", Description = "action/class"},
// These are undocumented test commands
new CommandLineParameter(xs.testElevation, CommandLineValueCount.None, null, "true"),
new CommandLineParameter(xs.updateStage, CommandLineValueCount.Multiple, null, null)
}, "//", false);
foreach (var a in args)
if (!string.IsNullOrEmpty(a.Name) && string.IsNullOrEmpty(a.Switch) && a.Name!=xs.script && a.Name!=xs.scriptargs)
a.Switch = a.Name.Replace("xs.","");
return args;
}
/// <summary>
/// Initializes a new instance of the <b>ExportQueryOperation</b> class.
/// </summary>
/// <param name="parameters"></param>
public ExportQueryOperation(CommandLineParameters parameters)
: base(parameters)
{
}
public CompilerDriver(CommandLineParameters args)
{
Args = args;
}
public static int Help(ScriptContext context, UsageGenerator usage, CommandLineParameters xsParams)
{
context.WriteLine(OutputType.Bold, GetLogo(context));
context.WriteLine();
var command = context.GetStr(xs.help, null);
if (!string.IsNullOrEmpty(command))
{
var tt = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
tt["param"] = typeof (CommandLineParameter);
tt["versionInfo"] = typeof(VersionInfo);
tt["usage"] = typeof(UsageGenerator);
foreach (var s in context.GetKnownTypes())
{
foreach (var at in CustomAttributeHelper.All<XsTypeAttribute>(s))
if (!string.IsNullOrEmpty(at.Name))
tt[at.Name] = s;
}
Type type;
if (tt.TryGetValue(command,out type))
{
writeCommandHelp(context, type, usage.CorrectWidth(-1));
return -2;
}
if (command == "*")
{
List<Var> v = new List<Var>();
v.Add(new Var("param",getDescr(typeof(CommandLineParameter))));
v.Add(new Var("versioninfo", getDescr(typeof(VersionInfo))));
v.Add(new Var("usage", getDescr(typeof(UsageGenerator))));
foreach (var s in context.GetKnownTypes())
{
var xst = CustomAttributeHelper.First<XsTypeAttribute>(s);
if (xst == null || string.IsNullOrEmpty(xst.Name))
continue;
v.Add(new Var(xst.Name, getDescr(s)));
}
v.Sort((a, b) => string.Compare(a.Name, b.Name));
v.Insert(0, new Var("Actions:", null));
v.Insert(1, new Var("", null));
Utils.WrapTwoColumns(context.Out, v, 30, usage.CorrectWidth(-1));
return -2;
}
if (command.StartsWith(".", StringComparison.Ordinal))
{
bool success = false;
foreach (var nn in ((IEvaluationContext)context).GetNonameObjects())
{
success =writeTypeHelp(context, nn.Type, new StringFilter(command.Substring(1)),usage.CorrectWidth(-1)) || success;
}
if (!success)
context.Error.WriteLine("Cannot find method '" + command + "'. ");
return -2;
}
Type t = context.FindType(command);
if (t == null)
t = context.FindType("XS." + command);
if (t != null)
writeTypeHelp(context, t, null, usage.CorrectWidth(-1));
else if (command.Contains("?") || command.Contains("*"))
{
var r = Utils.WildcardToRegex(command, RegexOptions.IgnoreCase);
foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
foreach (var ttt in a.GetTypes())
if (ttt != null && ttt.IsPublic && (r.IsMatch(ttt.Name) || r.IsMatch(Dump.GetFriendlyTypeName(ttt))))
{
context.WriteLine(Dump.GetFriendlyTypeName(ttt,true));
}
}
else
context.Error.WriteLine("Cannot find command or type '" + command + "'. Use //help * to display the list of commands");
}
else
context.WriteLine(usage.GetUsage(context, null, null, -1, xsParams));
return -2;
}
private object GetTargetsObjectFromAssembly(MethodInfo getTargetsMethod, CommandLineParameters parameters)
{
ParameterInfo[] methodParameters = getTargetsMethod.GetParameters();
if (methodParameters.Length == 1) {
if (methodParameters[0].ParameterType.IsAssignableFrom(typeof(IParameters)))
{
return getTargetsMethod.Invoke(null, new[] { parameters });
}
}
if (methodParameters.Length == 0) {
return getTargetsMethod.Invoke(null, new object[0]);
}
throw new TargetsMethodWrongSignatureException(getTargetsMethod.Name);
}
static int Main(string[] args)
{
var p = new CommandLineParameters();
p.Define().Name("html").Describe("[Experimental] Output to html unordered lists").Allow(ParameterType.Flag);
p.Define().Name("fmthdr", "formatheader").Describe("Header to put before starting the children output; example \"<ul>\"");
p.Define().Name("fmt", "formatter").Describe("Named storyformatter; example \"<li>{Type} {Description} <a href='#' title='{StatusInfo}'>{StatusText}</a></li>\"");
p.Define().Name("fmtftr", "formatfooter").Describe("Footer to put after ending the children output; example \"</ul>\"");
p.Define().Name("h", "?", "help").Describe("Show the syntax of the commandline parameters").Allow(ParameterType.Flag);
p.Define().Name("v", "verbose").Describe("Show verbose output").Allow(ParameterType.Flag);
p.Define().Name("p", "parseonly").Describe("Only parse the files to look for syntax errors").Allow(ParameterType.Flag);
p.Define().Name("d", "dsl").Describe("Show the available DSL definitions").Allow(ParameterType.Flag);
p.Define().Name("c", "context").Describe("The full classname of the default context class to use").Allow(ParameterType.Single);
p.Define().Name("a", "assembly").Describe("The full name of the assembly the default context class is in").Allow(ParameterType.Single);
p.Define().Name("db","debugbreak").Describe("Invoke an assert so you can attach a debugger").Allow(ParameterType.Flag);
//p.Define().Name("s", "syntax").Describe("Filename of a syntax definition file").Allow(ParameterType.Single);
p.ParseLine(string.Join(" ", args));
if (p["help"].Count > 0)
{
ShowHeader("","");
ShowUsage(p);
return 0;
}
if (p.Unnamed.Count == 0 && p["d"].Count ==0)
{
ShowHeader("","");
Console.WriteLine("Error : no story files defined or dsl requested; use the switch /h for usage info");
return -1;
}
var fmthdr = p["fmthdr"];
var fmt = p["fmt"];
var fmtftr = p["fmtftr"];
if (p["html"].Count > 0)
{
fmthdr.Clear();fmthdr.Add("<ul>");
fmt.Clear(); fmt.Add("<li>{Type} {Description} <a href='#' title='{StatusInfo}'>{StatusText}</a></li>");
fmtftr.Clear(); fmtftr.Add("</ul>");
}
if (fmthdr.Count == 0) fmthdr.Add("");
if (fmt.Count == 0) fmt.Add("{Type} {Description} =>{StatusText} {StatusInfo}");
if (fmtftr.Count == 0) fmtftr.Add("");
ShowHeader(fmthdr[0],fmtftr[0]);
var storyextractor = new TextStoryExtractor();
var dslextractor = new TextDSLExtractor();
if (p["a"].Count > 0 && p["c"].Count > 0)
{
dslextractor.AddDSL("default", p["c"][0], p["a"][0]);
}
Console.Write(fmthdr[0]);
Console.WriteLine("Parsing files");
foreach (var arg in p.Unnamed)
{
Console.Write(fmthdr[0]);
Console.WriteLine(" Processing file(s) : " + arg);
foreach (var fn in Directory.GetFiles(Directory.GetCurrentDirectory(), arg))
{
Console.Write(fmthdr[0]);
Console.WriteLine(" Parsing file : " + fn);
foreach (var line in File.ReadAllLines(fn))
{
if (string.IsNullOrEmpty(line) || line.Trim() == "") continue;
var st = "Skipped";
if (dslextractor.ParseLine(line))
{ st = "Parsed DSL"; }
else if (storyextractor.ParseLine(line))
{ st = "Parsed element"; }
if (p["v"].Count > 0)
{
Console.Write(fmthdr[0]);
Console.WriteLine(" "+st+" : " + line);
Console.Write(fmtftr[0]);
}
}
Console.Write(fmtftr[0]);
}
Console.Write(fmtftr[0]);
}
Console.Write(fmtftr[0]);
if (p["v"].Count + p["p"].Count > 0)
{
Console.Write(fmthdr[0]);
Console.WriteLine("Stories:");
foreach (var sc in storyextractor.Stories)
{
Console.Write(fmthdr[0]);
Console.Write(" "+sc.Story.Description);
Console.WriteLine(fmtftr[0]);
}
Console.WriteLine(fmtftr[0]);
}
if (p["v"].Count + p["d"].Count > 0)
{
Console.Write(fmthdr[0]);
Console.WriteLine("DSLs:");
foreach (var sc in dslextractor.DSLs.Values)
{
Console.Write(fmthdr[0]);
Console.WriteLine(" "+ sc.Name + " [" + sc.ContextType.FullName + "]" );
foreach (var r in sc.Elements)
{
Console.Write(fmthdr[0]);
Console.Write(" "+r.Description);
Console.WriteLine(fmtftr[0]);
}
Console.WriteLine(fmtftr[0]);
}
Console.WriteLine(fmtftr[0]);
}
if (p["db"].Count > 0)
{
Console.WriteLine("Please attach the debugger to this process and press return");
Console.ReadLine();
}
if (p["p"].Count == 0)
{
var runner = new SpecRunner();
Console.Write(fmthdr[0]);
Console.WriteLine("Running Tests");
foreach (var sc in storyextractor.Stories)
{
Console.WriteLine(fmthdr[0]);
var dsl = runner.GetDSL(sc.Story, dslextractor.DSLs);
dsl = dsl ?? dslextractor.DSLs["default"];
PrettyPrint(runner.RunStory(sc.Story, dsl, sc.ColumnToken), 1, fmthdr[0], fmt[0], fmtftr[0]);
Console.WriteLine(fmtftr[0]);
}
Console.Write(fmtftr[0]);
}
return 0;
}
/// Parse command line arguments
public void ParseArguments(IEnumerable<string> args)
{
CommandLineParameters c = new CommandLineParameters(Parameters, SwitchPrefixes, UnknownSwitches);
c.Parse(Context, args, (Usage.Options & UsageOptions.IfHelp) != 0);
}
private string getArgsUsage(ScriptContext context, int width, CommandLineParameters items)
{
List<Var> sb = new List<Var>();
foreach (CommandLineParameter p in items)
{
string text = p.GetTransformedValue(context);
string vardescr = p.GetDescription(context);
string name;
bool emptyName = (p.Switch ?? string.Empty).Trim().Length == 0;
if (emptyName && string.IsNullOrEmpty(p.Var))
name = p.Switch ?? string.Empty;
else
{
if (string.IsNullOrEmpty(text))
continue;
if (emptyName)
name = " ";
else
{
var pp = items.GetSwitchPrefixesArray();
name = " " + ((pp != null && pp.Length > 0) ? pp[0] : string.Empty) + p.Switch;
}
}
if (p.Count != CommandLineValueCount.None)
{
if (p.Unspecified == null || emptyName)
{
if (!string.IsNullOrEmpty(vardescr))
name += " " + vardescr;
}
else
name += " [" + vardescr + "]";
}
StringBuilder vb = new StringBuilder();
vb.Append(text);
if ((Options & UsageOptions.AutoSuffix) != 0)
{
if (p.Required)
vb.Append(" (required)");
else if (p.Default != null && p.Count != CommandLineValueCount.None)
{
string def = Utils.To<string>(context.Transform(p.Default, p.Transform));
vb.Append(" (default: " + def + ")");
}
}
Var v = new Var(name, vb.ToString());
sb.Add(v);
}
StringWriter sw = new StringWriter();
Utils.WrapTwoColumns(sw, sb, 30, width);
return sw.ToString();
}
