private ProcessArgumentBuilder GetArguments( IEnumerable <FilePath> sourceFiles, FilePath outputFile, DotCoverMergeSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("Merge"); // Set configuration file if exists. GetConfigurationFileArgument(settings).CopyTo(builder); // Set the Source files. var source = string.Join(";", sourceFiles.Select(s => s.MakeAbsolute(_environment).FullPath)); builder.AppendSwitch("/Source", "=", source.Quote()); // Set the Output file. outputFile = outputFile.MakeAbsolute(_environment); builder.AppendSwitch("/Output", "=", outputFile.FullPath.Quote()); // Get Global settings GetArguments(settings).CopyTo(builder); return(builder); }
private ProcessArgumentBuilder GetArguments( ICakeContext context, Action <ICakeContext> action, DotCoverAnalyseSettings settings, FilePath outputPath) { var builder = new ProcessArgumentBuilder(); builder.Append("Analyse"); // Set configuration file if exists. GetConfigurationFileArgument(settings).CopyTo(builder); // Get Target executable arguments GetTargetArguments(context, action).CopyTo(builder); // Set the output file. outputPath = outputPath.MakeAbsolute(_environment); builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote()); // Set the report type, don't include the default value if (settings.ReportType != DotCoverReportType.XML) { builder.AppendSwitch("/ReportType", "=", settings.ReportType.ToString()); } // Get Coverage arguments GetCoverageArguments(settings).CopyTo(builder); // Get base arguments GetArguments(settings).CopyTo(builder); return(builder); }
/// <summary> /// Appends the SpecFlowSettings arguments to builder. /// </summary> /// <param name="settings">The settings.</param> /// <param name="builder">The argument builder.</param> protected void AppendArguments( SpecFlowSettings settings, ProcessArgumentBuilder builder) { if (settings == null) { throw new ArgumentNullException("settings"); } if (builder == null) { throw new ArgumentNullException("builder"); } // Set the out file. if (settings.Out != null) { var outFile = settings.Out.MakeAbsolute(_environment); builder.AppendSwitch("/out", ":", outFile.FullPath.Quote()); } // Set the xslt file. if (settings.XsltFile != null) { var xsltFile = settings.XsltFile.MakeAbsolute(_environment); builder.AppendSwitch("/xsltFile", ":", xsltFile.FullPath.Quote()); } }
private ProcessArgumentBuilder GetArguments( FilePath sourceFile, FilePath outputFile, DotCoverReportSettings settings) { var builder = new ProcessArgumentBuilder(); builder.Append("Report"); // Set the Source file. sourceFile = sourceFile.MakeAbsolute(_environment); builder.AppendSwitch("/Source", "=", sourceFile.FullPath.Quote()); // Set the Output file. outputFile = outputFile.MakeAbsolute(_environment); builder.AppendSwitch("/Output", "=", outputFile.FullPath.Quote()); // Set the report type, don't include the default value if (settings.ReportType != DotCoverReportType.XML) { builder.AppendSwitch("/ReportType", "=", settings.ReportType.ToString()); } // Get Global settings GetArguments(settings).CopyTo(builder); return(builder); }
private void AppendLogLevel(ProcessArgumentBuilder args, LibManVerbosity verbosity) { const string @switch = "--verbosity"; const string separator = " "; if (verbosity == LibManVerbosity.Default && CakeVerbosityLevel.HasValue) { verbosity = CakeToLibManLogLevelConverter(CakeVerbosityLevel.Value); } switch (verbosity) { case LibManVerbosity.Default: break; case LibManVerbosity.Normal: args.AppendSwitch(@switch, separator, "normal"); break; case LibManVerbosity.Detailed: args.AppendSwitch(@switch, separator, "detailed"); break; case LibManVerbosity.Quiet: args.AppendSwitch(@switch, separator, "quiet"); break; } }
private ProcessArgumentBuilder GetArguments( DotCoverContext context, DotCoverCoverSettings settings, FilePath outputPath) { var builder = new ProcessArgumentBuilder(); builder.Append("Cover"); // The target application to call. builder.AppendSwitch("/TargetExecutable", "=", context.FilePath.FullPath.Quote()); // The arguments to the target application. var arguments = context.Settings?.Arguments?.Render(); if (!string.IsNullOrWhiteSpace(arguments)) { arguments = arguments.Replace("\"", "\\\""); builder.AppendSwitch("/TargetArguments", "=", arguments.Quote()); } // Set the output file. outputPath = outputPath.MakeAbsolute(_environment); builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote()); // Set common Coverage settings settings.ToArguments(_environment).CopyTo(builder); return(builder); }
private static void AddSwitchArguments(ProcessArgumentBuilder builder, AppPackagerSettings settings) { builder.AppendSwitch(settings.Localized, "l"); builder.AppendSwitch(settings.OverwriteOutput, "o"); builder.AppendSwitch(settings.PreventOverwriteOutput, "no"); builder.AppendSwitch(settings.SkipSemanticValidation, "nv"); builder.AppendSwitch(settings.EnableVerboseLogging, "v"); }
private ProcessArgumentBuilder GetArguments(FilePath scriptFile, InnoSetupSettings settings) { var builder = new ProcessArgumentBuilder(); // Defines (/Ddefine[=value] if (settings.Defines != null) { foreach (var item in settings.Defines) { builder.Append(string.IsNullOrEmpty(item.Value) ? string.Format(CultureInfo.InvariantCulture, "/D{0}", item.Key) : string.Format(CultureInfo.InvariantCulture, "/D{0}={1}", item.Key, new TextArgument(item.Value))); } } // Enable output if (settings.EnableOutput.HasValue) { builder.Append(settings.EnableOutput.Value ? "/O+" : "/O-"); } // Output directory if (settings.OutputDirectory != null) { builder.AppendSwitch("/O", string.Empty, settings.OutputDirectory.MakeAbsolute(_environment).FullPath); } // Output base file name if (!string.IsNullOrEmpty(settings.OutputBaseFilename)) { builder.AppendSwitch("/F", string.Empty, settings.OutputBaseFilename); } // Quiet mode switch (settings.QuietMode) { case InnoSetupQuietMode.Off: break; case InnoSetupQuietMode.Quiet: builder.Append("/Q"); break; case InnoSetupQuietMode.QuietWithProgress: builder.Append("/Qp"); break; default: throw new ArgumentOutOfRangeException(); } // Quoted Script file builder.Append(scriptFile.MakeAbsolute(_environment).FullPath); return(builder); }
/// <summary> /// Builds the complete arguments for invoking newman /// </summary> /// <param name="args">The argument builder.</param> public void Build(ProcessArgumentBuilder args) { if (EnvironmentFile != null) { args.AppendSwitchQuoted(ArgumentNames.Environment, EnvironmentFile.FullPath); } if (GlobalVariablesFile != null) { args.AppendSwitchQuoted(ArgumentNames.Globals, GlobalVariablesFile.FullPath); } if (!string.IsNullOrWhiteSpace(Folder)) { args.AppendSwitchQuoted(ArgumentNames.Folder, Folder); } if (ExportEnvironmentPath != null) { args.AppendSwitchQuoted(ArgumentNames.ExportEnvironment, ExportEnvironmentPath.FullPath); } if (ExportGlobalsPath != null) { args.AppendSwitchQuoted(ArgumentNames.ExportGlobals, ExportGlobalsPath.FullPath); } if (ExportCollectionPath != null) { args.AppendSwitchQuoted(ArgumentNames.ExportCollection, ExportCollectionPath.FullPath); } if (RequestTimeout != default(int)) { args.AppendSwitch(ArgumentNames.RequestTimeout, RequestTimeout.ToString()); } if (DisableStrictSSL) { args.Append(ArgumentNames.Insecure); } if (IgnoreRedirects) { args.Append(ArgumentNames.IgnoreRedirects); } if (RequestDelay != default(int)) { args.AppendSwitch(ArgumentNames.RequestDelay, RequestDelay.ToString()); } if (ExitOnFirstFailure) { args.Append(ArgumentNames.Bail); } if (Reporters.Any()) { args.AppendSwitch(ArgumentNames.Reporters, string.Join(",", Reporters.Keys.Select(k => k.Trim()))); foreach (var reporter in Reporters) { reporter.Value?.RenderOptions(args); } } }
private ProcessArgumentBuilder GetArguments( OpenCoverContext context, OpenCoverSettings settings, FilePath outputPath) { var builder = new ProcessArgumentBuilder(); // The target application to call. builder.AppendSwitch("-target", ":", context.FilePath.FullPath.Quote()); // The arguments to the target application. if (context.Settings != null && context.Settings.Arguments != null) { var arguments = context.Settings.Arguments.Render(); if (!string.IsNullOrWhiteSpace(arguments)) { arguments = arguments.Replace("\"", "\\\""); builder.AppendSwitch("-targetargs", ":", arguments.Quote()); } } // Filters if (settings.Filters.Count > 0) { var filters = string.Join(" ", settings.Filters); builder.AppendSwitch("-filter", ":", filters.Quote()); } // Exclude by attribute if (settings.ExcludedAttributeFilters.Count > 0) { var filters = string.Join(";", settings.ExcludedAttributeFilters); builder.AppendSwitch("-excludebyattribute", ":", filters.Quote()); } // Exclude by file if (settings.ExcludedFileFilters.Count > 0) { var filters = string.Join(";", settings.ExcludedFileFilters); builder.AppendSwitch("-excludebyfile", ":", filters.Quote()); } if (settings.SkipAutoProps) { builder.Append("-skipautoprops"); } builder.AppendSwitch("-register", ":", settings.Register); if (settings.ReturnTargetCodeOffset != null) { builder.AppendSwitch("-returntargetcode", ":", settings.ReturnTargetCodeOffset.Value.ToString(System.Globalization.CultureInfo.InvariantCulture)); } // Set the output file. outputPath = outputPath.MakeAbsolute(_environment); builder.AppendSwitch("-output", ":", outputPath.FullPath.Quote()); return(builder); }
/// <summary> /// Applies the settings to the process arguments ready for execution. /// </summary> /// <param name="args">The builder to apply the settings to.</param> protected override void EvaluateCore(ProcessArgumentBuilder args) { base.EvaluateCore(args); if (AutoWatch) { args.Append("--auto-watch"); } if (NoAutoWatch) { args.Append("--no-auto-watch"); } if (Detached) { args.Append("--detached"); } if (SingleRun) { args.Append("--single-run"); } if (NoSingleRun) { args.Append("--no-single-run"); } if (CaptureTimeout.HasValue) { args.AppendSwitch("--capture-timeout", CaptureTimeout.Value.ToString()); } if (ReportSlowerThan.HasValue) { args.AppendSwitch("--report-slower-than", ReportSlowerThan.Value.ToString()); } if (Reporters != null && Reporters.Count > 0) { args.AppendSwitch("--reporters", string.Join(",", Reporters.Select(_ => _.ToString().ToLower()))); } if (Browsers != null && Browsers.Count > 0) { args.AppendSwitch("--browsers", string.Join(",", Browsers)); } }
private static void AddValue(ProcessArgumentBuilder args, string key, string value) { var quote = value.IndexOfAny(new[] { ' ', '*' }) >= 0; if (key.StartsWith("!", StringComparison.OrdinalIgnoreCase)) { if (quote) { args.AppendSwitchQuotedSecret(key.TrimStart('!'), value); } else { args.AppendSwitchSecret(key.TrimStart('!'), value); } } else { if (quote) { args.AppendSwitchQuoted(key, value); } else { args.AppendSwitch(key, value); } } }
internal static ProcessArgumentBuilder GetMSTestArguments(this SpecFlowContext context, FilePath projectFile, ICakeEnvironment environment) { var builder = new ProcessArgumentBuilder(); builder.Append("mstestexecutionreport"); // Set the project file builder.AppendQuoted(projectFile.MakeAbsolute(environment).FullPath); var arguments = context.RenderArguments(); // Set the test result var testResultMatch = Regex.Match(arguments, "\\/resultsfile:\\s*((?:\".+?\"|[^\\s]+))", RegexOptions.IgnoreCase); if (testResultMatch.Success && testResultMatch.Groups[1].Success) { builder.AppendSwitch("/testResult", ":", testResultMatch.Groups[1].Value); } else { throw new CakeException("MSTest must contain argument \"/resultsfile:<filename>\""); } return(builder); }
private ProcessArgumentBuilder GetArguments(CMakeBuildSettings settings) { var builder = new ProcessArgumentBuilder(); var binaryPath = settings.BinaryPath.MakeAbsolute(_environment); builder.AppendSwitchQuoted("--build", binaryPath.FullPath); // Generator if (settings.CleanFirst) { builder.Append("--clean-first"); } // Toolset if (settings.Targets != null) { builder.AppendSwitch("--target", string.Join(",", settings.Targets)); } // Options if (settings.Options != null) { foreach (string option in settings.Options) { builder.AppendQuoted(option); } } return(builder); }
/// <summary> /// Evaluates the settings and writes them to <paramref name="args"/>. /// </summary> /// <param name="args">The argument builder into which the settings should be written.</param> protected override void EvaluateCore(ProcessArgumentBuilder args) { const string separator = " "; base.EvaluateCore(args); if (string.IsNullOrWhiteSpace(Library)) { throw new ArgumentNullException(nameof(Library), $"Missing required {nameof(Library)} property."); } args.Append(Library); if (Destination != null) { args.AppendSwitchQuoted("--destination", separator, Destination.FullPath); } if (Provider != CdnProvider.Default) { args.AppendSwitch("--provider", separator, Provider.ToString()); } foreach (var file in Files) { args.AppendSwitchQuoted("--files", separator, file.FullPath); } }
public void Run(TerraformApplySettings settings) { var builder = new ProcessArgumentBuilder() .Append("apply"); // Order of AutoApprove and Plan are important. if (settings.AutoApprove) { builder.Append("-auto-approve"); } // Use Plan if it exists. if (settings.Plan != null) { builder.AppendQuoted(settings.Plan.FullPath); } if (settings.Parallelism != default(int)) { builder.AppendSwitch("-parallelism", "=", settings.Parallelism.ToString()); } if (!string.IsNullOrWhiteSpace(settings.InputVariablesFile)) { builder.AppendSwitchQuoted("-var-file", $"{settings.InputVariablesFile}"); } foreach (var inputVariable in settings.InputVariables ?? new Dictionary <string, string>()) { builder.AppendSwitchQuoted("-var", $"{inputVariable.Key}={inputVariable.Value}"); } Run(settings, builder); }
public static void AppendSwitch(this ProcessArgumentBuilder builder, bool include, string text) { if (include) { builder.AppendSwitch("/", text); } }
private ProcessArgumentBuilder GetArguments( ICakeContext context, Action <ICakeContext> action, DotCoverCoverSettings settings, FilePath outputPath) { var builder = new ProcessArgumentBuilder(); builder.Append("Cover"); // Set configuration file if exists. GetConfigurationFileArgument(settings).CopyTo(builder); // Get Target executable arguments GetTargetArguments(context, action).CopyTo(builder); // Set the output file. outputPath = outputPath.MakeAbsolute(_environment); builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote()); // Get Coverage arguments GetCoverageArguments(settings).CopyTo(builder); // Get base arguments GetArguments(settings).CopyTo(builder); return(builder); }
private ProcessArgumentBuilder GetArguments( IEnumerable <Uri> hosts, CurlDownloadSettings settings) { var arguments = new ProcessArgumentBuilder(); arguments.AppendSettings(settings); if (settings.OutputPaths != null) { foreach (var arg in JoinHostsAndOutputPaths(hosts, settings.OutputPaths)) { arguments.Append(arg); } } else { foreach (var host in hosts) { arguments.AppendSwitch("-O", host.AbsoluteUri); } } return(arguments); }
internal static ProcessArgumentBuilder GetXUnitArguments(this SpecFlowContext context, FilePath projectFile, ICakeEnvironment environment) { var builder = new ProcessArgumentBuilder(); builder.Append("nunitexecutionreport"); // Set the project file builder.AppendQuoted(projectFile.MakeAbsolute(environment).FullPath); var arguments = RenderArguments(context); // Set the xml test result var xmlTestResultMatch = Regex.Match(arguments, "-nunit\\s+((?:\".+?\"|.*))", RegexOptions.IgnoreCase); if (xmlTestResultMatch.Success && xmlTestResultMatch.Groups[1].Success) { builder.AppendSwitch("/xmlTestResult", ":", xmlTestResultMatch.Groups[1].Value); } else { throw new CakeException("XUnit2 must contain argument \"-nunit <filename>\""); } return(builder); }
internal static ProcessArgumentBuilder GetNUnitArguments(this SpecFlowContext context, FilePath projectFile, ICakeEnvironment environment) { var builder = new ProcessArgumentBuilder(); builder.Append("nunitexecutionreport"); // Set the project file builder.AppendQuoted(projectFile.MakeAbsolute(environment).FullPath); var arguments = context.RenderArguments(); // Set the xml test result var xmlTestResultMatch = Regex.Match(arguments, "\"--result=([^;]+);format=nunit2", RegexOptions.IgnoreCase); if (xmlTestResultMatch.Success && xmlTestResultMatch.Groups[1].Success) { builder.AppendSwitch("/xmlTestResult", ":", xmlTestResultMatch.Groups[1].Value.Quote()); } else { throw new CakeException("NUnit3 must contain argument \"--result=<filename>;format=nunit2\""); } // Set the test output var testOutputMatch = Regex.Match(arguments, "\"--out=([^\"]+)\"", RegexOptions.IgnoreCase); if (testOutputMatch.Success && testOutputMatch.Groups[1].Success) { builder.AppendSwitch("/testOutput", ":", testOutputMatch.Groups[1].Value.Quote()); } else { throw new CakeException("NUnit3 must contain argument \"--out=<filename>\""); } // Check for labels switch var testLabelsMatch = Regex.Match(arguments, "--labels=All", RegexOptions.IgnoreCase); if (!testLabelsMatch.Success) { throw new CakeException("NUnit3 must contain argument \"--labels=All\""); } return(builder); }
internal static ProcessArgumentBuilder AppendSwitch(this ProcessArgumentBuilder builder, string @switch, IEnumerable <string> values) { foreach (var type in values.Select(s => s.Trim())) { builder.AppendSwitch(@switch, type); } return(builder); }
internal static ProcessArgumentBuilder ToArguments(this DotCoverSettings settings, ICakeEnvironment environment) { var builder = new ProcessArgumentBuilder(); // TargetWorkingDir if (settings.TargetWorkingDir != null) { builder.AppendSwitch("/TargetWorkingDir", "=", settings.TargetWorkingDir.MakeAbsolute(environment).FullPath.Quote()); } // Scope if (settings.Scope.Count > 0) { var scope = string.Join(";", settings.Scope); builder.AppendSwitch("/Scope", "=", scope.Quote()); } // Filters if (settings.Filters.Count > 0) { var filters = string.Join(";", settings.Filters); builder.AppendSwitch("/Filters", "=", filters.Quote()); } // Filters if (settings.AttributeFilters.Count > 0) { var attributeFilters = string.Join(";", settings.AttributeFilters); builder.AppendSwitch("/AttributeFilters", "=", attributeFilters.Quote()); } // DisableDefaultFilters if (settings.DisableDefaultFilters) { builder.Append("/DisableDefaultFilters"); } // LogFile if (settings.LogFile != null) { var logFilePath = settings.LogFile.MakeAbsolute(environment); builder.AppendSwitch("/LogFile", "=", logFilePath.FullPath.Quote()); } return(builder); }
/// <summary> /// Get arguments from coverage settings. /// </summary> /// <param name="settings">The settings.</param> /// <returns>The process arguments.</returns> protected ProcessArgumentBuilder GetCoverageArguments(DotCoverCoverageSettings settings) { var builder = new ProcessArgumentBuilder(); // TargetWorkingDir if (settings.TargetWorkingDir != null) { builder.AppendSwitch("/TargetWorkingDir", "=", settings.TargetWorkingDir.MakeAbsolute(_environment).FullPath.Quote()); } // Scope if (settings.Scope.Count > 0) { var scope = string.Join(";", settings.Scope); builder.AppendSwitch("/Scope", "=", scope.Quote()); } // Filters if (settings.Filters.Count > 0) { var filters = string.Join(";", settings.Filters); builder.AppendSwitch("/Filters", "=", filters.Quote()); } // AttributeFilters if (settings.AttributeFilters.Count > 0) { var attributeFilters = string.Join(";", settings.AttributeFilters); builder.AppendSwitch("/AttributeFilters", "=", attributeFilters.Quote()); } // Filters if (settings.ProcessFilters.Count > 0) { var processFilters = string.Join(";", settings.ProcessFilters); builder.AppendSwitch("/ProcessFilters", "=", processFilters.Quote()); } // DisableDefaultFilters if (settings.DisableDefaultFilters) { builder.Append("/DisableDefaultFilters"); } return(builder); }
private ProcessArgumentBuilder GetArguments( DotCoverContext context, DotCoverCoverSettings settings, FilePath outputPath) { var builder = new ProcessArgumentBuilder(); builder.Append("Cover"); // The target application to call. builder.AppendSwitch("/TargetExecutable", "=", context.FilePath.FullPath.Quote()); // The arguments to the target application. var arguments = context.Settings?.Arguments?.Render(); if (!string.IsNullOrWhiteSpace(arguments)) { arguments = arguments.Replace("\"", "\\\""); builder.AppendSwitch("/TargetArguments", "=", arguments.Quote()); } // Set the output file. outputPath = outputPath.MakeAbsolute(_environment); builder.AppendSwitch("/Output", "=", outputPath.FullPath.Quote()); // TargetWorkingDir if (settings.TargetWorkingDir != null) { builder.AppendSwitch("/TargetWorkingDir", "=", settings.TargetWorkingDir.MakeAbsolute(_environment).FullPath.Quote()); } // Scope if (settings.Scope.Count > 0) { var scope = string.Join(";", settings.Scope); builder.AppendSwitch("/Scope", "=", scope.Quote()); } // Filters if (settings.Filters.Count > 0) { var filters = string.Join(";", settings.Filters); builder.AppendSwitch("/Filters", "=", filters.Quote()); } // Filters if (settings.AttributeFilters.Count > 0) { var attributeFilters = string.Join(";", settings.AttributeFilters); builder.AppendSwitch("/AttributeFilters", "=", attributeFilters.Quote()); } // DisableDefaultFilters if (settings.DisableDefaultFilters) { builder.Append("/DisableDefaultFilters"); } return(builder); }
/// <summary> /// Adds common commandline arguments. /// </summary> /// <param name="builder">Process argument builder to update.</param> /// <param name="settings">The settings.</param> /// <returns>Returns <see cref="ProcessArgumentBuilder"/> updated with common commandline arguments.</returns> private ProcessArgumentBuilder AppendCommonArguments(ProcessArgumentBuilder builder, TSettings settings) { if (!string.IsNullOrEmpty(settings.Namespace)) { builder.AppendSwitch("--namespace", "=", settings.Namespace); } return(builder); }
internal static void AppendDownloadToCurrentDirectory( this ProcessArgumentBuilder arguments, IEnumerable <Uri> hosts) { foreach (var host in hosts) { arguments.AppendSwitch("-O", host.AbsoluteUri); } }
/// <summary> /// Assemble the args to pass to sc.exe /// </summary> /// <param name="computer"></param> /// <param name="settings"></param> /// <returns></returns> public ProcessArgumentBuilder CreateInstallArguments(string computer, InstallSettings settings) { ProcessArgumentBuilder args = new ProcessArgumentBuilder(); string pathArgs = ""; if (settings.Arguments != null) { pathArgs = settings.Arguments.Render(); } this.SetFilePath(computer, settings); if (!String.IsNullOrEmpty(settings.ServiceName)) { args.AppendQuoted(settings.ServiceName); } if (String.IsNullOrEmpty(pathArgs)) { args.AppendSwitchQuoted("binPath=", " ", settings.ExecutablePath.FullPath); } else { args.AppendSwitch("binPath=", " ", "'" + @"\""" + settings.ExecutablePath.FullPath + @"\"" " + pathArgs.Replace("\"", "\\\"") + "'"); } if (!String.IsNullOrEmpty(settings.DisplayName)) { args.AppendSwitchQuoted("DisplayName=", " ", settings.DisplayName); } if (!String.IsNullOrEmpty(settings.Dependencies)) { args.AppendSwitchQuoted("depend=", " ", settings.Dependencies); } if (!String.IsNullOrEmpty(settings.StartMode)) { args.AppendSwitchQuoted("start=", " ", settings.StartMode); } if (!String.IsNullOrEmpty(settings.Username)) { args.AppendSwitchQuoted("obj=", " ", settings.Username); } if (!String.IsNullOrEmpty(settings.Password)) { args.AppendSwitchQuotedSecret("password="******" ", settings.Password); } return(args); }
private static ProcessArgumentBuilder BuildArguments(KnifeSettings settings) { var builder = new ProcessArgumentBuilder(); foreach (var kvp in settings.Options.Where(x => x.Key.StartsWith("--"))) { builder.AppendSwitch(kvp.Key, kvp.Value); } return(builder); }
private static ProcessArgumentBuilder BuildArguments(NamedPipeSettings settings) { var builder = new ProcessArgumentBuilder(); foreach (var kvp in settings.PipeServerArguments) { builder.AppendSwitch(kvp.Key, kvp.Value); } return(builder); }