Emit events for all known types

.github/workflows/build-on-ubuntu.yml

@@ -22,7 +22,7 @@ jobs:
         run: ./gradlew build --stacktrace
 
       # See: https://github.com/marketplace/actions/junit-report-action
-      - name: Publish Unit Test Report
+      - name: Publish Test Report
         uses: mikepenz/[email protected]
         if: always() # always run even if the previous step fails
         with:

api/src/main/kotlin/io/spine/protodata/AstExtensions.kt

@@ -195,12 +195,12 @@ private val FileDescriptor.typeUrlPrefix: String
 /**
  * Obtains the name of this `oneof` as a [OneofName].
  */
-internal fun OneofDescriptor.name(): OneofName = oneofName { value = name }
+public fun OneofDescriptor.name(): OneofName = oneofName { value = name }
 
 /**
  * Obtains the name of this field as a [FieldName].
  */
-internal fun FieldDescriptor.name(): FieldName = fieldName { value = name }
+public fun FieldDescriptor.name(): FieldName = fieldName { value = name }
 
 /**
  * Obtains the relative path to this file as a [FilePath].
@@ -219,7 +219,7 @@ public fun ServiceDescriptor.name(): ServiceName = serviceName {
 /**
  * Obtains the name of this RPC method as an [RpcName].
  */
-internal fun MethodDescriptor.name(): RpcName = rpcName { value = name }
+public fun MethodDescriptor.name(): RpcName = rpcName { value = name }
 
 /**
  * Obtains a [Type] wrapping this `PrimitiveType`.

api/src/main/kotlin/io/spine/protodata/plugin/Plugin.kt

@@ -68,7 +68,7 @@ public interface Plugin {
  */
 public fun BoundedContextBuilder.apply(plugin: Plugin) {
     val repos = plugin.viewRepositories().toMutableList()
-    val defaultRepos = plugin.views().map { io.spine.protodata.plugin.ViewRepository.default(it) }
+    val defaultRepos = plugin.views().map { ViewRepository.default(it) }
     repos.addAll(defaultRepos)
     val repeatedView = repos.map { it.entityClass() }
                             .groupingBy { it }

api/src/main/proto/spine/protodata/ast.proto

@@ -405,6 +405,9 @@ message Service {
 
     // Documentation of this service.
     Doc doc = 4;
+
+    // Path to the file which declares this service.
+    FilePath file = 5;
 }
 
 // A name of an RPC method.

api/src/main/proto/spine/protodata/events.proto

@@ -36,6 +36,7 @@ option java_outer_classname = "EventsProto";
 option java_multiple_files = true;
 
 import "spine/protodata/ast.proto";
+import "spine/protodata/source.proto";
 
 // Emitted when processing of a file begins.
 message FileEntered {
@@ -264,3 +265,23 @@ message RpcExited {
 
     RpcName rpc = 3;
 }
+
+// Emitted when the Protobuf compiler discovers a dependency file.
+//
+// The order of files reported by events of this type is unspecified. Users should not rely on any
+// particular order.
+//
+// Each file is only reported by one event, even if the file is imported into
+//
+// `DependencyDiscovered` events always precede all other Protobuf compiler events, i.e.
+// the first `FileEntered` will always be emitted after the last `DependencyDiscovered`.
+//
+// Normally, no code should be generated for dependencies. However, they can be used for additional
+// info when generating code for the module's own types.
+//
+message DependencyDiscovered {
+
+    FilePath file = 1;
+
+    ProtobufSourceFile content = 2;
+}

api/src/main/proto/spine/protodata/source.proto

@@ -42,7 +42,7 @@ import "spine/protodata/ast.proto";
 // Includes all the message types declared in the file, along with their fields.
 //
 message ProtobufSourceFile {
-    option (entity).kind = PROJECTION;
+    option (entity).kind = VIEW;
 
     FilePath file_path = 1;
 
@@ -70,3 +70,16 @@ message ProtobufSourceFile {
     //
     map<string, Service> service = 5;
 }
+
+// A Protobuf definitions file which is included into the module as a dependency.
+//
+// Unlike `ProtobufSourceFile`, `ProtobufDependencyFile` should not result in any code generation.
+// Rather, it serves an informative purpose.
+//
+message ProtobufDependencyFile {
+    option (entity).kind = VIEW;
+
+    FilePath file_path = 1;
+
+    ProtobufSourceFile content = 2;
+}

buildSrc/src/main/kotlin/io/spine/internal/dependency/Pmd.kt

@@ -28,5 +28,5 @@ package io.spine.internal.dependency
 
 // https://pmd.github.io/
 object Pmd {
-    const val version = "6.51.0"
+    const val version = "6.55.0"
 }

buildSrc/src/main/kotlin/io/spine/internal/dependency/Spine.kt

@@ -61,7 +61,7 @@ class Spine(p: ExtensionAware) {
          *
          * @see [ProtoData]
          */
-        const val protoData = "0.7.4"
+        const val protoData = "0.7.6"
 
         /**
          * The default version of `base` to use.
@@ -85,7 +85,7 @@ class Spine(p: ExtensionAware) {
         /**
          * The version of `mc-java` to use.
          */
-        const val mcJava = "2.0.0-SNAPSHOT.134"
+        const val mcJava = "2.0.0-SNAPSHOT.132"
 
         /**
          * The version of `base-types` to use.
@@ -116,7 +116,7 @@ class Spine(p: ExtensionAware) {
          * The version of `tool-base` to use.
          * @see [Spine.toolBase]
          */
-        const val toolBase = "2.0.0-SNAPSHOT.161"
+        const val toolBase = "2.0.0-SNAPSHOT.156"
 
         /**
          * The version of `validation` to use.

compiler/src/main/kotlin/io/spine/protodata/backend/AstComponents.kt

@@ -0,0 +1,198 @@
+/*
+ * Copyright 2023, TeamDev. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.protodata.backend
+
+import com.google.protobuf.Descriptors
+import com.google.protobuf.Empty
+import io.spine.protodata.EnumConstant
+import io.spine.protodata.Field
+import io.spine.protodata.Rpc
+import io.spine.protodata.ServiceName
+import io.spine.protodata.TypeName
+import io.spine.protodata.cardinality
+import io.spine.protodata.constantName
+import io.spine.protodata.file
+import io.spine.protodata.name
+import io.spine.protodata.path
+
+/**
+ * Converts this field descriptor into a [Field] with options.
+ *
+ * @see buildField
+ */
+internal fun Descriptors.FieldDescriptor.buildFieldWithOptions(
+    declaringType: TypeName,
+    documentation: Documentation
+): Field {
+    val field = buildField(declaringType, documentation)
+    return field.toBuilder()
+        .addAllOption(listOptions(options))
+        .build()
+}
+
+/**
+ * Converts this field descriptor into a [Field].
+ *
+ * The resulting [Field] will not reflect the field options.
+ *
+ * @see buildFieldWithOptions
+ */
+internal fun Descriptors.FieldDescriptor.buildField(
+    declaringType: TypeName,
+    documentation: Documentation
+): Field {
+    return Field.newBuilder()
+        .setName(name())
+        .setDeclaringType(declaringType)
+        .setNumber(number)
+        .setOrderOfDeclaration(index)
+        .assignTypeAndCardinality(this)
+        .setDoc(documentation.forField(this))
+        .build()
+}
+
+/**
+ * Assigns the field type and cardinality (`map`/`list`/`oneof_name`/`single`) to the receiver
+ * builder.
+ *
+ * @return the receiver for method chaining.
+ */
+private fun Field.Builder.assignTypeAndCardinality(
+    desc: Descriptors.FieldDescriptor
+): Field.Builder {
+    if (desc.isMapField) {
+        val (keyField, valueField) = desc.messageType.fields
+        map = Field.OfMap.newBuilder()
+            .setKeyType(keyField.primitiveType())
+            .build()
+        type = valueField.type()
+    } else {
+        type = desc.type()
+        when {
+            desc.isRepeated -> list = Empty.getDefaultInstance()
+            desc.realContainingOneof != null -> oneofName = desc.realContainingOneof.name()
+            else -> single = Empty.getDefaultInstance()
+        }
+    }
+    return this
+}
+
+/**
+ * Converts this enum value descriptor into an [EnumConstant] with options.
+ *
+ * @see buildConstant
+ */
+internal fun Descriptors.EnumValueDescriptor.buildConstantWithOptions(
+    declaringType: TypeName,
+    documentation: Documentation
+): EnumConstant {
+    val constant = buildConstant(declaringType, documentation)
+    return constant.toBuilder()
+        .addAllOption(listOptions(options))
+        .build()
+}
+
+/**
+ * Converts this enum value descriptor into an [EnumConstant].
+ *
+ * The resulting [EnumConstant] will not reflect the options on the enum constant.
+ *
+ * @see buildConstantWithOptions
+ */
+internal fun Descriptors.EnumValueDescriptor.buildConstant(
+    declaringType: TypeName,
+    documentation: Documentation
+): EnumConstant {
+    return EnumConstant.newBuilder()
+        .setName(constantName { value = name })
+        .setDeclaredIn(declaringType)
+        .setNumber(number)
+        .setOrderOfDeclaration(index)
+        .setDoc(documentation.forEnumConstant(this))
+        .build()
+}
+
+/**
+ * Converts this method descriptor into an [Rpc] with options.
+ *
+ * @see buildRpc
+ */
+internal fun Descriptors.MethodDescriptor.buildRpcWithOptions(
+    declaringService: ServiceName,
+    documentation: Documentation
+) : Rpc {
+    return buildRpc(declaringService, documentation)
+        .toBuilder()
+        .addAllOption(listOptions(options))
+        .build()
+}
+
+/**
+ * Converts this method descriptor into an [Rpc].
+ *
+ * The resulting [Rpc] will not reflect the method options.
+ *
+ * @see buildRpcWithOptions
+ */
+internal fun Descriptors.MethodDescriptor.buildRpc(
+    declaringService: ServiceName,
+    documentation: Documentation
+) : Rpc {
+    val name = name()
+    val cardinality = cardinality()
+    return Rpc.newBuilder()
+        .setName(name)
+        .setCardinality(cardinality)
+        .setRequestType(inputType.name())
+        .setResponseType(outputType.name())
+        .setDoc(documentation.forRpc(this))
+        .setService(declaringService)
+        .build()
+}
+
+/**
+ * Extracts metadata from this file descriptor, including file options.
+ *
+ * @see toFile
+ */
+internal fun Descriptors.FileDescriptor.toFileWithOptions() =
+    toFile()
+        .toBuilder()
+        .addAllOption(listOptions(options))
+        .build()
+
+/**
+ * Extracts metadata from this file descriptor, excluding file options.
+ *
+ * @see toFileWithOptions
+ */
+internal fun Descriptors.FileDescriptor.toFile() = file {
+    path = path()
+    packageName = `package`
+    syntax = [email protected]()
+}
+