public virtual ISubCommand Create(string[] args, ISubCommandController controller, SubCommandParseOption option)
{
var parser = CommandUtility.GetParser(option);
var options = Activator.CreateInstance <TOptions>();
bool parsed = parser.ParseArguments(args, options);
if (!parsed && option == SubCommandParseOption.Strict)
{
throw new OptionParserException();
}
var helpOption = options as ICanPrintHelpMessage;
if (helpOption != null && helpOption.PrintHelpMessage)
{
return(new HelpCommand(GetHelpText()));
}
var logOption = options as ILoggable;
if (logOption != null)
{
if (!string.IsNullOrWhiteSpace(logOption.LogFilePath))
{
Logger.AddOrReplaceListener(new ReportLogListener(logOption.LogFilePath), TypeEqualityComparer.Default);
}
if (logOption.LogLevel.HasValue)
{
Logger.LogLevelThreshold = logOption.LogLevel.Value;
}
}
return(CreateCommand(options, controller));
}
public override HelpCommand CreateCommand(HelpCommandOptions options, ISubCommandController controller)
{
if (string.IsNullOrEmpty(options.Command))
{
return(new HelpCommand(controller.GetHelpText()));
}
if (controller.TryGetCommandCreator(options.Command, out ISubCommandCreator creator))
{
return(new HelpCommand(creator.GetHelpText()));
}
else
{
throw new OptionParserException($"{options.Command} is not a supported sub command.");
}
}
public CompositeCommand(string[] args, ISubCommandController controller, CompositeOptions options)
{
var result = ToOrderedKeyValuePair(options.ConfigFile);
foreach (var pair in result)
{
ISubCommandCreator command;
if (!controller.TryGetCommandCreator(pair.Key, out command))
{
Logger.LogWarning($"{pair.Key} is not a recognized command name, ignored.");
}
else
{
Commands.Add(command.Create(args, controller, SubCommandParseOption.Loose));
}
}
}
public CompositeCommand(string[] args, ISubCommandController controller, CompositeOptions options)
{
var result = ToOrderedKeyValuePair(options.ConfigFile);
foreach (var pair in result)
{
if (!controller.TryGetCommandCreator(pair.Key, out ISubCommandCreator command))
{
Logger.LogWarning($"{pair.Key} is not a recognized command name, ignored.");
}
else
{
Commands.Add(command.Create(args, controller, SubCommandParseOption.Loose));
}
}
}
public virtual ISubCommand Create(string[] args, ISubCommandController controller, SubCommandParseOption option)
{
var parser = CommandUtility.GetParser(option);
var options = Activator.CreateInstance <TOptions>();
bool parsed = parser.ParseArguments(args, options);
if (!parsed && option == SubCommandParseOption.Strict)
{
throw new OptionParserException();
}
var helpOption = options as ICanPrintHelpMessage;
if (helpOption != null && helpOption.PrintHelpMessage)
{
return(new HelpCommand(GetHelpText()));
}
string root = string.Empty;
var buildOption = options as BuildCommandOptions;
if (buildOption != null)
{
root = Path.GetDirectoryName(buildOption.ConfigFile);
}
var logOption = options as ILoggable;
if (logOption != null)
{
if (!string.IsNullOrWhiteSpace(logOption.LogFilePath) && Logger.FindListener(l => l is ReportLogListener) == null)
{
if (string.IsNullOrWhiteSpace(logOption.RepoRoot))
{
Logger.RegisterListener(new ReportLogListener(logOption.LogFilePath, string.Empty, root));
}
else
{
Logger.RegisterListener(new ReportLogListener(logOption.LogFilePath, logOption.RepoRoot, root));
}
}
if (logOption.LogLevel.HasValue)
{
Logger.LogLevelThreshold = logOption.LogLevel.Value;
}
}
return(CreateCommand(options, controller));
}
public virtual ISubCommand Create(string[] args, ISubCommandController controller, SubCommandParseOption option)
{
var parser = CommandUtility.GetParser(option);
var options = Activator.CreateInstance <TOptions>();
bool parsed = parser.ParseArguments(args, options);
if (!parsed && option == SubCommandParseOption.Strict)
{
throw new OptionParserException();
}
var helpOption = options as ICanPrintHelpMessage;
if (helpOption != null && helpOption.PrintHelpMessage)
{
return(new HelpCommand(GetHelpText()));
}
var buildOption = options as BuildCommandOptions;
string root = Path.GetDirectoryName(buildOption?.ConfigFile ?? Directory.GetCurrentDirectory());
var logOption = options as LogOptions;
if (logOption != null)
{
if (!string.IsNullOrWhiteSpace(logOption.LogFilePath) && Logger.FindAsyncListener(l => l is ReportLogListener) == null)
{
Logger.RegisterAsyncListener(new ReportLogListener(logOption.LogFilePath, logOption.RepoRoot ?? string.Empty, root));
}
if (logOption.LogLevel.HasValue)
{
Logger.LogLevelThreshold = logOption.LogLevel.Value;
}
Logger.WarningsAsErrors = logOption.WarningsAsErrors;
if (!string.IsNullOrEmpty(logOption.CorrelationId))
{
if (AmbientContext.CurrentContext == null)
{
AmbientContext.InitializeAmbientContext(logOption.CorrelationId);
}
}
}
return(CreateCommand(options, controller));
}
public CompositeCommand(string[] args, ISubCommandController controller, CompositeOptions options)
{
var result = ToOrderedKeyValuePair(options.ConfigFile);
foreach (var pair in result)
{
if (!controller.TryGetCommandCreator(pair.Key, out ISubCommandCreator command))
{
if (!pair.Key.Equals("$schema", StringComparison.Ordinal))
{
Logger.LogWarning($"{pair.Key} is not a recognized command name, ignored.");
}
}
else
{
Commands.Add(command.Create(args, controller, SubCommandParseOption.Loose));
}
}
AllowReplay = Commands.Any(c => c.AllowReplay);
}
public abstract TCommand CreateCommand(TOptions options, ISubCommandController controller);
public override InitCommand CreateCommand(InitCommandOptions options, ISubCommandController controller)
{
return(new InitCommand(options));
}
public override ExportCommand CreateCommand(ExportCommandOptions options, ISubCommandController controller)
{
return(new ExportCommand(options));
}
public override TemplateCommand CreateCommand(TemplateCommandOptions options, ISubCommandController controller)
{
return(new TemplateCommand(options));
}
public override DownloadCommand CreateCommand(DownloadCommandOptions options, ISubCommandController controller)
{
return(new DownloadCommand(options));
}
public override PdfCommand CreateCommand(PdfCommandOptions options, ISubCommandController controller)
{
return(new PdfCommand(options));
}
public override MetadataCommand CreateCommand(MetadataCommandOptions options, ISubCommandController controller)
{
return new MetadataCommand(options);
}
public override MergeCommand CreateCommand(MergeCommandOptions options, ISubCommandController controller)
{
return(new MergeCommand(options));
}
public override BuildCommand CreateCommand(BuildCommandOptions options, ISubCommandController controller)
{
return(new BuildCommand(options));
}
public override DependencyCommand CreateCommand(DependencyCommandOptions options, ISubCommandController controller)
{
return(new DependencyCommand(options));
}
public override ServeCommand CreateCommand(ServeCommandOptions options, ISubCommandController controller)
{
return(new ServeCommand(options));
}
