public void Add_WithFooClassListSource_AddsTableArray() { // Arrange var tbl = Toml.Create(); // Act var newTbl = tbl.Add("x", FooClassList.List1).Added; // Assert FooClassList.List1.AssertIs(newTbl); FooClassList.List1.AssertIs(tbl["x"]); }
public void Add_WithFooStruct_AddsTable() { // Arrange var tbl = Toml.Create(); // Act var newTbl = tbl.Add("x", FooStruct.Foo1).Added; // Assert FooStruct.Foo1.AssertIs(tbl["x"]); FooStruct.Foo1.AssertIs(newTbl); }
internal static Config <T> CreateInternal <T>(Func <T> createDefault, IMergeConfigStore store) where T : class { createDefault.CheckNotNull(nameof(createDefault)); store.CheckNotNull(nameof(store)); var cfg = createDefault(); store.EnsureExists(Toml.Create(cfg)); return(new Config <T>(store)); }
public void Clone_WhenSourceTableHasTypeInline_CloneTableHasSameTableType() { // Arrange var tbl = Toml.Create(); tbl.TableType = TomlTable.TableTypes.Inline; // Act var cloned = tbl.Clone(); // Assert cloned.TableType.Should().Be(tbl.TableType); }
public void CreateArray_WhenSingleValueGiven_CreatesCorrespondingArray() { var tbl = Toml.Create(); var diff = Toml.Create().CreateAttachedValue(true); var a = tbl.CreateAttachedArray(new List <TomlValue>() { tbl.CreateAttachedValue(true) }); a.Length.Should().Be(1); a[0].Get <bool>().Should().Be(true); }
private TomlTable MergeTables(Func <IConfigStore, TomlTable> loadSingle) { Assert(this.stores.Count > 0, AssertAtLeastOneConfigMsg); TomlTable merged = Toml.Create(); foreach (var c in this.stores) { merged.OverwriteWithValuesForLoadFrom(loadSingle(c)); } return(merged); }
public void CreateAttached_WhenTomlIntIsPassed_ThrowsInvalidOperation() { // Arrange var tbl = Toml.Create(); var ti = tbl.Add("X", 1); // Act Action a = () => this.rootSource.CreateAttached(ti); // Assert a.ShouldThrow <ArgumentException>( because: "It is not allowed to convert TOML objects to new attached TOML tables"); }
public void OverwriteForSaveFrom_WhenTargetTableDoesntContainRow_AllTargetTableRowsGetDeleted() { // Arrange var tgtTable = Toml.Create(); tgtTable.AddValue("x", 0); var fromTable = Toml.Create(); // Act tgtTable.OverwriteWithValuesForSaveFrom(fromTable, addNewRows: false); // Assert tgtTable.Count.Should().Be(0); }
public void OverwriteForSaveFrom_WhenTargetTableDoesntContainRow_RowWillNotBeAddedToTargetTable() { // Arrange var targetTable = Toml.Create(); var fromTable = Toml.Create(); fromTable.AddValue("x", 0); // Act targetTable.OverwriteWithValuesForSaveFrom(fromTable, addNewRows: false); // Assert targetTable.Count.Should().Be(0); }
public void WriteFile_WithFloat_WritesCultureInvariant() { // Arrange var tt = Toml.Create(); tt.AddValue("TheFloat", 1.2); // Act Toml.WriteFile(tt, this.fn); // Assert var s = File.ReadAllText(this.fn); s.Should().Be("TheFloat = 1.2\r\n"); }
public void Write_WithFloat_WritesCultureInvariant() { // Arrange var tt = Toml.Create(); tt.Add("TheFloat", 1.2); // Act var s = Toml.WriteString(tt); Toml.WriteFile(tt, "test123.toml"); // Assert s.Should().Be("TheFloat = 1.2\r\n"); }
protected static void CreateMergedTestAppConfig(out string mainFile, out string userFile) { mainFile = "initMainSettings".TestRunUniqueName(Toml.FileExtension); userFile = "initUserSettings".TestRunUniqueName(Toml.FileExtension); var main = TestData.TestAppSettings.GlobalSettings; var userSettings = TestData.TestAppSettings.User1Settings; var user = Toml.Create(); user.AddTableFromClass(nameof(main.User), userSettings); // Act Toml.WriteFile(main, mainFile); Toml.WriteFile(user, userFile); }
public bool EnsureExists(TomlTable content) { Assert(this.stores.Count > 0, AssertAtLeastOneConfigMsg); // Create broadest scope table bool neededToCreate = false; neededToCreate |= this.stores.First().EnsureExists(content); // Initialize empty files for all other existing scopes foreach (var s in this.stores.Skip(1)) { neededToCreate |= s.EnsureExists(Toml.Create()); } return(neededToCreate); }
public void GivenDottedKeyValueWithAppendComment_WhenWrittenToFile_WritesCommentBeforeLine() { // Arrange var tbl = Toml.Create(); var obj = tbl.CreateEmptyAttachedTable(TomlTable.TableTypes.Dotted); tbl.Add(nameof(obj), obj); obj.Add("x", 1).Added.AddComment("The Comment", CommentLocation.Append); // Act var tml = Toml.WriteString(tbl); // Assert tml.Should().BeAfterTransforms(StringTransformForComparison, @" [obj] x=1#TheComment"); }
public void VerifyIssue44_UpdateTomlTableArrayRow_WasFixed() { // Arrange var tb = Toml.Create(); var tList = new List <TestTable>(); tList.Add(new TestTable("first", DateTimeOffset.MaxValue)); tb.Add("test", tList); tList.Add(new TestTable("second", DateTimeOffset.MinValue)); // Act var ta = tb.Update("test", tList); // Assert tb["test"].Should().BeOfType <TomlTableArray>(); ta.Added[0].Get <TestTable>().timestamp.Should().Be(DateTimeOffset.MaxValue); ta.Added[1].Get <TestTable>().timestamp.Should().Be(DateTimeOffset.MinValue); }
public void Write_WhenTableWasReadAsDotted_WritesTableAsDottedTableAgain() { // Arrange var root = Toml.Create(TomlTable.TableTypes.Dotted); var adat = new Dictionary <string, object>() { { "b", 1 }, { "c", 2 }, }; root.Add("a", adat, TomlTable.TableTypes.Dotted); // Act var written = Toml.WriteString(root); // Assert written.ShouldBeSemanticallyEquivalentTo("a.b=1 a.c=2"); }
public void VerifyIssue29_WhenConversionHasError_TheErrorMessgeIsSomewhatUseful() { // Arrange var cfg = TomlSettings.Create(c => c .ConfigureType <Item>(type => type .WithConversionFor <TomlString>(conv => conv .FromToml(s => Item.Parse(s.Value))))); TomlTable tbl = Toml.Create(cfg); tbl.Add("Item", "Item Parse Value"); // Act Action a = () => tbl.Get <ItmRoot>(); // Assert a.ShouldThrow <InvalidOperationException>().WithMessage( "Failed to convert TOML object with key 'Item', type 'string' and value 'Item Parse Value' " + "to object property with name 'Item' and type 'Nett.Tests.VerifyIssuesTests+Item'.") .WithInnerMessage("Simulate conversion error"); }
private void SaveConfig() { TomlTable appSettings = Toml.Create(); appSettings.Add("ListenPort", ServerPort); if (ConfigTable.ContainsKey("Application")) { ConfigTable.Remove("Application"); } ConfigTable.Add("Application", appSettings); foreach (var item in Items) { (item as IConfigViewModel).SaveConfig(ConfigTable); } Toml.WriteFile(ConfigTable, CONFIG_FILE); }
public void VerifyIssue51_InlineTableSerializedInWrongParentTable_IsFixed() { // Arrange var table = Toml.Create(); var root = table.Add("Root", new object(), TomlTable.TableTypes.Default).Added; root.Add("A", new object(), TomlTable.TableTypes.Default); root.Add("B", new object(), TomlTable.TableTypes.Inline); // Act var ser = Toml.WriteString(table); // Assert ser.ShouldBeSemanticallyEquivalentTo(@" [Root] B = { } [Root.A] "); }
public void VerifyIssue42_SerializedIntoWrongTable_WasFixed() { var tbl = Toml.Create(); tbl.Add("root1", 1); // These three keys added at root level tbl.Add("root2", 2); tbl.Add("root3", 3); var t2 = tbl.Add("Level2", Toml.Create()).Added; t2.Add("second1", "x"); t2.Add("second2", "y"); tbl.Add("root4", 4); // Added at root level but spuriously written into [Level2.Level3] var t3 = t2.Add("Level3", Toml.Create()).Added; t3.Add("third1", "a"); t3.Add("third2", "b"); t2.Add("second3", "z"); // Added to [Level2] but spuriously written into [Level2.Level3] tbl.Add("root5", 5); // Added at root level but spuriously written into [Level2.Level3] var result = Toml.WriteString(tbl); result.Trim().ShouldBeNormalizedEqualTo(@" root1 = 1 root2 = 2 root3 = 3 root4 = 4 root5 = 5 [Level2] second1 = ""x"" second2 = ""y"" second3 = ""z"" [Level2.Level3] third1 = ""a"" third2 = ""b""".Trim()); }
public static TomlTable Clone(this TomlTable input) { input.CheckNotNull(nameof(input)); TomlTable cloned = Toml.Create(input.Root.Settings); cloned.TableType = input.TableType; foreach (var r in input.InternalRows) { switch (r.Value.TomlType) { case TomlObjectType.Table: cloned.AddRow(r.Key, ((TomlTable)r.Value).Clone()); break; case TomlObjectType.ArrayOfTables: cloned.AddRow(r.Key, ((TomlTableArray)r.Value).Clone()); break; default: cloned[r.Key.Value] = r.Value; break; } } return(cloned); }
public KeyManager(string keyName, TomlTable parent, Action flush) { // Set Mod Name KeyName = keyName.PathEscape(); // Assign TOML Structure _parent = parent; try { // Try to get table from existing structure _settings = _parent.Get <TomlTable>(KeyName); } catch (KeyNotFoundException) { // Create new table if it doesn't exist _parent[KeyName] = Toml.Create(); _settings = _parent.Get <TomlTable>(KeyName); } // Define Interfaces _getter = new Getter(_settings, flush); _setter = new Setter(_settings, flush); }
public void Write_WhenNestedTableIsInlineTable_NestedTableIsWrittenAsInlineTable() { // Arrange var root = Toml.Create(TomlTable.TableTypes.Dotted); var adat = new Dictionary <string, object>() { { "b", 1 }, { "c", 2 }, }; var a = root.Add("a", adat, TomlTable.TableTypes.Dotted).Added; var ndat = new Dictionary <string, object>() { { "x", 3 }, }; a.Add("n", ndat, TomlTable.TableTypes.Inline); // Act var written = Toml.WriteString(root); // Assert written.ShouldBeSemanticallyEquivalentTo("a.b=1 a.c=2 a.n={x=3}"); }
static CombineTablesTests() { X = Toml.Create(); X.Add(XKey, XVal); X.Add(SameKey, XVal); var xs = X.Add(SubTableKey, Toml.Create()); xs.Add(SubTableValueKey, XSubTableVal); Y = Toml.Create(); Y.Add(YKey, YVal); Y.Add(SameKey, YVal); var ys = Y.Add(SubTableKey, X.CreateEmptyAttachedTable()); ys.Add(SubTableValueKey, YSubTableVal); Dx = Toml.Create(); Dx.Add("a", (long)1); Dx.Add("c", (long)3).AddComment("xcc"); Dy = Toml.Create(); Dy.Add("b", (long)2).AddComment("ybc"); Dy.Add("c", (long)4).AddComment("ycc"); }
public void Write_WhenDottedTablesAreNested_WritesTablesAsDottedTables() { // Arrange var root = Toml.Create(TomlTable.TableTypes.Dotted); var adat = new Dictionary <string, object>() { { "b", 1 }, { "c", 2 }, }; var a = root.Add("a", adat, TomlTable.TableTypes.Dotted); var ndat = new Dictionary <string, object>() { { "x", 3 }, }; a.ConfigureAdded(n => n.Add("n", ndat, TomlTable.TableTypes.Dotted)); // Act var written = Toml.WriteString(root); // Assert written.ShouldBeSemanticallyEquivalentTo("a.b=1 a.c=2 a.n.x=3"); }
internal void Save() { UpdateExecutionInterval(); _executionInterval.IfSome(ei => { if (ei != default) { var(ms, n) = ei; var tomlTable = Toml.Create(); tomlTable.Add(nameof(ms), ms); tomlTable.Add(nameof(n), n); var pathToExecutionInterval = Simulation.GetPrivatePath(new[] { nameof(SimData) }, EXECUTION_INTERVAL_FILE_NAME); try { Toml.WriteFile(tomlTable, pathToExecutionInterval); } catch (Exception ex) { Log.Error(ex, $"{nameof(SimExecutionInterval)}.{nameof(Save)}"); } } }); }
/// <inheritdoc /> public void SaveToFile() { if (_configFile == null) { Logger.Warning("[CFG] Cannot save the config file, because one was never loaded."); return; } try { var tblRoot = Toml.Create(); foreach (var kvCVar in _configVars) { var cVar = kvCVar.Value; var name = kvCVar.Key; var value = cVar.Value; if (value == null && cVar.Registered) { value = cVar.DefaultValue; } if (value == null) { Logger.Error($"[CFG] CVar {name} has no value or default value, was the default value registered as null?"); continue; } var keyIndex = name.LastIndexOf(TABLE_DELIMITER); var tblPath = name.Substring(0, keyIndex).Split(TABLE_DELIMITER); var keyName = name.Substring(keyIndex + 1); // locate the Table in the config tree var table = tblRoot; foreach (var curTblName in tblPath) { if (!table.TryGetValue(curTblName, out TomlObject tblObject)) { tblObject = table.AddTable(curTblName); } table = tblObject as TomlTable ?? throw new InvalidConfigurationException($"[CFG] Object {curTblName} is being used like a table, but it is a {tblObject}. Are your CVar names formed properly?"); } //runtime unboxing, either this or generic hell... ¯\_(ツ)_/¯ switch (value) { case Enum val: table.AddValue(keyName, (int)(object)val); // asserts Enum value != (ulong || long) break; case int val: table.AddValue(keyName, val); break; case long val: table.AddValue(keyName, val); break; case bool val: table.AddValue(keyName, val); break; case string val: table.AddValue(keyName, val); break; case float val: table.AddValue(keyName, val); break; case double val: table.AddValue(keyName, val); break; default: Logger.Warning($"[CFG] Cannot serialize '{name}', unsupported type."); break; } } Toml.WriteFile(tblRoot, _configFile); Logger.Info($"[CFG] Server config saved to '{_configFile}'."); } catch (Exception e) { Logger.Warning($"[CFG] Cannot save the config file '{_configFile}'.\n {e.Message}"); } }
private TomlObject TryWrapInConvertProxy(TomlObject obj, Func <TomlObject> resolveParent) { var conv = obj.Root.Settings.TryGetToTomlConverter(this.clrType); if (conv != null) { var convBack = obj.Root.Settings.TryGetConverter(obj.GetType(), this.clrType); if (convBack != null) { var instance = convBack.Convert(obj.Root, obj, this.clrType); var parentTable = (TomlTable)resolveParent(); var proxy = new ConversionMappingTableProxy( this.key, parentTable, instance.GetType(), obj.GetType(), Toml.Create(instance), conv); return(proxy); } } return(obj); }
private MultiLevelTableScenario() { this.Table = Toml.Create(this.Clr); }
private TomlTable CreateEmpty() { return(Toml.Create()); }