/// <summary>
/// Adds an action to be executed foreach item returned by the items function.
/// This method will be executed the first time the task is executed.
/// </summary>
/// <typeparam name="TData">The type of the data context.</typeparam>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="itemsFunc">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder DoesForEach <TData, TItem>(CakeTaskBuilder builder, Func <TData, ICakeContext, IEnumerable <TItem> > itemsFunc, Action <TItem> action)
where TData : class
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(DoesForEach(builder, context => itemsFunc(context.Data.Get <TData>(), context), (item, context) =>
{
action(item);
}));
}
/// <summary>
/// Adds a criteria that has to be fulfilled for the task to run.
/// The criteria is evaluated when traversal of the graph occurs.
/// </summary>
/// <typeparam name="TData">The type of the data context.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="criteria">The criteria.</param>
/// <param name="message">The message to display if the task was skipped due to the provided criteria.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder WithCriteria <TData>(this CakeTaskBuilder builder, Func <ICakeContext, TData, bool> criteria, string message) where TData : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Target.AddCriteria(
context => criteria(context, context.Data.Get <TData>()),
message);
return(builder);
}
/// <summary>
/// Adds an action to be executed foreach item in the list.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="items">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder{ActionTask}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <ActionTask> DoesForEach <TItem>(this CakeTaskBuilder <ActionTask> builder, IEnumerable <TItem> items, Action <TItem, ICakeContext> action)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
foreach (var item in items)
{
builder.Task.AddAction(context => action(item, context));
}
return(builder);
}
/// <summary>
/// Adds an action to be executed foreach item returned by the items function.
/// This method will be executed the first time the task is executed.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="itemsFunc">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder DoesForEach <TItem>(this CakeTaskBuilder builder, Func <IEnumerable <TItem> > itemsFunc, Action <TItem, ICakeContext> action)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(DoesForEach(builder, context => itemsFunc(), action));
}
/// <summary>
/// Creates a dependency between two tasks.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <param name="other">The name of the dependent task.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder IsDependentOn(this CakeTaskBuilder builder, CakeTaskBuilder other)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
builder.Target.AddDependency(other.Target.Name);
return(builder);
}
/// <summary>
/// Adds a criteria that has to be fulfilled for the task to run.
/// The criteria is evaluated when traversal of the graph occurs.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <param name="criteria">The criteria.</param>
/// <param name="message">The message to display if the task was skipped due to the provided criteria.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder WithCriteria(this CakeTaskBuilder builder, Func <bool> criteria, string message)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
builder.Target.AddCriteria(_ => criteria(), message);
return(builder);
}
/// <summary>
/// Adds an action to be executed when the task is invoked.
/// </summary>
/// <typeparam name="TData">The type of the data context.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder Does <TData>(this CakeTaskBuilder builder, Action <ICakeContext, TData> action)
where TData : class
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(Does(builder, context =>
{
var data = context.Data.Get <TData>();
action(context, data);
}));
}
/// <summary>
/// Adds an action to be executed foreach item returned by the items function.
/// This method will be executed the first time the task is executed.
/// </summary>
/// <typeparam name="TData">The type of the data context.</typeparam>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="itemsFunc">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder DoesForEach <TData, TItem>(this CakeTaskBuilder builder, Func <IEnumerable <TItem> > itemsFunc, Action <TData, TItem, ICakeContext> action)
where TData : class
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
return(DoesForEach(builder, itemsFunc, (item, context) =>
{
var data = context.Data.Get <TData>();
action(data, item, context);
}));
}
/// <summary>
/// Adds an action to be executed when the task is invoked.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder{ActionTask}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <ActionTask> Does(this CakeTaskBuilder <ActionTask> builder, Action <ICakeContext> action)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Task.AddAction(x =>
{
action(x);
return(Task.CompletedTask);
});
return(builder);
}
/// <summary>
/// Adds a criteria that has to be fulfilled for the task to run.
/// The criteria is evaluated when traversal of the graph occurs.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <param name="criteria">The criteria.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder WithCriteria(this CakeTaskBuilder builder, Func <ICakeContext, bool> criteria)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
builder.Target.AddCriteria(criteria);
return(builder);
}
/// <summary>
/// Adds an action to be executed when the task is invoked.
/// </summary>
/// <typeparam name="TData">The type of the data context.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="func">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder Does <TData>(this CakeTaskBuilder builder, Func <ICakeContext, TData, Task> func)
where TData : class
{
if (func == null)
{
throw new ArgumentNullException(nameof(func));
}
return(Does(builder, context =>
{
var data = context.Data.Get <TData>();
return func(context, data);
}));
}
/// <summary>
/// Adds an action to be executed when the task is invoked.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <param name="func">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder Does(this CakeTaskBuilder builder, Func <ICakeContext, Task> func)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (func == null)
{
throw new ArgumentNullException(nameof(func));
}
builder.Target.AddAction(func);
return(builder);
}
/// <summary>
/// Creates a dependency between two tasks.
/// </summary>
/// <typeparam name="T">The task type.</typeparam>
/// <typeparam name="TOther">The task type that this task depends on.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="other">The name of the dependent task.</param>
/// <returns>The same <see cref="CakeTaskBuilder{T}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <T> IsDependentOn <T, TOther>(this CakeTaskBuilder <T> builder, CakeTaskBuilder <TOther> other)
where T : CakeTask
where TOther : CakeTask
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
builder.Task.AddDependency(other.Task.Name);
return(builder);
}
/// <summary>
/// Adds an action to be executed foreach item returned by the items function.
/// This method will be executed the first time the task is executed.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="itemsFunc">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder{ActionTask}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <ActionTask> DoesForEach <TItem>(this CakeTaskBuilder <ActionTask> builder, Func <IEnumerable <TItem> > itemsFunc, Action <TItem, ICakeContext> action)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Task.AddDelayedAction(() =>
{
foreach (var item in itemsFunc())
{
builder.Task.AddAction(context => action(item, context));
}
});
return(builder);
}
/// <summary>
/// Adds an action to be executed when the task is invoked.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder Does(this CakeTaskBuilder builder, Action <ICakeContext> action)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
builder.Target.AddAction(context =>
{
action(context);
return(Task.CompletedTask);
});
return(builder);
}
/// <summary>
/// Adds an action to be executed foreach item in the list.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="items">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder DoesForEach <TItem>(this CakeTaskBuilder builder, IEnumerable <TItem> items, Action <TItem, ICakeContext> action)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
foreach (var item in items)
{
builder.Target.AddAction(context =>
{
action(item, context);
return(Task.CompletedTask);
});
}
return(builder);
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <typeparam name="TData">The extra data to operate with inside the error handler.</typeparam>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder OnError <TData>(this CakeTaskBuilder builder, Action <Exception, TData> errorHandler) where TData : class
{
return(OnError <TData>(builder, (exception, _, data) => errorHandler(exception, data)));
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <typeparam name="T">The task type.</typeparam>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <returns>The same <see cref="CakeTaskBuilder{T}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <T> OnError <T>(this CakeTaskBuilder <T> builder, Action errorHandler)
where T : CakeTask
{
return(OnError(builder, exception => errorHandler()));
}
/// <summary>
/// Adds an indication to the task that a thrown exception will not halt the script execution.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <returns>The same <see cref="CakeTaskBuilder{ActionTask}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <ActionTask> ContinueOnError(this CakeTaskBuilder <ActionTask> builder)
{
return(OnError(builder, () => { }));
}
/// <summary>
/// Adds an action to be executed foreach item returned by the items function.
/// This method will be executed the first time the task is executed.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="itemsFunc">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder{ActionTask}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <ActionTask> DoesForEach <TItem>(this CakeTaskBuilder <ActionTask> builder, Func <IEnumerable <TItem> > itemsFunc, Action <TItem> action)
{
return(DoesForEach(builder, itemsFunc, (i, c) => action(i)));
}
/// <summary>
/// Adds an action to be executed foreach item in the list.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="builder">The task builder.</param>
/// <param name="items">The items.</param>
/// <param name="action">The action.</param>
/// <returns>The same <see cref="CakeTaskBuilder{ActionTask}"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder <ActionTask> DoesForEach <TItem>(this CakeTaskBuilder <ActionTask> builder, IEnumerable <TItem> items, Action <TItem> action)
{
return(DoesForEach(builder, items, (item, context) => action(item)));
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <typeparam name="TData">The extra data to operate with inside the error handler.</typeparam>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder OnError <TData>(this CakeTaskBuilder builder, Action <Exception, ICakeContext, TData> errorHandler) where TData : class
{
return(OnError(builder, (exception, context) => errorHandler(exception, context, context.Data.Get <TData>())));
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <typeparam name="TData">The extra data to operate with inside the error handler.</typeparam>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder OnError <TData>(this CakeTaskBuilder builder, Func <Exception, ICakeContext, TData, Task> errorHandler) where TData : class
{
return(OnError(builder, async(exception, context) => await errorHandler(exception, context, context.Data.Get <TData>())));
}
/// <summary>
/// Adds an indication to the task that a thrown exception will not halt the script execution.
/// </summary>
/// <param name="builder">The task builder.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder ContinueOnError(this CakeTaskBuilder builder)
{
return(OnError(builder, () => { }));
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <typeparam name="TData">The extra data to operate with inside the error handler.</typeparam>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder OnError <TData>(this CakeTaskBuilder builder, Func <Exception, TData, Task> errorHandler) where TData : class
{
return(OnError <TData>(builder, async(exception, _, data) => await errorHandler(exception, data)));
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder OnError(this CakeTaskBuilder builder, Action errorHandler)
{
return(OnError(builder, exception => errorHandler()));
}
/// <summary>
/// Adds an error handler to be executed if an exception occurs in the task.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="errorHandler">The error handler.</param>
/// <returns>The same <see cref="CakeTaskBuilder"/> instance so that multiple calls can be chained.</returns>
public static CakeTaskBuilder OnError(this CakeTaskBuilder builder, Action <Exception> errorHandler)
{
return(OnError(builder, (exception, _) => errorHandler(exception)));
}
