class Taskinator::Definition::Builder

Attributes

args[R]
builder_options[R]
definition[R]
process[R]

Public Class Methods

new(process, definition, *args) click to toggle source
# File lib/taskinator/definition/builder.rb, line 10
def initialize(process, definition, *args)
  @process = process
  @definition = definition
  @builder_options = args.last.is_a?(Hash) ? args.pop : {}
  @args = args
  @executor = Taskinator::Executor.new(@definition)
end

Public Instance Methods

concurrent(complete_on=CompleteOn::Default, options={}, &block) click to toggle source

defines a sub process of tasks which are executed concurrently

# File lib/taskinator/definition/builder.rb, line 34
def concurrent(complete_on=CompleteOn::Default, options={}, &block)
  raise ArgumentError, 'block' unless block_given?

  sub_process = Process.define_concurrent_process_for(@definition, complete_on, options)
  task = define_sub_process_task(@process, sub_process, options)
  Builder.new(sub_process, @definition, *@args).instance_eval(&block)
  @process.tasks << task if sub_process.tasks.any?
  nil
end
for_each(method, options={}, &block) click to toggle source

dynamically defines tasks, using the given @iterator method the definition will be evaluated for each yielded item

# File lib/taskinator/definition/builder.rb, line 46
def for_each(method, options={}, &block)
  raise ArgumentError, 'method' if method.nil?
  raise NoMethodError, method unless @executor.respond_to?(method)
  raise ArgumentError, 'block' unless block_given?

  #
  # `for_each` is an exception, since it invokes the definition
  # in order to yield elements to the builder, and any options passed
  # are included with the builder options
  #
  method_args = options.any? ? [*@args, options] : @args
  @executor.send(method, *method_args) do |*args|
    Builder.new(@process, @definition, *args).instance_eval(&block)
  end
  nil
end
Also aliased as: transform
job(job, options={}) click to toggle source

defines a task which executes the given @job which is expected to implement a perform method either as a class or instance method

# File lib/taskinator/definition/builder.rb, line 76
def job(job, options={})
  raise ArgumentError, 'job' if job.nil?
  raise ArgumentError, 'job' unless job.methods.include?(:perform) || job.instance_methods.include?(:perform)

  define_job_task(@process, job, @args, options)
  nil
end
option?(key) { || ... } click to toggle source
# File lib/taskinator/definition/builder.rb, line 18
def option?(key, &block)
  yield if builder_options[key]
end
sequential(options={}, &block) click to toggle source

defines a sub process of tasks which are executed sequentially

# File lib/taskinator/definition/builder.rb, line 23
def sequential(options={}, &block)
  raise ArgumentError, 'block' unless block_given?

  sub_process = Process.define_sequential_process_for(@definition, options)
  task = define_sub_process_task(@process, sub_process, options)
  Builder.new(sub_process, @definition, *@args).instance_eval(&block)
  @process.tasks << task if sub_process.tasks.any?
  nil
end
sub_process(definition, options={}) click to toggle source

defines a sub process task, for the given @definition the definition specified must have input compatible arguments to the current definition

# File lib/taskinator/definition/builder.rb, line 87
def sub_process(definition, options={})
  raise ArgumentError, 'definition' if definition.nil?
  raise ArgumentError, "#{definition.name} does not extend the #{Definition.name} module" unless definition.kind_of?(Definition)

  # TODO: decide whether the sub process to dynamically receive arguments

  sub_process = definition.create_sub_process(*@args, combine_options(options))
  task = define_sub_process_task(@process, sub_process, options)
  Builder.new(sub_process, definition, *@args)
  @process.tasks << task if sub_process.tasks.any?
  nil
end
task(method, options={}) click to toggle source

defines a task which executes the given @method

# File lib/taskinator/definition/builder.rb, line 66
def task(method, options={})
  raise ArgumentError, 'method' if method.nil?
  raise NoMethodError, method unless @executor.respond_to?(method)

  define_step_task(@process, method, @args, options)
  nil
end
transform(method, options={}, &block)
Alias for: for_each

Private Instance Methods

combine_options(options={}) click to toggle source
# File lib/taskinator/definition/builder.rb, line 123
def combine_options(options={})
  builder_options.merge(options)
end
define_job_task(process, job, args, options={}) click to toggle source
# File lib/taskinator/definition/builder.rb, line 108
def define_job_task(process, job, args, options={})
  define_task(process) {
    Task.define_job_task(process, job, args, combine_options(options))
  }
end
define_step_task(process, method, args, options={}) click to toggle source
# File lib/taskinator/definition/builder.rb, line 102
def define_step_task(process, method, args, options={})
  define_task(process) {
    Task.define_step_task(process, method, args, combine_options(options))
  }
end
define_sub_process_task(process, sub_process, options={}) click to toggle source
# File lib/taskinator/definition/builder.rb, line 114
def define_sub_process_task(process, sub_process, options={})
  Task.define_sub_process_task(process, sub_process, combine_options(options))
end
define_task(process) { || ... } click to toggle source
# File lib/taskinator/definition/builder.rb, line 118
def define_task(process)
  process.tasks << task = yield
  task
end