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.


71
72
73
74
75
76
77
78
79
80
81
82
83
# File 'lib/rake/task.rb', line 71

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

Instance Attribute Details

#actionsObject (readonly)

List of actions attached to a task.


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

def actions
  @actions
end

#applicationObject

Application owning this task.


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

def application
  @application
end

#commentObject

Comment for this task. Restricted to a single line of no more than 50 characters.


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

def comment
  @comment
end

#full_commentObject (readonly)

Full text of the (possibly multi-line) comment.


29
30
31
# File 'lib/rake/task.rb', line 29

def full_comment
  @full_comment
end

#locationsObject (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).


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

def locations
  @locations
end

#prerequisitesObject (readonly)

List of prerequisites for a task.


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

def prerequisites
  @prerequisites
end

#scopeObject (readonly)

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


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

def scope
  @scope
end

#sourcesObject


50
51
52
# File 'lib/rake/task.rb', line 50

def sources
  @sources ||= []
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.


320
321
322
# File 'lib/rake/task.rb', line 320

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

.clearObject

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


307
308
309
# File 'lib/rake/task.rb', line 307

def clear
  Rake.application.clear
end

.create_rule(*args, &block) ⇒ Object

Define a rule for synthesizing tasks.


337
338
339
# File 'lib/rake/task.rb', line 337

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.


332
333
334
# File 'lib/rake/task.rb', line 332

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.


344
345
346
# File 'lib/rake/task.rb', line 344

def scope_name(scope, task_name)
  (scope + [task_name]).join(':')
end

.task_defined?(task_name) ⇒ Boolean

TRUE if the task name is already defined.

Returns:

  • (Boolean)

325
326
327
# File 'lib/rake/task.rb', line 325

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

.tasksObject

List of all defined tasks.


312
313
314
# File 'lib/rake/task.rb', line 312

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.


246
247
248
249
250
# File 'lib/rake/task.rb', line 246

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

#arg_descriptionObject

Argument description (nil if none).


107
108
109
# File 'lib/rake/task.rb', line 107

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

#arg_namesObject

Name of arguments for this task.


112
113
114
# File 'lib/rake/task.rb', line 112

def arg_names
  @arg_names || []
end

#clearObject

Clear the existing prerequisites and actions of a rake task.


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

def clear
  clear_prerequisites
  clear_actions
  clear_comments
  self
end

#clear_actionsObject

Clear the existing actions on a rake task.


137
138
139
140
# File 'lib/rake/task.rb', line 137

def clear_actions
  actions.clear
  self
end

#clear_commentsObject

Clear the existing comments on a rake task.


143
144
145
146
147
# File 'lib/rake/task.rb', line 143

def clear_comments
  @full_comment = nil
  @comment = nil
  self
end

#clear_prerequisitesObject

Clear the existing prerequisites of a rake task.


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

def clear_prerequisites
  prerequisites.clear
  self
end

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

Enhance a task with prerequisites or actions. Returns self.


86
87
88
89
90
# File 'lib/rake/task.rb', line 86

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.


213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
# File 'lib/rake/task.rb', line 213

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

#inspectObject


44
45
46
# File 'lib/rake/task.rb', line 44

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

#investigationObject

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


282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
# File 'lib/rake/task.rb', line 282

def investigation
  result = "------------------------------\n"
  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.collect { |pre| pre.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.


150
151
152
153
# File 'lib/rake/task.rb', line 150

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.


181
182
183
184
185
186
187
188
189
190
# File 'lib/rake/task.rb', line 181

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.


193
194
195
196
197
198
199
200
201
# File 'lib/rake/task.rb', line 193

def invoke_prerequisites_concurrently(task_args, invocation_chain) # :nodoc:
  futures = prerequisite_tasks.collect 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 { |f| f.value }
end

#nameObject

Name of the task, including any namespace qualifiers.


93
94
95
# File 'lib/rake/task.rb', line 93

def name
  @name.to_s
end

#name_with_argsObject

Name of task with argument list description.


98
99
100
101
102
103
104
# File 'lib/rake/task.rb', line 98

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

#needed?Boolean

Is this task needed?

Returns:

  • (Boolean)

234
235
236
# File 'lib/rake/task.rb', line 234

def needed?
  true
end

#prerequisite_tasksObject

List of prerequisite tasks


55
56
57
# File 'lib/rake/task.rb', line 55

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

#reenableObject

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


118
119
120
# File 'lib/rake/task.rb', line 118

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.


276
277
278
# File 'lib/rake/task.rb', line 276

def set_arg_names(args)
  @arg_names = args.map { |a| a.to_sym }
end

#sourceObject

First source from a rule (nil if no sources)


65
66
67
# File 'lib/rake/task.rb', line 65

def source
  @sources.first if defined?(@sources)
end

#timestampObject

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


240
241
242
# File 'lib/rake/task.rb', line 240

def timestamp
  prerequisite_tasks.collect { |pre| pre.timestamp }.max || Time.now
end

#to_sObject

Return task name


40
41
42
# File 'lib/rake/task.rb', line 40

def to_s
  name
end