void contentForm_CommandClick(object sender, CommandArgument e) { cf.SetChanges(); ContentFormResult cfr = cf.GetChanges(); cfr.Argument = e.Argument; WebDialogueContext.SendResult(cfr); }
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 void SetArgs(CommandArgument[] args) { bool pastOptional = false; foreach (var arg in args) { if (arg.Optional) pastOptional = true; if (!arg.Optional && pastOptional) throw new Exception("Cannot define a non-optional argument after an optional argument has been defined."); if (string.IsNullOrEmpty(arg.Name)) throw new Exception("Empty or null name for command argument"); if (arg.CommandType == null) throw new Exception("Invalid type for command argument"); } this.Arguments.Value = args; }
static int Main(string[] args) { var logger = new ConsoleLogger(); var app = new CommandLineApplication(); app.Name = "coverlet"; app.FullName = "Cross platform .NET Core code coverage tool"; app.HelpOption("-h|--help"); app.VersionOption("-v|--version", GetAssemblyVersion()); CommandArgument module = app.Argument("<ASSEMBLY>", "Path to the test assembly."); CommandOption target = app.Option("-t|--target", "Path to the test runner application.", CommandOptionType.SingleValue); CommandOption targs = app.Option("-a|--targetargs", "Arguments to be passed to the test runner.", CommandOptionType.SingleValue); CommandOption output = app.Option("-o|--output", "Output of the generated coverage report", CommandOptionType.SingleValue); CommandOption <LogLevel> verbosity = app.Option <LogLevel>("-v|--verbosity", "Sets the verbosity level of the command. Allowed values are quiet, minimal, normal, detailed.", CommandOptionType.SingleValue); CommandOption formats = app.Option("-f|--format", "Format of the generated coverage report.", CommandOptionType.MultipleValue); CommandOption threshold = app.Option("--threshold", "Exits with error if the coverage % is below value.", CommandOptionType.SingleValue); CommandOption thresholdTypes = app.Option("--threshold-type", "Coverage type to apply the threshold to.", CommandOptionType.MultipleValue); CommandOption thresholdStat = app.Option("--threshold-stat", "Coverage statistic used to enforce the threshold value.", CommandOptionType.SingleValue); CommandOption excludeFilters = app.Option("--exclude", "Filter expressions to exclude specific modules and types.", CommandOptionType.MultipleValue); CommandOption includeFilters = app.Option("--include", "Filter expressions to include only specific modules and types.", CommandOptionType.MultipleValue); CommandOption excludedSourceFiles = app.Option("--exclude-by-file", "Glob patterns specifying source files to exclude.", CommandOptionType.MultipleValue); CommandOption includeDirectories = app.Option("--include-directory", "Include directories containing additional assemblies to be instrumented.", CommandOptionType.MultipleValue); CommandOption excludeAttributes = app.Option("--exclude-by-attribute", "Attributes to exclude from code coverage.", CommandOptionType.MultipleValue); CommandOption includeTestAssembly = app.Option("--include-test-assembly", "Specifies whether to report code coverage of the test assembly.", CommandOptionType.NoValue); CommandOption singleHit = app.Option("--single-hit", "Specifies whether to limit code coverage hit reporting to a single hit for each location", CommandOptionType.NoValue); CommandOption mergeWith = app.Option("--merge-with", "Path to existing coverage result to merge.", CommandOptionType.SingleValue); CommandOption useSourceLink = app.Option("--use-source-link", "Specifies whether to use SourceLink URIs in place of file system paths.", CommandOptionType.NoValue); app.OnExecute(() => { if (string.IsNullOrEmpty(module.Value) || string.IsNullOrWhiteSpace(module.Value)) { throw new CommandParsingException(app, "No test assembly specified."); } if (!target.HasValue()) { throw new CommandParsingException(app, "Target must be specified."); } if (verbosity.HasValue()) { // Adjust log level based on user input. logger.Level = verbosity.ParsedValue; } // We add default exclusion filter if no specified if (excludeFilters.Values.Count == 0) { excludeFilters.Values.Add("[xunit*]*"); } Coverage coverage = new Coverage(module.Value, includeFilters.Values.ToArray(), includeDirectories.Values.ToArray(), excludeFilters.Values.ToArray(), excludedSourceFiles.Values.ToArray(), excludeAttributes.Values.ToArray(), includeTestAssembly.HasValue(), singleHit.HasValue(), mergeWith.Value(), useSourceLink.HasValue(), logger); coverage.PrepareModules(); Process process = new Process(); process.StartInfo.FileName = target.Value(); process.StartInfo.Arguments = targs.HasValue() ? targs.Value() : string.Empty; process.StartInfo.CreateNoWindow = true; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; process.OutputDataReceived += (sender, eventArgs) => { if (!string.IsNullOrEmpty(eventArgs.Data)) { logger.LogInformation(eventArgs.Data, important: true); } }; process.ErrorDataReceived += (sender, eventArgs) => { if (!string.IsNullOrEmpty(eventArgs.Data)) { logger.LogError(eventArgs.Data); } }; process.Start(); process.BeginErrorReadLine(); process.BeginOutputReadLine(); process.WaitForExit(); var dOutput = output.HasValue() ? output.Value() : Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar.ToString(); var dThreshold = threshold.HasValue() ? double.Parse(threshold.Value()) : 0; var dThresholdTypes = thresholdTypes.HasValue() ? thresholdTypes.Values : new List <string>(new string[] { "line", "branch", "method" }); var dThresholdStat = thresholdStat.HasValue() ? Enum.Parse <ThresholdStatistic>(thresholdStat.Value(), true) : Enum.Parse <ThresholdStatistic>("minimum", true); logger.LogInformation("\nCalculating coverage result..."); var result = coverage.GetCoverageResult(); var directory = Path.GetDirectoryName(dOutput); if (directory == string.Empty) { directory = Directory.GetCurrentDirectory(); } else if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } foreach (var format in (formats.HasValue() ? formats.Values : new List <string>(new string[] { "json" }))) { var reporter = new ReporterFactory(format).CreateReporter(); if (reporter == null) { throw new Exception($"Specified output format '{format}' is not supported"); } if (reporter.OutputType == ReporterOutputType.Console) { // Output to console logger.LogInformation(" Outputting results to console", important: true); logger.LogInformation(reporter.Report(result), important: true); } else { // Output to file var filename = Path.GetFileName(dOutput); filename = (filename == string.Empty) ? $"coverage.{reporter.Extension}" : filename; filename = Path.HasExtension(filename) ? filename : $"{filename}.{reporter.Extension}"; var report = Path.Combine(directory, filename); logger.LogInformation($" Generating report '{report}'", important: true); File.WriteAllText(report, reporter.Report(result)); } } var thresholdTypeFlags = ThresholdTypeFlags.None; foreach (var thresholdType in dThresholdTypes) { if (thresholdType.Equals("line", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Line; } else if (thresholdType.Equals("branch", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Branch; } else if (thresholdType.Equals("method", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Method; } } var coverageTable = new ConsoleTable("Module", "Line", "Branch", "Method"); var summary = new CoverageSummary(); int numModules = result.Modules.Count; var totalLinePercent = summary.CalculateLineCoverage(result.Modules).Percent; var totalBranchPercent = summary.CalculateBranchCoverage(result.Modules).Percent; var totalMethodPercent = summary.CalculateMethodCoverage(result.Modules).Percent; foreach (var _module in result.Modules) { var linePercent = summary.CalculateLineCoverage(_module.Value).Percent; var branchPercent = summary.CalculateBranchCoverage(_module.Value).Percent; var methodPercent = summary.CalculateMethodCoverage(_module.Value).Percent; coverageTable.AddRow(Path.GetFileNameWithoutExtension(_module.Key), $"{linePercent}%", $"{branchPercent}%", $"{methodPercent}%"); } logger.LogInformation(coverageTable.ToStringAlternative()); coverageTable.Columns.Clear(); coverageTable.Rows.Clear(); coverageTable.AddColumn(new[] { "", "Line", "Branch", "Method" }); coverageTable.AddRow("Total", $"{totalLinePercent}%", $"{totalBranchPercent}%", $"{totalMethodPercent}%"); coverageTable.AddRow("Average", $"{totalLinePercent / numModules}%", $"{totalBranchPercent / numModules}%", $"{totalMethodPercent / numModules}%"); logger.LogInformation(coverageTable.ToStringAlternative()); thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, dThreshold, thresholdTypeFlags, dThresholdStat); if (thresholdTypeFlags != ThresholdTypeFlags.None) { var exceptionMessageBuilder = new StringBuilder(); if ((thresholdTypeFlags & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} line coverage is below the specified {dThreshold}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} branch coverage is below the specified {dThreshold}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} method coverage is below the specified {dThreshold}"); } throw new Exception(exceptionMessageBuilder.ToString()); } return(process.ExitCode == 0 ? 0 : process.ExitCode); }); try { return(app.Execute(args)); } catch (CommandParsingException ex) { logger.LogError(ex.Message); app.ShowHelp(); return(1); } catch (Exception ex) { logger.LogError(ex.Message); return(1); } }
internal static void Register(CommandLineApplication app, Func <ILogger> getLogger, Action <LogLevel> setLogLevel) { app.Command("trust", trustedSignersCmd => { CommandArgument command = trustedSignersCmd.Argument( "<command>", Strings.TrustCommandActionDescription, multipleValues: true); CommandOption algorithm = trustedSignersCmd.Option( "--algorithm", Strings.TrustCommandAlgorithm, CommandOptionType.SingleValue); CommandOption allowUntrustedRootOption = trustedSignersCmd.Option( "--allow-untrusted-root", Strings.TrustCommandAllowUntrustedRoot, CommandOptionType.NoValue); CommandOption owners = trustedSignersCmd.Option( "--owners", Strings.TrustCommandOwners, CommandOptionType.MultipleValue); CommandOption verbosity = trustedSignersCmd.Option( "-v|--verbosity", Strings.Verbosity_Description, CommandOptionType.SingleValue); CommandOption configFile = trustedSignersCmd.Option( "--configfile", Strings.Option_ConfigFile, CommandOptionType.SingleValue); trustedSignersCmd.HelpOption(XPlatUtility.HelpOption); trustedSignersCmd.Description = Strings.TrustCommandDescription; trustedSignersCmd.OnExecute(async() => { TrustCommand action; if (!command.Values.Any() || string.IsNullOrEmpty(command.Values[0])) { action = TrustCommand.List; } else if (!Enum.TryParse(command.Values[0], ignoreCase: true, result: out action)) { throw new CommandLineArgumentCombinationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_UnknownAction, command.Values[0])); } string name = null; if (command.Values.Count > 1) { name = command.Values[1]; } string packagePath = null; string sourceUrl = null; string fingerprint = null; if (command.Values.Count() > 2) { if (action == TrustCommand.Author || action == TrustCommand.Repository) { packagePath = command.Values[2]; } else if (action == TrustCommand.Source) { sourceUrl = command.Values[2]; } else if (action == TrustCommand.Certificate) { fingerprint = command.Values[2]; } } ISettings settings = ProcessConfigFile(configFile.Value()); var trustedSignersArgs = new TrustedSignersArgs() { Action = MapTrustEnumAction(action), PackagePath = packagePath, Name = name, ServiceIndex = sourceUrl, CertificateFingerprint = fingerprint, FingerprintAlgorithm = algorithm.Value(), AllowUntrustedRoot = allowUntrustedRootOption.HasValue(), Author = action == TrustCommand.Author, Repository = action == TrustCommand.Repository, Owners = CommandLineUtility.SplitAndJoinAcrossMultipleValues(owners.Values), Logger = getLogger() }; setLogLevel(XPlatUtility.MSBuildVerbosityToNuGetLogLevel(verbosity.Value())); #pragma warning disable CS0618 // Type or member is obsolete var sourceProvider = new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false); #pragma warning restore CS0618 // Type or member is obsolete var trustedSignersProvider = new TrustedSignersProvider(settings); var runner = new TrustedSignersCommandRunner(trustedSignersProvider, sourceProvider); Task <int> trustedSignTask = runner.ExecuteCommandAsync(trustedSignersArgs); return(await trustedSignTask); }); }); }
public FilterTablesCommand(CommandArgument connectionIdArg, CommandArgument tablesArg, GlobalOptions globalOptions) { _tablesArg = tablesArg; _options = globalOptions; _connectionIdArg = connectionIdArg; }
public static Task Delete(ManagementClient client, CommandArgument name) { return(client.DeleteQueueAsync(name.Value)); }
internal static CommandConfigurationException RequiredArgumentsCannotHaveDefaultValue(CommandArgument option) { return(new CommandConfigurationException($"The required argument '{option.Value}' cannot have a default value.")); }
public void NoMatchingPropertyWithInferredShouldThrow() { var args = new[] { "/NoMatch" }; CommandLine.CommandEnvironment = new TestCommandEnvironment(args); var commandArg = new CommandArgument("/NoMatch", 0); commandArg.Command = "NoMatch"; Assert.Equal( new CommandLineArgumentInvalidException(typeof(string), commandArg).Message, Assert.Throws<CommandLineArgumentInvalidException>(() => CommandLine.Parse<InferredTestArgs>()).Message); }
public static CommandLineApplication BuildDocSampleCLA() { // Define the root command configuration var cla = new CommandLineApplication(throwOnUnexpectedArg: false); // Add various single-value or multi-value options or no-value options (flags) CommandOption greeting = cla.Option("-$|-g|--greeting <greeting>", "The greeting to display.", CommandOptionType.SingleValue); CommandOption uppercase = cla.Option("-u|--uppercase", "Display the name in uppercase.", CommandOptionType.NoValue); // Add some named arguments and/or child commands (here we combine both) CommandArgument names = null; cla.Command("name", (childCla) => { childCla.HelpOption("--help-me"); names = childCla.Argument( "names", "Enter the names of the people to be greeted.", multipleValues: true); // Define a handler for *resolving* the result of parsing the CLI args // which usually entails interpretting all the possible values and // combinations and invoking some action childCla.OnExecute(() => { cla.Out.WriteLine("Executing..."); if (greeting.HasValue()) { cla.Out.WriteLine("Greetings to the following:"); foreach (var n in names.Values) { cla.Out.WriteLine(greeting.Value() + " " + (uppercase.HasValue() ? n.ToUpper() : n)); } } return(0); }); }); // Enable built-in support for nicely-formatted help cla.HelpOption("-?|-h|--help"); cla.OnExecute(() => { cla.Out.WriteLine("Executing..."); if (greeting.HasValue()) { cla.Out.WriteLine($"{greeting.Value()} to the {(uppercase.HasValue() ? "WORLD" : "World")}"); } return(0); }); // Apply the configuration to interpret the CLI args //cla.Execute(args); return(cla); }
// setactivekey btcissuer public SetActiveKeyCommand() : base("setactivekey") { aliasArgument = RegisterArgument(new CommandArgument("alias")); }
public static bool TryPackageOnlyTagHelperResolution( CommandArgument assemblyNamesArgument, CommandOption protocolOption, CommandOption buildBasePathOption, CommandOption configurationOption, Project project, NuGetFramework framework, out int exitCode) { exitCode = 0; if (framework.IsDesktop()) { return(false); } var runtimeIdentifiers = RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers(); var projectContext = new ProjectContextBuilder() .WithProject(project) .WithTargetFramework(framework) .WithRuntimeIdentifiers(runtimeIdentifiers) .Build(); var configuration = configurationOption.Value() ?? Constants.DefaultConfiguration; var projectRuntimeOutputPath = projectContext.GetOutputPaths(configuration, buildBasePathOption.Value())?.RuntimeOutputPath; var projectAssemblyName = project.GetCompilerOptions(framework, configuration).OutputName; var projectOutputAssembly = Path.Combine(projectRuntimeOutputPath, projectAssemblyName + ".dll"); if (File.Exists(projectOutputAssembly)) { // There's already build output. Dispatch to build output; this ensures dependencies have been resolved. return(false); } var projectLibraries = projectContext.LibraryManager.GetLibraries(); var libraryLookup = projectLibraries.ToDictionary( library => library.Identity.Name, library => library, StringComparer.Ordinal); foreach (var assemblyName in assemblyNamesArgument.Values) { if (!IsPackageOnly(assemblyName, libraryLookup)) { return(false); } } var loadContext = projectContext.CreateLoadContext( projectContext.RuntimeIdentifier, configuration: "Debug", outputPath: null); var runner = new PackageOnlyResolveTagHelpersRunCommand(loadContext) { AssemblyNamesArgument = assemblyNamesArgument, ProtocolOption = protocolOption }; exitCode = runner.OnExecute(); return(true); }
public string PrettyFormat(CommandArgument command) { return string.Format("{0}\t\t{1}", command.CommandRegex, command.Description); }
public static bool Exists(string path, bool isLiteral) { // need to check if we should resolve wildcards var pathArg = new CommandArgument { Name = (isLiteral) ? "LiteralPath" : "Path", Value = path }; // best way to check paths in a static context return PipelineHelper.ExecuteScalar<bool>( new Command(@"Microsoft.PowerShell.Management\Test-Path"), pathArg); }
protected abstract int PrivateSend(CommandArgument argument);
public static int Run(string[] args) { DebugHelper.HandleDebugSwitch(ref args); CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false); app.Name = "dotnet build3"; app.FullName = ".NET Builder"; app.Description = "Builder for the .NET Platform. Delegates to the MSBuild 'Build' target in the project file."; app.AllowArgumentSeparator = true; app.HelpOption("-h|--help"); CommandArgument projectArgument = app.Argument("<PROJECT>", "The MSBuild project file to build. If a project file is not specified," + " MSBuild searches the current working directory for a file that has a file extension that ends in `proj` and uses that file."); CommandOption outputOption = app.Option("-o|--output <OUTPUT_DIR>", "Directory in which to place outputs", CommandOptionType.SingleValue); CommandOption frameworkOption = app.Option("-f|--framework <FRAMEWORK>", "Compile a specific framework", CommandOptionType.SingleValue); CommandOption configurationOption = app.Option("-c|--configuration <CONFIGURATION>", "Configuration under which to build", CommandOptionType.SingleValue); CommandOption versionSuffixOption = app.Option("--version-suffix <VERSION_SUFFIX>", "Defines the value for the $(VersionSuffix) property in the project", CommandOptionType.SingleValue); CommandOption noIncrementalOption = app.Option("--no-incremental", "Set this flag to turn off incremental build", CommandOptionType.NoValue); CommandOption noDependenciesOption = app.Option("--no-dependencies", "Set this flag to ignore project to project references and only build the root project", CommandOptionType.NoValue); app.OnExecute(() => { List <string> msbuildArgs = new List <string>(); if (!string.IsNullOrEmpty(projectArgument.Value)) { msbuildArgs.Add(projectArgument.Value); } if (noIncrementalOption.HasValue()) { msbuildArgs.Add("/t:Rebuild"); } else { msbuildArgs.Add("/t:Build"); } if (outputOption.HasValue()) { msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}"); } if (frameworkOption.HasValue()) { msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}"); } if (configurationOption.HasValue()) { msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}"); } if (versionSuffixOption.HasValue()) { msbuildArgs.Add($"/p:VersionSuffix={versionSuffixOption.Value()}"); } if (noDependenciesOption.HasValue()) { msbuildArgs.Add("/p:BuildProjectReferences=false"); } msbuildArgs.AddRange(app.RemainingArguments); return(new MSBuildForwardingApp(msbuildArgs).Execute()); }); return(app.Execute(args)); }
public static int Main(string[] args) { CommandLineApplication app = new CommandLineApplication(); CommandOption includes = app.Option("-i|--include", "Include items matching the pattern", CommandOptionType.MultipleValue); CommandOption excludes = app.Option("-x|--exclude", "Exclude items matching the pattern", CommandOptionType.MultipleValue); CommandOption rateLimit = app.Option("-r|--rate-limit", "The minimum number of milliseconds that must pass between processing dirty or include events", CommandOptionType.SingleValue); CommandOption help = app.Option("-h|--help", "Shows help", CommandOptionType.NoValue); CommandArgument run = app.Argument("run", "The task to run when an included file changes"); CommandArgument arguments = app.Argument("arguments", "The task to run when an included file changes"); app.OnExecute(async() => { if (help.HasValue()) { app.ShowHelp(); return(0); } int limit = int.Parse(rateLimit.Value() ?? "250"); string currentDir = Directory.GetCurrentDirectory(); Watcher <GlobbingPattern> watcher = await Watcher <GlobbingPattern> .For(currentDir).ConfigureAwait(false); Task currentTask = null; using (watcher) { foreach (string value in includes.Values) { watcher.AddPattern(EntryKind.Include, new GlobbingPattern(value)); } foreach (string value in excludes.Values) { watcher.AddPattern(EntryKind.Exclude, new GlobbingPattern(value)); } while (!watcher.Ready.IsCompleted) { await watcher.Ready; } watcher.Dirty += (sender, e) => { Task t = null; t = Task.Run(async() => { await Task.Delay(limit); if (currentTask == t) { CommandResult execResult = Command.Create(new CommandSpec(run.Value, arguments.Value, CommandResolutionStrategy.Path)).ForwardStdErr().ForwardStdOut().Execute(); if (execResult.ExitCode != 0) { Console.WriteLine($"{run.Value} {arguments.Value} exited with code {execResult.ExitCode}".Red().Bold()); } watcher.Clean(); } }); currentTask = t; }; watcher.FilteredEntriesChanged += (sender, e) => { Task t = null; t = Task.Run(async() => { await Task.Delay(limit); if (currentTask == t) { CommandResult execResult = Command.Create(new CommandSpec(run.Value, arguments.Value, CommandResolutionStrategy.Path)).ForwardStdErr().ForwardStdOut().Execute(); if (execResult.ExitCode != 0) { Console.WriteLine($"{run.Value} {arguments.Value} exited with code {execResult.ExitCode}".Red().Bold()); } watcher.Clean(); } }); currentTask = t; }; Console.WriteLine($"Now watching for changes in {currentDir}"); Console.WriteLine("Press [Enter] to stop..."); Console.ReadLine(); } return(0); }); int result; try { result = app.Execute(args); } catch (Exception ex) { AggregateException ax = ex as AggregateException; while (ax != null && ax.InnerExceptions.Count == 1) { ex = ax.InnerException; ax = ex as AggregateException; } Reporter.Error.WriteLine(ex.Message.Bold().Red()); while (ex.InnerException != null) { ex = ex.InnerException; ax = ex as AggregateException; while (ax != null && ax.InnerExceptions.Count == 1) { ex = ax.InnerException; ax = ex as AggregateException; } Reporter.Error.WriteLine(ex.Message.Bold().Red()); } Reporter.Error.WriteLine(ex.StackTrace.Bold().Red()); result = 1; } return(result); }
void cntFrm_CommandClick(object sender, CommandArgument e) { updateCodeEditors(((Template)cntFrm.Content).Filepath); }
public static int Run(string[] args) { // IMPORTANT: // When updating the command line args for dotnet-migrate, we need to update the in-VS caller of dotnet migrate as well. // It is located at dotnet/roslyn-project-system: // src/Microsoft.VisualStudio.ProjectSystem.CSharp.VS/ProjectSystem/VS/Xproj/MigrateXprojFactory.cs DebugHelper.HandleDebugSwitch(ref args); CommandLineApplication app = new CommandLineApplication(); app.Name = "dotnet migrate"; app.FullName = LocalizableStrings.AppFullName; app.Description = LocalizableStrings.AppDescription; app.HandleResponseFiles = true; app.HelpOption("-h|--help"); CommandArgument projectArgument = app.Argument( $"<{LocalizableStrings.CmdProjectArgument}>", LocalizableStrings.CmdProjectArgumentDescription); CommandOption template = app.Option( "-t|--template-file", LocalizableStrings.CmdTemplateDescription, CommandOptionType.SingleValue); CommandOption sdkVersion = app.Option( "-v|--sdk-package-version", LocalizableStrings.CmdVersionDescription, CommandOptionType.SingleValue); CommandOption xprojFile = app.Option( "-x|--xproj-file", LocalizableStrings.CmdXprojFileDescription, CommandOptionType.SingleValue); CommandOption skipProjectReferences = app.Option( "-s|--skip-project-references", LocalizableStrings.CmdSkipProjectReferencesDescription, CommandOptionType.BoolValue); CommandOption reportFile = app.Option( "-r|--report-file", LocalizableStrings.CmdReportFileDescription, CommandOptionType.SingleValue); CommandOption structuredReportOutput = app.Option( "--format-report-file-json", LocalizableStrings.CmdReportOutputDescription, CommandOptionType.BoolValue); CommandOption skipBackup = app.Option("--skip-backup", LocalizableStrings.CmdSkipBackupDescription, CommandOptionType.BoolValue); app.OnExecute(() => { MigrateCommand migrateCommand = new MigrateCommand( template.Value(), projectArgument.Value, sdkVersion.Value(), xprojFile.Value(), reportFile.Value(), skipProjectReferences.BoolValue.HasValue ? skipProjectReferences.BoolValue.Value : false, structuredReportOutput.BoolValue.HasValue ? structuredReportOutput.BoolValue.Value : false, skipBackup.BoolValue.HasValue ? skipBackup.BoolValue.Value : false); return(migrateCommand.Execute()); }); try { return(app.Execute(args)); } catch (GracefulException e) { Reporter.Error.WriteLine(e.Message); Reporter.Error.WriteLine(LocalizableStrings.MigrationFailedError); return(1); } catch (Exception) { Reporter.Error.WriteLine(LocalizableStrings.MigrationFailedError); throw; } }
public CollectGameModule() { AddOptions(new Dictionary<string, object> { { "rankup", 50 }, { "exchange", 500 }, { "maxWithdraw", 100 }, { "maxLovers", 20 }, { "journalStyle", "style=\"font-family:'Courier New', Courier, monospace; line-height: 100%;\"" }, { "jealousyHours", 24 }, { "jealousyCoins", 1000 }, { "hugSayings", "How nice!, You smile a bit!, You wonder why., How eccentric!, How lovely!, " + "You're pretty happy about it!, Your HP was restored by 10 points!, You became confused!, " + "Your defense fell!, Your spirits rose!, Maybe the world isn't so bad after all., " + "You cry a little., You cry a little inside., You burst into tears on their shoulder!, " + "You're a little uncomfortable., You want to return the favor., Your stress ebbs away., " + "You feel like you understand each other a bit better!, You feel warm inside., " + "*doki doki desu!*, This isn't so bad., You get a little nostalgic., " + "You want another one!, You value their friendship a bit more!, You're overcome with a tidal wave of emotions!, " + "You wish more people were like this!, The world isn't such a dark place anymore., " + "You feel a bit better!" } }); GeneralHelp = "In cgame, you collect items by using your hourly coins to draw random items. " + "Your goal is to collect all 100 items, which allows you to rank up and move through the leaderboards. " + "You can also trade items with other people, or simply be a nice person and give out free items."; CommandArgument price = new CommandArgument("price", ArgumentType.Integer); CommandArgument count = new CommandArgument("count", ArgumentType.Integer); CommandArgument multiplier = new CommandArgument("multiplier", ArgumentType.Custom, RepeatType.One, @"[xX]?[0-9]+"); CommandArgument item = new CommandArgument("item", ArgumentType.Custom, RepeatType.One, @"[a-zA-Z][0-9]"); CommandArgument itemList = new CommandArgument("itemList", ArgumentType.Custom, RepeatType.One, @"(?:[a-zA-Z][0-9]\s*)+"); CommandArgument player = new CommandArgument("player", ArgumentType.User); Commands.AddRange(new List<ModuleCommand> { new ModuleCommand("cgamedraw", new List<CommandArgument> { count }, "Get item(s) (Max: " + MaxWithdraw + ")"), new ModuleCommand("cgamedraw", new List<CommandArgument> { count, multiplier }, "Get item(s) with increased luck (Max multiplier: " + CollectionManager.MaxMultiplier + ")"), new ModuleCommand("cgamechance", new List<CommandArgument> { multiplier }, "Chance of new item with given multiplier"), new ModuleCommand("cgamerestock", new List<CommandArgument>(), "Get your cgame coins for the hour"), new ModuleCommand("cgamestock", new List<CommandArgument>(), "See your current collection"), new ModuleCommand("cgamestockm", new List<CommandArgument>(), "Mobile friendly cgamestock"), new ModuleCommand("cgametopitems", new List<CommandArgument>(), "Top items by number"), new ModuleCommand("cgameamount", new List<CommandArgument> { item }, "Show amount of item"), new ModuleCommand("cgamecompare", new List<CommandArgument> { player }, "Compare your inventory against another's for possible trades."), new ModuleCommand("cgamequery", new List<CommandArgument> { itemList }, "See who has the given items"), new ModuleCommand("cgamequeryall", new List<CommandArgument>(), "See who has any item you need"), new ModuleCommand("cgamesell", new List<CommandArgument> { itemList, player, price }, "Sell item(s) to player for price."), new ModuleCommand("cgamebuy", new List<CommandArgument> { itemList, player, price }, "Buy item(s) from player for price."), new ModuleCommand("cgameshopsell", new List<CommandArgument> { itemList }, "Sell item(s) to shop (low trade price). All of the item is sold."), new ModuleCommand("cgameshopsellall", new List<CommandArgument>(), "Sell all items to shop (low trade price)"), new ModuleCommand("cgamegive", new List<CommandArgument> { itemList, player }, "Give item(s) to player (how nice!).", true), new ModuleCommand("cgametrade", new List<CommandArgument> { itemList, player, itemList }, "Trade your item(s) for player's item(s)"), new ModuleCommand("cgamequicktrade", new List<CommandArgument> { player }, "Automatic maximum even trade with player"), new ModuleCommand("cgamelove", new List<CommandArgument> { player }, "Give all items you can to player"), new ModuleCommand("cgameaddlove", new List<CommandArgument> { player }, "Add a player to your love list"), new ModuleCommand("cgameremovelove", new List<CommandArgument> { player }, "Remove a player from your love list"), new ModuleCommand("cgameloveall", new List<CommandArgument>(), "Love everyone on your list"), new ModuleCommand("cgamelovelist", new List<CommandArgument>(), "Players on your love list"), new ModuleCommand("cgamejealousy", new List<CommandArgument>(), "Take items from other players (careful!)"), new ModuleCommand("cgamecheckjealousy", new List<CommandArgument>(), "Check what you'll get from jealousy"), new ModuleCommand("cgamehug", new List<CommandArgument> { player }, "Give a hug to reduce jealousy", true), new ModuleCommand("cgameaccept", new List<CommandArgument>(), "Accept trade/sell/buy offer"), new ModuleCommand("cgamedecline", new List<CommandArgument>(), "Decline trade/sell/buy offer"), new ModuleCommand("cgamerankup", new List<CommandArgument>(), "Reset journal and go to next rank"), new ModuleCommand("cgametop", new List<CommandArgument>(), "See top players"), new ModuleCommand("cgameclose", new List<CommandArgument>(), "See your competitors"), new ModuleCommand("cgamestats", new List<CommandArgument>(), "See your lifetime stats (ranked only)") }); chanceSimulator.DoWork += new DoWorkEventHandler(chanceSimulator_DoWork); chanceSimulator.RunWorkerCompleted += new RunWorkerCompletedEventHandler(chanceSimulator_RunWorkerCompleted); }
ValidationResult IArgumentValidator.GetValidationResult(CommandArgument argument, ValidationContext context) => _validator(context);
public static int Main(string[] args) { DebugHelper.HandleDebugSwitch(ref args); CommandLineApplication app = new CommandLineApplication(); app.Name = "dotnet compile-fsc"; app.FullName = ".NET F# Compiler"; app.Description = "F# Compiler for the .NET Platform"; app.HandleResponseFiles = true; app.HelpOption("-h|--help"); CommonCompilerOptionsCommandLine commonCompilerCommandLine = CommonCompilerOptionsCommandLine.AddOptions(app); AssemblyInfoOptionsCommandLine assemblyInfoCommandLine = AssemblyInfoOptionsCommandLine.AddOptions(app); CommandOption tempOutputOption = app.Option("--temp-output <arg>", "Compilation temporary directory", CommandOptionType.SingleValue); CommandOption outputNameOption = app.Option("--out <arg>", "Name of the output assembly", CommandOptionType.SingleValue); CommandOption referencesOption = app.Option("--reference <arg>...", "Path to a compiler metadata reference", CommandOptionType.MultipleValue); CommandOption resourcesOption = app.Option("--resource <arg>...", "Resources to embed", CommandOptionType.MultipleValue); CommandArgument sourcesArgument = app.Argument("<source-files>...", "Compilation sources", multipleValues: true); app.OnExecute(() => { if (!tempOutputOption.HasValue()) { Reporter.Error.WriteLine("Option '--temp-output' is required"); return(ExitFailed); } CommonCompilerOptions commonOptions = commonCompilerCommandLine.GetOptionValues(); AssemblyInfoOptions assemblyInfoOptions = assemblyInfoCommandLine.GetOptionValues(); // TODO less hacky bool targetNetCore = commonOptions.Defines.Contains("DNXCORE50") || commonOptions.Defines.Where(d => d.StartsWith("NETSTANDARDAPP1_")).Any() || commonOptions.Defines.Where(d => d.StartsWith("NETCOREAPP1_")).Any() || commonOptions.Defines.Where(d => d.StartsWith("NETSTANDARD1_")).Any(); // Get FSC Path upfront to use it for win32manifest path string tempOutDir = tempOutputOption.Value(); var fscCommandSpec = ResolveFsc(null, tempOutDir); var fscExeFile = fscCommandSpec.FscExeFile; var fscExeDir = fscCommandSpec.FscExeDir; // FSC arguments var allArgs = new List <string>(); //HACK fsc raise error FS0208 if target exe doesnt have extension .exe bool hackFS0208 = targetNetCore && commonOptions.EmitEntryPoint == true; string outputName = outputNameOption.Value(); var originalOutputName = outputName; if (outputName != null) { if (hackFS0208) { outputName = Path.ChangeExtension(outputName, ".exe"); } allArgs.Add($"--out:{outputName}"); } //let's pass debugging type only if options.DebugType is specified, until //portablepdb are confirmed to work. //so it's possibile to test portable pdb without breaking existing build if (string.IsNullOrEmpty(commonOptions.DebugType)) { //debug info (only windows pdb supported, not portablepdb) if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { allArgs.Add("--debug"); //TODO check if full or pdbonly allArgs.Add("--debug:pdbonly"); } else { allArgs.Add("--debug-"); } } else { allArgs.Add("--debug"); allArgs.Add($"--debug:{commonOptions.DebugType}"); } // Default options allArgs.Add("--noframework"); allArgs.Add("--nologo"); allArgs.Add("--simpleresolution"); allArgs.Add("--nocopyfsharpcore"); // project.json compilationOptions if (commonOptions.Defines != null) { allArgs.AddRange(commonOptions.Defines.Select(def => $"--define:{def}")); } if (commonOptions.GenerateXmlDocumentation == true) { allArgs.Add($"--doc:{Path.ChangeExtension(outputName, "xml")}"); } if (commonOptions.KeyFile != null) { allArgs.Add($"--keyfile:{commonOptions.KeyFile}"); } if (commonOptions.Optimize == true) { allArgs.Add("--optimize+"); } //--resource doesnt expect " //bad: --resource:"path/to/file",name //ok: --resource:path/to/file,name allArgs.AddRange(resourcesOption.Values.Select(resource => $"--resource:{resource.Replace("\"", "")}")); allArgs.AddRange(referencesOption.Values.Select(r => $"-r:{r}")); if (commonOptions.EmitEntryPoint != true) { allArgs.Add("--target:library"); } else { allArgs.Add("--target:exe"); //HACK we need default.win32manifest for exe var win32manifestPath = Path.Combine(fscExeDir, "..", "..", "runtimes", "any", "native", "default.win32manifest"); allArgs.Add($"--win32manifest:{win32manifestPath}"); } if (commonOptions.SuppressWarnings != null && commonOptions.SuppressWarnings.Any()) { allArgs.Add("--nowarn:" + string.Join(",", commonOptions.SuppressWarnings.ToArray())); } if (commonOptions.LanguageVersion != null) { // Not used in fsc } if (commonOptions.Platform != null) { allArgs.Add($"--platform:{commonOptions.Platform}"); } if (commonOptions.AllowUnsafe == true) { } if (commonOptions.WarningsAsErrors == true) { allArgs.Add("--warnaserror"); } //set target framework if (targetNetCore) { allArgs.Add("--targetprofile:netcore"); } if (commonOptions.DelaySign == true) { allArgs.Add("--delaysign+"); } if (commonOptions.PublicSign == true) { } if (commonOptions.AdditionalArguments != null) { // Additional arguments are added verbatim allArgs.AddRange(commonOptions.AdditionalArguments); } // Generate assembly info var assemblyInfo = Path.Combine(tempOutDir, $"dotnet-compile.assemblyinfo.fs"); File.WriteAllText(assemblyInfo, AssemblyInfoFileGenerator.GenerateFSharp(assemblyInfoOptions)); //source files + assemblyInfo allArgs.AddRange(GetSourceFiles(sourcesArgument.Values, assemblyInfo).ToArray()); //TODO check the switch enabled in fsproj in RELEASE and DEBUG configuration var rsp = Path.Combine(tempOutDir, "dotnet-compile-fsc.rsp"); File.WriteAllLines(rsp, allArgs, Encoding.UTF8); // Execute FSC! var result = RunFsc(new List <string> { $"@{rsp}" }, tempOutDir) .ForwardStdErr() .ForwardStdOut() .Execute(); bool successFsc = result.ExitCode == 0; if (hackFS0208 && File.Exists(outputName)) { if (File.Exists(originalOutputName)) { File.Delete(originalOutputName); } File.Move(outputName, originalOutputName); } //HACK dotnet build require a pdb (crash without), fsc atm cant generate a portable pdb, so an empty pdb is created string pdbPath = Path.ChangeExtension(outputName, ".pdb"); if (successFsc && !File.Exists(pdbPath)) { File.WriteAllBytes(pdbPath, Array.Empty <byte>()); } return(result.ExitCode); }); try { return(app.Execute(args)); } catch (Exception ex) { #if DEBUG Reporter.Error.WriteLine(ex.ToString()); #else Reporter.Error.WriteLine(ex.Message); #endif return(ExitFailed); } }
public static CleanCommand FromArgs(string[] args, string msbuildPath = null) { DebugHelper.HandleDebugSwitch(ref args); CommandLineApplication app = new CommandLineApplication(throwOnUnexpectedArg: false) { Name = "dotnet clean", FullName = LocalizableStrings.AppFullName, Description = LocalizableStrings.AppDescription, HandleRemainingArguments = true, ArgumentSeparatorHelpText = HelpMessageStrings.MSBuildAdditionalArgsHelpText }; app.HelpOption("-h|--help"); CommandArgument projectArgument = app.Argument( $"<{LocalizableStrings.CmdArgProject}>", LocalizableStrings.CmdArgProjDescription); CommandOption outputOption = app.Option( $"-o|--output <{LocalizableStrings.CmdOutputDir}>", LocalizableStrings.CmdOutputDirDescription, CommandOptionType.SingleValue); CommandOption frameworkOption = app.Option( $"-f|--framework <{LocalizableStrings.CmdFramework}>", LocalizableStrings.CmdFrameworkDescription, CommandOptionType.SingleValue); CommandOption configurationOption = app.Option( $"-c|--configuration <{LocalizableStrings.CmdConfiguration}>", LocalizableStrings.CmdConfigurationDescription, CommandOptionType.SingleValue); CommandOption verbosityOption = AddVerbosityOption(app); List <string> msbuildArgs = null; app.OnExecute(() => { msbuildArgs = new List <string>(); if (!string.IsNullOrEmpty(projectArgument.Value)) { msbuildArgs.Add(projectArgument.Value); } msbuildArgs.Add("/t:Clean"); if (outputOption.HasValue()) { msbuildArgs.Add($"/p:OutputPath={outputOption.Value()}"); } if (frameworkOption.HasValue()) { msbuildArgs.Add($"/p:TargetFramework={frameworkOption.Value()}"); } if (configurationOption.HasValue()) { msbuildArgs.Add($"/p:Configuration={configurationOption.Value()}"); } if (verbosityOption.HasValue()) { msbuildArgs.Add($"/verbosity:{verbosityOption.Value()}"); } msbuildArgs.AddRange(app.RemainingArguments); return(0); }); int exitCode = app.Execute(args); if (msbuildArgs == null) { throw new CommandCreationException(exitCode); } return(new CleanCommand(msbuildArgs, msbuildPath)); }
public static Task Delete(ServiceBusAdministrationClient client, CommandArgument name) { return(client.DeleteQueueAsync(name.Value)); }
public SignHashCommand() : base("signhash") { privatekeyArgument = RegisterArgument(new CommandArgument("private key")); hashArgument = RegisterArgument(new CommandArgument("hash")); }
static void Main(string[] args) { var app = new CommandLineApplication(); app.Name = "xmldoc2md"; app.VersionOption("-v|--version", () => { return(string.Format( "Version {0}", Assembly.GetEntryAssembly() .GetCustomAttribute <AssemblyInformationalVersionAttribute>() .InformationalVersion .ToString())); }); app.HelpOption("-?|-h|--help"); CommandArgument srcArg = app.Argument("src", "DLL source path"); CommandArgument outArg = app.Argument("out", "Output directory"); CommandOption namespaceMatchOption = app.Option( "--namespace-match <regex>", "Regex pattern to select namespaces", CommandOptionType.SingleValue); CommandOption indexPageNameOption = app.Option( "--index-page-name <regex>", "Name of the index page (default: \"index\")", CommandOptionType.SingleValue); app.OnExecute(() => { string src = srcArg.Value; string @out = outArg.Value; string namespaceMatch = namespaceMatchOption.Value(); string indexPageName = indexPageNameOption.HasValue() ? indexPageNameOption.Value() : "index"; var xmlDocumentation = new XmlDocumentation(src, namespaceMatch); if (!Directory.Exists(@out)) { Directory.CreateDirectory(@out); } var indexBuilder = new MarkdownBuilder(); indexBuilder.Header(1, xmlDocumentation.AssemblyName); foreach (var g in xmlDocumentation.Types.GroupBy(x => x.Namespace).OrderBy(x => x.Key)) { string subDir = Path.Combine(@out, g.Key); if (!Directory.Exists(subDir)) { Directory.CreateDirectory(subDir); } indexBuilder.AppendLine(); indexBuilder.HeaderWithCode(2, g.Key); indexBuilder.AppendLine(); foreach (var item in g.OrderBy(x => x.Name)) { string typeName = item.BeautifyName.Replace("<", "{").Replace(">", "}").Replace(",", "").Replace(" ", "-"); var sb = new StringBuilder(); indexBuilder.ListLink(MarkdownBuilder.MarkdownCodeQuote(item.BeautifyName), g.Key + "/" + typeName); sb.Append(item.ToString()); File.WriteAllText(Path.Combine(@out, g.Key, $"{typeName}.md"), sb.ToString()); } } File.WriteAllText(Path.Combine(@out, $"{indexPageName}.md"), indexBuilder.ToString()); return(0); }); try { app.Execute(args); } catch (CommandParsingException ex) { Console.WriteLine(ex.Message); } catch (Exception ex) { Console.WriteLine("Unable to execute application: {0}", ex.Message); } }
// getaccount qyl68tygnjx6qqwrsmynmejmc9wxlw7almv3397j public GetAccountCommand() : base("getaccount") { addressArgument = RegisterArgument(new CommandArgument("address")); }
public static int Run(string[] args) { // IMPORTANT: // When updating the command line args for dotnet-migrate, we need to update the in-VS caller of dotnet migrate as well. // It is located at dotnet/roslyn-project-system: // src/Microsoft.VisualStudio.ProjectSystem.CSharp.VS/ProjectSystem/VS/Xproj/MigrateXprojFactory.cs DebugHelper.HandleDebugSwitch(ref args); CommandLineApplication app = new CommandLineApplication(); app.Name = "dotnet migrate"; app.FullName = ".NET Migrate Command"; app.Description = "Command used to migrate project.json projects to msbuild"; app.HandleResponseFiles = true; app.HelpOption("-h|--help"); CommandArgument projectArgument = app.Argument("<PROJECT_JSON/GLOBAL_JSON/PROJECT_DIR>", string.Join(Environment.NewLine, "The path to ", " - a project.json file to migrate.", "or", " - a global.json file, it will migrate the folders specified in global.json.", "or", " - a directory to migrate, it will recursively search for project.json files to migrate.", "Defaults to current directory if nothing is specified.")); CommandOption template = app.Option("-t|--template-file", "Base MSBuild template to use for migrated app. The default is the project included in dotnet new", CommandOptionType.SingleValue); CommandOption sdkVersion = app.Option("-v|--sdk-package-version", "The version of the sdk package that will be referenced in the migrated app. The default is the version of the sdk in dotnet new", CommandOptionType.SingleValue); CommandOption xprojFile = app.Option("-x|--xproj-file", "The path to the xproj file to use. Required when there is more than one xproj in a project directory.", CommandOptionType.SingleValue); CommandOption skipProjectReferences = app.Option("-s|--skip-project-references", "Skip migrating project references. By default project references are migrated recursively", CommandOptionType.BoolValue); CommandOption reportFile = app.Option("-r|--report-file", "Output migration report to a file in addition to the console.", CommandOptionType.SingleValue); CommandOption structuredReportOutput = app.Option("--format-report-file-json", "Output migration report file as json rather than user messages", CommandOptionType.BoolValue); app.OnExecute(() => { MigrateCommand migrateCommand = new MigrateCommand( template.Value(), projectArgument.Value, sdkVersion.Value(), xprojFile.Value(), reportFile.Value(), skipProjectReferences.BoolValue.HasValue ? skipProjectReferences.BoolValue.Value : false, structuredReportOutput.BoolValue.HasValue ? structuredReportOutput.BoolValue.Value : false); return(migrateCommand.Execute()); }); try { return(app.Execute(args)); } catch (Exception ex) { #if DEBUG Reporter.Error.WriteLine(ex.ToString()); #else Reporter.Error.WriteLine(ex.Message); #endif Reporter.Error.WriteLine("Migration failed."); return(1); } }
/// <summary> /// Gets the validation result for a command line argument. /// </summary> /// <param name="argument"></param> /// <param name="context"></param> /// <returns></returns> public ValidationResult?GetValidationResult(CommandArgument argument, ValidationContext context) => GetValidationResult(argument.Values, context);
protected override int PrivateSend(CommandArgument commandArgument) { throw new NotImplementedException(); }
public static int Main(string[] args) { try { Logger.SystemLogger = LogUtils.GetLogger(Console.Error); Console.Error.WriteLine("CANAPE.Cli (c) 2017 James Forshaw, 2014 Context Information Security."); CommandLineApplication app = new CommandLineApplication(false); CommandArgument script = app.Argument("script", "Specify a script file to run."); CommandOption compile = app.Option( "-c | --compile", "Compile script file only.", CommandOptionType.NoValue); CommandOption verbose = app.Option( "-v | --verbose", "Enable verbose logging output.", CommandOptionType.NoValue); CommandOption include = app.Option( "-i | --include", "Specify additional include directories to be accessed via the #load directive.", CommandOptionType.MultipleValue); CommandOption libs = app.Option( "-l | --libs", "Specify additional library directories to be accessed via the #r directive.", CommandOptionType.MultipleValue); CommandOption color = app.Option( "--color", "Enable ANSI 24 bit color output (if supported).", CommandOptionType.NoValue); app.ShowInHelpText = true; app.HelpOption("-? | -h | --help"); app.OnExecute(() => { IEnumerable <string> include_dirs = include.HasValue() ? include.Values.Select(p => Path.GetFullPath(p)) : new string[0]; IEnumerable <string> metadata_dirs = libs.HasValue() ? libs.Values.Select(p => Path.GetFullPath(p)) : new string[0]; ConsoleUtils.EnableColor = color.HasValue(); if (verbose.HasValue()) { Logger.SystemLogger.LogLevel = Logger.LogEntryType.All; } if (script.Value == null) { RunConsole(include_dirs, metadata_dirs).Wait(); } else { string filename = Path.GetFullPath(script.Value); if (compile.HasValue()) { if (CompileScript(filename, include_dirs, metadata_dirs) != null) { Console.Error.WriteLine("SUCCESS: Script compiled with no errors"); } } else { RunScript(filename, include_dirs, metadata_dirs, app.RemainingArguments).Wait(); } } return(0); }); return(app.Execute(args)); } catch (Exception ex) { PrintException(ex, false); return(1); } }
private static bool Match(PropertyInfo property, CommandArgument argument) { var propertyName = PascalCase(argument.Name); return(string.Equals(property.Name, propertyName, StringComparison.Ordinal)); }
public static int Main(string[] args) { CommandLineApplication app = new CommandLineApplication(false) { Name = "dotnet new3", FullName = "Template Instantiation Commands for .NET Core CLI." }; CommandArgument template = app.Argument("template", "The template to instantiate."); CommandOption listOnly = app.Option("-l|--list", "Lists templates with containing the specified name.", CommandOptionType.NoValue); CommandOption name = app.Option("-n|--name", "The name for the output. If no name is specified, the name of the current directory is used.", CommandOptionType.SingleValue); CommandOption dir = app.Option("-d|--dir", "Indicates whether to display create a directory for the generated content.", CommandOptionType.NoValue); CommandOption alias = app.Option("-a|--alias", "Creates an alias for the specified template", CommandOptionType.SingleValue); CommandOption parametersFiles = app.Option("-x|--extra-args", "Adds a parameters file.", CommandOptionType.MultipleValue); CommandOption install = app.Option("-i|--install", "Installs a source or a template pack.", CommandOptionType.MultipleValue); CommandOption help = app.Option("-h|--help", "Indicates whether to display the help for the template's parameters instead of creating it.", CommandOptionType.NoValue); CommandOption quiet = app.Option("--quiet", "Doesn't output any status information.", CommandOptionType.NoValue); CommandOption skipUpdateCheck = app.Option("--skip-update-check", "Don't check for updates.", CommandOptionType.NoValue); CommandOption update = app.Option("--update", "Update matching templates.", CommandOptionType.NoValue); app.OnExecute(async() => { bool reinitFlag = app.RemainingArguments.Any(x => x == "--debug:reinit"); if (reinitFlag) { Paths.User.FirstRunCookie.Delete(); } if (reinitFlag || app.RemainingArguments.Any(x => x == "--debug:reset-config")) { Paths.User.AliasesFile.Delete(); Paths.User.SettingsFile.Delete(); Paths.User.TemplateCacheFile.Delete(); return(0); } if (!Paths.User.BaseDir.Exists() || !Paths.User.FirstRunCookie.Exists()) { if (!quiet.HasValue()) { Reporter.Output.WriteLine("Getting things ready for first use..."); } ConfigureEnvironment(); Paths.User.FirstRunCookie.WriteAllText(""); } if (app.RemainingArguments.Any(x => x == "--debug:showconfig")) { ShowConfig(); return(0); } if (install.HasValue()) { InstallPackage(install.Values, quiet.HasValue()); return(0); } if (update.HasValue()) { //return PerformUpdateAsync(template.Value, quiet.HasValue(), source); } if (listOnly.HasValue()) { ListTemplates(template); return(0); } IReadOnlyDictionary <string, string> parameters; try { parameters = app.ParseExtraArgs(parametersFiles); } catch (Exception ex) { Reporter.Error.WriteLine(ex.Message.Red().Bold()); app.ShowHelp(); return(-1); } if (string.IsNullOrWhiteSpace(template.Value) && help.HasValue()) { app.ShowHelp(); return(0); } string aliasName = alias.HasValue() ? alias.Value() : null; ITemplateEngineHost host = new DotNetNew3TemplateEngineHost(); string fallbackName = new DirectoryInfo(Directory.GetCurrentDirectory()).Name; if (await TemplateCreator.Instantiate(host, template.Value ?? "", name.Value(), fallbackName, dir.HasValue(), aliasName, parameters, skipUpdateCheck.HasValue()) == -1) { ListTemplates(template); return(-1); } return(0); }); int result; try { using (Timing.Over("Execute")) { result = app.Execute(args); } } catch (Exception ex) { AggregateException ax = ex as AggregateException; while (ax != null && ax.InnerExceptions.Count == 1) { ex = ax.InnerException; ax = ex as AggregateException; } Reporter.Error.WriteLine(ex.Message.Bold().Red()); while (ex.InnerException != null) { ex = ex.InnerException; ax = ex as AggregateException; while (ax != null && ax.InnerExceptions.Count == 1) { ex = ax.InnerException; ax = ex as AggregateException; } Reporter.Error.WriteLine(ex.Message.Bold().Red()); } Reporter.Error.WriteLine(ex.StackTrace.Bold().Red()); result = 1; } return(result); }
private static int Main(string[] args) { var app = new CommandLineApplication { Name = "GenAPI", FullName = "A command line tool to generate code for the API surface of an assembly.", ResponseFileHandling = ResponseFileHandling.ParseArgsAsSpaceSeparated }; app.HelpOption("-?|-h|--help"); app.VersionOption("-v|--version", GetAssemblyVersion()); CommandArgument assemblyArg = app.Argument("assembly", "Path for an specific assembly or a directory to get all assemblies."); assemblyArg.IsRequired(); CommandOption libPath = app.Option("-l|--lib-path", "Delimited (',' or ';') set of paths to use for resolving assembly references", CommandOptionType.SingleValue); CommandOption apiList = app.Option("-a|--api-list", "Specify a api list in the DocId format of which APIs to include.", CommandOptionType.SingleValue); CommandOption outFilePath = app.Option("-o|--out", "Output path. Default is the console. Can specify an existing directory as well and then a file will be created for each assembly with the matching name of the assembly.", CommandOptionType.SingleValue); CommandOption headerFile = app.Option("-h|--header-file", "Specify a file with header content to prepend to output.", CommandOptionType.SingleValue); CommandOption <WriterType> writerType = app.Option <WriterType>("-w|--writer", "Specify the writer type to use. Legal values: CSDecl, DocIds, TypeForwards, TypeList. Default is CSDecl.", CommandOptionType.SingleValue); CommandOption <SyntaxWriterType> syntaxWriterType = app.Option <SyntaxWriterType>("-s|--syntax", "Specific the syntax writer type. Only used if the writer is CSDecl. Legal values: Text, Html, Xml. Default is Text.", CommandOptionType.SingleValue); CommandOption <DocIdKinds> docIdKinds = app.Option <DocIdKinds>("-d|--doc-id-kinds", "Only include API of the specified kinds. Legal values: A, Assembly, Namespace, N, T, Type, Field, F, P, Property, Method, M, Event, E, All. Default is All.", CommandOptionType.SingleValue); CommandOption exceptionMessage = app.Option("-t|--throw", "Method bodies should throw PlatformNotSupportedException.", CommandOptionType.SingleValue); CommandOption globalPrefix = app.Option("-g|--global", "Include global prefix for compilation.", CommandOptionType.NoValue); CommandOption excludeApiList = app.Option("--exclude-api-list", "Specify a api list in the DocId format of which APIs to exclude.", CommandOptionType.SingleValue); CommandOption excludeAttributesList = app.Option("--exclude-attributes-list", "Specify a list in the DocId format of which attributes should be excluded from being applied on apis.", CommandOptionType.SingleValue); CommandOption apiOnly = app.Option("--api-only", "[CSDecl] Include only API's not CS code that compiles.", CommandOptionType.NoValue); CommandOption all = app.Option("--all", "Include all API's not just public APIs. Default is public only.", CommandOptionType.NoValue); CommandOption memberHeadings = app.Option("--member-headings", "[CSDecl] Include member headings for each type of member.", CommandOptionType.NoValue); CommandOption hightlightBaseMembers = app.Option("--hightlight-base-members", "[CSDecl] Highlight overridden base members.", CommandOptionType.NoValue); CommandOption hightlightInterfaceMembers = app.Option("--hightlight-interface-members", "[CSDecl] Highlight interface implementation members.", CommandOptionType.NoValue); CommandOption alwaysIncludeBase = app.Option("--always-include-base", "[CSDecl] Include base types, interfaces, and attributes, even when those types are filtered.", CommandOptionType.NoValue); CommandOption excludeMembers = app.Option("--exclude-members", "Exclude members when return value or parameter types are excluded.", CommandOptionType.NoValue); CommandOption langVersion = app.Option("--lang-version", "Language Version to target", CommandOptionType.SingleValue); app.OnExecute(() => { HostEnvironment host = new HostEnvironment(); host.UnableToResolve += (sender, e) => Console.WriteLine("Unable to resolve assembly '{0}' referenced by '{1}'.", e.Unresolved.ToString(), e.Referrer.ToString());; host.UnifyToLibPath = true; if (!string.IsNullOrWhiteSpace(libPath.Value())) { host.AddLibPaths(HostEnvironment.SplitPaths(libPath.Value())); } IEnumerable <IAssembly> assemblies = host.LoadAssemblies(HostEnvironment.SplitPaths(assemblyArg.Value)); if (!assemblies.Any()) { Console.WriteLine("ERROR: Failed to load any assemblies from '{0}'", assemblyArg.Value); return(1); } string headerText = GetHeaderText(headerFile.Value()); bool loopPerAssembly = Directory.Exists(outFilePath.Value()); if (loopPerAssembly) { foreach (var assembly in assemblies) { using (TextWriter output = GetOutput(GetFilename(assembly, writerType.ParsedValue, syntaxWriterType.ParsedValue))) using (IStyleSyntaxWriter syntaxWriter = GetSyntaxWriter(output, writerType.ParsedValue, syntaxWriterType.ParsedValue)) { if (headerText != null) { output.Write(headerText); } ICciWriter writer = GetWriter(output, syntaxWriter); writer.WriteAssemblies(new IAssembly[] { assembly }); } } } else { using (TextWriter output = GetOutput(outFilePath.Value())) using (IStyleSyntaxWriter syntaxWriter = GetSyntaxWriter(output, writerType.ParsedValue, syntaxWriterType.ParsedValue)) { if (headerText != null) { output.Write(headerText); } ICciWriter writer = GetWriter(output, syntaxWriter); writer.WriteAssemblies(assemblies); } } return(0); }); ICciWriter GetWriter(TextWriter output, ISyntaxWriter syntaxWriter) { ICciFilter filter = GetFilter(apiList.Value(), all.HasValue(), apiOnly.HasValue(), excludeApiList.Value(), excludeMembers.HasValue(), excludeAttributesList.Value()); switch (writerType.ParsedValue) { case WriterType.DocIds: DocIdKinds docIdKind = docIdKinds.HasValue() ? docIdKinds.ParsedValue : DocIdKinds.All; return(new DocumentIdWriter(output, filter, docIdKind)); case WriterType.TypeForwards: return(new TypeForwardWriter(output, filter) { IncludeForwardedTypes = true }); case WriterType.TypeList: return(new TypeListWriter(syntaxWriter, filter)); default: case WriterType.CSDecl: { CSharpWriter writer = new CSharpWriter(syntaxWriter, filter, apiOnly.HasValue()); writer.IncludeSpaceBetweenMemberGroups = writer.IncludeMemberGroupHeadings = memberHeadings.HasValue(); writer.HighlightBaseMembers = hightlightBaseMembers.HasValue(); writer.HighlightInterfaceMembers = hightlightInterfaceMembers.HasValue(); writer.PutBraceOnNewLine = true; writer.PlatformNotSupportedExceptionMessage = exceptionMessage.Value(); writer.IncludeGlobalPrefixForCompilation = globalPrefix.HasValue(); writer.AlwaysIncludeBase = alwaysIncludeBase.HasValue(); writer.LangVersion = GetLangVersion(); return(writer); } } } Version GetLangVersion() { if (langVersion.HasValue()) { var langVersionValue = langVersion.Value(); if (langVersionValue.Equals("default", StringComparison.OrdinalIgnoreCase)) { return(CSDeclarationWriter.LangVersionDefault); } else if (langVersionValue.Equals("latest", StringComparison.OrdinalIgnoreCase)) { return(CSDeclarationWriter.LangVersionLatest); } else if (langVersionValue.Equals("preview", StringComparison.OrdinalIgnoreCase)) { return(CSDeclarationWriter.LangVersionPreview); } else if (Version.TryParse(langVersionValue, out var parsedVersion)) { return(parsedVersion); } } return(CSDeclarationWriter.LangVersionDefault); } return(app.Execute(args)); }
private static void FlipDataset(CommandArgument fileArgs, CommandOption jpgOption, bool basic) { //var flip = parser.GetOptions().FirstOrDefault(option => option.ShortName == "flip"); //var flipBasic = parser.GetOptions().FirstOrDefault(option => option.ShortName == "flip-basic"); var dataSource = fileArgs.Value; using (var metadata = Dlib.ImageDatasetMetadata.LoadImageDatasetMetadata(dataSource)) using (var origMetadata = Dlib.ImageDatasetMetadata.LoadImageDatasetMetadata(dataSource)) { // Set the current directory to be the one that contains the // metadata file. We do this because the file might contain // file paths which are relative to this folder. var parentDir = Path.GetDirectoryName(Path.GetFullPath(dataSource)); Environment.CurrentDirectory = parentDir; var metadataFilename = Path.Combine(parentDir, $"flipped_{Path.GetFileName(dataSource)}"); var images = metadata.Images; for (int i = 0, iCount = images.Count; i < iCount; ++i) { var f = new FileInfo(images[i].FileName); var parent = Path.GetDirectoryName(f.FullName); var filename = Path.Combine(parent, $"flipped_{ToPngName(f.Name)}"); using (var img = Dlib.LoadImage <RgbPixel>(images[i].FileName)) using (var temp = new Array2D <RgbPixel>()) { Dlib.FlipImageLeftRight(img, temp); if (jpgOption.HasValue()) { filename = ToJpgName(filename); Dlib.SaveJpeg(temp, filename, JpegQuality); } else { Dlib.SavePng(temp, filename); } var boxes = images[i].Boxes; for (int j = 0, bCount = boxes.Count; j < bCount; ++j) { boxes[j].Rect = Dlib.FlipRectLeftRight(boxes[j].Rect, img.Rect); // flip all the object parts foreach (var kvp in boxes[j].Parts.ToArray()) { var rect = new Rectangle(kvp.Value, kvp.Value); var flipRect = Dlib.FlipRectLeftRight(rect, img.Rect); boxes[j].Parts[kvp.Key] = flipRect.TopLeft; } } images[i].FileName = filename; } } //if (flipBasic == null || !flipBasic.HasValue()) if (!basic) { MakePartLabelingMatchTargetDataset(origMetadata, metadata); } Dlib.ImageDatasetMetadata.SaveImageDatasetMetadata(metadata, metadataFilename); } }
public VoteModule() { CommandArgument title = new CommandArgument("title", ArgumentType.Custom, RepeatType.One, @"""[^""]+"""); CommandArgument choiceList = new CommandArgument("choices", ArgumentType.Custom, RepeatType.OneOrMore, @"\S+"); CommandArgument poll = new CommandArgument("poll#", ArgumentType.Integer); CommandArgument choice = new CommandArgument("choice", ArgumentType.Word); //CommandArgument pageNumber = new CommandArgument("page", ArgumentType.Integer, RepeatType.ZeroOrOne); CommandArgument search = new CommandArgument("search", ArgumentType.FullString); Commands.Add(new ModuleCommand("polls", new List<CommandArgument>(), "See the top open polls")); Commands.Add(new ModuleCommand("poll", new List<CommandArgument> { poll }, "See data for poll#")); Commands.Add(new ModuleCommand("pollcreate", new List<CommandArgument>{ title, choiceList }, "Create a poll with given options.", true)); Commands.Add(new ModuleCommand("vote", new List<CommandArgument> { choice, poll }, "Vote on poll#.")); Commands.Add(new ModuleCommand("pollclose", new List<CommandArgument> { poll }, "Close the given poll", true)); Commands.Add(new ModuleCommand("pollsearch", new List<CommandArgument> { search }, "Search for poll with given title")); Commands.Add(new ModuleCommand("pollsopen", new List<CommandArgument>(), "See your open polls")); AddOptions(new Dictionary<string, object> { { "maxUserPolls", 1 }, { "maxPollChoices", 10 }, { "archivesPerPage", 20 }, { "searchResults", 5 } }); GeneralHelp = "Quickstart: Do /polls to see the list of polls you can vote on. " + "Do /poll 1 to see the voting options for poll #1." + "Do /vote yes 1 to vote \"yes\" on poll #1. " + "Do /pollsearch Blah blah blah to search for a poll by title. " + "To create a poll, do /pollcreate \"This is my poll\" option1 option2 etc... " + "Options do not have to be yes or no, they can be anything. Options cannot have spaces."; }
public static void Main(string[] args) { App app = new App(); Program program = new Program(); app.SetCurrentCulture(); program.SetExtractValues(); CommandLineApplication commandLineApplication = new CommandLineApplication(true) { Description = "Extract Heroes of the Storm game data into XML and JSON format", }; commandLineApplication.HelpOption("-?|-h|--help"); commandLineApplication.VersionOption("-v|--version", $"Heroes Data Parser ({App.Version})"); ListCommand.Add(commandLineApplication).SetCommand(); ReadCommand.Add(commandLineApplication).SetCommand(); ExtractCommand.Add(commandLineApplication).SetCommand(); ImageCommand.Add(commandLineApplication).SetCommand(); QuickCompareCommand.Add(commandLineApplication).SetCommand(); V4ConvertCommand.Add(commandLineApplication).SetCommand(); CommandArgument storagePathArgument = commandLineApplication.Argument("storage-path", "The 'Heroes of the Storm' directory or an already extracted 'mods' directory."); CommandOption setOutputDirectoryOption = commandLineApplication.Option("-o|--output-directory <FILEPATH>", "Sets the output directory.", CommandOptionType.SingleValue); CommandOption setDescriptionOption = commandLineApplication.Option("-d|--description <VALUE>", "Sets the description output type (0 - 6) - Default: 0.", CommandOptionType.SingleValue); CommandOption extractDataFilesOption = commandLineApplication.Option("-e|--extract-data <VALUE>", $"Extracts data files - Default: herodata.", CommandOptionType.MultipleValue); CommandOption extractImageFilesOption = commandLineApplication.Option("-i|--extract-images <VALUE>", $"Extracts image files, only available using the Heroes of the Storm game directory.", CommandOptionType.MultipleValue); CommandOption setGameStringLocalizations = commandLineApplication.Option("-l|--localization <LOCALE>", "Sets the gamestring localization(s) - Default: enUS.", CommandOptionType.MultipleValue); CommandOption setBuildOption = commandLineApplication.Option("-b|--build <NUMBER>", "Sets the override build file(s).", CommandOptionType.SingleValue); CommandOption setMaxDegreeParallismOption = commandLineApplication.Option("-t|--threads <NUMBER>", "Limits the maximum amount of threads to use.", CommandOptionType.SingleValue); CommandOption xmlOutputOption = commandLineApplication.Option("--xml", "Creates xml output.", CommandOptionType.NoValue); CommandOption jsonOutputOption = commandLineApplication.Option("--json", "Creates json output.", CommandOptionType.NoValue); CommandOption setFileSplitOption = commandLineApplication.Option("--file-split", "Splits the XML and JSON file(s) into multiple files.", CommandOptionType.NoValue); CommandOption localizedTextOption = commandLineApplication.Option("--localized-text", "Extracts localized gamestrings from the XML and JSON file(s) into a text file.", CommandOptionType.NoValue); CommandOption minifyOption = commandLineApplication.Option("--minify", "Creates .min file(s) along with current output file(s).", CommandOptionType.NoValue); CommandOption validationWarningsOption = commandLineApplication.Option("--warnings", "Displays all validation warnings.", CommandOptionType.NoValue); commandLineApplication.OnExecute(() => { App.Defaults = false; if (extractImageFilesOption.HasValue() && !extractDataFilesOption.HasValue()) { return(InvalidCommand("You need to set the -e|--extract-data option")); } if (!string.IsNullOrWhiteSpace(storagePathArgument.Value)) { App.StoragePath = storagePathArgument.Value; } if (setMaxDegreeParallismOption.HasValue() && int.TryParse(setMaxDegreeParallismOption.Value(), out int result)) { App.MaxParallelism = result; } if (setDescriptionOption.HasValue() && Enum.TryParse(setDescriptionOption.Value(), out DescriptionType resultType)) { App.DescriptionType = resultType; } if (setBuildOption.HasValue() && int.TryParse(setBuildOption.Value(), out result)) { App.OverrideBuild = result; } if (setOutputDirectoryOption.HasValue()) { App.OutputDirectory = setOutputDirectoryOption.Value(); } else { App.OutputDirectory = Path.Combine(program.AssemblyPath, "output"); } // data file extraction if (extractDataFilesOption.HasValue()) { if (extractDataFilesOption.Values.Exists(x => x.Equals("ALL", StringComparison.OrdinalIgnoreCase))) { App.ExtractDataOption = ExtractDataOption.All; } else { foreach (ExtractDataOption extractDataOption in Enum.GetValues(typeof(ExtractDataOption))) { if (extractDataOption == ExtractDataOption.None || extractDataOption == ExtractDataOption.All) { continue; } if (program.ExtractDataValues.TryGetValue(extractDataOption, out List <string> values)) { if (extractDataFilesOption.Values.Intersect(values, StringComparer.OrdinalIgnoreCase).Any()) { App.ExtractDataOption |= extractDataOption; } } } } // none is default as defined in App if (App.ExtractDataOption != ExtractDataOption.None) { App.ExtractDataOption &= ~ExtractDataOption.None; } } else { App.ExtractDataOption = ExtractDataOption.HeroData; } // image file extraction if (extractImageFilesOption.HasValue() && !string.IsNullOrEmpty(storagePathArgument.Value)) { if (extractImageFilesOption.Values.Exists(x => x.Equals("ALL", StringComparison.OrdinalIgnoreCase))) { App.ExtractFileOption = ExtractImageOption.All; } else if (extractImageFilesOption.Values.Exists(x => x.Equals("ALL-SPLIT", StringComparison.OrdinalIgnoreCase) || x.Equals("ALLSPLIT", StringComparison.OrdinalIgnoreCase))) { App.ExtractFileOption = ExtractImageOption.AllSplit; } else { foreach (ExtractImageOption extractFileOption in Enum.GetValues(typeof(ExtractImageOption))) { if (extractFileOption == ExtractImageOption.None || extractFileOption == ExtractImageOption.All) { continue; } if (program.ExtractImageValues.TryGetValue(extractFileOption, out List <string> values)) { if (extractImageFilesOption.Values.Intersect(values, StringComparer.OrdinalIgnoreCase).Any()) { App.ExtractFileOption |= extractFileOption; } } } } // none is default as defined in App if (App.ExtractFileOption != ExtractImageOption.None) { App.ExtractFileOption &= ~ExtractImageOption.None; } } if (setGameStringLocalizations.HasValue()) { IEnumerable <string> localizations = new List <string>(); if (setGameStringLocalizations.Values.Exists(x => x.Equals("ALL", StringComparison.OrdinalIgnoreCase))) { localizations = Enum.GetNames(typeof(Localization)); } else { localizations = setGameStringLocalizations.Values; } foreach (string locale in localizations) { if (Enum.TryParse(locale, true, out Localization localization)) { app.Localizations.Add(localization); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine($"Unknown localization - {locale}"); } } Console.ResetColor(); Console.WriteLine(); } else { app.Localizations.Add(Localization.ENUS); } App.CreateXml = xmlOutputOption.HasValue(); App.CreateJson = jsonOutputOption.HasValue(); // if both not set, default to both true if (!xmlOutputOption.HasValue() && !jsonOutputOption.HasValue()) { App.CreateXml = true; App.CreateJson = true; } App.ShowValidationWarnings = validationWarningsOption.HasValue(); App.IsFileSplit = setFileSplitOption.HasValue(); App.IsLocalizedText = localizedTextOption.HasValue(); App.CreateMinFiles = minifyOption.HasValue(); app.Run(); Console.ResetColor(); return(0); }); if (args != null && args.Length > 0) { try { commandLineApplication.Execute(args); } catch (CommandParsingException) { return; } } else // defaults { App.Defaults = true; app.Run(); } Console.ResetColor(); }
private CommandArgument[] GenerateArguments( string[] arguments) { CommandArgument[] resultArguments = new CommandArgument[ arguments.Length ]; int currentArgument = 0; foreach ( string argument in arguments ) { resultArguments[ currentArgument++ ] = new CommandArgument( argument ); } return resultArguments; }
static int Main(string[] args) { IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddTransient <IRetryHelper, RetryHelper>(); serviceCollection.AddTransient <IProcessExitHandler, ProcessExitHandler>(); serviceCollection.AddTransient <IFileSystem, FileSystem>(); serviceCollection.AddTransient <ILogger, ConsoleLogger>(); // We need to keep singleton/static semantics serviceCollection.AddSingleton <IInstrumentationHelper, InstrumentationHelper>(); serviceCollection.AddSingleton <ISourceRootTranslator, SourceRootTranslator>(provider => new SourceRootTranslator(provider.GetRequiredService <ILogger>(), provider.GetRequiredService <IFileSystem>())); serviceCollection.AddSingleton <ICecilSymbolHelper, CecilSymbolHelper>(); ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider(); var logger = (ConsoleLogger)serviceProvider.GetService <ILogger>(); var fileSystem = serviceProvider.GetService <IFileSystem>(); var app = new CommandLineApplication { Name = "coverlet", FullName = "Cross platform .NET Core code coverage tool" }; app.HelpOption("-h|--help"); app.VersionOption("-v|--version", GetAssemblyVersion()); int exitCode = (int)CommandExitCodes.Success; CommandArgument moduleOrAppDirectory = app.Argument("<ASSEMBLY|DIRECTORY>", "Path to the test assembly or application directory."); CommandOption target = app.Option("-t|--target", "Path to the test runner application.", CommandOptionType.SingleValue); CommandOption targs = app.Option("-a|--targetargs", "Arguments to be passed to the test runner.", CommandOptionType.SingleValue); CommandOption output = app.Option("-o|--output", "Output of the generated coverage report", CommandOptionType.SingleValue); CommandOption <LogLevel> verbosity = app.Option <LogLevel>("-v|--verbosity", "Sets the verbosity level of the command. Allowed values are quiet, minimal, normal, detailed.", CommandOptionType.SingleValue); CommandOption formats = app.Option("-f|--format", "Format of the generated coverage report.", CommandOptionType.MultipleValue); CommandOption threshold = app.Option("--threshold", "Exits with error if the coverage % is below value.", CommandOptionType.SingleValue); CommandOption thresholdTypes = app.Option("--threshold-type", "Coverage type to apply the threshold to.", CommandOptionType.MultipleValue); CommandOption thresholdStat = app.Option("--threshold-stat", "Coverage statistic used to enforce the threshold value.", CommandOptionType.SingleValue); CommandOption excludeFilters = app.Option("--exclude", "Filter expressions to exclude specific modules and types.", CommandOptionType.MultipleValue); CommandOption includeFilters = app.Option("--include", "Filter expressions to include only specific modules and types.", CommandOptionType.MultipleValue); CommandOption excludedSourceFiles = app.Option("--exclude-by-file", "Glob patterns specifying source files to exclude.", CommandOptionType.MultipleValue); CommandOption includeDirectories = app.Option("--include-directory", "Include directories containing additional assemblies to be instrumented.", CommandOptionType.MultipleValue); CommandOption excludeAttributes = app.Option("--exclude-by-attribute", "Attributes to exclude from code coverage.", CommandOptionType.MultipleValue); CommandOption includeTestAssembly = app.Option("--include-test-assembly", "Specifies whether to report code coverage of the test assembly.", CommandOptionType.NoValue); CommandOption singleHit = app.Option("--single-hit", "Specifies whether to limit code coverage hit reporting to a single hit for each location", CommandOptionType.NoValue); CommandOption skipAutoProp = app.Option("--skipautoprops", "Neither track nor record auto-implemented properties.", CommandOptionType.NoValue); CommandOption mergeWith = app.Option("--merge-with", "Path to existing coverage result to merge.", CommandOptionType.SingleValue); CommandOption useSourceLink = app.Option("--use-source-link", "Specifies whether to use SourceLink URIs in place of file system paths.", CommandOptionType.NoValue); CommandOption doesNotReturnAttributes = app.Option("--does-not-return-attribute", "Attributes that mark methods that do not return.", CommandOptionType.MultipleValue); app.OnExecute(() => { if (string.IsNullOrEmpty(moduleOrAppDirectory.Value) || string.IsNullOrWhiteSpace(moduleOrAppDirectory.Value)) { throw new CommandParsingException(app, "No test assembly or application directory specified."); } if (!target.HasValue()) { throw new CommandParsingException(app, "Target must be specified."); } if (verbosity.HasValue()) { // Adjust log level based on user input. logger.Level = verbosity.ParsedValue; } CoverageParameters parameters = new() { IncludeFilters = includeFilters.Values.ToArray(), IncludeDirectories = includeDirectories.Values.ToArray(), ExcludeFilters = excludeFilters.Values.ToArray(), ExcludedSourceFiles = excludedSourceFiles.Values.ToArray(), ExcludeAttributes = excludeAttributes.Values.ToArray(), IncludeTestAssembly = includeTestAssembly.HasValue(), SingleHit = singleHit.HasValue(), MergeWith = mergeWith.Value(), UseSourceLink = useSourceLink.HasValue(), SkipAutoProps = skipAutoProp.HasValue(), DoesNotReturnAttributes = doesNotReturnAttributes.Values.ToArray() }; ISourceRootTranslator sourceRootTranslator = serviceProvider.GetRequiredService <ISourceRootTranslator>(); Coverage coverage = new(moduleOrAppDirectory.Value, parameters, logger, serviceProvider.GetRequiredService <IInstrumentationHelper>(), fileSystem, sourceRootTranslator, serviceProvider.GetRequiredService <ICecilSymbolHelper>()); coverage.PrepareModules(); Process process = new(); process.StartInfo.FileName = target.Value(); process.StartInfo.Arguments = targs.HasValue() ? targs.Value() : string.Empty; process.StartInfo.CreateNoWindow = true; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; process.OutputDataReceived += (sender, eventArgs) => { if (!string.IsNullOrEmpty(eventArgs.Data)) { logger.LogInformation(eventArgs.Data, important: true); } }; process.ErrorDataReceived += (sender, eventArgs) => { if (!string.IsNullOrEmpty(eventArgs.Data)) { logger.LogError(eventArgs.Data); } }; process.Start(); process.BeginErrorReadLine(); process.BeginOutputReadLine(); process.WaitForExit(); var dOutput = output.HasValue() ? output.Value() : Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar.ToString(); var dThresholdTypes = thresholdTypes.HasValue() ? thresholdTypes.Values : new List <string>(new string[] { "line", "branch", "method" }); var dThresholdStat = thresholdStat.HasValue() ? Enum.Parse <ThresholdStatistic>(thresholdStat.Value(), true) : Enum.Parse <ThresholdStatistic>("minimum", true); logger.LogInformation("\nCalculating coverage result..."); var result = coverage.GetCoverageResult(); var directory = Path.GetDirectoryName(dOutput); if (directory == string.Empty) { directory = Directory.GetCurrentDirectory(); } else if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } foreach (var format in formats.HasValue() ? formats.Values : new List <string>(new string[] { "json" })) { var reporter = new ReporterFactory(format).CreateReporter(); if (reporter == null) { throw new Exception($"Specified output format '{format}' is not supported"); } if (reporter.OutputType == ReporterOutputType.Console) { // Output to console logger.LogInformation(" Outputting results to console", important: true); logger.LogInformation(reporter.Report(result, sourceRootTranslator), important: true); } else { // Output to file var filename = Path.GetFileName(dOutput); filename = (filename == string.Empty) ? $"coverage.{reporter.Extension}" : filename; filename = Path.HasExtension(filename) ? filename : $"{filename}.{reporter.Extension}"; var report = Path.Combine(directory, filename); logger.LogInformation($" Generating report '{report}'", important: true); fileSystem.WriteAllText(report, reporter.Report(result, sourceRootTranslator)); } } var thresholdTypeFlagQueue = new Queue <ThresholdTypeFlags>(); foreach (var thresholdType in dThresholdTypes) { if (thresholdType.Equals("line", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Line); } else if (thresholdType.Equals("branch", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Branch); } else if (thresholdType.Equals("method", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Method); } } Dictionary <ThresholdTypeFlags, double> thresholdTypeFlagValues = new Dictionary <ThresholdTypeFlags, double>(); if (threshold.HasValue() && threshold.Value().Contains(',')) { var thresholdValues = threshold.Value().Split(',', StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()); if (thresholdValues.Count() != thresholdTypeFlagQueue.Count()) { throw new Exception($"Threshold type flag count ({thresholdTypeFlagQueue.Count()}) and values count ({thresholdValues.Count()}) doesn't match"); } foreach (var thresholdValue in thresholdValues) { if (double.TryParse(thresholdValue, out var value)) { thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = value; } else { throw new Exception($"Invalid threshold value must be numeric"); } } } else { double thresholdValue = threshold.HasValue() ? double.Parse(threshold.Value()) : 0; while (thresholdTypeFlagQueue.Any()) { thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = thresholdValue; } } var coverageTable = new ConsoleTable("Module", "Line", "Branch", "Method"); var summary = new CoverageSummary(); var linePercentCalculation = summary.CalculateLineCoverage(result.Modules); var branchPercentCalculation = summary.CalculateBranchCoverage(result.Modules); var methodPercentCalculation = summary.CalculateMethodCoverage(result.Modules); var totalLinePercent = linePercentCalculation.Percent; var totalBranchPercent = branchPercentCalculation.Percent; var totalMethodPercent = methodPercentCalculation.Percent; var averageLinePercent = linePercentCalculation.AverageModulePercent; var averageBranchPercent = branchPercentCalculation.AverageModulePercent; var averageMethodPercent = methodPercentCalculation.AverageModulePercent; foreach (var _module in result.Modules) { var linePercent = summary.CalculateLineCoverage(_module.Value).Percent; var branchPercent = summary.CalculateBranchCoverage(_module.Value).Percent; var methodPercent = summary.CalculateMethodCoverage(_module.Value).Percent; coverageTable.AddRow(Path.GetFileNameWithoutExtension(_module.Key), $"{linePercent}%", $"{branchPercent}%", $"{methodPercent}%"); } logger.LogInformation(coverageTable.ToStringAlternative()); coverageTable.Columns.Clear(); coverageTable.Rows.Clear(); coverageTable.AddColumn(new[] { "", "Line", "Branch", "Method" }); coverageTable.AddRow("Total", $"{totalLinePercent}%", $"{totalBranchPercent}%", $"{totalMethodPercent}%"); coverageTable.AddRow("Average", $"{averageLinePercent}%", $"{averageBranchPercent}%", $"{averageMethodPercent}%"); logger.LogInformation(coverageTable.ToStringAlternative()); if (process.ExitCode > 0) { exitCode += (int)CommandExitCodes.TestFailed; } var thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, dThresholdStat); if (thresholdTypeFlags != ThresholdTypeFlags.None) { exitCode += (int)CommandExitCodes.CoverageBelowThreshold; var exceptionMessageBuilder = new StringBuilder(); if ((thresholdTypeFlags & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} line coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Line]}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} branch coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Branch]}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} method coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Method]}"); } throw new Exception(exceptionMessageBuilder.ToString()); } return(exitCode); }); try { return(app.Execute(args)); } catch (CommandParsingException ex) { logger.LogError(ex.Message); app.ShowHelp(); return((int)CommandExitCodes.CommandParsingException); } catch (Win32Exception we) when(we.Source == "System.Diagnostics.Process") { logger.LogError($"Start process '{target.Value()}' failed with '{we.Message}'"); return(exitCode > 0 ? exitCode : (int)CommandExitCodes.Exception); } catch (Exception ex) { logger.LogError(ex.Message); return(exitCode > 0 ? exitCode : (int)CommandExitCodes.Exception); } }
public void DuplicateArgsShouldThrow() { CommandLine.CommandEnvironment = new TestCommandEnvironment("/N:123 /N:345"); var commandArg = new CommandArgument("/N:345", 7); commandArg.Command = "N"; Assert.Equal( new CommandLineArgumentInvalidException(typeof(string), commandArg).Message, Assert.Throws<CommandLineArgumentInvalidException>(() => CommandLine.Parse<TestArgs>()).Message); }
static int Main(string[] args) { Logger logger = new Logger(); var app = new CommandLineApplication(); app.Name = "dotnet get"; app.FullName = ".NET Core Tools Global Installer"; app.Description = "Install and use command line tools built on .NET Core"; app.HelpOption("-h|--help"); app.VersionOption("-v|--version", GetAssemblyVersion()); CommandOption verboseOption = app.Option("--verbose", "Enable verbose output", CommandOptionType.NoValue); app.OnExecute(() => { app.ShowHelp(); return(0); }); app.Command("install", c => { c.Description = "Installs a .NET Core tool"; c.HelpOption("-h|--help"); CommandArgument source = c.Argument("<SOURCE>", "The tool to install. Can be a NuGet package"); c.OnExecute(() => { logger = new Logger(verboseOption.HasValue()); if (string.IsNullOrWhiteSpace(source.Value)) { logger.LogError("<SOURCE> argument is required. Use -h|--help to see help"); return(1); } InstallCommand installCommand = new InstallCommand(source.Value, logger); return(installCommand.Execute() ? 0 : 1); }); }); app.Command("update", c => { c.Description = "Updates a .NET Core tool"; c.HelpOption("-h|--help"); CommandArgument source = c.Argument("<SOURCE>", "The tool to update."); c.OnExecute(() => { logger = new Logger(verboseOption.HasValue()); if (string.IsNullOrWhiteSpace(source.Value)) { return(Update(logger) ? 0 : 1); } UpdateCommand updateCommand = new UpdateCommand(source.Value, logger); return(updateCommand.Execute() ? 0 : 1); }); }); app.Command("list", c => { c.Description = "Lists all installed .NET Core tools"; c.HelpOption("-h|--help"); c.OnExecute(() => { logger = new Logger(verboseOption.HasValue()); ListCommand listCommand = new ListCommand(logger); return(listCommand.Execute() ? 0 : 1); }); }); app.Command("uninstall", c => { c.Description = "Uninstalls a .NET Core tool"; c.HelpOption("-h|--help"); CommandArgument source = c.Argument("<SOURCE>", "The tool to uninstall."); c.OnExecute(() => { logger = new Logger(verboseOption.HasValue()); if (string.IsNullOrWhiteSpace(source.Value)) { logger.LogError("<SOURCE> argument is required. Use -h|--help to see help"); return(1); } UninstallCommand uninstallCommand = new UninstallCommand(source.Value, logger); return(uninstallCommand.Execute() ? 0 : 1); }); }); try { return(app.Execute(args)); } catch (CommandParsingException ex) { logger.LogWarning(ex.Message); app.ShowHelp(); return(1); } }