Isolated pipelines can now be dependencies

statiqdev · Sep 25, 2019 · 47586eb · 47586eb
1 parent b4284fb
commit 47586eb
Show file tree

Hide file tree

Showing 6 changed files with 16 additions and 37 deletions.
diff --git a/RELEASE.md b/RELEASE.md
@@ -1,9 +1,10 @@
 # 1.0.0-alpha.4
 
 - Updated to .NET Core 3.0 final
-- Renames delegate-based `IBootstrapper.AddSettings()` overload to `IBoostrapper.ConfigureSettings()`
-- Renames `IBootstrapper.AddServices()` to `IBoostrapper.ConfigureServices()`
-- Adds `IBootstrapper.ConfigureEngine()`
+- Isolated pipelines can now be dependencies of other pipelines (but output documents still can't be accessed).
+- Renames delegate-based `IBootstrapper.AddSettings()` overload to `IBoostrapper.ConfigureSettings()`.
+- Renames `IBootstrapper.AddServices()` to `IBoostrapper.ConfigureServices()`.
+- Adds `IBootstrapper.ConfigureEngine()`.
 - Adds a `StartProcess` module to start a process and create a document from it's output or run it in the background.
 - The bootstrapper now adds environment variables to the settings by default with ALL_CAPS keys.
 - Any setting with an ALL_CAPS key is masked during debug output on startup.

diff --git a/src/core/Statiq.App/PipelineBuilder.cs b/src/core/Statiq.App/PipelineBuilder.cs
@@ -197,9 +197,9 @@ public PipelineBuilder WithManualTrigger()
             return this;
         }
 
-        public PipelineBuilder WithDependencyTrigger()
+        public PipelineBuilder WithManualOrDependencyTrigger()
         {
-            _actions.Add(x => x.WithDependencyTrigger());
+            _actions.Add(x => x.WithManualOrDependencyTrigger());
             return this;
         }
 

diff --git a/src/core/Statiq.Common/Execution/IPipelineExtensions.cs b/src/core/Statiq.Common/Execution/IPipelineExtensions.cs
@@ -95,10 +95,10 @@ public static TPipeline WithManualTrigger<TPipeline>(this TPipeline pipeline)
             return pipeline;
         }
 
-        public static TPipeline WithDependencyTrigger<TPipeline>(this TPipeline pipeline)
+        public static TPipeline WithManualOrDependencyTrigger<TPipeline>(this TPipeline pipeline)
             where TPipeline : IPipeline
         {
-            pipeline.Trigger = PipelineTrigger.Dependency;
+            pipeline.Trigger = PipelineTrigger.ManualOrDependency;
             return pipeline;
         }
 

diff --git a/src/core/Statiq.Common/Execution/PipelineTrigger.cs b/src/core/Statiq.Common/Execution/PipelineTrigger.cs
@@ -23,10 +23,7 @@ public enum PipelineTrigger
         /// The pipeline is not normally executed unless explicitly specified
         /// or as a dependency of an executing pipeline.
         /// </summary>
-        /// <remarks>
-        /// Pipelines triggered by a dependency can also be triggered manually.
-        /// </remarks>
-        Dependency,
+        ManualOrDependency,
 
         /// <summary>
         /// The pipeline is always executed, regardless of explicitly specified pipelines.

diff --git a/src/core/Statiq.Core/Execution/Engine.cs b/src/core/Statiq.Core/Execution/Engine.cs
@@ -464,15 +464,15 @@ PipelinePhases Visit(string name, IPipeline pipeline)
                             {
                                 throw new PipelineException($"Could not find pipeline dependency {dependencyName} of {name}");
                             }
-                            if (dependency.Isolated)
-                            {
-                                throw new PipelineException($"Pipeline {name} can not have dependency on isolated pipeline {dependencyName}");
-                            }
                             if (dependency.Trigger == PipelineTrigger.Manual)
                             {
                                 throw new PipelineException($"Pipeline {name} can not have dependency on manually triggered pipeline {dependencyName}");
                             }
-                            processDependencies.Add(Visit(dependencyName, dependency).Process);
+                            if (!dependency.Isolated)
+                            {
+                                // Only add the phase dependency if the dependency is not isolated
+                                processDependencies.Add(Visit(dependencyName, dependency).Process);
+                            }
                         }
                     }
 

diff --git a/tests/core/Statiq.Core.Tests/Execution/EngineFixture.cs b/tests/core/Statiq.Core.Tests/Execution/EngineFixture.cs
@@ -92,11 +92,11 @@ private Engine GetEngine()
                 });
                 engine.Pipelines.Add("C", new TestPipeline
                 {
-                    Trigger = PipelineTrigger.Dependency
+                    Trigger = PipelineTrigger.ManualOrDependency
                 });
                 engine.Pipelines.Add("D", new TestPipeline
                 {
-                    Trigger = PipelineTrigger.Dependency,
+                    Trigger = PipelineTrigger.ManualOrDependency,
                     Dependencies = new HashSet<string>(new[] { "A" })
                 });
                 engine.Pipelines.Add("E", new TestPipeline
@@ -184,25 +184,6 @@ public void ThrowsForCyclicDependency()
                 Should.Throw<PipelineException>(() => Engine.GetPipelinePhases(pipelines, logger));
             }
 
-            [Test]
-            public void ThrowsForIsolatedDependency()
-            {
-                // Given
-                IPipelineCollection pipelines = new TestPipelineCollection();
-                pipelines.Add("Bar", new TestPipeline
-                {
-                    Isolated = true
-                });
-                pipelines.Add("Foo", new TestPipeline
-                {
-                    Dependencies = new HashSet<string>(new[] { "Bar" })
-                });
-                TestLogger logger = new TestLogger();
-
-                // When, Then
-                Should.Throw<PipelineException>(() => Engine.GetPipelinePhases(pipelines, logger));
-            }
-
             [Test]
             public void ThrowsForManualDependency()
             {