Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Support for annotations on all types #147

Merged
merged 16 commits into from
Nov 8, 2021
Merged

Support for annotations on all types #147

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
afb57ec
Add addonation to Schema[A] interface and add as field in Schema.Sequ…
alexvanolst Nov 3, 2021
74a8ec0
Add annotation field to Schema.Transform
alexvanolst Nov 4, 2021
6307cd9
Add annotation field to Schema.Primitive
alexvanolst Nov 4, 2021
b83f373
Add annotations field to Schema.Optional
alexvanolst Nov 4, 2021
6e70938
Add annotations field to Schema.Fail
alexvanolst Nov 4, 2021
90f6bae
Add annotations field to Schema.Tuple
alexvanolst Nov 4, 2021
cd7e154
Add annotations field to EitherSchema
alexvanolst Nov 5, 2021
b33c266
Add annotations field to Schema.Lazy
alexvanolst Nov 5, 2021
b97ffcf
Add annotations field to Schema.Meta
alexvanolst Nov 5, 2021
959a3df
Add remaining assertion equality checks to equalsSchema
alexvanolst Nov 5, 2021
03a50c5
Remove annotations from Record[A] (since it exists in Schema[A] alrea…
alexvanolst Nov 5, 2021
de0a9f0
Fix test case for schema generation on annotated ADT
alexvanolst Nov 5, 2021
95c6d10
Fix handling of annotations for Lazy (and thus failing tests)
alexvanolst Nov 6, 2021
3751a3c
Wherever we accept an annotations chunk in the constructor/method we …
alexvanolst Nov 6, 2021
36061af
Add `def annotate(annotation: Any): Schema[A]` to Schema
alexvanolst Nov 6, 2021
9d8e55f
Replace usage of Chunk.appended with :+ to fix 2.12.12 compilation
alexvanolst Nov 6, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
60 changes: 30 additions & 30 deletions zio-schema-json/shared/src/main/scala/zio/schema/codec/JsonCodec.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -101,21 +101,21 @@ object JsonCodec extends Codec {
}

private[codec] def schemaEncoder[A](schema: Schema[A]): JsonEncoder[A] = schema match {
case Schema.Primitive(standardType) => primitiveCodec(standardType)
case Schema.Sequence(schema, _, g) => JsonEncoder.chunk(schemaEncoder(schema)).contramap(g)
case Schema.Transform(c, _, g) => transformEncoder(c, g)
case Schema.Tuple(l, r) => JsonEncoder.tuple2(schemaEncoder(l), schemaEncoder(r))
case Schema.Optional(schema) => JsonEncoder.option(schemaEncoder(schema))
case Schema.Fail(_) => unitEncoder.contramap(_ => ())
case Schema.GenericRecord(structure) => recordEncoder(structure.toChunk)
case EitherSchema(left, right) => JsonEncoder.either(schemaEncoder(left), schemaEncoder(right))
case l @ Schema.Lazy(_) => schemaEncoder(l.schema)
case Schema.Meta(_) => astEncoder
case ProductEncoder(encoder) => encoder
case Schema.Enum1(c, _) => enumEncoder(c)
case Schema.Enum2(c1, c2, _) => enumEncoder(c1, c2)
case Schema.Enum3(c1, c2, c3, _) => enumEncoder(c1, c2, c3)
case Schema.EnumN(cs, _) => enumEncoder(cs.toSeq: _*)
case Schema.Primitive(standardType, _) => primitiveCodec(standardType)
case Schema.Sequence(schema, _, g, _) => JsonEncoder.chunk(schemaEncoder(schema)).contramap(g)
case Schema.Transform(c, _, g, _) => transformEncoder(c, g)
case Schema.Tuple(l, r, _) => JsonEncoder.tuple2(schemaEncoder(l), schemaEncoder(r))
case Schema.Optional(schema, _) => JsonEncoder.option(schemaEncoder(schema))
case Schema.Fail(_, _) => unitEncoder.contramap(_ => ())
case Schema.GenericRecord(structure, _) => recordEncoder(structure.toChunk)
case EitherSchema(left, right, _) => JsonEncoder.either(schemaEncoder(left), schemaEncoder(right))
case l @ Schema.Lazy(_) => schemaEncoder(l.schema)
case Schema.Meta(_, _) => astEncoder
case ProductEncoder(encoder) => encoder
case Schema.Enum1(c, _) => enumEncoder(c)
case Schema.Enum2(c1, c2, _) => enumEncoder(c1, c2)
case Schema.Enum3(c1, c2, c3, _) => enumEncoder(c1, c2, c3)
case Schema.EnumN(cs, _) => enumEncoder(cs.toSeq: _*)
}

private val astEncoder: JsonEncoder[Schema[_]] =
Expand Down Expand Up @@ -188,21 +188,21 @@ object JsonCodec extends Codec {
schemaDecoder(schema).decodeJson(json)

private[codec] def schemaDecoder[A](schema: Schema[A]): JsonDecoder[A] = schema match {
case Schema.Primitive(standardType) => primitiveCodec(standardType)
case Schema.Optional(codec) => JsonDecoder.option(schemaDecoder(codec))
case Schema.Tuple(left, right) => JsonDecoder.tuple2(schemaDecoder(left), schemaDecoder(right))
case Schema.Transform(codec, f, _) => schemaDecoder(codec).mapOrFail(f)
case Schema.Sequence(codec, f, _) => JsonDecoder.chunk(schemaDecoder(codec)).map(f)
case Schema.Fail(message) => failDecoder(message)
case Schema.GenericRecord(structure) => recordDecoder(structure.toChunk)
case Schema.EitherSchema(left, right) => JsonDecoder.either(schemaDecoder(left), schemaDecoder(right))
case l @ Schema.Lazy(_) => schemaDecoder(l.schema)
case Schema.Meta(_) => astDecoder
case ProductDecoder(decoder) => decoder
case Schema.Enum1(c, _) => enumDecoder(c)
case Schema.Enum2(c1, c2, _) => enumDecoder(c1, c2)
case Schema.Enum3(c1, c2, c3, _) => enumDecoder(c1, c2, c3)
case Schema.EnumN(cs, _) => enumDecoder(cs.toSeq: _*)
case Schema.Primitive(standardType, _) => primitiveCodec(standardType)
case Schema.Optional(codec, _) => JsonDecoder.option(schemaDecoder(codec))
case Schema.Tuple(left, right, _) => JsonDecoder.tuple2(schemaDecoder(left), schemaDecoder(right))
case Schema.Transform(codec, f, _, _) => schemaDecoder(codec).mapOrFail(f)
case Schema.Sequence(codec, f, _, _) => JsonDecoder.chunk(schemaDecoder(codec)).map(f)
case Schema.Fail(message, _) => failDecoder(message)
case Schema.GenericRecord(structure, _) => recordDecoder(structure.toChunk)
case Schema.EitherSchema(left, right, _) => JsonDecoder.either(schemaDecoder(left), schemaDecoder(right))
case l @ Schema.Lazy(_) => schemaDecoder(l.schema)
case Schema.Meta(_, _) => astDecoder
case ProductDecoder(decoder) => decoder
case Schema.Enum1(c, _) => enumDecoder(c)
case Schema.Enum2(c1, c2, _) => enumDecoder(c1, c2)
case Schema.Enum3(c1, c2, c3, _) => enumDecoder(c1, c2, c3)
case Schema.EnumN(cs, _) => enumDecoder(cs.toSeq: _*)
}

private def astDecoder: JsonDecoder[Schema[_]] =
Expand Down
82 changes: 41 additions & 41 deletions zio-schema-protobuf/shared/src/main/scala/zio/schema/codec/ProtobufCodec.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -84,15 +84,15 @@ object ProtobufCodec extends Codec {
*/
@scala.annotation.tailrec
def canBePacked(schema: Schema[_]): Boolean = schema match {
case Schema.Sequence(element, _, _) => canBePacked(element)
case Schema.Transform(codec, _, _) => canBePacked(codec)
case Schema.Primitive(standardType) => canBePacked(standardType)
case _: Schema.Tuple[_, _] => false
case _: Schema.Optional[_] => false
case _: Schema.Fail[_] => false
case _: Schema.EitherSchema[_, _] => false
case lzy @ Schema.Lazy(_) => canBePacked(lzy.schema)
case _ => false
case Schema.Sequence(element, _, _, _) => canBePacked(element)
case Schema.Transform(codec, _, _, _) => canBePacked(codec)
case Schema.Primitive(standardType, _) => canBePacked(standardType)
case _: Schema.Tuple[_, _] => false
case _: Schema.Optional[_] => false
case _: Schema.Fail[_] => false
case _: Schema.EitherSchema[_, _] => false
case lzy @ Schema.Lazy(_) => canBePacked(lzy.schema)
case _ => false
}

private def canBePacked(standardType: StandardType[_]): Boolean = standardType match {
Expand Down Expand Up @@ -134,21 +134,21 @@ object ProtobufCodec extends Codec {

def encode[A](fieldNumber: Option[Int], schema: Schema[A], value: A): Chunk[Byte] =
(schema, value) match {
case (Schema.GenericRecord(structure), v: Map[String, _]) => encodeRecord(fieldNumber, structure.toChunk, v)
case (Schema.Sequence(element, _, g), v) => encodeSequence(fieldNumber, element, g(v))
case (Schema.Transform(codec, _, g), _) => g(value).map(encode(fieldNumber, codec, _)).getOrElse(Chunk.empty)
case (Schema.Primitive(standardType), v) => encodePrimitive(fieldNumber, standardType, v)
case (Schema.Tuple(left, right), v @ (_, _)) => encodeTuple(fieldNumber, left, right, v)
case (Schema.Optional(codec), v: Option[_]) => encodeOptional(fieldNumber, codec, v)
case (Schema.EitherSchema(left, right), v: Either[_, _]) => encodeEither(fieldNumber, left, right, v)
case (lzy @ Schema.Lazy(_), v) => encode(fieldNumber, lzy.schema, v)
case (Schema.Meta(ast), _) => encode(fieldNumber, Schema[SchemaAst], ast)
case ProductEncoder(encode) => encode(fieldNumber)
case (Schema.Enum1(c, _), v) => encodeEnum(fieldNumber, v, c)
case (Schema.Enum2(c1, c2, _), v) => encodeEnum(fieldNumber, v, c1, c2)
case (Schema.Enum3(c1, c2, c3, _), v) => encodeEnum(fieldNumber, v, c1, c2, c3)
case (Schema.EnumN(cs, _), v) => encodeEnum(fieldNumber, v, cs.toSeq: _*)
case (_, _) => Chunk.empty
case (Schema.GenericRecord(structure, _), v: Map[String, _]) => encodeRecord(fieldNumber, structure.toChunk, v)
case (Schema.Sequence(element, _, g, _), v) => encodeSequence(fieldNumber, element, g(v))
case (Schema.Transform(codec, _, g, _), _) => g(value).map(encode(fieldNumber, codec, _)).getOrElse(Chunk.empty)
case (Schema.Primitive(standardType, _), v) => encodePrimitive(fieldNumber, standardType, v)
case (Schema.Tuple(left, right, _), v @ (_, _)) => encodeTuple(fieldNumber, left, right, v)
case (Schema.Optional(codec, _), v: Option[_]) => encodeOptional(fieldNumber, codec, v)
case (Schema.EitherSchema(left, right, _), v: Either[_, _]) => encodeEither(fieldNumber, left, right, v)
case (lzy @ Schema.Lazy(_), v) => encode(fieldNumber, lzy.schema, v)
case (Schema.Meta(ast, _), _) => encode(fieldNumber, Schema[SchemaAst], ast)
case ProductEncoder(encode) => encode(fieldNumber)
case (Schema.Enum1(c, _), v) => encodeEnum(fieldNumber, v, c)
case (Schema.Enum2(c1, c2, _), v) => encodeEnum(fieldNumber, v, c1, c2)
case (Schema.Enum3(c1, c2, c3, _), v) => encodeEnum(fieldNumber, v, c1, c2, c3)
case (Schema.EnumN(cs, _), v) => encodeEnum(fieldNumber, v, cs.toSeq: _*)
case (_, _) => Chunk.empty
}

private def encodeEnum[Z](fieldNumber: Option[Int], value: Z, cases: Schema.Case[_, Z]*): Chunk[Byte] = {
Expand Down Expand Up @@ -424,11 +424,11 @@ object ProtobufCodec extends Codec {

private[codec] def decoder[A](schema: Schema[A]): Decoder[A] =
schema match {
case Schema.GenericRecord(structure) => recordDecoder(structure.toChunk)
case Schema.Sequence(elementSchema @ Schema.Sequence(_, _, _), fromChunk, _) =>
case Schema.GenericRecord(structure, _) => recordDecoder(structure.toChunk)
case Schema.Sequence(elementSchema @ Schema.Sequence(_, _, _, _), fromChunk, _, _) =>
if (canBePacked(elementSchema)) packedSequenceDecoder(elementSchema).map(fromChunk)
else nonPackedSequenceDecoder(elementSchema).map(fromChunk)
case Schema.Sequence(elementSchema, fromChunk, _) =>
case Schema.Sequence(elementSchema, fromChunk, _, _) =>
Decoder[A](
{ bytes =>
{
Expand All @@ -443,19 +443,19 @@ object ProtobufCodec extends Codec {
},
true
)
case Schema.Transform(codec, f, _) => transformDecoder(codec, f)
case Schema.Primitive(standardType) => primitiveDecoder(standardType)
case Schema.Tuple(left, right) => tupleDecoder(left, right)
case Schema.Optional(codec) => optionalDecoder(codec)
case Schema.Fail(message) => fail(message)
case Schema.EitherSchema(left, right) => eitherDecoder(left, right)
case lzy @ Schema.Lazy(_) => decoder(lzy.schema)
case Schema.Meta(_) => astDecoder
case ProductDecoder(decoder) => decoder
case Schema.Enum1(c, _) => enumDecoder(c)
case Schema.Enum2(c1, c2, _) => enumDecoder(c1, c2)
case Schema.Enum3(c1, c2, c3, _) => enumDecoder(c1, c2, c3)
case Schema.EnumN(cs, _) => enumDecoder(cs.toSeq: _*)
case Schema.Transform(codec, f, _, _) => transformDecoder(codec, f)
case Schema.Primitive(standardType, _) => primitiveDecoder(standardType)
case Schema.Tuple(left, right, _) => tupleDecoder(left, right)
case Schema.Optional(codec, _) => optionalDecoder(codec)
case Schema.Fail(message, _) => fail(message)
case Schema.EitherSchema(left, right, _) => eitherDecoder(left, right)
case lzy @ Schema.Lazy(_) => decoder(lzy.schema)
case Schema.Meta(_, _) => astDecoder
case ProductDecoder(decoder) => decoder
case Schema.Enum1(c, _) => enumDecoder(c)
case Schema.Enum2(c1, c2, _) => enumDecoder(c1, c2)
case Schema.Enum3(c1, c2, c3, _) => enumDecoder(c1, c2, c3)
case Schema.EnumN(cs, _) => enumDecoder(cs.toSeq: _*)
}

private val astDecoder: Decoder[Schema[_]] =
Expand Down Expand Up @@ -563,7 +563,7 @@ object ProtobufCodec extends Codec {

private def transformDecoder[A, B](schema: Schema[B], f: B => Either[String, A]): Decoder[A] =
schema match {
case Schema.Primitive(typ) if typ == StandardType.UnitType =>
case Schema.Primitive(typ, _) if typ == StandardType.UnitType =>
Decoder { (chunk: Chunk[Byte]) =>
f(().asInstanceOf[B]) match {
case Left(err) => Left(err)
Expand Down
Loading