module Lucid
module InterfaceRb
# It is necessary for the RbLucid module to be mixed in to the top level
# object. This is what allows TDL test definitions and hooks to be
# resolved as valid methods.
module RbLucid
class << self
attr_writer :rb_language
def alias_adverb(adverb)
alias_method adverb, :register_rb_step_definition
end
def build_rb_world_factory(domain_modules, proc)
@rb_language.build_rb_world_factory(domain_modules, proc)
end
def register_rb_hook(phase, tag_names, proc)
@rb_language.register_rb_hook(phase, tag_names, proc)
end
def register_rb_transform(regexp, proc)
@rb_language.register_rb_transform(regexp, proc)
end
def register_rb_step_definition(regexp, proc_or_sym, options = {})
@rb_language.register_rb_step_definition(regexp, proc_or_sym, options)
end
end
# Registers any number of +domain_modules+ (Ruby Modules) and/or a Proc.
# The +proc+ will be executed once before each scenario to create an
# Object that the scenario's steps will run within. Any +domain_modules+
# will be mixed into this Object (via Object#extend).
#
# This method is typically called from one or more Ruby scripts under
# common/support. You can call this method as many times as you
# like (to register more modules), but if you try to register more than
# one Proc you will get an error.
#
# Lucid will not yield anything to the +proc+. Examples:
#
# Domain do
# MyClass.new
# end
#
# Domain(MyModule)
#
def Domain(*domain_modules, &proc)
RbLucid.build_rb_world_factory(domain_modules, proc)
end
# Registers a proc that will run before each Scenario. You can register as many
# as you want (typically from ruby scripts under support/hooks.rb).
def Before(*tag_expressions, &proc)
RbLucid.register_rb_hook('before', tag_expressions, proc)
end
# Registers a proc that will run after each Scenario. You can register as many
# as you want (typically from ruby scripts under support/hooks.rb).
def After(*tag_expressions, &proc)
RbLucid.register_rb_hook('after', tag_expressions, proc)
end
# Registers a proc that will be wrapped around each scenario. The proc
# should accept two arguments: two arguments: the scenario and a "block"
# argument (but passed as a regular argument, since blocks cannot accept
# blocks in 1.8), on which it should call the .call method. You can register
# as many as you want (typically from ruby scripts under support/hooks.rb).
def Around(*tag_expressions, &proc)
RbLucid.register_rb_hook('around', tag_expressions, proc)
end
# Registers a proc that will run after each Step. You can register as
# as you want (typically from ruby scripts under support/hooks.rb).
def AfterStep(*tag_expressions, &proc)
RbLucid.register_rb_hook('after_step', tag_expressions, proc)
end
# Registers a proc that will be called with a step definition argument if it
# matches the pattern passed as the first argument to Transform. Alternatively, if
# the pattern contains captures then they will be yielded as arguments to the
# provided proc. The return value of the proc is consequently yielded to the
# step definition.
def Transform(regexp, &proc)
RbLucid.register_rb_transform(regexp, proc)
end
# Registers a proc that will run after Lucid is configured. You can register as
# as you want (typically from ruby scripts under support/hooks.rb).
# TODO: Deprecate this
def AfterConfiguration(&proc)
RbLucid.register_rb_hook('after_configuration', [], proc)
end
# Registers a new Ruby StepDefinition. This method is aliased
# to Given, When and Then, and
# also to the i18n translations whenever a feature of a
# new language is loaded.
#
# If provided, the +symbol+ is sent to the Domain object
# as defined by #Domain. A new Domain object is created
# for each scenario and is shared across step definitions within
# that scenario. If the +options+ hash contains an :on
# key, the value for this is assumed to be a proc. This proc
# will be executed in the context of the Domain object
# and then sent the +symbol+.
#
# If no +symbol+ if provided then the +&proc+ gets executed in
# the context of the Domain object.
def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
proc_or_sym = symbol || proc
RbLucid.register_rb_step_definition(regexp, proc_or_sym, options)
end
end
end
end
extend(Lucid::InterfaceRb::RbLucid)