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>();
}
