both single and collection filters referencing two entities each in one test. tree reordering is done. closes #6 readme update pending.

Author: repinvv

TestingContext/Implementation/Dependencies/CollectionDependency.cs

@@ -13,18 +13,17 @@ public CollectionDependency(Definition definition)
             Definition = definition;
         }
 
-        public IEnumerable<TItem> GetValue(IResolutionContext context, NodeResolver resolver)
+        public IEnumerable<TItem> GetValue(IResolutionContext context)
         {
-            return resolver.ResolveCollection(Definition, context)
-                           .Where(x => x.MeetsConditions)
+            return context.Get(Definition)
                            .Distinct()
                            .Cast<IResolutionContext<TItem>>()
                            .Select(x => x.Value);
         }
 
-        public bool TryGetValue(IResolutionContext context, NodeResolver resolver, out IEnumerable<TItem> value)
+        public bool TryGetValue(IResolutionContext context, out IEnumerable<TItem> value)
         {
-            value = GetValue(context, resolver);
+            value = GetValue(context);
             return true;
         }
 

TestingContext/Implementation/Dependencies/IDependency.cs

@@ -12,6 +12,6 @@ internal interface IDependency
 
     internal interface IDependency<TSource> : IDependency
     {
-        bool TryGetValue(IResolutionContext context, NodeResolver resolver, out TSource value);
+        bool TryGetValue(IResolutionContext context, out TSource value);
     }
 }

TestingContext/Implementation/Dependencies/SingleDependency.cs

@@ -11,7 +11,7 @@ public SingleDependency(Definition definition)
             Definition = definition;
         }
 
-        public bool TryGetValue(IResolutionContext context, NodeResolver resolver, out TSource value)
+        public bool TryGetValue(IResolutionContext context, out TSource value)
         {
             var definedcontext = context.ResolveSingle(Definition) as IResolutionContext<TSource>;
             value = definedcontext.Value;

TestingContext/Implementation/Filters/Filter1.cs

@@ -32,7 +32,7 @@ public bool MeetsCondition(IResolutionContext context, NodeResolver resolver, ou
             T1 argument;
             failureWeight = EmptyArray;
             failure = this;
-            if (!dependency.TryGetValue(context, resolver, out argument))
+            if (!dependency.TryGetValue(context, out argument))
             {
                 return false;
             }

TestingContext/Implementation/Filters/Filter2.cs

@@ -36,7 +36,7 @@ public bool MeetsCondition(IResolutionContext context, NodeResolver resolver, ou
             failureWeight = EmptyArray;
             failure = this;
 
-            if (!dependency1.TryGetValue(context, resolver, out argument1) || !dependency2.TryGetValue(context, resolver, out argument2))
+            if (!dependency1.TryGetValue(context, out argument1) || !dependency2.TryGetValue(context, out argument2))
             {
                 return false;
             }

TestingContext/Implementation/ProhibitedRelation.cs

@@ -25,7 +25,7 @@ public Provider(IDependency<TSource> dependency,
         public IEnumerable<IResolutionContext> Resolve(IResolutionContext parentContext, INode node)
         {
             TSource sourceValue;
-            if (!dependency.TryGetValue(parentContext, node.Resolver, out sourceValue))
+            if (!dependency.TryGetValue(parentContext, out sourceValue))
             {
                 return Enumerable.Empty<IResolutionContext>();
             }

TestingContext/Implementation/Providers/Provider.cs

@@ -20,7 +20,7 @@ public Node(Tree tree, Definition definition, IProvider provider, NodeFilters fi
 
         public INode SourceParent { get; set; }
 
-        public bool IsChildOf(INode node) =>  Parent == node || Parent.IsChildOf(node);
+        public bool IsChildOf(INode node) => Parent == node || Parent.IsChildOf(node);
 
         public List<INode> GetParentalChain()
         {

TestingContext/Implementation/TreeOperation/Nodes/Node.cs

@@ -15,54 +15,29 @@ public static void ReorderNodesForFilter(Tree tree, IFilter filter)
             {
                 for (int j = i + 1; j < filter.Dependencies.Length; j++)
                 {
-                    if (!ReorderNodesForDependencies(tree, filter.Dependencies[i], filter.Dependencies[j]))
-                    {
-                        throw new ResolutionException($"Filter implies chaining of entities, that is not allowed by other filters. " +
-                                                      $"This filter makes graph that was not successfully resolved." +
-                                                      $"{filter.Key} {filter.FilterString} ");
-                    }
+                    ReorderNodesForDependencies(tree, filter.Dependencies[i], filter.Dependencies[j]);
                 }
             }
         }
 
-        private static bool ReorderNodesForDependencies(Tree tree, IDependency dep1, IDependency dep2)
+        private static void ReorderNodesForDependencies(Tree tree, IDependency dep1, IDependency dep2)
         {
             if (dep1.Definition == dep2.Definition || dep1.IsCollectionDependency || dep2.IsCollectionDependency)
             {
-                return true;
+                return;
             }
 
             var node1 = tree.Nodes[dep1.Definition];
             var node2 = tree.Nodes[dep2.Definition];
             if (node1.IsChildOf(node2) || node2.IsChildOf(node1))
             {
-                return true;
+                return;
             }
 
             var chain1 = node1.GetParentalChain();
             var chain2 = node2.GetParentalChain();
             var closestParentIndex = FindClosestParent(chain1, chain2);
-            var chained = ChainUpNodes(tree, chain1[closestParentIndex + 1], node2);
-            chained = chained || ChainUpNodes(tree, chain1[closestParentIndex + 1], node2);
-            return chained;
-        }
-
-        private static bool ChainUpNodes(Tree tree, INode node, INode newParent)
-        {
-            if (!ChainUpIsValid(tree, node, newParent))
-            {
-                return false;
-            }
-
-            node.Parent = newParent;
-            return true;
-        }
-
-        private static bool ChainUpIsValid(Tree tree, INode node, INode newParent)
-        {
-            return !tree.ProhibitedRelations
-                        .Where(prohibitedRelation => prohibitedRelation.Child.IsChildOf(node))
-                        .Any(prohibitedRelation => newParent.IsChildOf(prohibitedRelation.Parent));
+            chain1[closestParentIndex + 1].Parent = node2;
         }
     }
 }