Merge branch 'patriksvensson-feature/GH-2094' into develop

* patriksvensson-feature/GH-2094:
  (GH-2094) Allow no dependecy exec of single task * fixes #2094

Author: devlead

src/Cake.Core.Tests/Fixtures/ScriptHostFixture.cs

@@ -49,7 +49,7 @@ public ScriptHostFixture()
             Context.Log.Returns(Log);
 
             Engine = Substitute.For<ICakeEngine>();
-            Engine.RunTargetAsync(Context, Arg.Any<IExecutionStrategy>(), Arg.Any<string>())
+            Engine.RunTargetAsync(Context, Arg.Any<IExecutionStrategy>(), Arg.Any<ExecutionSettings>())
                 .Returns(new CakeReport());
         }
 

src/Cake.Core.Tests/Unit/CakeEngineTests.cs

@@ -179,13 +179,17 @@ public void RegisterTaskTeardownAction<TData>(Action<ITaskTeardownContext, TData
         /// </summary>
         /// <param name="context">The context.</param>
         /// <param name="strategy">The execution strategy.</param>
-        /// <param name="target">The target to run.</param>
+        /// <param name="settings">The execution settings.</param>
         /// <returns>The resulting report.</returns>
-        public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStrategy strategy, string target)
+        public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStrategy strategy, ExecutionSettings settings)
         {
-            if (target == null)
+            if (settings == null)
             {
-                throw new ArgumentNullException(nameof(target));
+                throw new ArgumentNullException(nameof(settings));
+            }
+            if (string.IsNullOrWhiteSpace(settings.Target))
+            {
+                throw new ArgumentException("No target specified.", nameof(settings));
             }
 
             if (strategy == null)
@@ -200,6 +204,7 @@ public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStr
             var graph = CakeGraphBuilder.Build(_tasks);
 
             // Make sure target exist.
+            var target = settings.Target;
             if (!graph.Exist(target))
             {
                 const string format = "The target '{0}' was not found.";
@@ -228,26 +233,18 @@ public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStr
 
                 PerformSetup(strategy, context, targetNode, orderedTasks, stopWatch, report);
 
-                foreach (var task in orderedTasks)
+                if (settings.Exclusive)
                 {
-                    // Is this the current target?
-                    var isTarget = task.Name.Equals(target, StringComparison.OrdinalIgnoreCase);
-
-                    // Should we execute the task?
-                    var skipped = false;
-                    foreach (var criteria in task.Criterias)
-                    {
-                        if (!ShouldTaskExecute(context, task, criteria, isTarget))
-                        {
-                            SkipTask(context, strategy, task, report, criteria);
-                            skipped = true;
-                            break;
-                        }
-                    }
-
-                    if (!skipped)
+                    // Execute only the target task.
+                    var task = _tasks.FirstOrDefault(x => x.Name.Equals(settings.Target, StringComparison.OrdinalIgnoreCase));
+                    await RunTask(context, strategy, task, target, stopWatch, report);
+                }
+                else
+                {
+                    // Execute all scheduled tasks.
+                    foreach (var task in orderedTasks)
                     {
-                        await ExecuteTaskAsync(context, strategy, stopWatch, task, report).ConfigureAwait(false);
+                        await RunTask(context, strategy, task, target, stopWatch, report);
                     }
                 }
 
@@ -265,6 +262,29 @@ public async Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStr
             }
         }
 
+        private async Task RunTask(ICakeContext context, IExecutionStrategy strategy, CakeTask task, string target, Stopwatch stopWatch, CakeReport report)
+        {
+            // Is this the current target?
+            var isTarget = task.Name.Equals(target, StringComparison.OrdinalIgnoreCase);
+
+            // Should we execute the task?
+            var skipped = false;
+            foreach (var criteria in task.Criterias)
+            {
+                if (!ShouldTaskExecute(context, task, criteria, isTarget))
+                {
+                    SkipTask(context, strategy, task, report, criteria);
+                    skipped = true;
+                    break;
+                }
+            }
+
+            if (!skipped)
+            {
+                await ExecuteTaskAsync(context, strategy, stopWatch, task, report).ConfigureAwait(false);
+            }
+        }
+
         private void PerformSetup(IExecutionStrategy strategy, ICakeContext context, CakeTask targetTask,
             CakeTask[] tasks, Stopwatch stopWatch, CakeReport report)
         {
@@ -283,8 +303,7 @@ private void PerformSetup(IExecutionStrategy strategy, ICakeContext context, Cak
             }
         }
 
-        private static bool ShouldTaskExecute(ICakeContext context, CakeTask task, CakeTaskCriteria criteria,
-            bool isTarget)
+        private static bool ShouldTaskExecute(ICakeContext context, CakeTask task, CakeTaskCriteria criteria, bool isTarget)
         {
             if (!criteria.Predicate(context))
             {

src/Cake.Core/CakeEngine.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Cake.Core
+{
+    /// <summary>
+    /// Contains settings related to execution of the script.
+    /// </summary>
+    public sealed class ExecutionSettings
+    {
+        /// <summary>
+        /// Gets the target to be executed.
+        /// </summary>
+        public string Target { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether or not to use the target exclusively.
+        /// </summary>
+        public bool Exclusive { get; private set; }
+
+        /// <summary>
+        /// Sets the target to be executed.
+        /// </summary>
+        /// <param name="target">The target.</param>
+        /// <returns>The same <see cref="ExecutionSettings"/> instance so that multiple calls can be chained.</returns>
+        public ExecutionSettings SetTarget(string target)
+        {
+            Target = target;
+            return this;
+        }
+
+        /// <summary>
+        /// Whether or not to use the target exclusively.
+        /// </summary>
+        /// <returns>The same <see cref="ExecutionSettings"/> instance so that multiple calls can be chained.</returns>
+        public ExecutionSettings UseExclusiveTarget()
+        {
+            Exclusive = true;
+            return this;
+        }
+    }
+}

src/Cake.Core/ExecutionSettings.cs

@@ -81,9 +81,9 @@ public interface ICakeEngine
         /// </summary>
         /// <param name="context">The context.</param>
         /// <param name="strategy">The execution strategy.</param>
-        /// <param name="target">The target to run.</param>
+        /// <param name="settings">The execution settings.</param>
         /// <returns>The resulting report.</returns>
-        Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStrategy strategy, string target);
+        Task<CakeReport> RunTargetAsync(ICakeContext context, IExecutionStrategy strategy, ExecutionSettings settings);
 
         /// <summary>
         /// Allows registration of an action that's executed before each task is run.

src/Cake.Core/ICakeEngine.cs

@@ -26,6 +26,12 @@ public abstract class ScriptHost : IScriptHost
         /// <value>The context.</value>
         public ICakeContext Context { get; }
 
+        /// <summary>
+        /// Gets the settings.
+        /// </summary>
+        /// <value>The settings.</value>
+        public ExecutionSettings Settings { get; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ScriptHost"/> class.
         /// </summary>
@@ -43,6 +49,7 @@ protected ScriptHost(ICakeEngine engine, ICakeContext context)
             }
             Engine = engine;
             Context = context;
+            Settings = new ExecutionSettings();
         }
 
         /// <summary>

src/Cake.Core/Scripting/ScriptHost.cs

@@ -580,6 +580,23 @@ public void Can_Parse_Bootstrap(string input, bool expected)
                     // Then
                     Assert.Equal(expected, result.Bootstrap);
                 }
+
+                [Theory]
+                [InlineData("--exclusive", true)]
+                [InlineData("--exclusive=true", true)]
+                [InlineData("--exclusive=false", false)]
+                public void Can_Parse_Exclusive(string input, bool expected)
+                {
+                    // Given
+                    var fixture = new ArgumentParserFixture();
+                    var parser = new ArgumentParser(fixture.Log, fixture.VerbosityParser);
+
+                    // When
+                    var result = parser.Parse(new[] { "build.cake", input });
+
+                    // Then
+                    Assert.Equal(expected, result.Exclusive);
+                }
             }
         }
     }

src/Cake.Tests/Unit/Arguments/ArgumentParserTests.cs

@@ -30,22 +30,26 @@ public async Task Should_Proxy_Call_To_Engine()
                 host.RunTarget("Target");
 
                 // Then
-                await engine.Received(1).RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), "Target");
+                await engine.Received(1).RunTargetAsync(context,
+                    Arg.Any<DefaultExecutionStrategy>(),
+                    Arg.Is<ExecutionSettings>(e => e.Target == "Target"));
             }
 
             [Fact]
             public async Task Should_Print_Report()
             {
                 // Given
                 var report = new CakeReport();
-                report.Add("Target", TimeSpan.FromSeconds(1));
                 var engine = Substitute.For<ICakeEngine>();
                 var context = Substitute.For<ICakeContext>();
-                engine.RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), "Target").Returns(Task.FromResult(report));
                 var printer = Substitute.For<ICakeReportPrinter>();
                 var log = Substitute.For<ICakeLog>();
                 var host = new BuildScriptHost(engine, context, printer, log);
 
+                report.Add("Target", TimeSpan.FromSeconds(1));
+                engine.RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), Arg.Any<ExecutionSettings>())
+                    .Returns(Task.FromResult(report));
+
                 // When
                 await host.RunTargetAsync("Target");
 
@@ -59,11 +63,13 @@ public async Task Should_Not_Print_Report_That_Is_Null()
                 // Given
                 var engine = Substitute.For<ICakeEngine>();
                 var context = Substitute.For<ICakeContext>();
-                engine.RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), Arg.Any<string>()).Returns(Task.FromResult((CakeReport)null));
                 var printer = Substitute.For<ICakeReportPrinter>();
                 var log = Substitute.For<ICakeLog>();
                 var host = new BuildScriptHost(engine, context, printer, log);
 
+                engine.RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), Arg.Any<ExecutionSettings>())
+                    .Returns(Task.FromResult((CakeReport)null));
+
                 // When
                 await host.RunTargetAsync("Target");
 
@@ -77,11 +83,13 @@ public async Task Should_Not_Print_Empty_Report()
                 // Given
                 var engine = Substitute.For<ICakeEngine>();
                 var context = Substitute.For<ICakeContext>();
-                engine.RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), Arg.Any<string>()).Returns(Task.FromResult(new CakeReport()));
                 var printer = Substitute.For<ICakeReportPrinter>();
                 var log = Substitute.For<ICakeLog>();
                 var host = new BuildScriptHost(engine, context, printer, log);
 
+                engine.RunTargetAsync(context, Arg.Any<DefaultExecutionStrategy>(), Arg.Any<ExecutionSettings>())
+                    .Returns(Task.FromResult(new CakeReport()));
+
                 // When
                 await host.RunTargetAsync("Target");
 

src/Cake.Tests/Unit/Scripting/BuildScriptHostTests.cs

@@ -75,7 +75,7 @@ public async Task Should_Not_Call_To_Engine()
                 await engine.Received(0).RunTargetAsync(
                     context,
                     Arg.Any<DefaultExecutionStrategy>(),
-                    "Target");
+                    Arg.Is<ExecutionSettings>(e => e.Target == "Target"));
             }
         }
     }

src/Cake.Tests/Unit/Scripting/DescriptionScriptHostTests.cs

@@ -72,7 +72,9 @@ public void Should_Invoke_The_Engine_With_Correct_Execution_Strategy()
                 host.RunTarget("TheTarget");
 
                 // Then
-                engine.Received(1).RunTargetAsync(context, Arg.Any<DryRunExecutionStrategy>(), "TheTarget");
+                engine.Received(1).RunTargetAsync(context,
+                    Arg.Any<DryRunExecutionStrategy>(),
+                    Arg.Is<ExecutionSettings>(e => e.Target == "TheTarget"));
             }
         }
     }