Remove type reference from (by) option

base/src/main/java/io/spine/validate/FieldContext.java → base/src/main/java/io/spine/code/proto/FieldContext.java

@@ -18,24 +18,21 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package io.spine.validate;
+package io.spine.code.proto;
 
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.Immutable;
 import com.google.protobuf.Descriptors.FieldDescriptor;
-import io.spine.annotation.Internal;
 import io.spine.base.FieldPath;
 
-import java.util.Collections;
-import java.util.List;
 import java.util.Optional;
 
 import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Lists.newLinkedList;
-import static java.util.Collections.singleton;
 
 /**
  * Provides information about a proto field in the nesting hierarchy.
  */
-@Internal
+@Immutable
 public final class FieldContext {
 
     /**
@@ -58,16 +55,16 @@ public final class FieldContext {
      * <p>The value of this field for the {@code value} field of the {@code UserId} is
      * {@code [FieldDescriptor_for_id, FieldDescriptor_for_value]}.
      */
-    private final List<FieldDescriptor> descriptors;
+    private final ImmutableList<FieldDescriptor> descriptors;
 
     /**
      * Provides field names in the nesting hierarchy.
      */
     private final FieldPath fieldPath;
 
-    private FieldContext(Iterable<FieldDescriptor> descriptors) {
-        this.descriptors = newLinkedList(descriptors);
-        this.fieldPath = fieldPathOf(descriptors);
+    private FieldContext(ImmutableList<FieldDescriptor> descriptors) {
+        this.descriptors = descriptors;
+        this.fieldPath = toPath(descriptors);
     }
 
     /**
@@ -77,16 +74,16 @@ private FieldContext(Iterable<FieldDescriptor> descriptors) {
      * @return the field context
      */
     public static FieldContext create(FieldDescriptor field) {
-        return new FieldContext(singleton(field));
+        return new FieldContext(ImmutableList.of(field));
     }
 
     /**
      * Creates empty descriptor context.
      *
      * @return the descriptor context
      */
-    static FieldContext empty() {
-        return new FieldContext(Collections.emptyList());
+    public static FieldContext empty() {
+        return new FieldContext(ImmutableList.of());
     }
 
     /**
@@ -96,23 +93,26 @@ static FieldContext empty() {
      * @return the child descriptor context
      */
     public FieldContext forChild(FieldDescriptor child) {
-        List<FieldDescriptor> newDescriptors = newLinkedList(descriptors);
-        newDescriptors.add(child);
-        return new FieldContext(newDescriptors);
+        return new FieldContext(
+                ImmutableList.<FieldDescriptor>builder()
+                        .addAll(descriptors)
+                        .add(child)
+                        .build()
+        );
     }
 
     /**
      * Obtains target of this context.
      *
      * @return the target descriptor
      */
-    public FieldDescriptor getTarget() {
+    public FieldDescriptor target() {
         checkState(!descriptors.isEmpty(), "Empty context cannot have a target.");
         int targetIndex = descriptors.size() - 1;
         return descriptors.get(targetIndex);
     }
 
-    private Optional<FieldDescriptor> getTargetParent() {
+    private Optional<FieldDescriptor> targetParent() {
         int targetParentIndex = descriptors.size() - 2;
         boolean parentExists = targetParentIndex > -1;
         return parentExists
@@ -125,7 +125,7 @@ private Optional<FieldDescriptor> getTargetParent() {
      *
      * @return the field path
      */
-    FieldPath getFieldPath() {
+    public FieldPath fieldPath() {
         return fieldPath;
     }
 
@@ -137,23 +137,32 @@ FieldPath getFieldPath() {
      * @return {@code true} if this context has the same target and the same parent
      */
     public boolean hasSameTargetAndParent(FieldContext other) {
-        String thisTargetName = getTarget().getFullName();
-        String otherTargetName = other.getTarget()
+        String thisTargetName = target().getFullName();
+        String otherTargetName = other.target()
                                       .getFullName();
         boolean sameTarget = thisTargetName.equals(otherTargetName);
         if (!sameTarget) {
             return false;
         }
-        Optional<String> parentFromThis = getTargetParent()
+        Optional<String> parentFromThis = targetParent()
                 .map(FieldDescriptor::getFullName);
         Optional<String> parentFromOther = other
-                .getTargetParent()
+                .targetParent()
                 .map(FieldDescriptor::getFullName);
         boolean bothHaveParents = parentFromThis.isPresent() && parentFromOther.isPresent();
         return bothHaveParents && parentFromThis.get()
                                                 .equals(parentFromOther.get());
     }
 
+    private static FieldPath toPath(Iterable<FieldDescriptor> descriptors) {
+        FieldPath.Builder builder = FieldPath.newBuilder();
+        for (FieldDescriptor descriptor : descriptors) {
+            String fieldName = descriptor.getName();
+            builder = builder.addFieldName(fieldName);
+        }
+        return builder.build();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) {
@@ -172,13 +181,4 @@ public boolean equals(Object o) {
     public int hashCode() {
         return descriptors.hashCode();
     }
-
-    private static FieldPath fieldPathOf(Iterable<FieldDescriptor> descriptors) {
-        FieldPath.Builder builder = FieldPath.newBuilder();
-        for (FieldDescriptor descriptor : descriptors) {
-            String fieldName = descriptor.getName();
-            builder = builder.addFieldName(fieldName);
-        }
-        return builder.build();
-    }
 }

base/src/main/java/io/spine/code/proto/FieldName.java

@@ -37,9 +37,6 @@ public final class FieldName extends AbstractFieldName implements UnderscoredNam
 
     private static final long serialVersionUID = 0L;
 
-    /** A delimiter between a type name and a field name. */
-    public static final String TYPE_SEPARATOR = ".";
-
     /**
      * The separator is an underscore or a digit.
      *

base/src/main/java/io/spine/code/proto/ref/BuiltIn.java

@@ -20,52 +20,20 @@
 
 package io.spine.code.proto.ref;
 
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.annotations.Immutable;
 import com.google.protobuf.Descriptors.Descriptor;
 
 import java.util.Optional;
 import java.util.stream.Stream;
 
-import static com.google.common.base.Preconditions.checkArgument;
-import static io.spine.util.Preconditions2.checkNotEmptyOrBlank;
-
 /**
  * Provides typical type references used for referencing types in proto definitions.
  *
- * <p>A type reference is usually used in a field reference
+ * <p>A type reference is usually used in a field reference.
  */
 @Immutable
 enum BuiltIn implements TypeRef {
 
-    /**
-     * Wildcard option used to reference all types.
-     *
-     * <p>A typical usage would be in a field reference in the {@code (by)} option to
-     * specify all types containing a field with a certain name. Consider the following message
-     * declaration:
-     * <pre>{@code
-     * message MyEnrichment {
-     *    string enrichment_value = 1 [(by) = "*.my_id"];
-     * }}
-     * </pre>
-     * tells that the enrichment field is populated after the a field named {@code my_id}
-     * found in any type. This, in turn, means that the type {@code MyEnrichment} will be used
-     * for all the messages declaring a field with such name.
-     *
-     * <p>A special care should be taken for ensuring that such fields have the same type, and
-     * that an enrichment function is provided for obtaining enrichment field value from a source
-     * message field.
-     */
-    ALL("*") {
-
-        /** Accepts all message types. */
-        @Override
-        public boolean test(Descriptor message) {
-            return true;
-        }
-    },
-
     SELF("") {
 
         /**
@@ -124,31 +92,6 @@ Optional<TypeRef> parse(String value) {
         return Optional.empty();
     }
 
-    /**
-     * Ensures that the passed value is:
-     * <ol>
-     * <li>not null
-     * <li>not empty or blank
-     * <li>not a wild card type reference in a suffix form
-     *  (such as {@code '*CommonEventNameSuffix.field_name'}, which is not currently supported.
-     * </ol>
-     */
-    @CanIgnoreReturnValue
-    static String checkTypeReference(String typeReference) {
-        checkNotEmptyOrBlank(typeReference);
-        String wildcard = ALL.value();
-        if (typeReference.startsWith(wildcard)) {
-            checkArgument(
-                    typeReference.equals(wildcard),
-                    "Referencing types with a suffix form (`%s`) in wildcard reference " +
-                            "is not supported . " +
-                            "Please use '%s.<field_name>' when referencing a field of many types.",
-                    typeReference,
-                    wildcard);
-        }
-        return typeReference;
-    }
-
     /** Obtains the value of the reference. */
     @Override
     public String value() {

base/src/main/java/io/spine/code/proto/ref/CompositeTypeRef.java

@@ -75,12 +75,13 @@ static CompositeTypeRef parse(String value) {
     }
 
     private static TypeRef parsePart(String part) {
-        Parsing p = new Parsing(part, InPackage::parse, DirectTypeRef::parse);
+        Parsing parsing = new Parsing(part, InPackage::parse, DirectTypeRef::parse);
         TypeRef result =
-                p.parse()
-                 .orElseThrow(() -> newIllegalArgumentException(
-                         "The value (`%s`) cannot be used in a composite type reference.", part
-                 ));
+                parsing.parse()
+                       .orElseThrow(() -> newIllegalArgumentException(
+                               "The value (`%s`) cannot be used in a composite type reference.",
+                               part
+                       ));
         return result;
     }
 

base/src/main/java/io/spine/code/proto/ref/DirectTypeRef.java

@@ -31,7 +31,6 @@
 import java.util.Optional;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static io.spine.code.proto.ref.BuiltIn.ALL;
 import static io.spine.code.proto.ref.BuiltIn.SELF;
 import static java.util.stream.Collectors.toList;
 
@@ -54,10 +53,10 @@ public final class DirectTypeRef extends AbstractTypeRef {
      */
     static Optional<TypeRef> parse(String value) {
         checkNotNull(value);
-        if (value.equals(SELF.value())) {
+        if (value.contains(InPackage.WILDCARD)) {
             return Optional.empty();
         }
-        if (value.contains(ALL.value())) {
+        if (value.equals(SELF.value())) {
             return Optional.empty();
         }
         TypeRef result = new DirectTypeRef(value);