public void CanLoadMultipleCommands()
{
var commands = new CommandLoader().LoadCommandsFrom(this);
Assert.True(commands["hello"] != null);
Assert.True(commands["goodbye"] != null);
}
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args)
{
await CommandLoader.InitAsync(args);
Text.Line();
Text.Cyan("Genesis"); Text.GrayLine($" {Program.GetVersionDisplayString()}");
Text.Line();
foreach (var cmd in CommandLoader.Commands)
{
if (cmd.Name == string.Empty) //default command leaves an empty line otherwise
{
continue;
}
Text.Green($"\t{cmd.Name}"); Text.WhiteLine($"\t{cmd.Description}");
}
Text.Line();
return(await Task.FromResult(new BlankGenesisExecutionResult()
{
Success = true, Message = ""
}));
}
private void Init()
{
commandsUtils = new CommandsUtils();
List <ICommand> loaderList = CommandLoader.Load();
commandsUtils.RegCommands(loaderList);
}
private static void WriteHelp(
string commandName,
bool online,
bool manual,
bool includeValues,
Filter filter = null)
{
if (online)
{
OpenHelpInBrowser(commandName);
}
else if (commandName != null)
{
Command command = CommandLoader.LoadCommand(typeof(HelpCommand).Assembly, commandName);
if (command == null)
{
throw new InvalidOperationException($"Command '{commandName}' does not exist.");
}
WriteCommandHelp(command, includeValues: includeValues, filter: filter);
}
else if (manual)
{
WriteManual(includeValues: includeValues, filter: filter);
}
else
{
WriteCommandsHelp(includeValues: includeValues, filter: filter);
}
}
internal static MapContextCommand ShowMapContextMenu(Control parent, Point location, MapContextCommand[] hideCommands, CommandManager commandManager)
{
Command returnCommand;
using (CommandLoader commandLoader = new CommandLoader(commandManager, FilterMapContextMenuCommands(hideCommands)))
{
CommandContextMenuDefinition ccmd = new CommandContextMenuDefinition();
ccmd.CommandBar = false;
ccmd.Entries.Add(CommandId.MapAddPushpin, false, true);
ccmd.Entries.Add(CommandId.MapZoomStreetLevel, false, false);
ccmd.Entries.Add(CommandId.MapZoomCityLevel, false, false);
ccmd.Entries.Add(CommandId.MapZoomRegionLevel, false, false);
ccmd.Entries.Add(CommandId.MapCenterMap, false, false);
returnCommand = CommandContextMenu.ShowModal(
commandManager, parent, location, ccmd);
}
if (returnCommand != null)
{
return((MapContextCommand)_mapCommandIds[Enum.Parse(typeof(CommandId), returnCommand.Identifier)]);
}
else
{
return(MapContextCommand.None);
}
}
public override void Action(CommandCaller caller, string input, string[] args)
{
if (args.Length > 0)
{
if (!CommandLoader.GetCommand(caller, args[0], out ModCommand mc))
{
throw new UsageException("Unknown command: " + args[0], Color.Red);
}
if (mc != null)
{
caller.Reply(mc.Usage);
if (!string.IsNullOrEmpty(mc.Description))
{
caller.Reply(mc.Description);
}
}
return;
}
var help = CommandLoader.GetHelp(caller.CommandType);
caller.Reply(caller.CommandType + " Commands:", Color.Yellow);
foreach (var entry in help)
{
caller.Reply(entry.Item1 + " " + entry.Item2);
}
if (Main.netMode == 1)
{
//send the command to the server
ChatHelper.SendChatMessageFromClient(new ChatMessage(input));
}
}
private static void Main(string[] args)
{
var bot = new BotBitsClient();
// Events
EventLoader
.Of(bot)
.LoadStatic <Program>();
// Commands
CommandsExtension.LoadInto(bot, '!', '.');
CommandLoader
.Of(bot)
.LoadStatic <Program>();
// Login
Login.Of(bot)
.AsGuest()
.CreateJoinRoom("PW01");
// Console commands
while (true)
{
CommandManager.Of(bot).ReadNextConsoleCommand();
}
}
private SessionHandler GetSessionHandler()
{
var path = Environment.CurrentDirectory;
var commandLoader = new CommandLoader(new PluginsPath(path + "\\..\\..\\..\\bin\\Debug\\Plugins"),
new MockEventStorage(), new MockPersonsStorage());
return(new SessionHandler(commandLoader));
}
public void CanRunHelloCommand()
{
using (StringWriter sw = new StringWriter())
{
Console.SetOut(sw);
var commands = new CommandLoader().LoadCommandsFrom(this);
commands["hello"].Invoke(null);
Assert.Equal("Output from hello command!", sw.ToString());
}
}
public Commands()
{
InitializeFinish += (sender, e) =>
{
roundsManager = RoundsManager.Of(BotBits);
if (!CommandsExtension.IsLoadedInto(BotBits))
{
return;
}
CommandLoader.Of(BotBits).Load(this);
requireModerator = PermissionsExtension.IsLoadedInto(BotBits);
};
}
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args)
{
await CommandLoader.InitAsync(args);
Text.Line();
Text.Cyan("Genesis"); Text.GrayLine($" {Program.GetVersionDisplayString()}");
Text.Line();
foreach (var cmd in CommandLoader.Commands)
{
Text.Green($"\t{cmd.Name}"); Text.WhiteLine($"\t{cmd.Description}");
}
return(await Task.FromResult(new BlankTaskResult()
{
Success = true, Message = ""
}));
}
internal static PushpinContextCommand ShowPushpinContextMenu(Control parent, Point location, CommandManager commandManager)
{
Command command;
using (CommandLoader commandLoader = new CommandLoader(commandManager, PushpinContextMenuIds))
{
CommandContextMenuDefinition ccmd = new CommandContextMenuDefinition();
ccmd.CommandBar = false;
ccmd.Entries.Add(CommandId.MapEditPushpin, false, false);
ccmd.Entries.Add(CommandId.MapDeletePushpin, false, false);
command = CommandContextMenu.ShowModal(
commandManager, parent, location, ccmd);
}
if (command != null)
{
return((PushpinContextCommand)_pushpinCommandIds[Enum.Parse(typeof(CommandId), command.Identifier)]);
}
else
{
return(PushpinContextCommand.None);
}
}
private static void Main(params string[] args)
{
IEnumerable <Command> commands = CommandLoader.LoadCommands(typeof(CommandLoader).Assembly)
.Select(c => c.WithOptions(c.Options.OrderBy(f => f, CommandOptionComparer.Instance)))
.OrderBy(c => c.Name, StringComparer.InvariantCulture);
var application = new CommandLineApplication(
"orang",
"Search, replace, rename and delete files and its content using the power of .NET regular expressions.",
commands.OrderBy(f => f.Name, StringComparer.InvariantCulture));
string destinationDirectoryPath = null;
string dataDirectoryPath = null;
if (Debugger.IsAttached)
{
destinationDirectoryPath = (args.Length > 0) ? args[0] : @"..\..\..\..\..\docs\cli";
dataDirectoryPath = @"..\..\..\data";
}
else
{
destinationDirectoryPath = args[0];
dataDirectoryPath = @"..\src\DocumentationGenerator\data";
}
string readmeFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, "README.md"));
using (var sw = new StreamWriter(readmeFilePath, append: false, Encoding.UTF8))
using (MarkdownWriter mw = MarkdownWriter.Create(sw))
{
mw.WriteHeading1("Orang Command-Line Interface");
mw.WriteString(application.Description);
mw.WriteLine();
mw.WriteHeading2("Commands");
foreach (Command command in application.Commands)
{
mw.WriteStartBulletItem();
mw.WriteLink(command.Name, command.Name + "-command.md");
mw.WriteEndBulletItem();
}
mw.WriteLine();
string readmeLinksFilePath = Path.Combine(dataDirectoryPath, "readme_bottom.md");
if (File.Exists(readmeLinksFilePath))
{
mw.WriteRaw(File.ReadAllText(readmeLinksFilePath));
}
WriteFootNote(mw);
Console.WriteLine(readmeFilePath);
}
string valuesFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, "AllowedValues.md"));
ImmutableArray <OptionValueProvider> providers = HelpProvider.GetProviders(commands).ToImmutableArray();
MDocument document = Document(
Heading1("List of Allowed Values"),
BulletList(providers.Select(f => Link(f.Name, "#" + f.Name
.ToLower()
.Replace("<", "")
.Replace(">", "")
.Replace("_", "-")))),
providers.Select(provider =>
{
return(new MObject[]
{
Heading2(provider.Name),
Table(
TableRow("Value", "Description"),
provider.Values.Select(f => TableRow(f.HelpValue, f.Description)))
});
}));
var markdownFormat = new MarkdownFormat(tableOptions: MarkdownFormat.Default.TableOptions | TableOptions.FormatContent);
File.WriteAllText(valuesFilePath, document.ToString(markdownFormat));
foreach (Command command in application.Commands)
{
readmeFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, $"{command.Name}-command.md"));
using (var sw = new StreamWriter(readmeFilePath, append: false, Encoding.UTF8))
using (MarkdownWriter mw = MarkdownWriter.Create(sw))
{
var writer = new DocumentationWriter(mw);
writer.WriteCommandHeading(command, application);
writer.WriteCommandDescription(command);
writer.WriteCommandSynopsis(command, application);
writer.WriteArguments(command.Arguments);
writer.WriteOptions(command.Options);
string samplesFilePath = Path.Combine(dataDirectoryPath, command.Name + "_bottom.md");
if (File.Exists(samplesFilePath))
{
string content = File.ReadAllText(samplesFilePath);
mw.WriteRaw(content);
}
WriteFootNote(mw);
Console.WriteLine(readmeFilePath);
}
}
Console.WriteLine("Done");
if (Debugger.IsAttached)
{
Console.ReadKey();
}
}
private static void Main(params string[] args)
{
IEnumerable <Command> commands = CommandLoader.LoadCommands(typeof(CommandLoader).Assembly)
.Select(c => c.WithOptions(c.Options.OrderBy(f => f, CommandOptionComparer.Name)))
.OrderBy(c => c.Name, StringComparer.InvariantCulture);
var application = new CommandLineApplication(
"roslynator",
"Roslynator Command-line Tool",
commands.OrderBy(f => f.Name, StringComparer.InvariantCulture));
string destinationDirectoryPath = null;
string dataDirectoryPath = null;
if (Debugger.IsAttached)
{
destinationDirectoryPath = (args.Length > 0) ? args[0] : @"..\..\..\..\..\docs\cli";
dataDirectoryPath = @"..\..\..\data";
}
else
{
destinationDirectoryPath = args[0];
dataDirectoryPath = @"..\src\CommandLine.DocumentationGenerator\data";
}
foreach (Command command in application.Commands)
{
string commandFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, $"{command.Name}-command.md"));
using (var sw = new StreamWriter(commandFilePath, append: false, Encoding.UTF8))
using (MarkdownWriter mw = MarkdownWriter.Create(sw))
{
var writer = new DocumentationWriter(mw);
mw.WriteLine();
writer.WriteCommandHeading(command, application);
writer.WriteCommandDescription(command);
mw.WriteLink("Home", "README.md");
string additionalContentFilePath = Path.Combine(dataDirectoryPath, command.Name + "_bottom.md");
string additionalContent = (File.Exists(additionalContentFilePath))
? File.ReadAllText(additionalContentFilePath)
: "";
var sections = new List <string>()
{
"Synopsis", "Arguments", "Options"
};
if (Regex.IsMatch(additionalContent, @"^\#+ Examples", RegexOptions.Multiline))
{
sections.Add("Examples");
}
foreach (string section in sections)
{
mw.WriteString(" ");
mw.WriteCharEntity((char)0x2022);
mw.WriteString(" ");
mw.WriteLink(section, "#" + section);
}
mw.WriteLine();
writer.WriteCommandSynopsis(command, application);
writer.WriteArguments(command.Arguments);
writer.WriteOptions(command.Options);
if (!string.IsNullOrEmpty(additionalContent))
{
mw.WriteLine();
mw.WriteLine();
mw.WriteRaw(additionalContent);
}
WriteFootNote(mw);
Console.WriteLine(commandFilePath);
}
}
Console.WriteLine("Done");
if (Debugger.IsAttached)
{
Console.ReadKey();
}
}
public ConsoleHandler(CommandLoader commands)
{
_commands = commands;
}
private static int Main(string[] args)
{
#if DEBUG
if (args.LastOrDefault() == "--debug")
{
WriteArgs(args.Take(args.Length - 1).ToArray(), Verbosity.Quiet);
return(ExitCodes.NotSuccess);
}
#endif
Parser parser = null;
try
{
parser = CreateParser(ignoreUnknownArguments: true);
if (args == null ||
args.Length == 0)
{
HelpCommand.WriteCommandsHelp();
return(ExitCodes.Success);
}
bool?success = null;
ParserResult <BaseCommandLineOptions> defaultResult = parser
.ParseArguments <BaseCommandLineOptions>(args)
.WithParsed(options =>
{
if (!options.Help)
{
return;
}
string commandName = args?.FirstOrDefault();
Command command = (commandName != null)
? CommandLoader.LoadCommand(typeof(Program).Assembly, commandName)
: null;
if (!ParseVerbosityAndOutput(options))
{
success = false;
return;
}
WriteArgs(args, Verbosity.Diagnostic);
if (command != null)
{
HelpCommand.WriteCommandHelp(command);
}
else
{
HelpCommand.WriteCommandsHelp();
}
success = true;
});
if (success == false)
{
return(ExitCodes.Error);
}
if (success == true)
{
return(ExitCodes.Success);
}
parser = CreateParser();
ParserResult <object> parserResult = parser.ParseArguments(
args,
new Type[]
{
typeof(AnalyzeCommandLineOptions),
typeof(FixCommandLineOptions),
typeof(FormatCommandLineOptions),
typeof(GenerateDocCommandLineOptions),
typeof(GenerateDocRootCommandLineOptions),
typeof(HelpCommandLineOptions),
typeof(ListSymbolsCommandLineOptions),
typeof(LogicalLinesOfCodeCommandLineOptions),
typeof(MigrateCommandLineOptions),
typeof(PhysicalLinesOfCodeCommandLineOptions),
typeof(RenameSymbolCommandLineOptions),
typeof(SpellcheckCommandLineOptions),
#if DEBUG
typeof(AnalyzeAssemblyCommandLineOptions),
typeof(FindSymbolsCommandLineOptions),
typeof(GenerateSourceReferencesCommandLineOptions),
typeof(ListVisualStudioCommandLineOptions),
typeof(ListReferencesCommandLineOptions),
typeof(SlnListCommandLineOptions),
#endif
});
parserResult.WithNotParsed(e =>
{
if (e.Any(f => f.Tag == ErrorType.VersionRequestedError))
{
Console.WriteLine(typeof(Program).GetTypeInfo().Assembly.GetName().Version);
success = false;
return;
}
var helpText = new HelpText(SentenceBuilder.Create(), HelpCommand.GetHeadingText());
helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText);
VerbAttribute verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>();
if (verbAttribute != null)
{
helpText.AddPreOptionsText(Environment.NewLine + HelpCommand.GetFooterText(verbAttribute.Name));
}
Console.Error.WriteLine(helpText);
success = false;
});
if (success == true)
{
return(ExitCodes.Success);
}
if (success == false)
{
return(ExitCodes.Error);
}
parserResult.WithParsed <AbstractCommandLineOptions>(
options =>
{
if (ParseVerbosityAndOutput(options))
{
WriteArgs(args, Verbosity.Diagnostic);
}
else
{
success = false;
}
});
if (success == false)
{
return(ExitCodes.Error);
}
return(parserResult.MapResult(
(MSBuildCommandLineOptions options) =>
{
switch (options)
{
case AnalyzeCommandLineOptions analyzeCommandLineOptions:
return AnalyzeAsync(analyzeCommandLineOptions).Result;
case FixCommandLineOptions fixCommandLineOptions:
return FixAsync(fixCommandLineOptions).Result;
case FormatCommandLineOptions formatCommandLineOptions:
return FormatAsync(formatCommandLineOptions).Result;
case GenerateDocCommandLineOptions generateDocCommandLineOptions:
return GenerateDocAsync(generateDocCommandLineOptions).Result;
case GenerateDocRootCommandLineOptions generateDocRootCommandLineOptions:
return GenerateDocRootAsync(generateDocRootCommandLineOptions).Result;
case ListSymbolsCommandLineOptions listSymbolsCommandLineOptions:
return ListSymbolsAsync(listSymbolsCommandLineOptions).Result;
case LogicalLinesOfCodeCommandLineOptions logicalLinesOfCodeCommandLineOptions:
return LogicalLinesOrCodeAsync(logicalLinesOfCodeCommandLineOptions).Result;
case PhysicalLinesOfCodeCommandLineOptions physicalLinesOfCodeCommandLineOptions:
return PhysicalLinesOfCodeAsync(physicalLinesOfCodeCommandLineOptions).Result;
case RenameSymbolCommandLineOptions renameSymbolCommandLineOptions:
return RenameSymbolAsync(renameSymbolCommandLineOptions).Result;
case SpellcheckCommandLineOptions spellcheckCommandLineOptions:
return SpellcheckAsync(spellcheckCommandLineOptions).Result;
#if DEBUG
case FindSymbolsCommandLineOptions findSymbolsCommandLineOptions:
return FindSymbolsAsync(findSymbolsCommandLineOptions).Result;
case GenerateSourceReferencesCommandLineOptions generateSourceReferencesCommandLineOptions:
return GenerateSourceReferencesAsync(generateSourceReferencesCommandLineOptions).Result;
case ListReferencesCommandLineOptions listReferencesCommandLineOptions:
return ListReferencesAsync(listReferencesCommandLineOptions).Result;
case SlnListCommandLineOptions slnListCommandLineOptions:
return SlnListAsync(slnListCommandLineOptions).Result;
#endif
default:
throw new InvalidOperationException();
}
},
(AbstractCommandLineOptions options) =>
{
switch (options)
{
case HelpCommandLineOptions helpCommandLineOptions:
return Help(helpCommandLineOptions);
case MigrateCommandLineOptions migrateCommandLineOptions:
return Migrate(migrateCommandLineOptions);
#if DEBUG
case AnalyzeAssemblyCommandLineOptions analyzeAssemblyCommandLineOptions:
return AnalyzeAssembly(analyzeAssemblyCommandLineOptions);
case ListVisualStudioCommandLineOptions listVisualStudioCommandLineOptions:
return ListVisualStudio(listVisualStudioCommandLineOptions);
#endif
default:
throw new InvalidOperationException();
}
},
_ => ExitCodes.Error));
}
catch (Exception ex) when(ex is AggregateException ||
ex is FileNotFoundException ||
ex is InvalidOperationException)
{
WriteError(ex);
}
finally
{
parser?.Dispose();
Out?.Dispose();
Out = null;
}
return(ExitCodes.Error);
}
public void CanLoadHelloCommand()
{
var commands = new CommandLoader().LoadCommandsFrom(this);
Assert.True(commands["hello"] != null);
}
private static void Main(params string[] args)
{
IEnumerable <Command> commands = CommandLoader.LoadCommands(typeof(CommandLoader).Assembly)
.Select(c => c.WithOptions(c.Options.OrderBy(f => f, CommandOptionComparer.Name)))
.OrderBy(c => c.Name, StringComparer.InvariantCulture);
var application = new CommandLineApplication(
"orang",
"Search, replace, rename and delete files and its content using the power of .NET regular expressions.",
commands.OrderBy(f => f.Name, StringComparer.InvariantCulture));
string?destinationDirectoryPath = null;
string?dataDirectoryPath = null;
if (Debugger.IsAttached)
{
destinationDirectoryPath = (args.Length > 0) ? args[0] : @"..\..\..\..\..\docs\cli";
dataDirectoryPath = @"..\..\..\data";
}
else
{
destinationDirectoryPath = args[0];
dataDirectoryPath = @"..\src\DocumentationGenerator\data";
}
string readmeFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, "README.md"));
var settings = new MarkdownWriterSettings(
MarkdownFormat.Default.WithTableOptions(
MarkdownFormat.Default.TableOptions | TableOptions.FormatHeaderAndContent));
using (var sw = new StreamWriter(readmeFilePath, append: false, Encoding.UTF8))
using (MarkdownWriter mw = MarkdownWriter.Create(sw, settings))
{
mw.WriteStartHeading(1);
mw.WriteString("Orang Command-Line Interface");
mw.WriteRaw(" <img align=\"left\" src=\"../../images/icon48.png\">");
mw.WriteEndHeading();
mw.WriteString(application.Description);
mw.WriteLine();
mw.WriteHeading2("Commands");
Table(
TableRow("Command", "Description"),
application
.Commands
.Select(f => TableRow(Link(f.Name, f.Name + "-command.md"), f.Description)))
.WriteTo(mw);
mw.WriteLine();
string readmeLinksFilePath = Path.Combine(dataDirectoryPath, "readme_bottom.md");
if (File.Exists(readmeLinksFilePath))
{
mw.WriteRaw(File.ReadAllText(readmeLinksFilePath));
}
WriteFootNote(mw);
Console.WriteLine(readmeFilePath);
}
string valuesFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, "OptionValues.md"));
ImmutableArray <OptionValueProvider> providers = OptionValueProvider.GetProviders(
commands.SelectMany(f => f.Options),
OptionValueProviders.ProvidersByName.Select(f => f.Value))
.ToImmutableArray();
MDocument document = Document(
Heading1("List of Option Values"),
BulletList(providers.Select(f => Link(
f.Name,
MarkdownHelpers.CreateGitHubHeadingLink(f.Name)))),
providers.Select(provider =>
{
return(new MObject[]
{
Heading2(provider.Name),
Table(
TableRow("Value", " ", "Description"),
provider.Values.Select(f => CreateTableRow(f, providers)))
});
}));
document.Add(
Heading2("Expression Syntax"),
Table(
TableRow("Expression", "Description"),
HelpProvider.GetExpressionItems(includeDate: true)
.Select(f => TableRow(InlineCode(f.expression), f.description))));
AddFootnote(document);
var markdownFormat = new MarkdownFormat(
tableOptions: MarkdownFormat.Default.TableOptions | TableOptions.FormatContent);
File.WriteAllText(valuesFilePath, document.ToString(markdownFormat));
foreach (Command command in application.Commands)
{
readmeFilePath = Path.GetFullPath(Path.Combine(destinationDirectoryPath, $"{command.Name}-command.md"));
using (var sw = new StreamWriter(readmeFilePath, append: false, Encoding.UTF8))
using (MarkdownWriter mw = MarkdownWriter.Create(sw))
{
var writer = new DocumentationWriter(mw);
writer.WriteCommandHeading(command, application);
writer.WriteCommandDescription(command);
mw.WriteLink("Home", "README.md#readme");
foreach (string section in new[] { "Synopsis", "Arguments", "Options", "Samples" })
{
mw.WriteString(" ");
mw.WriteCharEntity((char)0x2022);
mw.WriteString(" ");
mw.WriteLink(section, "#" + section);
}
mw.WriteLine();
writer.WriteCommandSynopsis(command, application);
writer.WriteArguments(command.Arguments);
writer.WriteOptions(command.Options);
string samplesFilePath = Path.Combine(dataDirectoryPath, command.Name + "_bottom.md");
if (File.Exists(samplesFilePath))
{
string content = File.ReadAllText(samplesFilePath);
mw.WriteRaw(content);
}
WriteFootNote(mw);
Console.WriteLine(readmeFilePath);
}
}
Console.WriteLine("Done");
if (Debugger.IsAttached)
{
Console.ReadKey();
}
}
