refactor(context): reduce responsibilities taken by Context, ClassContext, ExampleBase

sln/src/NSpec/Domain/ActChain.cs

@@ -0,0 +1,20 @@
+namespace NSpec.Domain
+{
+    public class ActChain : TraversingHookChain
+    {
+        protected override bool CanRun(nspec instance)
+        {
+            return context.BeforeAllChain.AnyThrew()
+                ? false
+                : !context.BeforeChain.AnyThrew();
+        }
+
+        public ActChain(Context context, Conventions conventions)
+            : base(context, "act", "actAsync", "act_each")
+        {
+            methodSelector = conventions.GetMethodLevelAct;
+            asyncMethodSelector = conventions.GetAsyncMethodLevelAct;
+            chainSelector = c => c.ActChain;
+        }
+    }
+}

sln/src/NSpec/Domain/AfterAllChain.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace NSpec.Domain
+{
+    public class AfterAllChain : HookChainBase
+    {
+        protected override bool CanRun(nspec instance)
+        {
+            return context.BeforeAllChain.AncestorsThrew()
+                ? false
+                : context.AnyUnfilteredExampleInSubTree(instance);
+        }
+
+        public bool AnyThrew()
+        {
+            return (AnyException() != null);
+        }
+
+        public override Exception AnyException()
+        {
+            // when hook chain is NOT traversed, build up exceptions along ancestor chain
+
+            // give precedence to Exception closer in the chain
+            return Exception ?? context.Parent?.AfterAllChain.AnyException();
+        }
+
+        public AfterAllChain(Context context, Conventions conventions)
+            : base(context, "afterAll", "afterAllAsync", "after_all", reversed: true)
+        {
+            methodSelector = conventions.GetMethodLevelAfterAll;
+            asyncMethodSelector = conventions.GetAsyncMethodLevelAfterAll;
+        }
+    }
+}

sln/src/NSpec/Domain/AfterChain.cs

@@ -0,0 +1,18 @@
+namespace NSpec.Domain
+{
+    public class AfterChain : TraversingHookChain
+    {
+        protected override bool CanRun(nspec instance)
+        {
+            return !context.BeforeAllChain.AnyThrew();
+        }
+
+        public AfterChain(Context context, Conventions conventions)
+            : base(context, "after", "afterAsync", "after_each", reversed: true)
+        {
+            methodSelector = conventions.GetMethodLevelAfter;
+            asyncMethodSelector = conventions.GetAsyncMethodLevelAfter;
+            chainSelector = c => c.AfterChain;
+        }
+    }
+}

sln/src/NSpec/Domain/AsyncActionRegister.cs

@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace NSpec.Domain

sln/src/NSpec/Domain/AsyncMethodLevelHooks.cs

@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
+using System.Reflection;
 
 namespace NSpec.Domain
 {

sln/src/NSpec/Domain/AsyncMismatchException.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace NSpec.Domain
 {

sln/src/NSpec/Domain/BeforeAllChain.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace NSpec.Domain
+{
+    public class BeforeAllChain : HookChainBase
+    {
+        protected override bool CanRun(nspec instance)
+        {
+            return AncestorsThrew()
+                ? false
+                : context.AnyUnfilteredExampleInSubTree(instance);
+        }
+
+        public bool AnyThrew()
+        {
+            return (Exception != null || AncestorsThrew());
+        }
+
+        public bool AncestorsThrew()
+        {
+            return (context.Parent?.BeforeAllChain.AnyThrew() ?? false);
+        }
+
+        public override Exception AnyException()
+        {
+            // when hook chain is NOT traversed, build up exceptions along ancestor chain
+
+            // give precedence to Exception farther up in the chain
+            return context.Parent?.BeforeAllChain.AnyException() ?? Exception;
+        }
+
+        public BeforeAllChain(Context context, Conventions conventions)
+            : base(context, "beforeAll", "beforeAllAsync", "before_all")
+        {
+            methodSelector = conventions.GetMethodLevelBeforeAll;
+            asyncMethodSelector = conventions.GetAsyncMethodLevelBeforeAll;
+        }
+    }
+}

sln/src/NSpec/Domain/BeforeChain.cs

@@ -0,0 +1,18 @@
+namespace NSpec.Domain
+{
+    public class BeforeChain : TraversingHookChain
+    {
+        protected override bool CanRun(nspec instance)
+        {
+            return !context.BeforeAllChain.AnyThrew();
+        }
+
+        public BeforeChain(Context context, Conventions conventions)
+            : base(context, "before", "beforeAsync", "before_each")
+        {
+            methodSelector = conventions.GetMethodLevelBefore;
+            asyncMethodSelector = conventions.GetAsyncMethodLevelBefore;
+            chainSelector = c => c.BeforeChain;
+        }
+    }
+}

sln/src/NSpec/Domain/ClassContext.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 using NSpec.Domain.Extensions;
 
@@ -10,15 +9,15 @@ public class ClassContext : Context
     {
         public override void Build(nspec unused = null)
         {
-            BuildMethodLevelBefore();
+            BeforeAllChain.BuildMethodLevel(classHierarchy);
 
-            BuildMethodLevelBeforeAll();
+            BeforeChain.BuildMethodLevel(classHierarchy);
 
-            BuildMethodLevelAct();
+            ActChain.BuildMethodLevel(classHierarchy);
 
-            BuildMethodLevelAfter();
+            AfterChain.BuildMethodLevel(classHierarchy);
 
-            BuildMethodLevelAfterAll();
+            AfterAllChain.BuildMethodLevel(classHierarchy);
 
             try
             {
@@ -46,96 +45,6 @@ public override bool IsSub(Type baseType)
             return baseType == SpecType;
         }
 
-        IEnumerable<MethodInfo> GetMethodsFromHierarchy(Func<Type, MethodInfo> methodAccessor)
-        {
-            return classHierarchyToClass.Select(methodAccessor).Where(mi => mi != null);
-        }
-
-        void BuildMethodLevelBefore()
-        {
-            var befores = GetMethodsFromHierarchy(conventions.GetMethodLevelBefore).ToList();
-
-            if (befores.Count > 0)
-            {
-                BeforeInstance = instance => befores.Do(b => b.Invoke(instance, null));
-            }
-
-            var asyncBefores = GetMethodsFromHierarchy(conventions.GetAsyncMethodLevelBefore).ToList();
-
-            if (asyncBefores.Count > 0)
-            {
-                BeforeInstanceAsync = instance => asyncBefores.Do(b => new AsyncMethodLevelBefore(b).Run(instance));
-            }
-        }
-
-        void BuildMethodLevelBeforeAll()
-        {
-            var beforeAlls = GetMethodsFromHierarchy(conventions.GetMethodLevelBeforeAll).ToList();
-
-            if (beforeAlls.Count > 0)
-            {
-                BeforeAllInstance = instance => beforeAlls.Do(a => a.Invoke(instance, null));
-            }
-
-            var asyncBeforeAlls = GetMethodsFromHierarchy(conventions.GetAsyncMethodLevelBeforeAll).ToList();
-
-            if (asyncBeforeAlls.Count > 0)
-            {
-                BeforeAllInstanceAsync = instance => asyncBeforeAlls.Do(b => new AsyncMethodLevelBeforeAll(b).Run(instance));
-            }
-        }
-
-        void BuildMethodLevelAct()
-        {
-            var acts = GetMethodsFromHierarchy(conventions.GetMethodLevelAct).ToList();
-
-            if (acts.Count > 0)
-            {
-                ActInstance = instance => acts.Do(a => a.Invoke(instance, null));
-            }
-
-            var asyncActs = GetMethodsFromHierarchy(conventions.GetAsyncMethodLevelAct).ToList();
-
-            if (asyncActs.Count > 0)
-            {
-                ActInstanceAsync = instance => asyncActs.Do(a => new AsyncMethodLevelAct(a).Run(instance));
-            }
-        }
-
-        void BuildMethodLevelAfter()
-        {
-            var afters = GetMethodsFromHierarchy(conventions.GetMethodLevelAfter).Reverse().ToList();
-
-            if (afters.Count > 0)
-            {
-                AfterInstance = instance => afters.Do(a => a.Invoke(instance, null));
-            }
-
-            var asyncAfters = GetMethodsFromHierarchy(conventions.GetAsyncMethodLevelAfter).Reverse().ToList();
-
-            if (asyncAfters.Count > 0)
-            {
-                AfterInstanceAsync = instance => asyncAfters.Do(a => new AsyncMethodLevelAfter(a).Run(instance));
-            }
-        }
-
-        void BuildMethodLevelAfterAll()
-        {
-            var afterAlls = GetMethodsFromHierarchy(conventions.GetMethodLevelAfterAll).Reverse().ToList();
-
-            if (afterAlls.Count > 0)
-            {
-                AfterAllInstance = instance => afterAlls.Do(a => a.Invoke(instance, null));
-            }
-
-            var asyncAfterAlls = GetMethodsFromHierarchy(conventions.GetAsyncMethodLevelAfterAll).Reverse().ToList();
-
-            if (asyncAfterAlls.Count > 0)
-            {
-                AfterAllInstanceAsync = instance => asyncAfterAlls.Do(a => new AsyncMethodLevelAfterAll(a).Run(instance));
-            }
-        }
-
         void AddFailingExample(Exception targetEx)
         {
             var reportedEx = (targetEx.InnerException != null)
@@ -149,6 +58,9 @@ void AddFailingExample(Exception targetEx)
 
             var failingExample = new Example(exampleName, action: emptyAction)
             {
+                // flag the one and only failing example as being run;
+                // nothing else is needed: no parents, no childs, no before/after hooks
+                HasRun = true,
                 Exception = new ContextBareCodeException(reportedEx),
             };
 
@@ -157,38 +69,29 @@ void AddFailingExample(Exception targetEx)
 
         public override void Run(bool failFast, nspec instance = null, bool recurse = true)
         {
-            if (cantCreateInstance)
-            {
-                // flag the one and only failing example as being run;
-                // nothing else is needed: no parents, no childs, no before/after hooks
-                Examples.Single().HasRun = true;
-            }
-            else
-            {
-                base.Run(failFast, instance, recurse);
-            }
+            if (cantCreateInstance) return;
+
+            base.Run(failFast, instance, recurse);
         }
 
         public ClassContext(Type type, Conventions conventions = null, Tags tagsFilter = null, string tags = null)
-            : base(type.CleanName(), tags)
+            : base(type.CleanName(), tags, false, conventions)
         {
             this.SpecType = type;
 
-            this.conventions = conventions ?? new DefaultConventions().Initialize();
-
             this.tagsFilter = tagsFilter;
 
-            if (type != typeof(nspec))
-            {
-                classHierarchyToClass.AddRange(type.GetAbstractBaseClassChainWithClass());
-            }
+            this.classHierarchy = (type == typeof(nspec))
+                ? new List<Type>()
+                : new List<Type>(type.GetAbstractBaseClassChainWithClass());
+
+            cantCreateInstance = false;
         }
 
         public Type SpecType;
 
         Tags tagsFilter;
-        List<Type> classHierarchyToClass = new List<Type>();
-        Conventions conventions;
-        bool cantCreateInstance = false;
+        List<Type> classHierarchy;
+        bool cantCreateInstance;
     }
 }