public void IgnoreDuplicateSymbols(string symbol)
{
var duplicate = $"{symbol}_dupe";
var schema = new EnumSchema("test");
Assert.Empty(schema.Symbols);
schema.Symbols.Add(duplicate);
Assert.Equal(new[] { duplicate }, schema.Symbols);
schema.Symbols.Add(symbol);
Assert.Equal(new[] { duplicate, symbol }, schema.Symbols);
schema.Symbols.Add(duplicate);
Assert.Equal(new[] { duplicate, symbol }, schema.Symbols);
schema.Symbols = new[] { duplicate, duplicate, duplicate };
Assert.Equal(new[] { duplicate }, schema.Symbols);
}
/// <summary>
/// Generates a compilation unit (essentially a single .cs file) that contains types that
/// match the schema.
/// </summary>
/// <param name="schema">
/// The schema to generate code for. Code can only be generated for enum
/// and record schemas.
/// </param>
/// <returns>
/// A compilation unit containing types that match the schema.
/// </returns>
/// <throws cref="UnsupportedSchemaException">
/// Thrown when the schema is not an enum or record, or when a record
/// field schema is not recognized.
/// </throws>
public virtual CompilationUnitSyntax GenerateCompilationUnit(Schema schema)
{
var candidates = GetCandidateSchemas(schema)
.OrderBy(s => s.Name)
.GroupBy(s => s.Namespace)
.OrderBy(g => g.Key);
if (candidates.Count() < 1)
{
throw new UnsupportedSchemaException(schema, $"Code can only be generated for enums and records.");
}
var unit = SyntaxFactory.CompilationUnit();
foreach (var group in candidates)
{
var members = group
.Select(candidate => candidate switch
{
EnumSchema enumSchema => GenerateEnum(enumSchema) as MemberDeclarationSyntax,
RecordSchema recordSchema => GenerateClass(recordSchema) as MemberDeclarationSyntax,
_ => default,
public void EnumCode(EnumSchema enumSchema, string expectedName, string expectedNamespace, string[] expectedSymbols, string expectedDoc, string[] expectedAliases)
{
var assembly = CodeGen.Compile(Guid.NewGuid().ToString(), enumSchema, out var xmlDocument);
var type = assembly.ExportedTypes.FirstOrDefault(r => r.Name == expectedName);
Assert.NotNull(type);
Assert.IsTrue(type.IsEnum);
Assert.AreEqual(expectedNamespace, type.Namespace);
var symbols = Enum.GetNames(type);
Assert.AreEqual(expectedSymbols, symbols);
var doc = GetSummaryText(xmlDocument, type.FullName);
Assert.AreEqual(expectedDoc, doc);
var aliases = GetAliasList(xmlDocument, type.FullName);
Assert.AreEqual(expectedAliases, aliases);
}
public GenericEnum(EnumSchema schema, string value)
{
this.Schema = schema;
this.Value = value;
}
protected abstract EnumAccess GetEnumAccess(EnumSchema readerSchema);
public void RecordWithMissingFields()
{
var boolean = new BooleanSchema();
var array = new ArraySchema(boolean);
var map = new MapSchema(new IntSchema());
var @enum = new EnumSchema("Ordinal", new[] { "None", "First", "Second", "Third", "Fourth" });
var union = new UnionSchema(new Schema[]
{
new NullSchema(),
array,
});
var schema = new RecordSchema("AllFields")
{
Fields = new[]
{
new RecordField("First", union),
new RecordField("Second", union),
new RecordField("Third", array),
new RecordField("Fourth", array),
new RecordField("Fifth", map),
new RecordField("Sixth", map),
new RecordField("Seventh", @enum),
new RecordField("Eighth", @enum),
},
};
var deserialize = deserializerBuilder.BuildDelegate <WithoutEvenFields>(schema);
var serialize = serializerBuilder.BuildDelegate <WithEvenFields>(schema);
var value = new WithEvenFields()
{
First = new List <bool>()
{
false
},
Second = new List <bool>()
{
false, false
},
Third = new List <bool>()
{
false, false, false
},
Fourth = new List <bool>()
{
false
},
Fifth = new Dictionary <string, int>()
{
{ "first", 1 }
},
Sixth = new Dictionary <string, int>()
{
{ "first", 1 }, { "second", 2 }
},
Seventh = ImplicitEnum.First,
Eighth = ImplicitEnum.None,
};
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
Assert.Equal(value.Seventh, deserialize(ref reader).Seventh);
}
public SpecificEnumAccess(EnumSchema schema)
{
type = ObjectCreator.Instance.GetType(schema);
}
public GenericEnumAccess(EnumSchema schema)
{
this.schema = schema;
}
protected override EnumAccess GetEnumAccess(EnumSchema readerSchema)
{
return(new SpecificEnumAccess());
}
private object ReadEnum(object reuse, EnumSchema enumSchema)
{
var enumType = LoadType(enumSchema);
return(Enum.Parse(enumType, (string)((JValue)reuse).Value, true));
}
/// <summary>
/// Reads an enum from the given decoder
/// </summary>
/// <param name="reuse">object to store data read</param>
/// <param name="writerSchema">schema of the object that wrote the data</param>
/// <param name="readerSchema">schema of the object that will store the data</param>
/// <param name="dec">decoder object that contains the data to be read</param>
/// <returns>enum value</returns>
protected override object ReadEnum(object reuse, EnumSchema writerSchema, Schema readerSchema, Decoder dec)
{
EnumSchema rs = readerSchema as EnumSchema;
return(rs.Ordinal(writerSchema[dec.ReadEnum()]));
}
private static string GenerateCore(EnumSchema schema, string defaultNamespace, bool forceNamespace)
{
return(new EnumTemplate(schema, defaultNamespace, forceNamespace).TransformText());
}
private object ReadEnum(JsonReader jr, EnumSchema enumSchema)
{
var enumType = LoadType(enumSchema);
return(Enum.Parse(enumType, (string)jr.Value, true));
}
private void VisitCore(EnumSchema s)
{
s.Serializer = new EnumSerializer(s);
}
/// <summary>
/// Reads an <see cref="EnumSchema" />.
/// </summary>
/// <returns>
/// A successful <see cref="JsonSchemaReaderCaseResult" /> with a <see cref="BytesSchema" />
/// or <see cref="FixedSchema" /> if <paramref name="element" /> is a bytes or fixed schema
/// with a decimal logical type; an unsuccessful <see cref="JsonSchemaReaderCaseResult" />
/// with an <see cref="UnknownSchemaException" /> otherwise.
/// </returns>
/// <exception cref="InvalidSchemaException">
/// Thrown when a symbols property is not present on the schema.
/// </exception>
/// <inheritdoc />
public virtual JsonSchemaReaderCaseResult Read(JsonElement element, JsonSchemaReaderContext context)
{
if (element.ValueKind == JsonValueKind.Object &&
element.TryGetProperty(JsonAttributeToken.Type, out var type) &&
type.ValueEquals(JsonSchemaToken.Enum))
{
if (!element.TryGetProperty(JsonAttributeToken.Name, out var name) || name.ValueKind != JsonValueKind.String)
{
throw new InvalidSchemaException($"Named schemas must contain a \"{JsonAttributeToken.Name}\" key.");
}
if (!element.TryGetProperty(JsonAttributeToken.Symbols, out var symbols) || symbols.ValueKind != JsonValueKind.Array)
{
throw new InvalidSchemaException($"\"{JsonSchemaToken.Enum}\" schemas must contain a \"{JsonAttributeToken.Symbols}\" key.");
}
var scope = element.TryGetProperty(JsonAttributeToken.Namespace, out var @namespace)
? @namespace.GetString()
: context.Scope;
var schema = new EnumSchema(QualifyName(name.GetString(), scope))
{
Symbols = symbols.EnumerateArray().Select(symbol => symbol.GetString()).ToArray(),
};
if (element.TryGetProperty(JsonAttributeToken.Aliases, out var aliases))
{
schema.Aliases = aliases.EnumerateArray()
.Select(alias => QualifyName(alias.GetString(), scope))
.ToArray();
}
if (element.TryGetProperty(JsonAttributeToken.Default, out var @default))
{
schema.Default = @default.GetString();
if (!schema.Symbols.Contains(schema.Default))
{
throw new InvalidSchemaException($"The default value \"{schema.Default}\" is not a symbol in {schema.FullName}.");
}
}
if (element.TryGetProperty(JsonAttributeToken.Doc, out var doc))
{
schema.Documentation = doc.GetString();
}
try
{
context.Schemas.Add(schema.FullName, schema);
}
catch (ArgumentException)
{
throw new InvalidSchemaException($"Invalid name; a definition for {schema.FullName} was already read.");
}
foreach (var alias in schema.Aliases)
{
if (alias == schema.FullName)
{
continue;
}
try
{
context.Schemas.Add(alias, schema);
}
catch (ArgumentException)
{
throw new InvalidSchemaException($"Invalid alias; a definition for {alias} was already read.");
}
}
return(JsonSchemaReaderCaseResult.FromSchema(schema));
}
else
{
return(JsonSchemaReaderCaseResult.FromException(new UnknownSchemaException($"{nameof(JsonEnumSchemaReaderCase)} can only be applied to \"{JsonSchemaToken.Enum}\" schemas.")));
}
}
/// <summary>
/// Reads an enum from the given decoder
/// </summary>
/// <param name="reuse">object to store data read</param>
/// <param name="writerSchema">schema of the object that wrote the data</param>
/// <param name="readerSchema">schema of the object that will store the data</param>
/// <param name="dec">decoder object that contains the data to be read</param>
/// <returns>enum value</returns>
protected override object ReadEnum(object reuse, EnumSchema writerSchema, Schema readerSchema, Decoder dec)
{
return(dec.ReadEnum());
}
//enum value should represented as integer
private void WriteEnum(object source, JsonWriter jsonWriter, EnumSchema enumSchema)
{
jsonWriter.WriteValue(source.ToString());
}
/// <summary>
/// Deserializes a enum. Uses CreateEnum to construct the new enum object.
/// </summary>
/// <param name="reuse">If appropirate, uses this instead of creating a new enum object.</param>
/// <param name="writerSchema">The schema the writer used while writing the enum</param>
/// <param name="readerSchema">The schema the reader is using</param>
/// <param name="d">The decoder for deserialization.</param>
/// <returns>An enum object.</returns>
protected virtual object ReadEnum(object reuse, EnumSchema writerSchema, Schema readerSchema, Decoder d)
{
return(CreateEnum(reuse, readerSchema as EnumSchema, writerSchema[d.ReadEnum()]));
}
private JToken EncodeEnum(
EnumSchema schema,
GenericEnum value)
{
return(new JValue(value.Value));
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumTemplate"/> class.
/// </summary>
/// <param name="enumSchema">The enum schema.</param>
/// <param name="userDefinedNamespace">The default namespace.</param>
/// <param name="forceNamespace">Determines whether the UserDefinedNamespace should be used.</param>
public EnumTemplate(EnumSchema enumSchema, string userDefinedNamespace, bool forceNamespace)
{
this.Schema = enumSchema;
this.UserDefinedNamespace = userDefinedNamespace;
this.ForceNamespace = forceNamespace;
}
protected virtual object ReadEnum(EnumSchema writerSchema, Schema readerSchema, IReader d)
{
EnumSchema es = readerSchema as EnumSchema;
return(new Enum(es, writerSchema[d.ReadEnum()]));
}
public void ThrowWhenSymbolCollectionIsSetToNull()
{
var schema = new EnumSchema("test");
Assert.Throws <ArgumentNullException>(() => schema.Aliases = null);
}
/// <summary> /// Serializes an enumeration. /// </summary> /// <param name="es">The EnumSchema for serialization</param> protected abstract WriteItem ResolveEnum(EnumSchema es);
/// <summary>
/// Initializes a new instance of the <see cref="GenericEnum"/> class.
/// </summary>
/// <param name="schema">Schema for this enum.</param>
/// <param name="value">Value of the enum.</param>
public GenericEnum(EnumSchema schema, string value)
{
Schema = schema;
Value = value;
}
protected override EnumAccess GetEnumAccess(EnumSchema schema)
{
return(new GenericEnumAccess(schema));
}
private ReadItem ResolveEnum(EnumSchema schema)
{
var enumAccess = GetEnumAccess(schema);
return((r, d) => enumAccess.CreateEnum(r, d.ReadEnum()));
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericEnum"/> class.
/// </summary>
/// <param name="schema">Schema for this enum.</param>
/// <param name="value">Value of the enum.</param>
public GenericEnum(EnumSchema schema, string value)
{
this.Schema = schema;
this.Value = value;
}
protected abstract EnumAccess GetEnumAccess(EnumSchema schema);
