style: replaced principal with left and dependent with right whenever it referred to relationships

Author: maurei

src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs

@@ -239,8 +239,8 @@ private IList GetTrackedManyRelationshipValue(IEnumerable<IIdentifiable> relatio
             {   // convert each element in the value list to relationshipAttr.DependentType.
                 var tracked = AttachOrGetTracked(pointer);
                 if (tracked != null) _wasAlreadyAttached = true;
-                return Convert.ChangeType(tracked ?? pointer, relationshipAttr.DependentType);
-            }).ToList().Cast(relationshipAttr.DependentType);
+                return Convert.ChangeType(tracked ?? pointer, relationshipAttr.RightType);
+            }).ToList().Cast(relationshipAttr.RightType);
             if (_wasAlreadyAttached) wasAlreadyAttached = true;
             return (IList)trackedPointerCollection;
         }
@@ -262,7 +262,7 @@ public async Task UpdateRelationshipsAsync(object parent, RelationshipAttribute
             // of the property...
             var typeToUpdate = (relationship is HasManyThroughAttribute hasManyThrough)
                 ? hasManyThrough.ThroughType
-                : relationship.DependentType;
+                : relationship.RightType;
 
             var genericProcessor = _genericProcessorFactory.GetProcessor<IGenericProcessor>(typeof(GenericProcessor<>), typeToUpdate);
             await genericProcessor.UpdateRelationshipsAsync(parent, relationship, relationshipIds);
@@ -365,7 +365,7 @@ protected void LoadCurrentRelationships(TResource oldEntity, RelationshipAttribu
 
         /// <summary>
         /// The relationshipValue parameter contains the dependent side of the relationship (Tags).
-        /// We can't directly add them to the principal entity (Article): we need to 
+        /// We can't directly add them to the left entity (Article): we need to 
         /// use the join table (ArticleTags). This methods assigns the relationship value to entity
         /// by taking care of that
         /// </summary>

src/JsonApiDotNetCore/Hooks/Execution/EntityHashSet.cs

@@ -44,15 +44,15 @@ internal EntityHashSet(IEnumerable entities,
 
 
         /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type principalType)
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type leftType)
         {
-            return _relationships.GetByRelationship(principalType);
+            return _relationships.GetByRelationship(leftType);
         }
 
         /// <inheritdoc />
-        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TRelatedResource>() where TRelatedResource : class, IIdentifiable
+        public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TRightResource>() where TRightResource : class, IIdentifiable
         {
-            return GetByRelationship(typeof(TRelatedResource));
+            return GetByRelationship(typeof(TRightResource));
         }
 
         /// <inheritdoc />

src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs

@@ -7,11 +7,9 @@
 using JsonApiDotNetCore.Internal.Generics;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Extensions;
-using PrincipalType = System.Type;
-using DependentType = System.Type;
-using Microsoft.EntityFrameworkCore;
+using LeftType = System.Type;
+using RightType = System.Type;
 using JsonApiDotNetCore.Internal;
-using JsonApiDotNetCore.Internal.Contracts;
 using JsonApiDotNetCore.Configuration;
 
 namespace JsonApiDotNetCore.Hooks
@@ -22,31 +20,31 @@ internal class HookExecutorHelper : IHookExecutorHelper
         private readonly IdentifiableComparer _comparer = new IdentifiableComparer();
         private readonly IJsonApiOptions _options;
         protected readonly IGenericProcessorFactory _genericProcessorFactory;
-        protected readonly Dictionary<DependentType, IResourceHookContainer> _hookContainers;
-        protected readonly Dictionary<DependentType, IHooksDiscovery> _hookDiscoveries;
+        protected readonly Dictionary<RightType, IResourceHookContainer> _hookContainers;
+        protected readonly Dictionary<RightType, IHooksDiscovery> _hookDiscoveries;
         protected readonly List<ResourceHook> _targetedHooksForRelatedEntities;
 
         public HookExecutorHelper(IGenericProcessorFactory genericProcessorFactory,
                                   IJsonApiOptions options)
         {
             _options = options;
             _genericProcessorFactory = genericProcessorFactory;
-            _hookContainers = new Dictionary<DependentType, IResourceHookContainer>();
-            _hookDiscoveries = new Dictionary<DependentType, IHooksDiscovery>();
+            _hookContainers = new Dictionary<RightType, IResourceHookContainer>();
+            _hookDiscoveries = new Dictionary<RightType, IHooksDiscovery>();
             _targetedHooksForRelatedEntities = new List<ResourceHook>();
         }
 
         /// <inheritdoc/>
-        public IResourceHookContainer GetResourceHookContainer(DependentType dependentType, ResourceHook hook = ResourceHook.None)
+        public IResourceHookContainer GetResourceHookContainer(RightType rightType, ResourceHook hook = ResourceHook.None)
         {
             /// checking the cache if we have a reference for the requested container, 
             /// regardless of the hook we will use it for. If the value is null, 
             /// it means there was no implementation IResourceHookContainer at all, 
             /// so we need not even bother.
-            if (!_hookContainers.TryGetValue(dependentType, out IResourceHookContainer container))
+            if (!_hookContainers.TryGetValue(rightType, out IResourceHookContainer container))
             {
-                container = (_genericProcessorFactory.GetProcessor<IResourceHookContainer>(typeof(ResourceDefinition<>), dependentType));
-                _hookContainers[dependentType] = container;
+                container = (_genericProcessorFactory.GetProcessor<IResourceHookContainer>(typeof(ResourceDefinition<>), rightType));
+                _hookContainers[rightType] = container;
             }
             if (container == null) return container;
 
@@ -65,7 +63,7 @@ public IResourceHookContainer GetResourceHookContainer(DependentType dependentTy
 
             foreach (ResourceHook targetHook in targetHooks)
             {
-                if (ShouldExecuteHook(dependentType, targetHook)) return container;
+                if (ShouldExecuteHook(rightType, targetHook)) return container;
             }
             return null;
         }
@@ -76,7 +74,7 @@ public IResourceHookContainer<TResource> GetResourceHookContainer<TResource>(Res
             return (IResourceHookContainer<TResource>)GetResourceHookContainer(typeof(TResource), hook);
         }
 
-        public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] inclusionChain)
+        public IEnumerable LoadDbValues(LeftType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] inclusionChain)
         {
             var idType = TypeHelper.GetIdentifierType(entityTypeForRepository);
             var parameterizedGetWhere = GetType()
@@ -107,7 +105,7 @@ public bool ShouldLoadDbValues(Type entityType, ResourceHook hook)
             return _options.LoaDatabaseValues;
         }
 
-        bool ShouldExecuteHook(DependentType entityType, ResourceHook hook)
+        bool ShouldExecuteHook(RightType entityType, ResourceHook hook)
         {
             var discovery = GetHookDiscovery(entityType);
             return discovery.ImplementedHooks.Contains(hook);
@@ -145,46 +143,46 @@ IResourceReadRepository<TResource, TId> GetRepository<TResource, TId>() where TR
 
 
         public Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(
-            Dictionary<RelationshipAttribute, IEnumerable> principalEntitiesByRelation,
-            IEnumerable existingDependentEntities = null)
+            Dictionary<RelationshipAttribute, IEnumerable> leftEntitiesByRelation,
+            IEnumerable existingRightEntities = null)
         {
             var implicitlyAffected = new Dictionary<RelationshipAttribute, IEnumerable>();
-            foreach (var kvp in principalEntitiesByRelation)
+            foreach (var kvp in leftEntitiesByRelation)
             {
-                if (IsHasManyThrough(kvp, out var principals, out var relationship)) continue;
+                if (IsHasManyThrough(kvp, out var lefts, out var relationship)) continue;
 
                 // note that we dont't have to check if BeforeImplicitUpdate hook is implemented. If not, it wont ever get here.
-                var includedPrincipals = LoadDbValues(relationship.PrincipalType, principals, ResourceHook.BeforeImplicitUpdateRelationship, relationship);
+                var includedLefts = LoadDbValues(relationship.LeftType, lefts, ResourceHook.BeforeImplicitUpdateRelationship, relationship);
 
-                foreach (IIdentifiable ip in includedPrincipals)
+                foreach (IIdentifiable ip in includedLefts)
                 {
-                    IList dbDependentEntityList = null;
+                    IList dbRightEntityList = null;
                     var relationshipValue = relationship.GetValue(ip);
                     if (!(relationshipValue is IEnumerable))
                     {
-                        dbDependentEntityList = TypeHelper.CreateListFor(relationship.DependentType);
-                        if (relationshipValue != null) dbDependentEntityList.Add(relationshipValue);
+                        dbRightEntityList = TypeHelper.CreateListFor(relationship.RightType);
+                        if (relationshipValue != null) dbRightEntityList.Add(relationshipValue);
                     }
                     else
                     {
-                        dbDependentEntityList = (IList)relationshipValue;
+                        dbRightEntityList = (IList)relationshipValue;
                     }
-                    var dbDependentEntityListCasted = dbDependentEntityList.Cast<IIdentifiable>().ToList();
-                    if (existingDependentEntities != null) dbDependentEntityListCasted = dbDependentEntityListCasted.Except(existingDependentEntities.Cast<IIdentifiable>(), _comparer).ToList();
+                    var dbRightEntityListCasted = dbRightEntityList.Cast<IIdentifiable>().ToList();
+                    if (existingRightEntities != null) dbRightEntityListCasted = dbRightEntityListCasted.Except(existingRightEntities.Cast<IIdentifiable>(), _comparer).ToList();
 
-                    if (dbDependentEntityListCasted.Any())
+                    if (dbRightEntityListCasted.Any())
                     {
                         if (!implicitlyAffected.TryGetValue(relationship, out IEnumerable affected))
                         {
-                            affected = TypeHelper.CreateListFor(relationship.DependentType);
+                            affected = TypeHelper.CreateListFor(relationship.RightType);
                             implicitlyAffected[relationship] = affected;
                         }
-                        ((IList)affected).AddRange(dbDependentEntityListCasted);
+                        ((IList)affected).AddRange(dbRightEntityListCasted);
                     }
                 }
             }
 
-            return implicitlyAffected.ToDictionary(kvp => kvp.Key, kvp => TypeHelper.CreateHashSetFor(kvp.Key.DependentType, kvp.Value));
+            return implicitlyAffected.ToDictionary(kvp => kvp.Key, kvp => TypeHelper.CreateHashSetFor(kvp.Key.RightType, kvp.Value));
 
         }
 

src/JsonApiDotNetCore/Hooks/Execution/IHookExecutorHelper.cs

@@ -37,7 +37,7 @@ internal interface IHookExecutorHelper
         /// Load the implicitly affected entities from the database for a given set of target target entities and involved relationships
         /// </summary>
         /// <returns>The implicitly affected entities by relationship</returns>
-        Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(Dictionary<RelationshipAttribute, IEnumerable> principalEntities, IEnumerable existingDependentEntities = null);
+        Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(Dictionary<RelationshipAttribute, IEnumerable> leftEntities, IEnumerable existingRightEntities = null);
 
         /// <summary>
         /// For a set of entities, loads current values from the database

src/JsonApiDotNetCore/Hooks/Execution/RelationshipsDictionary.cs

@@ -16,51 +16,51 @@ public interface IRelationshipsDictionary { }
     /// <summary>
     /// An interface that is implemented to expose a relationship dictionary on another class.
     /// </summary>
-    public interface IByAffectedRelationships<TDependentResource> :
-        IRelationshipGetters<TDependentResource> where TDependentResource : class, IIdentifiable
+    public interface IByAffectedRelationships<TRightResource> :
+        IRelationshipGetters<TRightResource> where TRightResource : class, IIdentifiable
     {
         /// <summary>
         /// Gets a dictionary of affected resources grouped by affected relationships.
         /// </summary>
-        Dictionary<RelationshipAttribute, HashSet<TDependentResource>> AffectedRelationships { get; }
+        Dictionary<RelationshipAttribute, HashSet<TRightResource>> AffectedRelationships { get; }
     }
 
     /// <summary>
     /// A helper class that provides insights in which relationships have been updated for which entities.
     /// </summary>
-    public interface IRelationshipsDictionary<TDependentResource> :
-        IRelationshipGetters<TDependentResource>,
-        IReadOnlyDictionary<RelationshipAttribute, HashSet<TDependentResource>>,
-        IRelationshipsDictionary where TDependentResource : class, IIdentifiable
+    public interface IRelationshipsDictionary<TRightResource> :
+        IRelationshipGetters<TRightResource>,
+        IReadOnlyDictionary<RelationshipAttribute, HashSet<TRightResource>>,
+        IRelationshipsDictionary where TRightResource : class, IIdentifiable
     { }
 
     /// <summary>
     /// A helper class that provides insights in which relationships have been updated for which entities.
     /// </summary>
-    public interface IRelationshipGetters<TResource> where TResource : class, IIdentifiable
+    public interface IRelationshipGetters<TLeftResource> where TLeftResource : class, IIdentifiable
     {
         /// <summary>
-        /// Gets a dictionary of all entities that have an affected relationship to type <typeparamref name="TPrincipalResource"/>
+        /// Gets a dictionary of all entities that have an affected relationship to type <typeparamref name="TLeftResource"/>
         /// </summary>
-        Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<TRelatedResource>() where TRelatedResource : class, IIdentifiable;
+        Dictionary<RelationshipAttribute, HashSet<TLeftResource>> GetByRelationship<TRightResource>() where TRightResource : class, IIdentifiable;
         /// <summary>
-        /// Gets a dictionary of all entities that have an affected relationship to type <paramref name="principalType"/>
+        /// Gets a dictionary of all entities that have an affected relationship to type <paramref name="relatedResourceType"/>
         /// </summary>
-        Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type relatedResourceType);
+        Dictionary<RelationshipAttribute, HashSet<TLeftResource>> GetByRelationship(Type relatedResourceType);
         /// <summary>
-        /// Gets a collection of all the entities for the property within <paramref name="NavigationAction"/>
+        /// Gets a collection of all the entities for the property within <paramref name="navigationAction"/>
         /// has been affected by the request
         /// </summary>
-        /// <param name="NavigationAction"></param>
-        HashSet<TResource> GetAffected(Expression<Func<TResource, object>> NavigationAction);
+        /// <param name="navigationAction"></param>
+        HashSet<TLeftResource> GetAffected(Expression<Func<TLeftResource, object>> navigationAction);
     }
 
 
     /// <summary>
-    /// Implementation of IAffectedRelationships{TDependentResource}
+    /// Implementation of IAffectedRelationships{TRightResource}
     /// 
-    /// It is practically a ReadOnlyDictionary{RelationshipAttribute, HashSet{TDependentResource}} dictionary
-    /// with the two helper methods defined on IAffectedRelationships{TDependentResource}.
+    /// It is practically a ReadOnlyDictionary{RelationshipAttribute, HashSet{TRightResource}} dictionary
+    /// with the two helper methods defined on IAffectedRelationships{TRightResource}.
     /// </summary>
     public class RelationshipsDictionary<TResource> :
         Dictionary<RelationshipAttribute, HashSet<TResource>>,