99 lines
2.5 KiB
Ruby
99 lines
2.5 KiB
Ruby
module Vagrant
|
|
class Action
|
|
# Represents an action environment which is what is passed
|
|
# to the `call` method of each action. This environment contains
|
|
# some helper methods for accessing the environment as well
|
|
# as being a hash, to store any additional options.
|
|
class Environment < Hash
|
|
# The {Vagrant::Environment} object represented by this
|
|
# action environment.
|
|
attr_reader :env
|
|
|
|
# If nonnil, the error associated with this environment. Set
|
|
# using {#error!}
|
|
attr_reader :error
|
|
|
|
def initialize(env)
|
|
super() do |h,k|
|
|
# By default, try to find the key as a method on the
|
|
# environment. Gross eval use here.
|
|
begin
|
|
value = eval("h.env.#{k}")
|
|
h[k] = value
|
|
rescue Exception
|
|
nil
|
|
end
|
|
end
|
|
|
|
@env = env
|
|
@error = nil
|
|
end
|
|
|
|
# Returns a logger associated with the environment.
|
|
def logger
|
|
env.logger
|
|
end
|
|
|
|
# Flags the environment as erroneous. Stores the given key
|
|
# and options until the end of the action sequence.
|
|
#
|
|
# @param [Symbol] key Key to translation to display error message.
|
|
# @param [Hash] options Variables to pass to the translation
|
|
def error!(key, options=nil)
|
|
@error = [key, (options || {})]
|
|
end
|
|
|
|
# Returns boolean denoting if environment is in erroneous state.
|
|
#
|
|
# @return [Boolean]
|
|
def error?
|
|
!error.nil?
|
|
end
|
|
|
|
# Returns a boolean denoting if environment has been interrupted
|
|
# with a SIGINT.
|
|
def interrupted?
|
|
error? && error.first == :interrupt
|
|
end
|
|
|
|
#-----------------------------------------------------------------
|
|
# Hash with indifferent access
|
|
#-----------------------------------------------------------------
|
|
def [](key)
|
|
super(convert_key(key))
|
|
end
|
|
|
|
def []=(key, value)
|
|
super(convert_key(key), value)
|
|
end
|
|
|
|
def delete(key)
|
|
super(convert_key(key))
|
|
end
|
|
|
|
def values_at(*indices)
|
|
indices.collect { |key| self[convert_key(key)] }
|
|
end
|
|
|
|
def merge(other)
|
|
dup.merge!(other)
|
|
end
|
|
|
|
def merge!(other)
|
|
other.each do |key, value|
|
|
self[convert_key(key)] = value
|
|
end
|
|
self
|
|
end
|
|
|
|
def has_key?(key)
|
|
super(convert_key(key))
|
|
end
|
|
|
|
def convert_key(key)
|
|
key.is_a?(Symbol) ? key.to_s : key
|
|
end
|
|
end
|
|
end
|
|
end
|