Class: Vagrant::Action::Builtin::Call

Inherits:
Object
  • Object
show all
Defined in:
lib/vagrant/action/builtin/call.rb

Overview

This middleware class allows a sort of "conditional" run within a single middlware sequence. It takes another middleware runnable, runs it with the same environment, then yields the resulting env to a block, allowing that block to determine the next course of action in the middleware sequence.

The first argument to this middleware sequence is anywhere middleware runnable, whether it be a class, lambda, or something else that responds to call. This middleware runnable is run with the same environment as this class.

After running, Call takes the environment and yields it to a block given to initialize the class, along with an instance of Vagrant::Action::Builder. The result is used to build up a new sequence on the given builder. This builder is then run.

Instance Method Summary collapse

Constructor Details

#initialize(app, env, callable, *callable_args) {|result, builder| ... } ⇒ Call

For documentation, read the description of the Vagrant::Action::Builtin::Call class.

Parameters:

  • callable (Object)

    A valid middleware runnable object. This can be a class, a lambda, or an object that responds to call.

Yields:

  • (result, builder)

    This block is expected to build on builder which is the next middleware sequence that will be run.

Raises:

  • (ArgumentError)

26
27
28
29
30
31
32
33
34
# File 'lib/vagrant/action/builtin/call.rb', line 26

def initialize(app, env, callable, *callable_args, &block)
  raise ArgumentError, "A block must be given to Call" if !block

  @app      = app
  @callable = callable
  @callable_args = callable_args
  @block    = block
  @child_app = nil
end

Instance Method Details

#call(env) ⇒ Object


36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# File 'lib/vagrant/action/builtin/call.rb', line 36

def call(env)
  runner  = Runner.new

  # Build the callable that we'll run
  callable = Builder.build(@callable, *@callable_args)

  # Run our callable with our environment
  new_env = runner.run(callable, env)

  # Build our new builder based on the result
  builder = Builder.new
  @block.call(new_env, builder)

  # Append our own app onto the builder so we slide the new
  # stack into our own chain...
  builder.use @app
  @child_app = builder.to_app(new_env)
  final_env  = runner.run(@child_app, new_env)

  # Merge the environment into our original environment
  env.merge!(final_env)
end

#recover(env) ⇒ Object


59
60
61
62
# File 'lib/vagrant/action/builtin/call.rb', line 59

def recover(env)
  # Call back into our compiled application and recover it.
  @child_app.recover(env) if @child_app
end