public void Deserialize_Table_DeserializesCorrectly() { var parsed = Toml.ReadString(@"[table]"); Assert.Single(parsed.Rows); Assert.NotNull(parsed.Get <TomlTable>("table")); }
public void Deserialize_IntWithUnderscoreSeperator_ProducesCorrectObject(string toParse, string key, object expectedValue) { var parsed = Toml.ReadString(toParse); Assert.NotNull(parsed); Assert.Equal(expectedValue, parsed.Get <int>(key)); }
public void Deserialize_TableArray_DeserializesCorrectly() { string toParse = @" [[products]] name = ""Hammer"" sku = 738594937 [[products]] [[products]] name = ""Nail"" sku = 284758393 color = ""gray"" "; var parsed = Toml.ReadString(toParse); var a = (TomlTableArray)parsed["products"]; Assert.Equal(3, a.Count); var t1 = a[0]; Assert.Equal("Hammer", t1.Get <string>("name")); var t2 = a[1]; Assert.Empty(t2.Rows); var t3 = a[2]; Assert.Equal("Nail", t3.Get <string>("name")); }
public void Deserialize_SimpleyKeyValuePair_ProducesCorrectObject(string toParse, string key, long expectedValue) { var parsed = Toml.ReadString(toParse); Assert.NotNull(parsed); Assert.Equal(expectedValue, parsed.Get <int>(key)); }
public void ToString_WithTableArraysAtRoot_ReplacesRealKeyWithPlaceholderKey() { // Arrange const string input = @" [[x]] a = 1 [[x]] a = 2 "; const string expectedSub = @" [[_]] a = 1 [[_]] a = 2 "; var r = Toml.ReadString(input); // Act var t1 = r.ToString(); var t2 = r.Get("x").ToString(); var t3 = r.Get <TomlTableArray>("x")[1].ToString(); // Assert t1.ShouldBeSemanticallyEquivalentTo(input); t2.ShouldBeSemanticallyEquivalentTo(expectedSub); t3.ShouldBeSemanticallyEquivalentTo("a=2"); }
private static Task <AFileModel> ReadFileModel(ProjectItemType type, string content) { switch (type) { case ProjectItemType.Bank: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <BankModel>(content))); case ProjectItemType.Character: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <CharacterModel>(content))); case ProjectItemType.Map: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <MapModel>(content))); case ProjectItemType.TileSet: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <TileSetModel>(content))); case ProjectItemType.Palette: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <PaletteModel>(content))); case ProjectItemType.World: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <WorldModel>(content))); case ProjectItemType.Entity: return(Task <AFileModel> .Factory.StartNew(() => Toml.ReadString <EntityModel>(content))); case ProjectItemType.None: default: return(Task.FromResult <AFileModel>(null)); } }
public static void OnLoadEvent(MongoClient client) { AlExtension.ColorizeWriteLine(LogIndex.CONFIG_INFORMATION, "-->^ FIRST INITIALIZATION.", new [] { ConsoleColor.Blue, ConsoleColor.Green }); List <string> configFolders = _ConfigFolderDir(); Dictionary <string, string[]> configFiles = _ConfigFileDir(configFolders); Dictionary <string, Dictionary <string, ConfigScheme> > groupedDict = new Dictionary <string, Dictionary <string, ConfigScheme> >(); foreach (KeyValuePair <string, string[]> fileComponent in configFiles) { Dictionary <string, ConfigScheme> loadedDict = new Dictionary <string, ConfigScheme>(); AlExtension.ColorizeWriteLine(LogIndex.CONFIG_INFORMATION, $"Parse Group [ ^{fileComponent.Key.Substring(GeneralSettings.ConfigDir.Length)}^ ]", new [] { ConsoleColor.Green, ConsoleColor.Cyan, ConsoleColor.Green }); // AlConsole.WriteLine(CONFIG_INFORMATION, $"Parse Group [ {fileComponent.Key.Substring(Settings.ConfigDir.Length)} ]"); foreach (string file in fileComponent.Value) { using (StreamReader reader = new StreamReader(file)) { string raw = reader.ReadToEnd(); ConfigScheme clazzParse = Toml.ReadString <ConfigScheme>(raw); AlExtension.ColorizeWriteLine(LogIndex.CONFIG_INFORMATION, $"{clazzParse.Profile.Name + ".toml", 32}^ => Parsed!", new [] { ConsoleColor.Magenta, ConsoleColor.Green }); // AlConsole.WriteLine(CONFIG_INFORMATION, $"{clazzParse.Profile.Name + ".toml", 32} => Parsed!"); loadedDict.Add(clazzParse.Profile.DBName, clazzParse); } } groupedDict.Add(fileComponent.Key.Substring(GeneralSettings.ConfigDir.Length), loadedDict); } AlConsole.WriteLine(LogIndex.CONFIG_INFORMATION, $"Loaded All Config Operational!"); AlExtension.ColorizeWriteLine(LogIndex.CONFIG_INFORMATION, "-->^ SECOND INITIALIZATION.", new [] { ConsoleColor.Blue, ConsoleColor.Green }); // AlConsole.WriteLine(CONFIG_INFORMATION, "-> Second Initialization."); GenerateDataBaseProperty(client, groupedDict); AlConsole.WriteLine(LogIndex.CONFIG_INFORMATION, $"Generated DataBase Property from Loaded Config."); }
public void ToProviderDictionary_CreatesDictionaryCorrespondingToTomlContent() { // Arrange var tml = Toml.ReadString(@" Option1 = ""Hello From TOML"" Option2 = 666 [subsection] SubOption1 = ""SubHello from TOML"" SubOption2 = 333 [subsection.SubSubOpts] SSOPT1 = ""hello"" SSOPT2 = 16.4"); // Act var providerDict = ProviderDictionaryConverter.ToProviderDictionary(tml); // Assert providerDict.Should().Equal(new Dictionary <string, string>() { { "Option1", "Hello From TOML" }, { "Option2", "666" }, { "subsection:SubOption1", "SubHello from TOML" }, { "subsection:SubOption2", "333" }, { "subsection:SubSubOpts:SSOPT1", "hello" }, { "subsection:SubSubOpts:SSOPT2", "16.4" }, }); }
void AddTable(string tableName, string key, string value) { this.document = Toml.ReadString( this.document.ToString() + "\n" + $"[{tableName}]\n" + $"{key} = \"{value}\"\n"); }
public void WriteGuidToml() { var obj = new TableContainingMoney() { NotSupported = new Money() { Ammount = 9.99m, Currency = "EUR" } }; //var config = TomlConfig.Create(cfg => cfg // .ConfigureType<decimal>(type => type // .WithConversionFor<TomlFloat>(convert => convert // .ToToml(dec => (double)dec) // .FromToml(tf => (decimal)tf.Value)))); var config = TomlSettings.Create(cfg => cfg .ConfigureType <Money>(type => type .WithConversionFor <TomlString>(convert => convert .ToToml(custom => custom.ToString()) .FromToml(tmlString => Money.Parse(tmlString.Value))))); //var config = TomlConfig.Create(); var s = Toml.WriteString(obj, config); var read = Toml.ReadString <TableContainingMoney>(s, config); }
public void VerifyIssue71_WithDeepNestedObjects_StillProdcuesCorrectProviderDict() { // Arrange var tml = Toml.ReadString(@" Option1 = ""Hello From TOML"" Option2 = 666 [subsection] SubOption1 = ""SubHello from TOML"" SubOption2 = 333 [subsection.SubSubOpts] SSOPT1 = ""hello"" SSOPT2 = 16.4"); // Act var providerDict = ProviderDictionaryConverter.ToProviderDictionary(tml); // Assert providerDict.Should().Equal(new Dictionary <string, string>() { { "Option1", "Hello From TOML" }, { "Option2", "666" }, { "subsection:SubOption1", "SubHello from TOML" }, { "subsection:SubOption2", "333" }, { "subsection:SubSubOpts:SSOPT1", "hello" }, { "subsection:SubSubOpts:SSOPT2", "16.4" }, }); }
public void ReadValidToml_TableArrayNested() { // Arrange var toml = TomlStrings.Valid.TableArrayNested; // Act var read = Toml.ReadString(toml); // Assert Assert.Single(read.Rows); Assert.Equal(typeof(TomlTableArray), read["albums"].GetType()); var arr = read.Get <TomlTableArray>("albums"); Assert.Equal(2, arr.Count); var t0 = arr[0]; Assert.Equal("Born to Run", t0.Get <string>("name")); var t0s = t0.Get <TomlTableArray>("songs"); Assert.Equal(2, t0s.Count); var s0 = t0s[0]; var s1 = t0s[1]; Assert.Equal("Jungleland", s0.Get <string>("name")); Assert.Equal("Meeting Across the River", s1.Get <string>("name")); }
public void Foo() { using (var fn = TestFileName.Create("input", ".toml")) { // Arrange const string tml = @" [User] [User.Items] first = true second = false third = true "; File.WriteAllText(fn, tml); // Act var cfg = Config.CreateAs() .MappedToType(() => new AppSettings()) .StoredAs(store => store.File(fn)) .Initialize(); var u = Toml.ReadString <AppSettings>(tml); // Assert cfg.Get(c => c.User.Items).Count.Should().Be(3); } }
public void RadToml_WithGenricConverters_CanFindCorrectConverter() { // Arrange var config = TomlSettings.Create(cfg => cfg .ConfigureType <IGeneric <string> >(ct => ct .WithConversionFor <TomlString>(conv => conv .FromToml((m, ts) => new GenericImpl <string>(ts.Value)) ) ) .ConfigureType <IGeneric <int> >(ct => ct .WithConversionFor <TomlString>(conv => conv .FromToml((m, ts) => new GenericImpl <int>(int.Parse(ts.Value))) ) ) ); string toml = @" Foo = ""Hello"" Foo2 = ""10"" Foo3 = [""A""]"; // Act var co = Toml.ReadString <GenericHost>(toml, config); // Assert Assert.NotNull(co); Assert.NotNull(co.Foo); Assert.Equal("Hello", co.Foo.Value); Assert.NotNull(co.Foo2); Assert.Equal(10, co.Foo2.Value); }
public void ReadValidToml_HetArray() { // Arrange var toml = TomlStrings.Valid.ArrayHeterogenous; // Act var read = Toml.ReadString(toml); // Assert var a = read.Get <TomlArray>("mixed"); Assert.NotNull(a); Assert.Equal(3, a.Length); var intArray = a.Get <TomlArray>(0); Assert.Equal(1, intArray.Get <int>(0)); Assert.Equal(2, intArray.Get <int>(1)); var stringArray = a.Get <TomlArray>(1); Assert.Equal("a", stringArray.Get <string>(0)); Assert.Equal("b", stringArray.Get <string>(1)); var doubleArray = a.Get <TomlArray>(2); Assert.Equal(1.1, doubleArray.Get <double>(0)); Assert.Equal(2.1, doubleArray.Get <double>(1)); }
public void ReadValidToml_WithCommentsOnInlineTableInTableArray_AttachesCommentsToTheTomlObjects() { // Arrange const string tml = @" # KVP PreComment a = [ # Oh no a nasty comment location { x = 1 } # Oh no another nasty comment location ]"; // Act var to = Toml.ReadString(tml); // Assert var a = to.Get <TomlTableArray>("a"); a.Comments.Should().HaveCount(1); a.Comments.Should().Contain(c => c.Location == CommentLocation.Prepend && c.Text == " KVP PreComment"); var t = a[0]; t.Comments.Should().HaveCount(2); t.Comments.Should().Contain(c => c.Location == CommentLocation.Prepend && c.Text == " Oh no a nasty comment location"); t.Comments.Should().Contain(c => c.Location == CommentLocation.Append && c.Text == " Oh no another nasty comment location"); }
private Configuration LoadFromToml(string configurationName) { var settings = CreateTomlSettings(); try { var configuration = Toml.ReadString <Configuration>(TomlText, settings); // Set the name to the configuration if none is specified configuration.Id = configuration.Id ?? configurationName; if (configuration.Visit == null) { configuration.Visit = new VisitDefinition(); } configuration.Aliases = CreateCaseInsensitiveAliases(configuration.Aliases); return(configuration); } catch (Exception exception) { var parseException = GetParseException(exception); if (parseException != null) { throw new ConfigurationException($"Invalid configuration: {configurationName}: {parseException.Message}"); } throw; } }
public void ToString_WithTables_RemovesParentTableKeyPrefix() { // Arrange const string input = @" x = 1 y = 2 [t] z = 100 [t.s] h = 1 "; const string expectedSub = @" z = 100 [s] h = 1 "; var r = Toml.ReadString(input); // Act var t1 = r.ToString(); var t2 = r["t"].ToString(); // Assert t1.ShouldBeSemanticallyEquivalentTo(input); t2.ShouldBeSemanticallyEquivalentTo(expectedSub); }
public void ActivateAll() { var config = TomlSettings.Create(cfg => cfg.AllowImplicitConversions(TomlSettings.ConversionSets.All)); var tbl = Toml.ReadString("f = 0.99", config); var i = tbl.Get <int>("f"); i.Should().Be(1); }
static GitScenario() { MergedDefaultContent = RepoDefaultContent + Environment.NewLine + SystemDefaultContent.Replace("[Core]", "") + UserDefaultContent + Environment.NewLine; MergedDefault = Toml.ReadString <GitConfig>(MergedDefaultContent); }
public void VerifyIssue54_ReadTomlWithMultiArrays_ProducesCorrectObject() { // Act var obj = Toml.ReadString <MultiDimArray>(MultiDimArray.TomlRep); // Assert obj.ShouldBeEquivalentTo(new MultiDimArray()); }
public static void Parser_WhenInputIsInvalid_GeneratesSomewhatUsefulErrorMessage(string toml, string error, int _, int __) { // Act Action a = () => Toml.ReadString(toml); // Assert a.ShouldThrow <Exception>().WithMessage($"*{error}*"); }
public void Read_CanReadAllIntTypes(string input, int expected) { // Act var read = Toml.ReadString(input); // Assert read.Get <int>("x").Should().Be(expected); }
public void ReadValidTomls_SupportsAllKeyTypes(string toml, string key, object expected) { // Act var read = Toml.ReadString(toml); // Assert read[key].Get <string>().As <object>().Should().Be(expected); }
public static void Parser_WhenInputIsInvalid_GeneratesErrorMessageWithLineAndColumn(string toml, string _, int line, int column) { // Act Action a = () => Toml.ReadString(toml); // Assert a.ShouldThrow <Exception>().WithMessage($"Line {line}, Column {column}:*"); }
public void ReadToml_WhenValueIsNotInSameLineAsKey_ThrowsExc() { // Act Action a = () => Toml.ReadString("X = \r\n 2.0"); // Assert a.ShouldThrow <Exception>(); }
public void Read_CanHandleSpecialFloats(string input, double expected) { // Act var read = Toml.ReadString(input); // Assert read.Get <double>("x").Should().Be(expected); }
public void ReadToml_WithBadByteEscape_ThrowsExc() { // Act Action a = () => Toml.ReadString("naughty = \"\xAg\""); // Assert a.ShouldThrow <Exception>(); }
public void ReadDateTime_ReadsCorrecTypeOfDateTime(string tml, Type expected) { // Act var r = Toml.ReadString(tml); // Assert r.Get("x").Should().BeOfType(expected); }
public void ReadToml_WhenArrayTypesMixed_ThrowsExc() { // Act Action a = () => Toml.ReadString(@"arrays-and-ints = [1, [""Arrays are not integers.""]]"); // Assert a.ShouldThrow <Exception>(); }