Wrap the execution of a number of steps with before/after functions.

Unlike Reactor.Step.Around, this step doesn't need to run a nested Reactor instance, but instead can emit the steps directly into the parent Reactor.

Options

• before - a three-arity function that will be called before running any child steps.
• after - a three-arity function that will be called after running any emitted steps.
• allow_async? - a boolean indicating whether the emitted steps can be executed asynchronously or must remain within the current process.

Before function

The before function will be passed the following arguments:

1. arguments - the values of any step arguments needed by the group.
2. context - the Reactor context.
3. steps - the list of steps passed in the options.

This provides you the opportunity to modify the arguments, context and list of steps to be executed.

The successful return value should be {:ok, arguments, context, steps}. The returned arguments will be used to provide any input arguments to nested steps.

Example

def no_time_travel(arguments, context, steps) do
  steps = steps
    |> Enum.filter(&(&1.name == :program_time_circuits))

  arguments = arguments
    |> Map.delete(:destination_time)

  {:ok, arguments, context, steps}
end

After function

The after function will be called with a single argument; a map of the nested step results.

The successful return value should be {:ok, any} where any will be treated as the result of the group.

def find_current_year(results) do
  case Map.fetch(results, :time_circuits) do
    {:ok, %{present_time: present_time}} -> {:ok, present_time.year}
    _ -> {:error, "Unable to read the present time from the time circuits"}
  end
end