/// <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))); }