public async void IsIdempotant() { var dryRun = new DryRun(false, this.dryRunLogger); await this.AssertMetadata(BeforeFixSamples, FirmwareVersion); var actual = await this.fixer.ProcessFileAsync(this.target.Path, dryRun, false); Assert.Equal(FixStatus.Fixed, actual.Status); Assert.Contains($"Old total samples was", actual.Message); await this.AssertMetadata(AfterFixSamples, FirmwareVersion, PatchedTag); var first = await this.fileUtilities.CalculateChecksum(this.target.Path, HashAlgorithmName.SHA256); // now again! var secondActual = await this.fixer.ProcessFileAsync(this.target.Path, dryRun, false); Assert.Equal(FixStatus.NoOperation, secondActual.Status); Assert.Contains($"File has already had it's duration repaired", secondActual.Message); Assert.Equal(CheckStatus.Repaired, secondActual.CheckResult.Status); var second = await this.fileUtilities.CalculateChecksum(this.target.Path, HashAlgorithmName.SHA256); Assert.Equal(first, second); await this.AssertMetadata(AfterFixSamples, FirmwareVersion, PatchedTag); }
internal sealed record OptionArgs( SourcePath SourcePath, DestinationDirectory DestinationDirectory, DryRun DryRun, KeepGoing KeepGoing, SkipDateSubdirectory SkipDateSubdirectory, Overwrite Overwrite);
public void Apply(IServiceProvider serviceProvider) { var settings = serviceProvider.GetService <IOptions <Settings> >().Value; if (Host.HasValue()) { settings.Admin.Host = Host.Value(); } if (OutputFolder.HasValue()) { settings.OutputFolder = OutputFolder.Value(); } if (Port.HasValue()) { settings.Admin.Port = int.Parse(Port.Value()); } settings.DryRun = DryRun.HasValue(); if (InputFolder.HasValue()) { settings.InputFolder = InputFolder.Value(); } }
public async void WillBackupIfRequested() { var backupPath = this.target.Path + ".bak"; var dryRun = new DryRun(false, this.dryRunLogger); var before = await this.fileUtilities.CalculateChecksum(this.target.Path, HashAlgorithmName.SHA256); await this.AssertMetadata(BeforeFixSamples, FirmwareVersion); var actual = await this.fixer.ProcessFileAsync(this.target.Path, dryRun, true); Assert.Equal(FixStatus.Fixed, actual.Status); Assert.Contains($"Old total samples was", actual.Message); // modified file await this.AssertMetadata(AfterFixSamples, FirmwareVersion, PatchedTag); // backup using (var stream = (FileStream)this.fileSystem.File.OpenRead(backupPath)) { var actualSamples = (ulong)Flac.ReadTotalSamples(stream); var actualFirmware = (FirmwareRecord) await ReadFirmwareAsync(stream); Assert.Equal(BeforeFixSamples, actualSamples); Assert.Equal(FirmwareVersion, actualFirmware.Version); actualFirmware.Tags.Should().BeEquivalentTo(Array.Empty <string>()); } var after = await this.fileUtilities.CalculateChecksum(backupPath, HashAlgorithmName.SHA256); // the backup file has the same hash as the original Assert.Equal(before, after); }
private async Task <int> Execute() { if (!TryValidateProjectPath(Project, out var projectPath)) { return(1); } if (Plugins.Values.Count == 0) { ShowHelp(); return(1); } var analysisContext = Analysis.CreateContext(); var compilation = await GetCompilationAsync(projectPath); analysisContext.SetData <CSharpCompilation>(compilation); var operations = new List <Operation>(); for (var i = 0; i < Plugins.Values.Count; i++) { var name = Plugins.Values[i]; Out.WriteLine($"Processing '{name}'..."); if (!KnownPlugins.Plugins.TryGetValue(name, out var plugin)) { Out.WriteLine($"Unknown plugin '{name}'"); return(1); } operations.AddRange(await plugin.GetOperationsAsync(analysisContext)); } Out.WriteLine("Resolved operations:"); for (var i = 0; i < operations.Count; i++) { Out.WriteLine($"\t{operations[i]}"); } Out.WriteLine(); if (!DryRun.HasValue()) { var editorContext = new EditorContext(); editorContext.SetData <CSharpCompilation>(await analysisContext.GetDataAsync <CSharpCompilation>().ConfigureAwait(false)); var editor = Editor.Create(); Out.WriteLine("Performing operations:"); for (var i = 0; i < operations.Count; i++) { Out.WriteLine($"\t{operations[i]}"); await editor.ApplyAsync(editorContext, operations[i]); } } Out.WriteLine(); return(0); }
public override int GetHashCode() { unchecked { int hashCode = base.GetHashCode(); hashCode = (hashCode * 397) ^ DryRun.GetHashCode(); hashCode = (hashCode * 397) ^ (Manifests != null ? Manifests.GetHashCode() : 0); hashCode = (hashCode * 397) ^ Prune.GetHashCode(); return(hashCode); } }
public override async Task <int> InvokeAsync(InvocationContext context) { // validate options // resolve targets this.logger.LogDebug("Input targets: {targets}", this.Targets); var files = this.fileMatcher.ExpandMatches(this.fileSystem.Directory.GetCurrentDirectory(), this.Targets); this.WriteHeader <RenameResult>(); this.Write("Looking for targets..."); using var dryRun = new DryRun(this.DryRun, this.dryRunLogger); var(renames, failed) = await this.ProcessFiles(files, dryRun); int success = 0, unchanged = 0, fail = 0; if (renames.Any()) { if (failed) { fail = renames.Length; } else { foreach (var result in renames) { if (result.Reason is not null) { fail++; } else if (result.OldName == result.NewName) { unchanged++; } else { success++; } } } } else { this.WriteFooter($"No files matched targets: {this.Targets.FormatInlineList()}"); } this.WriteFooter($"{renames.Length} files, {success} renamed, {unchanged} unchanged, {fail} failed"); return(ExitCodes.Get(!failed)); }
public async void CanRepairFaultyDurations() { var dryRun = new DryRun(false, this.dryRunLogger); await this.AssertMetadata(BeforeFixSamples, FirmwareVersion); var actual = await this.fixer.ProcessFileAsync(this.target.Path, dryRun, false); Assert.Equal(FixStatus.Fixed, actual.Status); Assert.Contains($"Old total samples was", actual.Message); await this.AssertMetadata(AfterFixSamples, FirmwareVersion, PatchedTag); }
public async void WillDoNothingInADryRun() { var dryRun = new DryRun(true, this.dryRunLogger); var before = await this.fileUtilities.CalculateChecksum(this.target.Path, HashAlgorithmName.SHA256); await this.AssertMetadata(BeforeFixSamples, FirmwareVersion); var actual = await this.fixer.ProcessFileAsync(this.target.Path, dryRun, false); Assert.Equal(FixStatus.Fixed, actual.Status); Assert.Contains($"Old total samples was", actual.Message); await this.AssertMetadata(BeforeFixSamples, FirmwareVersion); var after = await this.fileUtilities.CalculateChecksum(this.target.Path, HashAlgorithmName.SHA256); Assert.Equal(before, after); }
public static async Task ClassCleanup() { await DryRun.DisableSafeMode(); }
public async Task DapperQueriesWork(QueryContext ctx) { await DryRun.ExecuteQuery(ctx); }
public static async Task ClassInit(TestContext context) { await DryRun.EnableSafeMode(ConnectionString); }
public IDictionary <string, string> to_token_dictionary() { var tokens = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); tokens["AfterMigrationFolderName"] = AfterMigrationFolderName.to_string(); tokens["AlterDatabaseFolderName"] = AlterDatabaseFolderName.to_string(); tokens["Baseline"] = Baseline.to_string(); tokens["BeforeMigrationFolderName"] = BeforeMigrationFolderName.to_string(); tokens["CommandTimeout"] = CommandTimeout.to_string(); tokens["CommandTimeoutAdmin"] = CommandTimeoutAdmin.to_string(); tokens["ConfigurationFile"] = ConfigurationFile.to_string(); tokens["ConnectionString"] = ConnectionString.to_string(); tokens["ConnectionStringAdmin"] = ConnectionStringAdmin.to_string(); tokens["CreateDatabaseCustomScript"] = CreateDatabaseCustomScript.to_string(); tokens["DatabaseName"] = DatabaseName.to_string(); tokens["DatabaseType"] = DatabaseType.to_string(); tokens["Debug"] = Debug.to_string(); tokens["DisableOutput"] = DisableOutput.to_string(); tokens["DisableTokenReplacement"] = DisableTokenReplacement.to_string(); tokens["DoNotAlterDatabase"] = DoNotAlterDatabase.to_string(); tokens["DoNotCreateDatabase"] = DoNotCreateDatabase.to_string(); tokens["DoNotStoreScriptsRunText"] = DoNotStoreScriptsRunText.to_string(); tokens["DownFolderName"] = DownFolderName.to_string(); tokens["Drop"] = Drop.to_string(); tokens["DryRun"] = DryRun.to_string(); tokens["EnvironmentName"] = string.Join(",", EnvironmentNames); tokens["EnvironmentNames"] = string.Join(",", EnvironmentNames); tokens["FunctionsFolderName"] = FunctionsFolderName.to_string(); tokens["IndexesFolderName"] = IndexesFolderName.to_string(); tokens["Initialize"] = Initialize.to_string(); tokens["OutputPath"] = OutputPath.to_string(); tokens["PermissionsFolderName"] = PermissionsFolderName.to_string(); tokens["RecoveryMode"] = RecoveryMode.to_string(); tokens["RepositoryPath"] = RepositoryPath.to_string(); tokens["Restore"] = Restore.to_string(); tokens["RestoreCustomOptions"] = RestoreCustomOptions.to_string(); tokens["RestoreFromPath"] = RestoreFromPath.to_string(); tokens["RestoreTimeout"] = RestoreTimeout.to_string(); tokens["RunAfterCreateDatabaseFolderName"] = RunAfterCreateDatabaseFolderName.to_string(); tokens["RunAfterOtherAnyTimeScriptsFolderName"] = RunAfterOtherAnyTimeScriptsFolderName.to_string(); tokens["RunAllAnyTimeScripts"] = RunAllAnyTimeScripts.to_string(); tokens["RunBeforeUpFolderName"] = RunBeforeUpFolderName.to_string(); tokens["RunFirstAfterUpFolderName"] = RunFirstAfterUpFolderName.to_string(); tokens["SchemaName"] = SchemaName.to_string(); tokens["ScriptsRunErrorsTableName"] = ScriptsRunErrorsTableName.to_string(); tokens["ScriptsRunTableName"] = ScriptsRunTableName.to_string(); tokens["SearchAllSubdirectoriesInsteadOfTraverse"] = SearchAllSubdirectoriesInsteadOfTraverse.to_string(); tokens["ServerName"] = ServerName.to_string(); tokens["Silent"] = Silent.to_string(); tokens["SprocsFolderName"] = SprocsFolderName.to_string(); tokens["SqlFilesDirectory"] = SqlFilesDirectory.to_string(); tokens["TriggersFolderName"] = TriggersFolderName.to_string(); tokens["UpFolderName"] = UpFolderName.to_string(); tokens["Version"] = Version.to_string(); tokens["VersionFile"] = VersionFile.to_string(); tokens["VersionTableName"] = VersionTableName.to_string(); tokens["VersionXPath"] = VersionXPath.to_string(); tokens["ViewsFolderName"] = ViewsFolderName.to_string(); tokens["WarnAndIgnoreOnOneTimeScriptChanges"] = WarnAndIgnoreOnOneTimeScriptChanges.to_string(); tokens["WarnOnOneTimeScriptChanges"] = WarnOnOneTimeScriptChanges.to_string(); tokens["WithTransaction"] = WithTransaction.to_string(); if (UserTokens != null) { foreach (var t in UserTokens) { tokens[t.Key] = t.Value; } } return(tokens); }
#pragma warning restore CS0612 // Type or member is obsolete public async Task <int> ExecuteAsync(CancellationToken cancellationToken) { var sw = System.Diagnostics.Stopwatch.StartNew(); _logger.SetDebugEnable(Verbose.HasValue()); try { var(baseRegistry, destRegistry) = CreateRegistries(); var(manifest, image) = await LoadBaseImage(baseRegistry); UpdateImageConfig(image); UpdateConfigInManifest(manifest, image); var layersAdded = new List <BuilderLayer>(); if (Add.HasValue()) { var layer = CreateLayer(Add.Values, AddFolder.Values, $"layer{layersAdded.Count():00}"); layersAdded.Add(layer); AddLayerToConfigAndManifest(layer, manifest, image); } var pusher = new Pusher(GetFromImage(), GetToImage(), destRegistry, layersAdded, CreateLogger("PUSHR")) { FakePullAndRetryMount = true, }; bool configExists = await pusher.CheckConfigExists(manifest); var missingLayers = await pusher.FindMissingLayers(manifest, !DryRun.HasValue() && destRegistry == baseRegistry); if (!DryRun.HasValue()) { if (!configExists) { await pusher.PushConfig(manifest.config, () => GetJsonStream(image)); } await pusher.CopyLayers(baseRegistry, ImageHelper.GetImageName(GetFromImage()), missingLayers); await pusher.PushLayers(f => File.OpenRead(Path.Combine(_tempFolderPath, f))); await pusher.PushManifest(() => GetJsonStream(manifest)); } string manifestDigest; using (var manifestStream = GetJsonStream(manifest)) { manifestDigest = FileHelper.Digest(manifestStream); } _logger.LogDebug($"Image digest: {manifestDigest}"); if (DigestFile.HasValue()) { string digestFilepath; if (!string.IsNullOrEmpty(DigestFile.Value())) { digestFilepath = DigestFile.Value(); } else { EnsureTempFolder(); digestFilepath = Path.Combine(_tempFolderPath, ManifestDigestFileName); } File.WriteAllText(digestFilepath, manifestDigest); } _logger.LogDebug($"completed in {sw.ElapsedMilliseconds} ms"); Console.WriteLine(manifestDigest); return(0); } catch (Exception ex) { Console.Error.WriteLine($"Error: {ex.Message}"); _logger.LogDebug(ex, "exception"); _logger.LogDebug($"completed in {sw.ElapsedMilliseconds} ms"); return(1); } }
public async Task <int> ExecuteCore(bool generateOnly) { if (!OutputDirectory.HasValue()) { OutputDirectory.TryParse($"_output"); } var logsPath = Path.Combine(OutputDirectory.Required(), "logs"); if (Directory.Exists(logsPath)) { foreach (var file in Directory.EnumerateFiles(logsPath)) { File.Delete(file); } } var generatedPath = Path.Combine(OutputDirectory.Required(), "generated"); if (Directory.Exists(generatedPath)) { foreach (var file in Directory.EnumerateFiles(generatedPath, "*.*", new EnumerationOptions { RecurseSubdirectories = true })) { File.Delete(file); } foreach (var folder in Directory.EnumerateDirectories(generatedPath)) { Directory.Delete(folder, recursive: true); } } var blueprint = await _blueprintManager.GetBlueprintPackage(Blueprint.Required()); if (blueprint == null) { throw new ApplicationException($"Unable to locate blueprint {Blueprint.Required()}"); } var eachValues = new List <object>(); var defaultValuesFiles = File.Exists("values.yaml") ? new[] { "values.yaml" } : new string[0]; foreach (var valuesFile in Values.OptionalMany(defaultValuesFiles)) { using (var reader = File.OpenText(valuesFile)) { eachValues.Add(_serializers.YamlDeserializer.Deserialize(reader)); } } if (Set.HasValue()) { var setValues = new Dictionary <object, object>(); foreach (var set in Set.Values) { var parts = set.Split('=', 2); if (parts.Length == 1) { throw new ApplicationException("Equal sign required when using the option --set name=value"); } var name = parts[0]; var value = parts[1]; var segments = name.Split('.'); if (segments.Any(segment => string.IsNullOrEmpty(segment))) { throw new ApplicationException("Name must not have empty segments when using the option --set name=value"); } var cursor = (IDictionary <object, object>)setValues; foreach (var segment in segments.Reverse().Skip(1).Reverse()) { if (cursor.TryGetValue(segment, out var child) && child is IDictionary <object, object> ) { cursor = (IDictionary <object, object>)child; } else { child = new Dictionary <object, object>(); cursor[segment] = child; cursor = (IDictionary <object, object>)child; } } cursor[segments.Last()] = value; } eachValues.Add(setValues); } IDictionary <object, object> values = new Dictionary <object, object>(); foreach (var addValues in eachValues) { values = (IDictionary <object, object>)MergeUtils.Merge(addValues, values) ?? values; } var(templateEngine, workflow, effectiveValues) = _workflowLoader.Load(blueprint, values, GenerateOutput); if (generateOnly == false) { var patternMatcher = _patternMatcherFactory.Create(Target.Values.Any() ? Target.Values : new List <string>() { "/**" }); var context = new ExecutionContext.Builder() .UseBlueprintPackage(blueprint) .UseTemplateEngine(templateEngine) .UsePatternMatcher(patternMatcher) .SetOutputDirectory(OutputDirectory.Required()) .SetNonInteractive(NonInteractive?.HasValue() ?? false) .SetDryRun(DryRun?.HasValue() ?? false) .SetValues(effectiveValues) .Build(); context.AddValuesIn(_valuesEngine.ProcessValues(workflow.values, context.Values) ?? context.Values); var resultOut = await _workflowEngine.ExecuteOperations(context, workflow.operations); if (workflow.output != null) { context.AddValuesOut(_valuesEngine.ProcessValues(workflow.output, MergeUtils.Merge(resultOut, context.Values) ?? context.Values)); } else { context.AddValuesOut(resultOut); } if (context.ValuesOut != null) { GenerateOutput("output.yaml", writer => _serializers.YamlSerializer.Serialize(writer, context.ValuesOut)); using (var writer = _secretTracker.FilterTextWriter(_console.Out)) { _serializers.YamlSerializer.Serialize(writer, context.ValuesOut); } } } return(0); }
public dynamic Submit(DryRun dryRun = DryRun.Off) { var context = new StoreContext(); var type = Type.GetType(boundRecord.entityClass); var entitySet = context.Set(type); var entity = entitySet.Find(boundRecord.primaryKey); context.Entry(entity); type.GetProperty(fieldToUpdate).SetValue(entity, newValue); if (dryRun == DryRun.Off) { var saveResult = context.SaveChanges(); if (saveResult > 0) { return boundRecord.primaryKey; } else { return null; } } else { return this; } }
public bool Submit(DryRun dryRun = DryRun.Off) { var context = new StoreContext(); var type = Type.GetType(boundRecord.entityClass); var entitySet = context.Set(type); var entity = entitySet.Find(boundRecord.primaryKey); entitySet.Remove(entity); var result = context.SaveChanges(); if (result > 0) { return true; } return false; }
public IDictionary <string, string> to_token_dictionary() { var tokens = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) { { nameof(AccessToken), AccessToken.to_string() }, { nameof(AfterMigrationFolderName), AfterMigrationFolderName.to_string() }, { nameof(AlterDatabaseFolderName), AlterDatabaseFolderName.to_string() }, { nameof(Baseline), Baseline.to_string() }, { nameof(BeforeMigrationFolderName), BeforeMigrationFolderName.to_string() }, { nameof(CommandTimeout), CommandTimeout.to_string() }, { nameof(CommandTimeoutAdmin), CommandTimeoutAdmin.to_string() }, { nameof(ConfigurationFile), ConfigurationFile.to_string() }, { nameof(ConnectionString), ConnectionString.to_string() }, { nameof(ConnectionStringAdmin), ConnectionStringAdmin.to_string() }, { nameof(CreateDatabaseCustomScript), CreateDatabaseCustomScript.to_string() }, { nameof(DatabaseName), DatabaseName.to_string() }, { nameof(DatabaseType), DatabaseType.to_string() }, { nameof(Debug), Debug.to_string() }, { nameof(DisableOutput), DisableOutput.to_string() }, { nameof(DisableTokenReplacement), DisableTokenReplacement.to_string() }, { nameof(DoNotAlterDatabase), DoNotAlterDatabase.to_string() }, { nameof(DoNotCreateDatabase), DoNotCreateDatabase.to_string() }, { nameof(DoNotStoreScriptsRunText), DoNotStoreScriptsRunText.to_string() }, { nameof(DownFolderName), DownFolderName.to_string() }, { nameof(Drop), Drop.to_string() }, { nameof(DryRun), DryRun.to_string() }, #pragma warning disable 618 { nameof(EnvironmentName), string.Join(",", EnvironmentNames) }, #pragma warning restore 618 { nameof(EnvironmentNames), string.Join(",", EnvironmentNames) }, { nameof(FunctionsFolderName), FunctionsFolderName.to_string() }, { nameof(IndexesFolderName), IndexesFolderName.to_string() }, { nameof(Initialize), Initialize.to_string() }, { nameof(OutputPath), OutputPath.to_string() }, { nameof(PermissionsFolderName), PermissionsFolderName.to_string() }, { nameof(RecoveryMode), RecoveryMode.to_string() }, { nameof(RepositoryPath), RepositoryPath.to_string() }, { nameof(Restore), Restore.to_string() }, { nameof(RestoreCustomOptions), RestoreCustomOptions.to_string() }, { nameof(RestoreFromPath), RestoreFromPath.to_string() }, { nameof(RestoreTimeout), RestoreTimeout.to_string() }, { nameof(RunAfterCreateDatabaseFolderName), RunAfterCreateDatabaseFolderName.to_string() }, { nameof(RunAfterOtherAnyTimeScriptsFolderName), RunAfterOtherAnyTimeScriptsFolderName.to_string() }, { nameof(RunAllAnyTimeScripts), RunAllAnyTimeScripts.to_string() }, { nameof(RunBeforeUpFolderName), RunBeforeUpFolderName.to_string() }, { nameof(RunFirstAfterUpFolderName), RunFirstAfterUpFolderName.to_string() }, { nameof(SchemaName), SchemaName.to_string() }, { nameof(ScriptsRunErrorsTableName), ScriptsRunErrorsTableName.to_string() }, { nameof(ScriptsRunTableName), ScriptsRunTableName.to_string() }, { nameof(SearchAllSubdirectoriesInsteadOfTraverse), SearchAllSubdirectoriesInsteadOfTraverse.to_string() }, { nameof(ServerName), ServerName.to_string() }, { nameof(Silent), Silent.to_string() }, { nameof(SprocsFolderName), SprocsFolderName.to_string() }, { nameof(SqlFilesDirectory), SqlFilesDirectory.to_string() }, { nameof(TriggersFolderName), TriggersFolderName.to_string() }, { nameof(UpFolderName), UpFolderName.to_string() }, { nameof(Version), Version.to_string() }, { nameof(VersionFile), VersionFile.to_string() }, { nameof(VersionTableName), VersionTableName.to_string() }, { nameof(VersionXPath), VersionXPath.to_string() }, { nameof(ViewsFolderName), ViewsFolderName.to_string() }, { nameof(WarnAndIgnoreOnOneTimeScriptChanges), WarnAndIgnoreOnOneTimeScriptChanges.to_string() }, { nameof(WarnOnOneTimeScriptChanges), WarnOnOneTimeScriptChanges.to_string() }, { nameof(WithTransaction), WithTransaction.to_string() }, }; if (UserTokens != null) { foreach (var t in UserTokens) { tokens[t.Key] = t.Value; } } return(tokens); }
public ConversionOptions GetConfiguration() { var options = new ConversionOptions(); if (Path.HasValue()) { options.Paths = Path.Values; } if (File.HasValue()) { options.Files = File.Values; } if (List.HasValue()) { options.ListFile = List.Value(); } if (options.Paths.Count == 0 && options.Files.Count == 0 && String.IsNullOrEmpty(options.ListFile)) { throw new ConfigurationException("Nothing to process, must specify one of --path, --file or --list"); } if (IndentStyle.HasValue()) { var style = IndentStyle.Value().ToLower(); if (style == "tabs") { options.Indentation = IndentationStyle.Tabs; } else if (style == "spaces") { options.Indentation = IndentationStyle.Spaces; } else if (style == "leave") { options.Indentation = IndentationStyle.Leave; } else { throw new ConfigurationException($"'{style}' is an invalid indentation style"); } } if (LineEndings.HasValue()) { var lineEndingStyle = LineEndings.Value().ToLower(); if (lineEndingStyle == "crlf") { options.LineEndingStyle = LineEnding.CRLF; } else if (lineEndingStyle == "lf") { options.LineEndingStyle = LineEnding.LF; } else { throw new ConfigurationException("Line Endings must be crlf or lf"); } } options.StripTrailingSpaces = StripTrailingSpaces.HasValue(); // no point going any further if one of the change options isn't actually specified if (options.StripTrailingSpaces == false && options.Indentation == IndentationStyle.Leave && options.LineEndingStyle == LineEnding.Leave) { throw new ConfigurationException("Nothing to do, you must specify one of --strip-trailing-spaces, --line-endings or --indent"); } if (TabWidth.HasValue()) { if (!Int32.TryParse(TabWidth.Value(), out int tabWidth)) { throw new ConfigurationException("tabwidth must be a valid number"); } options.TabWidth = tabWidth; } if (IncludeExtensions.HasValue()) { options.IncludeExtensions = ParseFileExtensionsOption(IncludeExtensions.Values); } if (ExcludeExtensions.HasValue()) { options.ExcludeExtensions = ParseFileExtensionsOption(ExcludeExtensions.Values); } if (ExcludeFolders.HasValue()) { options.ExcludeFolders = ExcludeFolders.Values; } // the presence of recurse|dryrun means it's on, there is no value options.Recurse = Recurse.HasValue(); options.DryRun = DryRun.HasValue(); options.Verbose = Verbose.HasValue(); return(options); }