Class: Rake::Task

Inherits:
Object
  • Object
show all
Defined in:
lib/rake/task.rb

Overview

A Task is the basic unit of work in a Rakefile. Tasks have associated actions (possibly more than one) and a list of prerequisites. When invoked, a task will first ensure that all of its prerequisites have an opportunity to run and then it will execute its own actions.

Tasks are not usually created directly using the new method, but rather use the file and task convenience methods.

Direct Known Subclasses

FileTask, MultiTask

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(task_name, app) ⇒ Task

Create a task named task_name with no actions or prerequisites. Use enhance to add actions and prerequisites.



95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rake/task.rb', line 95

def initialize(task_name, app)
  @name            = task_name.to_s
  @prerequisites   = []
  @actions         = []
  @already_invoked = false
  @comments        = []
  @lock            = Monitor.new
  @application     = app
  @scope           = app.current_scope
  @arg_names       = nil
  @locations       = []
end

Instance Attribute Details

#actions ⇒ Object (readonly)

List of actions attached to a task.



20
21
22
 
# File 'lib/rake/task.rb', line 20

def actions
  @actions
end

#already_invoked ⇒ Object (readonly)

Has this task already been invoked? Already invoked tasks will be skipped unless you reenable them.



35
36
37
 
# File 'lib/rake/task.rb', line 35

def already_invoked
  @already_invoked
end

#application ⇒ Object

Application owning this task.



23
24
25
 
# File 'lib/rake/task.rb', line 23

def application
  @application
end

#locations ⇒ Object (readonly)

File/Line locations of each of the task definitions for this task (only valid if the task was defined with the detect location option set).



31
32
33
 
# File 'lib/rake/task.rb', line 31

def locations
  @locations
end

#prerequisites ⇒ Object (readonly)

List of prerequisites for a task.



17
18
19
 
# File 'lib/rake/task.rb', line 17

def prerequisites
  @prerequisites
end

#scope ⇒ Object (readonly)

Array of nested namespaces names used for task lookup by this task.



26
27
28
 
# File 'lib/rake/task.rb', line 26

def scope
  @scope
end

#sources ⇒ Object 



48
49
50
51
52
53
54
 
# File 'lib/rake/task.rb', line 48

def sources
  if defined?(@sources)
    @sources
  else
    prerequisites
  end
end

Class Method Details

.[](task_name) ⇒ Object

Return a task with the given name. If the task is not currently known, try to synthesize one from the defined rules. If no rules are found, but an existing file matches the task name, assume it is a file task with no dependencies or actions.



361
362
363
 
# File 'lib/rake/task.rb', line 361

def [](task_name)
  Rake.application[task_name]
end

.clear ⇒ Object

Clear the task list. This cause rake to immediately forget all the tasks that have been assigned. (Normally used in the unit tests.)



348
349
350
 
# File 'lib/rake/task.rb', line 348

def clear
  Rake.application.clear
end

.create_rule(*args, &block) ⇒ Object

Define a rule for synthesizing tasks.



378
379
380
 
# File 'lib/rake/task.rb', line 378

def create_rule(*args, &block)
  Rake.application.create_rule(*args, &block)
end

.define_task(*args, &block) ⇒ Object

Define a task given args and an option block. If a rule with the given name already exists, the prerequisites and actions are added to the existing task. Returns the defined task.



373
374
375
 
# File 'lib/rake/task.rb', line 373

def define_task(*args, &block)
  Rake.application.define_task(self, *args, &block)
end

.scope_name(scope, task_name) ⇒ Object

Apply the scope to the task name according to the rules for this kind of task. Generic tasks will accept the scope as part of the name.



385
386
387
 
# File 'lib/rake/task.rb', line 385

def scope_name(scope, task_name)
  scope.path_with_task_name(task_name)
end

.task_defined?(task_name) ⇒ Boolean

TRUE if the task name is already defined.

Returns:

  • (Boolean) 


366
367
368
 
# File 'lib/rake/task.rb', line 366

def task_defined?(task_name)
  Rake.application.lookup(task_name) != nil
end

.tasks ⇒ Object

List of all defined tasks.



353
354
355
 
# File 'lib/rake/task.rb', line 353

def tasks
  Rake.application.tasks
end

Instance Method Details

#add_description(description) ⇒ Object

Add a description to the task. The description can consist of an option argument list (enclosed brackets) and an optional comment.



267
268
269
270
271
 
# File 'lib/rake/task.rb', line 267

def add_description(description)
  return unless description
  comment = description.strip
  add_comment(comment) if comment && ! comment.empty?
end

#all_prerequisite_tasks ⇒ Object

List of all unique prerequisite tasks including prerequisite tasks’ prerequisites. Includes self when cyclic dependencies are found.



73
74
75
76
77
 
# File 'lib/rake/task.rb', line 73

def all_prerequisite_tasks
  seen = {}
  collect_prerequisites(seen)
  seen.values
end

#arg_description ⇒ Object

Argument description (nil if none).



130
131
132
 
# File 'lib/rake/task.rb', line 130

def arg_description # :nodoc:
  @arg_names ? "[#{arg_names.join(',')}]" : nil
end

#arg_names ⇒ Object

Name of arguments for this task.



135
136
137
 
# File 'lib/rake/task.rb', line 135

def arg_names
  @arg_names || []
end

#clear ⇒ Object

Clear the existing prerequisites, actions, comments, and arguments of a rake task.



146
147
148
149
150
151
152
 
# File 'lib/rake/task.rb', line 146

def clear
  clear_prerequisites
  clear_actions
  clear_comments
  clear_args
  self
end

#clear_actions ⇒ Object

Clear the existing actions on a rake task.



161
162
163
164
 
# File 'lib/rake/task.rb', line 161

def clear_actions
  actions.clear
  self
end

#clear_args ⇒ Object

Clear the existing arguments on a rake task.



173
174
175
176
 
# File 'lib/rake/task.rb', line 173

def clear_args
  @arg_names = nil
  self
end

#clear_comments ⇒ Object

Clear the existing comments on a rake task.



167
168
169
170
 
# File 'lib/rake/task.rb', line 167

def clear_comments
  @comments = []
  self
end

#clear_prerequisites ⇒ Object

Clear the existing prerequisites of a rake task.



155
156
157
158
 
# File 'lib/rake/task.rb', line 155

def clear_prerequisites
  prerequisites.clear
  self
end

#comment ⇒ Object

First line (or sentence) of all comments. Multiple comments are separated by a “/”.



291
292
293
 
# File 'lib/rake/task.rb', line 291

def comment
  transform_comments(" / ") { |c| first_sentence(c) }
end

#comment=(comment) ⇒ Object

:nodoc:



273
274
275
 
# File 'lib/rake/task.rb', line 273

def comment=(comment) # :nodoc:
  add_comment(comment)
end

#enhance(deps = nil, &block) ⇒ Object

Enhance a task with prerequisites or actions. Returns self.



109
110
111
112
113
 
# File 'lib/rake/task.rb', line 109

def enhance(deps=nil, &block)
  @prerequisites |= deps if deps
  @actions << block if block_given?
  self
end

#execute(args = nil) ⇒ Object

Execute the actions associated with this task.



243
244
245
246
247
248
249
250
251
252
 
# File 'lib/rake/task.rb', line 243

def execute(args=nil)
  args ||= EMPTY_TASK_ARGS
  if application.options.dryrun
    application.trace "** Execute (dry run) #{name}"
    return
  end
  application.trace "** Execute #{name}" if application.options.trace
  application.enhance_with_matching_rule(name) if @actions.empty?
  @actions.each { |act| act.call(self, args) }
end

#full_comment ⇒ Object

Full collection of comments. Multiple comments are separated by newlines.



285
286
287
 
# File 'lib/rake/task.rb', line 285

def full_comment
  transform_comments("\n")
end

#inspect ⇒ Object

:nodoc:



42
43
44
 
# File 'lib/rake/task.rb', line 42

def inspect # :nodoc:
  "<#{self.class} #{name} => [#{prerequisites.join(', ')}]>"
end

#investigation ⇒ Object

Return a string describing the internal state of a task. Useful for debugging.



323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/rake/task.rb', line 323

def investigation
  result = "------------------------------\n".dup
  result << "Investigating #{name}\n"
  result << "class: #{self.class}\n"
  result <<  "task needed: #{needed?}\n"
  result <<  "timestamp: #{timestamp}\n"
  result << "pre-requisites: \n"
  prereqs = prerequisite_tasks
  prereqs.sort! { |a, b| a.timestamp <=> b.timestamp }
  prereqs.each do |p|
    result << "--#{p.name} (#{p.timestamp})\n"
  end
  latest_prereq = prerequisite_tasks.map(&:timestamp).max
  result <<  "latest-prerequisite time: #{latest_prereq}\n"
  result << "................................\n\n"
  return result
end

#invoke(*args) ⇒ Object

Invoke the task if it is needed. Prerequisites are invoked first.



179
180
181
182
 
# File 'lib/rake/task.rb', line 179

def invoke(*args)
  task_args = TaskArguments.new(arg_names, args)
  invoke_with_call_chain(task_args, InvocationChain::EMPTY)
end

#invoke_prerequisites(task_args, invocation_chain) ⇒ Object

Invoke all the prerequisites of a task.



211
212
213
214
215
216
217
218
219
220
 
# File 'lib/rake/task.rb', line 211

def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
  if application.options.always_multitask
    invoke_prerequisites_concurrently(task_args, invocation_chain)
  else
    prerequisite_tasks.each { |p|
      prereq_args = task_args.new_scope(p.arg_names)
      p.invoke_with_call_chain(prereq_args, invocation_chain)
    }
  end
end

#invoke_prerequisites_concurrently(task_args, invocation_chain) ⇒ Object

Invoke all the prerequisites of a task in parallel.



223
224
225
226
227
228
229
230
231
 
# File 'lib/rake/task.rb', line 223

def invoke_prerequisites_concurrently(task_args, invocation_chain)# :nodoc:
  futures = prerequisite_tasks.map do |p|
    prereq_args = task_args.new_scope(p.arg_names)
    application.thread_pool.future(p) do |r|
      r.invoke_with_call_chain(prereq_args, invocation_chain)
    end
  end
  futures.each(&:value)
end

#name ⇒ Object

Name of the task, including any namespace qualifiers.



116
117
118
 
# File 'lib/rake/task.rb', line 116

def name
  @name.to_s
end

#name_with_args ⇒ Object

Name of task with argument list description.



121
122
123
124
125
126
127
 
# File 'lib/rake/task.rb', line 121

def name_with_args # :nodoc:
  if arg_description
    "#{name}#{arg_description}"
  else
    name
  end
end

#needed? ⇒ Boolean

Is this task needed?

Returns:

  • (Boolean) 


255
256
257
 
# File 'lib/rake/task.rb', line 255

def needed?
  true
end

#prerequisite_tasks ⇒ Object

List of prerequisite tasks



57
58
59
 
# File 'lib/rake/task.rb', line 57

def prerequisite_tasks
  prerequisites.map { |pre| lookup_prerequisite(pre) }
end

#reenable ⇒ Object

Reenable the task, allowing its tasks to be executed if the task is invoked again.



141
142
143
 
# File 'lib/rake/task.rb', line 141

def reenable
  @already_invoked = false
end

#set_arg_names(args) ⇒ Object

Set the names of the arguments for this task. args should be an array of symbols, one for each argument name.



317
318
319
 
# File 'lib/rake/task.rb', line 317

def set_arg_names(args)
  @arg_names = args.map(&:to_sym)
end

#source ⇒ Object

First source from a rule (nil if no sources)



89
90
91
 
# File 'lib/rake/task.rb', line 89

def source
  sources.first
end

#timestamp ⇒ Object

Timestamp for this task. Basic tasks return the current time for their time stamp. Other tasks can be more sophisticated.



261
262
263
 
# File 'lib/rake/task.rb', line 261

def timestamp
  Time.now
end

#to_s ⇒ Object

Return task name



38
39
40
 
# File 'lib/rake/task.rb', line 38

def to_s
  name
end