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>>,