Utility to decode [SchemaProto] and [EntityTypeProto] (#4833)

Author: bgogul

java/arcs/core/data/proto/BUILD

@@ -36,6 +36,7 @@ arcs_kt_library(
     deps = [
         ":recipe_java_proto",
         "//java/arcs/core/data",
+        "//java/arcs/core/type",
     ],
 )
 

java/arcs/core/data/proto/SchemaProtoDecoder.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020 Google LLC.
+ *
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ *
+ * Code distributed by Google as part of this project is also subject to an additional IP rights
+ * grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+package arcs.core.data.proto
+
+import arcs.core.data.FieldName
+import arcs.core.data.FieldType
+import arcs.core.data.Schema
+import arcs.core.data.SchemaFields
+import arcs.core.data.SchemaName
+
+/**
+ * Returns the names in the [SchemaProto] as List<SchemaName>.
+ */
+fun SchemaProto.decodeNames(): List<SchemaName> = getNamesList().map { SchemaName(it) }
+
+/**
+ * Returns the fields in the [SchemaProto] as a Kotlin [SchemaFields] instance.
+ */
+fun SchemaProto.decodeFields(): SchemaFields {
+    val singletons = mutableMapOf<FieldName, FieldType>()
+    val collections = mutableMapOf<FieldName, FieldType>()
+    for ((name, type) in getFieldsMap()) {
+        when (type.getDataCase()) {
+            TypeProto.DataCase.PRIMITIVE -> singletons[name] = type.decodeAsFieldType()
+            // TODO: TypeProto.DataCase.COLLECTIONS
+            // TODO: TypeProto.DataCase.REFERENCE
+            TypeProto.DataCase.DATA_NOT_SET ->
+                throw IllegalArgumentException("Unknown data field in TypeProto.")
+            else ->
+                throw NotImplementedError(
+                    "decodeFields for ${type.getDataCase().name} is not implemented.")
+        }
+    }
+    return SchemaFields(singletons, collections)
+}
+
+/**
+ * Converts a [SchemaProto] proto instance into a Kotlin [Schema] instance.
+ */
+fun SchemaProto.decode() = Schema(names = decodeNames(), fields = decodeFields(), hash = "")
+// TODO: hash

java/arcs/core/data/proto/TypeProtoDecoders.kt

@@ -11,8 +11,10 @@
 
 package arcs.core.data.proto
 
+import arcs.core.data.EntityType
 import arcs.core.data.FieldType
 import arcs.core.data.PrimitiveType
+import arcs.core.type.Type
 
 /**
  * Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [PrimitiveType] instance.
@@ -47,3 +49,26 @@ fun TypeProto.decodeAsFieldType(): FieldType =
             throw IllegalArgumentException(
                 "Cannot decode a ${getDataCase().name} type to a [FieldType].")
     }
+
+/**
+ * Converts a [EntityTypeProto] protobuf instance into a Kotlin [EntityType] instance.
+ */
+fun EntityTypeProto.decode() = EntityType(getSchema().decode())
+
+/**
+ * Converts a [TypeProto] protobuf instance into a Kotlin [Type] instance.
+ */
+fun TypeProto.decode(): Type =
+    // TODO: optional, RefinementExpression.
+    when (getDataCase()) {
+        TypeProto.DataCase.ENTITY -> getEntity().decode()
+        TypeProto.DataCase.COLLECTION, TypeProto.DataCase.REFERENCE,
+        TypeProto.DataCase.TUPLE, TypeProto.DataCase.VARIABLE ->
+            throw NotImplementedError(
+                "Decoding of a ${getDataCase().name} type to a [Type] is not implemented.")
+        TypeProto.DataCase.DATA_NOT_SET ->
+            throw IllegalArgumentException("Unknown data field in TypeProto.")
+        else ->
+            throw IllegalArgumentException(
+                "Cannot decode a ${getDataCase().name} type to a [FieldType].")
+    }

javatests/arcs/core/data/proto/SchemaProtoDecoderTest.kt

@@ -0,0 +1,57 @@
+package arcs.core.data.proto
+
+import arcs.core.data.*
+import arcs.core.testutil.assertThrows
+import arcs.core.testutil.fail
+import arcs.repoutils.runfilesDir
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.Message.Builder
+import com.google.protobuf.Message
+import com.google.protobuf.TextFormat
+import java.io.File
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/**
+ * Decodes the text proto [protoText] for [SchemaProto] as [Schema].
+ */
+fun decodeSchemaProtoText(protoText: String): Schema {
+    val builder = SchemaProto.newBuilder()
+    TextFormat.getParser().merge(protoText, builder)
+    return builder.build().decode()
+}
+
+@RunWith(JUnit4::class)
+class SchemaProtoDecoderTest {
+    @Test
+    fun decodesNamesInSchemaProto() {
+        val schemaProtoText = """
+        names:  "Thing"
+        names:  "Object"
+        """.trimIndent()
+        val schema = decodeSchemaProtoText(schemaProtoText)
+        assertThat(schema.names).isEqualTo(listOf(SchemaName("Thing"), SchemaName("Object")))
+    }
+
+    @Test
+    fun decodesSingletonsInSchemaProto() {
+        val schemaProtoText = """
+        fields {
+          key: "text"
+          value: {
+            primitive: TEXT
+          }
+        }
+        fields {
+          key: "bool"
+          value: {
+            primitive: BOOLEAN
+          }
+        }
+        """.trimIndent()
+        val schema = decodeSchemaProtoText(schemaProtoText)
+        assertThat(schema.fields.singletons).isEqualTo(
+            mapOf("text" to FieldType.Text, "bool" to FieldType.Boolean))
+    }
+}

javatests/arcs/core/data/proto/TypeProtoDecodersTest.kt

@@ -62,4 +62,29 @@ class TypeProtoDecodersTest {
             checkPrimitive("""variable: { name: "Blah"}""", PrimitiveType.Text)
         }
     }
+
+    @Test
+    fun decodesEntityTypeProtoAsEntityType() {
+        val entityTypeProto = """
+        entity {
+          schema {
+            names: "Person"
+            fields: {
+              key: "name"
+              value: { primitive: TEXT }
+            }
+          }
+        }
+        """.trimIndent()
+        val entityType = parseTypeProtoText(entityTypeProto).decode()
+        val expectedSchema = Schema(
+            names = listOf(SchemaName("Person")),
+            fields = SchemaFields(singletons=mapOf("name" to FieldType.Text), collections=mapOf()),
+            hash = ""
+        )
+        when (entityType) {
+            is EntityType -> assertThat(entityType.entitySchema).isEqualTo(expectedSchema)
+            else -> fail("TypeProto should have been decoded to [EntityType].")
+        }
+    }
 }