[R] |
actions |
List of actions attached to a task.
|
[RW] |
application |
Application owning this task.
|
[R] |
comment |
Comment for this task. Restricted to a single line of no more than 50
characters.
|
[R] |
full_comment |
Full text of the (possibly multi-line) comment.
|
[R] |
locations |
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).
|
[R] |
prerequisites |
List of prerequisites for a task.
|
[R] |
scope |
Array of nested namespaces names used for task lookup by this task.
|
[W] |
sources |
List of sources for task.
|
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.
297: def [](task_name)
298: Rake.application[task_name]
299: end
Clear the task list. This cause rake to immediately forget all the tasks that have been assigned. (Normally used
in the unit tests.)
284: def clear
285: Rake.application.clear
286: end
Define a rule for synthesizing tasks.
314: def create_rule(*args, &block)
315: Rake.application.create_rule(*args, &block)
316: end
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.
309: def define_task(*args, &block)
310: Rake.application.define_task(self, *args, &block)
311: end
Create a task named task_name with no actions or prerequisites.
Use enhance to add actions and
prerequisites.
71: def initialize(task_name, app)
72: @name = task_name.to_s
73: @prerequisites = []
74: @actions = []
75: @already_invoked = false
76: @full_comment = nil
77: @comment = nil
78: @lock = Monitor.new
79: @application = app
80: @scope = app.current_scope
81: @arg_names = nil
82: @locations = []
83: end
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.
321: def scope_name(scope, task_name)
322: (scope + [task_name]).join(':')
323: end
TRUE if the task name is already defined.
302: def task_defined?(task_name)
303: Rake.application.lookup(task_name) != nil
304: end
List of all defined tasks.
289: def tasks
290: Rake.application.tasks
291: end
Add a description to the task. The description can consist of an option
argument list (enclosed brackets) and an optional comment.
223: def add_description(description)
224: return if ! description
225: comment = description.strip
226: add_comment(comment) if comment && ! comment.empty?
227: end
Name of arguments for this task.
112: def arg_names
113: @arg_names || []
114: end
Clear the existing prerequisites and actions of a rake task.
123: def clear
124: clear_prerequisites
125: clear_actions
126: self
127: end
Clear the existing actions on a rake task.
136: def clear_actions
137: actions.clear
138: self
139: end
Clear the existing prerequisites of a rake task.
130: def clear_prerequisites
131: prerequisites.clear
132: self
133: end
Writing to the comment attribute is the same as adding a description.
230: def comment=(description)
231: add_description(description)
232: end
Enhance a task with prerequisites or actions. Returns self.
86: def enhance(deps=nil, &block)
87: @prerequisites |= deps if deps
88: @actions << block if block_given?
89: self
90: end
Execute the actions associated with this task.
190: def execute(args=nil)
191: args ||= EMPTY_TASK_ARGS
192: if application.options.dryrun
193: puts "** Execute (dry run) #{name}"
194: return
195: end
196: if application.options.trace
197: puts "** Execute #{name}"
198: end
199: application.enhance_with_matching_rule(name) if @actions.empty?
200: @actions.each do |act|
201: case act.arity
202: when 1
203: act.call(self)
204: else
205: act.call(self, args)
206: end
207: end
208: end
44: def inspect
45: "<#{self.class} #{name} => [#{prerequisites.join(', ')}]>"
46: end
Return a string describing the internal state of a task. Useful for
debugging.
259: def investigation
260: result = "------------------------------\n"
261: result << "Investigating #{name}\n"
262: result << "class: #{self.class}\n"
263: result << "task needed: #{needed?}\n"
264: result << "timestamp: #{timestamp}\n"
265: result << "pre-requisites: \n"
266: prereqs = prerequisite_tasks
267: prereqs.sort! {|a,b| a.timestamp <=> b.timestamp}
268: prereqs.each do |p|
269: result << "--#{p.name} (#{p.timestamp})\n"
270: end
271: latest_prereq = prerequisite_tasks.collect { |pre| pre.timestamp }.max
272: result << "latest-prerequisite time: #{latest_prereq}\n"
273: result << "................................\n\n"
274: return result
275: end
Invoke the task if it is needed. Prerequites are invoked first.
142: def invoke(*args)
143: task_args = TaskArguments.new(arg_names, args)
144: invoke_with_call_chain(task_args, InvocationChain::EMPTY)
145: end
Name of the task, including any namespace qualifiers.
93: def name
94: @name.to_s
95: end
211: def needed?
212: true
213: end
List of prerequisite tasks
55: def prerequisite_tasks
56: prerequisites.collect { |pre| lookup_prerequisite(pre) }
57: end
Reenable the task, allowing its tasks to be
executed if the task is invoked again.
118: def reenable
119: @already_invoked = false
120: end
Set the names of the arguments for this task. args should be an
array of symbols, one for each argument name.
253: def set_arg_names(args)
254: @arg_names = args.map { |a| a.to_sym }
255: end
65: def source
66: @sources.first if defined?(@sources)
67: end
50: def sources
51: @sources ||= []
52: end
Timestamp for this task. Basic tasks return
the current time for their time stamp. Other tasks can be more sophisticated.
217: def timestamp
218: prerequisite_tasks.collect { |pre| pre.timestamp }.max || Time.now
219: end
40: def to_s
41: name
42: end