module Cucumber::Glue::Dsl

This module provides the methods the DSL you can use to define steps, hooks, transforms etc.

Attributes

rb_language[W]

Public Class Methods

alias_adverb(adverb) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 13
def alias_adverb(adverb)
  alias_method adverb, :register_rb_step_definition
end
build_rb_world_factory(world_modules, namespaced_world_modules, proc) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 17
def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
  @rb_language.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
end
define_parameter_type(parameter_type) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 25
def define_parameter_type(parameter_type)
  @rb_language.define_parameter_type(parameter_type)
end
register_rb_hook(phase, tag_names, proc) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 21
def register_rb_hook(phase, tag_names, proc)
  @rb_language.register_rb_hook(phase, tag_names, proc)
end
register_rb_step_definition(regexp, proc_or_sym, options = {}) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 29
def register_rb_step_definition(regexp, proc_or_sym, options = {})
  @rb_language.register_rb_step_definition(regexp, proc_or_sym, options)
end

Public Instance Methods

After(*tag_expressions, &proc) click to toggle source

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).

# File lib/cucumber/glue/dsl.rb, line 70
def After(*tag_expressions, &proc)
  Dsl.register_rb_hook('after', tag_expressions, proc)
end
AfterConfiguration(&proc) click to toggle source

Registers a proc that will run after Cucumber is configured. You can register as as you want (typically from ruby scripts under support/hooks.rb).

# File lib/cucumber/glue/dsl.rb, line 111
def AfterConfiguration(&proc)
  Dsl.register_rb_hook('after_configuration', [], proc)
end
AfterStep(*tag_expressions, &proc) click to toggle source

Registers a proc that will run after each Step. You can register as as you want (typically from ruby scripts under support/hooks.rb).

# File lib/cucumber/glue/dsl.rb, line 85
def AfterStep(*tag_expressions, &proc)
  Dsl.register_rb_hook('after_step', tag_expressions, proc)
end
Around(*tag_expressions, &proc) click to toggle source

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).

# File lib/cucumber/glue/dsl.rb, line 79
def Around(*tag_expressions, &proc)
  Dsl.register_rb_hook('around', tag_expressions, proc)
end
Before(*tag_expressions, &proc) click to toggle source

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).

# File lib/cucumber/glue/dsl.rb, line 64
def Before(*tag_expressions, &proc)
  Dsl.register_rb_hook('before', tag_expressions, proc)
end
ParameterType(options) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 89
def ParameterType(options)
  type = options[:type] || Object
  use_for_snippets = if_nil(options[:use_for_snippets], true)
  prefer_for_regexp_match = if_nil(options[:prefer_for_regexp_match], false)

  parameter_type = CucumberExpressions::ParameterType.new(
    options[:name],
    options[:regexp],
    type,
    options[:transformer],
    use_for_snippets,
    prefer_for_regexp_match
  )
  Dsl.define_parameter_type(parameter_type)
end
World(*world_modules, **namespaced_world_modules, &proc) click to toggle source

Registers any number of world_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 world_modules will be mixed into this Object (via Object#extend).

By default the +world modules+ are added to a global namespace. It is possible to create a namespaced #World by using an hash, where the symbols are the namespaces.

This method is typically called from one or more Ruby scripts under features/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.

Cucumber will not yield anything to the proc. Examples:

World do
  MyClass.new
end

World(MyModule)

World(my_module: MyModule)
# File lib/cucumber/glue/dsl.rb, line 58
def World(*world_modules, **namespaced_world_modules, &proc)
  Dsl.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
end
if_nil(value, default) click to toggle source
# File lib/cucumber/glue/dsl.rb, line 105
def if_nil(value, default)
  value.nil? ? default : value
end
register_rb_step_definition(regexp, symbol = nil, options = {}, &proc) click to toggle source

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 World object as defined by #World. A new World 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 World object and then sent the symbol.

If no symbol if provided then the +&proc+ gets executed in the context of the World object.

# File lib/cucumber/glue/dsl.rb, line 130
def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
  proc_or_sym = symbol || proc
  Dsl.register_rb_step_definition(regexp, proc_or_sym, options)
end