Module: Tasking

Defined in:
lib/tasking.rb,
lib/tasking/task.rb,
lib/tasking/options.rb,
lib/tasking/namespace.rb

Defined Under Namespace

Classes: Namespace, Options, Task

Instance Method Summary collapse

Instance Method Details

#after(task_name, *after_task_names) ⇒ Object 



60
61
62
63
64
65
 
# File 'lib/tasking.rb', line 60

def after( task_name, *after_task_names )
  @__late_evaluations ||= {}
  @__late_evaluations[:after] ||= []
  parent_namespace_name = @__parent_namespace.last&.name.to_s
  @__late_evaluations[:after] << [ task_name, parent_namespace_name, after_task_names.flatten ]
end

#before(task_name, *before_task_names) ⇒ Object 



53
54
55
56
57
58
 
# File 'lib/tasking.rb', line 53

def before( task_name, *before_task_names )
  @__late_evaluations ||= {}
  @__late_evaluations[:before] ||= []
  parent_namespace_name = @__parent_namespace.last&.name.to_s
  @__late_evaluations[:before] << [ task_name, parent_namespace_name, before_task_names.flatten ]
end

#execute(name, options = {}) ⇒ Object Also known as: invoke, run 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/tasking.rb', line 76

def execute( name, options = {} )
  if !@__subsequent_executions
    @__subsequent_executions = true
    late_evaluations
  end
  task = task_lookup( name )

  if !task
    msg = "Unknown task '#{name}'"
    msg << " or #{fully_qualified_name( name )}" if @__parent_namespace.size > 0
    abort( msg )
  end

  namespace_hierarchy_options = gather_options_for( name, task )
  namespace_hierarchy_options.merge!( options )
  @__parent_namespace.push( task.parent_namespace )
  task.execute( namespace_hierarchy_options )
  @__parent_namespace.pop
end

#late_after(task_name, parent_namespace_name, *after_task_names) ⇒ Object 



45
46
47
48
49
50
51
 
# File 'lib/tasking.rb', line 45

def late_after( task_name, parent_namespace_name, *after_task_names )
  task = Tasking::Namespace.find_task_in_namespace( parent_namespace_name, task_name ) ||
         Tasking::Namespace.find_task( task_name ) 
  abort( "Unknown task '#{task_name}' in after filter" ) unless task

  task.add_after_filters( *after_task_names )
end

#late_before(task_name, parent_namespace_name, *before_task_names) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/tasking.rb', line 37

def late_before( task_name, parent_namespace_name, *before_task_names )
  task = Tasking::Namespace.find_task_in_namespace( parent_namespace_name, task_name ) ||
         Tasking::Namespace.find_task( task_name ) 
  abort( "Unknown task '#{task_name}' in before filter" ) unless task

  task.add_before_filters( *before_task_names )
end

#late_evaluations ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/tasking.rb', line 67

def late_evaluations
  return unless @__late_evaluations
  @__late_evaluations.each_pair do |type, task_parameters|
    task_parameters.each do |( task_name, parent_namespace_name, args )|
      self.send( :"late_#{type}", task_name, parent_namespace_name, *args )
    end
  end
end

#namespace(name, options = {}, &block) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/tasking.rb', line 19

def namespace( name, options = {}, &block ) 
  abort( "Namespaces with empty names are not allowed" ) if name.to_s.empty?
  @__parent_namespace ||= []

  full_name = fully_qualified_name( name )
  parent_namespace_names, _ = split_task_from_namespace( full_name )
  build_namespace_hierarchy( parent_namespace_names )

  next_namespace = Tasking::Namespace.find_or_create( full_name, options )
  @__parent_namespace.push( next_namespace )
  next_namespace.execute( options, &block )
  @__parent_namespace.pop
end

#options(options) ⇒ Object 



33
34
35
 
# File 'lib/tasking.rb', line 33

def options( options ) 
  @__parent_namespace.last.merge_options( options )
end

#task(name, options = {}, &block) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/tasking.rb', line 4

def task( name, options = {}, &block )
  abort( "Tasks with empty names are not allowed" ) if name.to_s.empty?

  full_name = fully_qualified_name( name )
  namespace_name, task_name = split_task_from_namespace( full_name )

  abort( "Task '#{name}' is not in a namespace" ) if namespace_name.empty?

  build_namespace_hierarchy( namespace_name )

  parent_namespace = Tasking::Namespace.find_namespace( namespace_name )
  task = Tasking::Task.new( task_name, parent_namespace, options, &block )
  parent_namespace.register_task( task )
end