public static ValueTable AddTableWithSyntax(this ValueTable table, string name)
{
// Create a new table and matching syntax
var newSyntaxTable = new TableSyntax(name);
var newTable = new ValueTable()
{
MirrorSyntax = newSyntaxTable,
};
// Add the model to the parent table model
table.Add(name, new Value(newTable));
// Add the new syntax to the parent table syntax
switch (table.MirrorSyntax)
{
case DocumentSyntax documentSyntax:
documentSyntax.Tables.Add(newSyntaxTable);
break;
default:
throw new InvalidOperationException("Unknown Syntax on ValueTable");
}
return(newTable);
}
public override SyntaxNode VisitTable(TableSyntax node)
{
if ((this.NodeInSpan(node)) && (node.Members != null) && (node.Members.Count > 0) && (!node.ContainsDiagnostics))
{
node = node.WithMembers(this.Sort(node.Members));
}
return(base.VisitTable(node));
}
public TableSyntaxBase GetOrCreateNamespace([NotNull] string key)
{
var t = GetTable(key);
if (t != null)
{
return(t);
}
t = new TableSyntax(key);
_toml.Tables.Add(t);
return(t);
}
public override void Visit(TableSyntax table)
{
if (_currentValue != null)
{
throw new InvalidOperationException("An Table value must not have an active value.");
}
// A direct table reference is always from the root
_currentTable = _rootTable;
// Resolve the key
var(currentTable, valueName) = ResolveKey(table.Name);
_currentTable = GetTable(currentTable, valueName, false);
base.Visit(table);
}
public TableTypeInformation(TableSyntax tableSyntax) : this(tableSyntax.GetNameStringValue())
{
FieldListSyntax fields = tableSyntax.Fields;
if (fields != null)
{
SyntaxList <FieldSyntax> fieldsList = fields.Fields;
if (fieldsList != null)
{
foreach (FieldSyntax fieldSyntax in fieldsList)
{
TableFieldTypeInformation fieldTypeInformation = new TableFieldTypeInformation(fieldSyntax);
Add(fieldTypeInformation);
}
}
}
}
private static void AnalyzeTableFieldsIDs(SyntaxNodeAnalysisContext context)
{
TableSyntax tableSyntax = context.Node as TableSyntax;
KeyListSyntax keys = tableSyntax.Keys;
List <String> keysList = GetPrimaryKeyFieldsNames(keys);
if (keysList == null)
{
return;
}
FieldListSyntax fieldList = tableSyntax.Fields;
SyntaxList <FieldSyntax> fields = fieldList.Fields;
foreach (FieldSyntax fieldSyntax in fields)
{
IdentifierNameSyntax fieldName = fieldSyntax.Name;
SyntaxToken FieldNo = fieldSyntax.No;
if (FieldNo.Value as int? < 20 && !keysList.Contains(fieldName.Identifier.Value.ToString()))
{
ReportFieldsReservedForPrimaryKeyFields(context, FieldNo.GetLocation(), fieldName.Identifier.Value.ToString(), fieldName);
}
}
}
public override SyntaxNode VisitTable(TableSyntax node)
{
PropertySyntax propertySyntax = node.GetProperty("DataClassification");
if (propertySyntax == null)
{
NoOfChanges++;
node = node.AddPropertyListProperties(
this.CreateDataClassificationProperty(node));
}
else
{
string valueText = propertySyntax.Value.ToString();
if ((String.IsNullOrWhiteSpace(valueText)) ||
(valueText.Equals("ToBeClassified", StringComparison.CurrentCultureIgnoreCase)))
{
NoOfChanges++;
node = node.ReplaceNode(propertySyntax, this.CreateDataClassificationProperty(node));
}
}
return(base.VisitTable(node));
}
private static void SaveClass(Type type, DocumentSyntax document, KeySyntax key = null)
{
key ??= new KeySyntax(type.Name);
var fields = type.GetFields(StaticFlags);
var children = type.GetNestedTypes(StaticFlags);
var table = new TableSyntax(key);
var tableItems = table.Items;
foreach (var field in fields)
{
if (field.IsPrivate || field.IsInitOnly || !field.IsStatic || field.IsLiteral)
{
continue;
}
if (field.GetCustomAttribute <Config.ConfigIgnoreAttribute>() != null)
{
continue;
}
ValueSyntax value = null;
object fieldValue = field.GetValue(null);
switch (fieldValue)
{
case string v:
value = new StringValueSyntax(v);
break;
case sbyte v:
value = new IntegerValueSyntax(v);
break;
case byte v:
value = new IntegerValueSyntax(v);
break;
case short v:
value = new IntegerValueSyntax(v);
break;
case ushort v:
value = new IntegerValueSyntax(v);
break;
case int v:
value = new IntegerValueSyntax(v);
break;
case uint v:
value = new IntegerValueSyntax(v);
break;
case ulong v:
value = new IntegerValueSyntax(unchecked ((long)v));
break;
case float v:
value = new FloatValueSyntax(v);
break;
case double v:
value = new FloatValueSyntax(v);
break;
case bool v:
value = new BooleanValueSyntax(v);
break;
default:
if (fieldValue is List <string> slist)
{
value = new ArraySyntax(slist.ToArray());
}
else if (fieldValue is List <int> ilist)
{
value = new ArraySyntax(ilist.ToArray());
}
else if (fieldValue.GetType().IsEnum)
{
value = new StringValueSyntax(fieldValue.GetType().GetEnumName(fieldValue));
}
break;
}
if (value == null)
{
continue;
}
var keyValue = new KeyValueSyntax(
field.Name,
value
);
//if (field.GetAttribute<Config.CommentAttribute>(out var attribute)) {
//keyValue.GetChildren(Math.Max(0, keyValue.ChildrenCount - 2)).AddComment(attribute.Message);
//}
tableItems.Add(keyValue);
}
if (table.Items.ChildrenCount != 0)
{
document.Tables.Add(table);
}
foreach (var child in children)
{
if (child.IsNestedPrivate)
{
continue;
}
if (child.GetCustomAttribute <Config.ConfigIgnoreAttribute>() != null)
{
continue;
}
var childKey = new KeySyntax(typeof(Config).Name);
var parentKey = key.ToString().Split('.');
if (parentKey.Length != 0)
{
parentKey[0] = null;
}
foreach (var subKey in parentKey)
{
if (subKey == null)
{
continue;
}
childKey.DotKeys.Add(new DottedKeyItemSyntax(subKey));
}
childKey.DotKeys.Add(new DottedKeyItemSyntax(child.Name));
SaveClass(child, document, childKey);
}
}
public void TestDocument()
{
var table = new TableSyntax("test")
{
Items =
{
{ "a", 1 },
{ "b", true },
{ "c", "Check" },
{ "d", "ToEscape\nWithAnotherChar\t" },
{ "e", 12.5 },
{ "f", new int[] { 1, 2, 3, 4 } },
{ "g", new string[] { "0", "1", "2" } },
{ "key with space", 2 }
}
};
var doc = new DocumentSyntax()
{
Tables =
{
table
}
};
table.AddLeadingComment("This is a comment");
table.AddLeadingTriviaNewLine();
var firstElement = table.Items.GetChildren(0);
firstElement.AddTrailingComment("This is an item comment");
var secondElement = table.Items.GetChildren(2);
secondElement.AddLeadingTriviaNewLine();
secondElement.AddLeadingComment("This is a comment in a middle of a table");
secondElement.AddLeadingTriviaNewLine();
secondElement.AddLeadingTriviaNewLine();
var docStr = doc.ToString();
var expected = @"# This is a comment
[test]
a = 1 # This is an item comment
b = true
# This is a comment in a middle of a table
c = ""Check""
d = ""ToEscape\nWithAnotherChar\t""
e = 12.5
f = [1, 2, 3, 4]
g = [""0"", ""1"", ""2""]
""key with space"" = 2
";
AssertHelper.AreEqualNormalizeNewLine(expected, docStr);
// Reparse the result and compare it again
var newDoc = Toml.Parse(docStr);
AssertHelper.AreEqualNormalizeNewLine(expected, newDoc.ToString());
}
public override void Visit(TableSyntax table)
{
_currentTable = _rootTable;
_currentTable = SetKeyValue(table.Name, null, table.Kind);
base.Visit(table);
}
