Added support for relationship fields.

Author: Bob Garner

src/main/antlr4/org/entityc/compiler/EntityLanguage.g4

@@ -898,6 +898,32 @@ domainAttributeBody
     )*
     ;
 
+/*
+These are attributes of the "to" entity of a relationship. This allows
+tagging of attributes with respect to its "path" from a relationship.
+*/
+domainRelationshipAttributes
+    : ATTRIBUTES '{' domainRelationshipAttributesBody '}'
+    ;
+
+domainRelationshipAttributesBody
+    :
+    ( tagStatement
+    | domainRelationshipAttribute
+    )*
+    ;
+
+domainRelationshipAttribute
+    : id '{' domainRelationshipAttributeBody '}'
+    ;
+
+domainRelationshipAttributeBody
+    :
+    ( descriptionStatement
+    | tagStatement
+    )*
+    ;
+
 domainRelationships
     : RELATIONSHIPS '{' domainRelationshipsBody '}'
     ;
@@ -917,6 +943,7 @@ domainRelationshipBody
     :
     ( descriptionStatement
     | tagStatement
+    | domainRelationshipAttributes
     )*
     ;
 

src/main/java/org/entityc/compiler/ASTVisitor.java

@@ -22,21 +22,7 @@
 import org.entityc.compiler.model.config.MTSpaceInclude;
 import org.entityc.compiler.model.config.MTTemplate;
 import org.entityc.compiler.model.config.MTTransform;
-import org.entityc.compiler.model.domain.MTDApplyTemplate;
-import org.entityc.compiler.model.domain.MTDEAttribute;
-import org.entityc.compiler.model.domain.MTDEAttributeBitField;
-import org.entityc.compiler.model.domain.MTDEInterface;
-import org.entityc.compiler.model.domain.MTDEInterfaceOperation;
-import org.entityc.compiler.model.domain.MTDEInterfaceOperationConfig;
-import org.entityc.compiler.model.domain.MTDERelationship;
-import org.entityc.compiler.model.domain.MTDEntity;
-import org.entityc.compiler.model.domain.MTDEnum;
-import org.entityc.compiler.model.domain.MTDEnumItem;
-import org.entityc.compiler.model.domain.MTDModule;
-import org.entityc.compiler.model.domain.MTDView;
-import org.entityc.compiler.model.domain.MTDomain;
-import org.entityc.compiler.model.domain.MTNaming;
-import org.entityc.compiler.model.domain.MTNamingMethod;
+import org.entityc.compiler.model.domain.*;
 import org.entityc.compiler.model.entity.HalfRelationshipPlurality;
 import org.entityc.compiler.model.entity.MTAttribute;
 import org.entityc.compiler.model.entity.MTAttributeConstraint;
@@ -105,6 +91,7 @@ public class ASTVisitor extends EntityLanguageBaseVisitor {
     private       MTAttribute                                         currentAttribute;
     private       MTDModule                                           currentDomainModule;
     private       MTDEntity                                           currentDomainEntity;
+    private       MTDERelationship                                    currentDomainRelationship;
     private       MTDEnum                                             currentDomainEnum;
     private       MTLanguage                                          currentLanguage;
     private       MTConfiguration                                     currentConfiguration;
@@ -1990,8 +1977,24 @@ public Object visitDomainRelationship(EntityLanguageParser.DomainRelationshipCon
                     domainEntityRelationship.addTagsWithValues(tagStringsFromTagStatements(bodyContext.tagStatement()));
                 }
             }
+            this.currentDomainRelationship = domainEntityRelationship;
         }
-        return null;
+        Object object = super.visitDomainRelationship(ctx);
+
+        this.currentDomainRelationship = null;
+
+        return object;
+    }
+
+    @Override
+    public Object visitDomainRelationshipAttribute(EntityLanguageParser.DomainRelationshipAttributeContext ctx) {
+        String attributeName = ctx.id().getText();
+
+        MTDERelationshipField relationshipField = new MTDERelationshipField(ctx, currentDomainRelationship, attributeName);
+        currentDomainRelationship.addField(relationshipField);
+        Object object = super.visitDomainRelationshipAttribute(ctx);
+
+        return object;
     }
 
     @Override

src/main/java/org/entityc/compiler/EntityCompiler.java

@@ -52,8 +52,8 @@
 
 public class EntityCompiler {
 
-    public static final  String              COMPILER_VERSION   = "0.17.0";
-    public static final  String              LANGUAGE_VERSION   = "0.14.0";
+    public static final  String              COMPILER_VERSION   = "0.18.0";
+    public static final  String              LANGUAGE_VERSION   = "0.15.0";
     private static final Map<String, String> defineValues       = new HashMap<>();
     private static final Set<String>         templateSearchPath = new HashSet<>();
     private static       CommandLine         commandLine;

src/main/java/org/entityc/compiler/model/domain/MTDERelationship.java

@@ -18,31 +18,36 @@
 import org.entityc.compiler.model.entity.MTRelationship;
 import org.entityc.compiler.model.visitor.MTVisitor;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
 @ModelClass(type = ModelClassType.DOMAIN,
     description = "Represents a relationship in your model in the context of a domain.")
 public class MTDERelationship extends MTNode implements MTNamed, MTDomainBased, MTReferenceResolution {
 
-    private final String               relationshipName;
-    private       MTDomain             domain;
-    private       MTDEntity            domainEntity;
-    private       MTRelationship       relationship;
-    private       String               explicitName;
-    private       String               withViewName; // to-entity should map to a specific view
-    private       boolean              withPrimaryKey; // to-entity should map as its primary key only
-    private       MTDERelationshipHalf to;
-    private       boolean              resolvedReferences = false;
+    private final String relationshipName;
+    private MTDomain domain;
+    private MTDEntity domainEntity;
+    private MTRelationship relationship;
+    private String explicitName;
+    private String withViewName; // to-entity should map to a specific view
+    private boolean withPrimaryKey; // to-entity should map as its primary key only
+    private MTDERelationshipHalf to;
+    private boolean resolvedReferences = false;
+    private List<MTDERelationshipField> fields;
 
     public MTDERelationship(ParserRuleContext ctx, MTDEntity domainEntity, String relationshipName) {
         super(ctx);
-        this.domain           = domainEntity.getDomain();
-        this.domainEntity     = domainEntity;
+        this.domain = domainEntity.getDomain();
+        this.domainEntity = domainEntity;
         this.relationshipName = relationshipName;
     }
 
     public MTDERelationship(ParserRuleContext ctx, MTDomain domain, MTRelationship relationship) {
         super(ctx);
-        this.domain           = domain;
-        this.relationship     = relationship;
+        this.domain = domain;
+        this.relationship = relationship;
         this.relationshipName = relationship.getName();
     }
 
@@ -77,7 +82,7 @@ public void setWithViewName(String withViewName) {
     @ModelMethod(category = ModelMethodCategory.RELATIONSHIP,
         description =
             "If this relationship was explicitly renamed within its domain, it will return that name. Otherwise "
-            + "it will return `null`.")
+                + "it will return `null`.")
     public String getExplicitName() {
         return explicitName;
     }
@@ -108,6 +113,22 @@ public boolean isManyToMany() {
         return relationship != null && relationship.isManyToMany();
     }
 
+    public void addField(MTDERelationshipField field) {
+        if (this.fields == null) {
+            this.fields = new ArrayList<>();
+        }
+        this.fields.add(field);
+    }
+
+    public boolean hasFields() {
+        return this.fields != null && this.fields.size() > 0;
+    }
+    @ModelMethod(category = ModelMethodCategory.RELATIONSHIP,
+        description = "Returns all the declared fields of this relationship.")
+    public Collection<MTDERelationshipField> getFields() {
+        return this.fields;
+    }
+
     @Override
     public boolean resolveReferences(MTSpace space, int pass) {
         if (domain != null && domain.isSpecialized()) {
@@ -126,12 +147,19 @@ public boolean resolveReferences(MTSpace space, int pass) {
         }
         if (relationship != null && to == null) {
             to = new MTDERelationshipHalf(relationship.getParserRuleContext(), domain, relationship.getTo(),
-                                          withViewName);
+                withViewName);
             to.setAsPrimaryKey(withPrimaryKey);
             if (to.resolveReferences(space, pass)) {
                 anotherPass = true;
             }
         }
+        if (fields != null) {
+            for (MTDERelationshipField field : fields) {
+                if (field.resolveReferences(space, pass)) {
+                    anotherPass = true;
+                }
+            }
+        }
         if (!anotherPass) {
             resolvedReferences = true;
         }
@@ -146,21 +174,21 @@ public void accept(MTVisitor visitor) {
     @ModelMethod(category = ModelMethodCategory.RELATIONSHIP,
         description =
             "This returns the full name of this domain relationship which includes not only its domain based name "
-            + "but is also preceded with the domain's entity's full name. The delimiter can be provided which "
-            + "is used between all parts of the full name.")
+                + "but is also preceded with the domain's entity's full name. The delimiter can be provided which "
+                + "is used between all parts of the full name.")
     @Override
     public String getFullname(
         @ModelMethodParameter(description = "A delimiter to place between the segments of the domain namespace as well "
-                                            + "as between that namespace and the domain entity name and between the "
-                                            + "domain entity name and the domain relationship name.")
-            String delim) {
+            + "as between that namespace and the domain entity name and between the "
+            + "domain entity name and the domain relationship name.")
+        String delim) {
         return domainEntity.getFullname(delim) + delim + getName();
     }
 
     @ModelMethod(category = ModelMethodCategory.RELATIONSHIP,
         description =
             "Returns the domain relationship name which is the result of applying any defined naming conventions "
-            + "or explicit renaming.")
+                + "or explicit renaming.")
     @Override
     public String getName() {
         if (explicitName != null) {
@@ -230,7 +258,7 @@ public boolean isPrimaryParent() {
         description = "Returns whether this relationship's \"to\" entity is tagged with the specified tag.")
     public boolean hasToEntityTagged(
         @ModelMethodParameter(description = "The tag with which to check.")
-            String tag) {
+        String tag) {
         return to != null && to.getEntity().hasTag(tag);
     }
 }

src/main/java/org/entityc/compiler/model/domain/MTDERelationshipField.java

@@ -0,0 +1,86 @@
+package org.entityc.compiler.model.domain;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.entityc.compiler.doc.annotation.ModelClass;
+import org.entityc.compiler.doc.annotation.ModelClassType;
+import org.entityc.compiler.model.MTNode;
+import org.entityc.compiler.model.MTReferenceResolution;
+import org.entityc.compiler.model.config.MTSpace;
+import org.entityc.compiler.model.entity.MTEntity;
+import org.entityc.compiler.model.entity.MTRelationship;
+import org.entityc.compiler.model.visitor.MTVisitor;
+import org.entityc.compiler.util.ECLog;
+
+@ModelClass(type = ModelClassType.DOMAIN,
+    description = "Represents a field (attribute or relationship) associated with the __to__ entity of the relationship.")
+public class MTDERelationshipField extends MTNode implements MTNamed, MTDomainBased, MTReferenceResolution  {
+
+    public MTDERelationshipField(ParserRuleContext ctx,  MTDERelationship domainRelationship, String fieldName) {
+        super(ctx);
+        this.domainRelationship = domainRelationship;
+        this.fieldName = fieldName;
+    }
+    private MTDERelationship domainRelationship;
+    private MTDEAttribute fieldAttribute;
+    private MTDERelationship fieldRelationship;
+
+    private String fieldName;
+
+    public boolean fieldIsAttribute() {
+        return fieldAttribute != null;
+    }
+
+    public boolean fieldIsRelationship() {
+        return fieldRelationship != null;
+    }
+
+    public MTDEAttribute getAttribute() {
+        return fieldAttribute;
+    }
+
+    @Override
+    public void accept(MTVisitor visitor) {
+
+    }
+
+    @Override
+    public boolean resolveReferences(MTSpace space, int pass) {
+        ECLog.logInfo("Resolving domain relationship field references...");
+        if ( fieldIsAttribute() || fieldIsRelationship() ) {
+            return false;
+        }
+        MTRelationship relationship = domainRelationship.getRelationship();
+        if (relationship == null) {
+            return true;
+        }
+        MTEntity entity = relationship.getTo() != null && relationship.getTo().getEntity() != null ? relationship.getTo().getEntity() : null;
+        if (entity == null) {
+            return true;
+        }
+
+        if (entity.hasAttributeNamed(fieldName)) {
+            this.fieldAttribute = new MTDEAttribute(getParserRuleContext(), domainRelationship.getDomain(), entity.getName(), fieldName);
+            this.fieldAttribute.addTagsWithValues(this.getTagsWithValues()); // transfer the tags to it
+        } else if (entity.hasRelationshipNamed(fieldName)) {
+            ECLog.logFatal(getParserRuleContext(), "Domain relationship fields of type relationship currently not supported.");
+        } else {
+            ECLog.logFatal(getParserRuleContext(), "Domain relationship " + this.domainRelationship.getName() + " of entity " + entity.getName() + " does not have an attribute or relationship named: " + fieldName);
+        }
+        return false;
+    }
+
+    @Override
+    public MTDomain getDomain() {
+        return this.domainRelationship.getDomain();
+    }
+
+    @Override
+    public String getFullname(String delim) {
+        return this.domainRelationship.getFullname(delim) + delim + this.fieldName;
+    }
+
+    @Override
+    public String getName() {
+        return this.fieldName;
+    }
+}