Ejemplo n.º 1
0
        /// <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);
        }
Ejemplo n.º 3
0
        /// <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);
        }
Ejemplo n.º 4
0
        /// <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);
        }
Ejemplo n.º 6
0
        /// <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);
        }
Ejemplo n.º 7
0
        /// <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);
            }));
        }
Ejemplo n.º 8
0
        /// <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);
            }));
        }
Ejemplo n.º 9
0
        /// <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);
        }
Ejemplo n.º 10
0
        /// <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);
        }
Ejemplo n.º 11
0
        /// <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);
            }));
        }
Ejemplo n.º 12
0
        /// <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);
        }
Ejemplo n.º 13
0
        /// <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);
        }
Ejemplo n.º 14
0
        /// <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);
        }
Ejemplo n.º 15
0
        /// <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);
        }
Ejemplo n.º 16
0
        /// <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);
        }
Ejemplo n.º 17
0
 /// <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)));
 }
Ejemplo n.º 18
0
 /// <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()));
 }
Ejemplo n.º 19
0
 /// <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, () => { }));
 }
Ejemplo n.º 20
0
 /// <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)));
 }
Ejemplo n.º 21
0
 /// <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)));
 }
Ejemplo n.º 22
0
 /// <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>())));
 }
Ejemplo n.º 23
0
 /// <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>())));
 }
Ejemplo n.º 24
0
 /// <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, () => { }));
 }
Ejemplo n.º 25
0
 /// <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)));
 }
Ejemplo n.º 26
0
 /// <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()));
 }
Ejemplo n.º 27
0
 /// <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)));
 }