In Files

  • rake/task.rb

Rake::Task

######################################################################### 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.

Attributes

actions[R]

List of actions attached to a task.

application[RW]

Application owning this task.

comment[R]

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

full_comment[R]

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

locations[R]

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).

prerequisites[R]

List of prerequisites for a task.

scope[R]

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

sources[W]

List of sources for task.

Public Class Methods

new(task_name, app) click to toggle source

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

 
               # File 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
            

Public Instance Methods

[](task_name) click to toggle source

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.

 
               # File rake/task.rb, line 297
def [](task_name)
  Rake.application[task_name]
end
            
add_description(description) click to toggle source

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

 
               # File rake/task.rb, line 223
def add_description(description)
  return if ! description
  comment = description.strip
  add_comment(comment) if comment && ! comment.empty?
end
            
arg_names() click to toggle source

Name of arguments for this task.

 
               # File rake/task.rb, line 112
def arg_names
  @arg_names || []
end
            
clear() click to toggle source

Clear the existing prerequisites and actions of a rake task.

 
               # File rake/task.rb, line 123
def clear
  clear_prerequisites
  clear_actions
  self
end
            
clear_actions() click to toggle source

Clear the existing actions on a rake task.

 
               # File rake/task.rb, line 136
def clear_actions
  actions.clear
  self
end
            
clear_prerequisites() click to toggle source

Clear the existing prerequisites of a rake task.

 
               # File rake/task.rb, line 130
def clear_prerequisites
  prerequisites.clear
  self
end
            
comment=(description) click to toggle source

Writing to the comment attribute is the same as adding a description.

 
               # File rake/task.rb, line 230
def comment=(description)
  add_description(description)
end
            
create_rule(*args, &block) click to toggle source

Define a rule for synthesizing tasks.

 
               # File rake/task.rb, line 314
def create_rule(*args, &block)
  Rake.application.create_rule(*args, &block)
end
            
define_task(*args, &block) click to toggle source

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.

 
               # File rake/task.rb, line 309
def define_task(*args, &block)
  Rake.application.define_task(self, *args, &block)
end
            
enhance(deps=nil, &block) click to toggle source

Enhance a task with prerequisites or actions. Returns self.

 
               # File rake/task.rb, line 86
def enhance(deps=nil, &block)
  @prerequisites |= deps if deps
  @actions << block if block_given?
  self
end
            
execute(args=nil) click to toggle source

Execute the actions associated with this task.

 
               # File rake/task.rb, line 190
def execute(args=nil)
  args ||= EMPTY_TASK_ARGS
  if application.options.dryrun
    $stderr.puts "** Execute (dry run) #{name}"
    return
  end
  if application.options.trace
    $stderr.puts "** 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
            
inspect() click to toggle source
 
               # File rake/task.rb, line 44
def inspect
  "<#{self.class} #{name} => [#{prerequisites.join(', ')}]>"
end
            
investigation() click to toggle source

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

 
               # File rake/task.rb, line 259
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) click to toggle source

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

 
               # File rake/task.rb, line 142
def invoke(*args)
  task_args = TaskArguments.new(arg_names, args)
  invoke_with_call_chain(task_args, InvocationChain::EMPTY)
end
            
name() click to toggle source

Name of the task, including any namespace qualifiers.

 
               # File rake/task.rb, line 93
def name
  @name.to_s
end
            
needed?() click to toggle source

Is this task needed?

 
               # File rake/task.rb, line 211
def needed?
  true
end
            
prerequisite_tasks() click to toggle source

List of prerequisite tasks

 
               # File rake/task.rb, line 55
def prerequisite_tasks
  prerequisites.collect { |pre| lookup_prerequisite(pre) }
end
            
reenable() click to toggle source

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

 
               # File rake/task.rb, line 118
def reenable
  @already_invoked = false
end
            
scope_name(scope, task_name) click to toggle source

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.

 
               # File rake/task.rb, line 321
def scope_name(scope, task_name)
  (scope + [task_name]).join(':')
end
            
set_arg_names(args) click to toggle source

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

 
               # File rake/task.rb, line 253
def set_arg_names(args)
  @arg_names = args.map { |a| a.to_sym }
end
            
source() click to toggle source

First source from a rule (nil if no sources)

 
               # File rake/task.rb, line 65
def source
  @sources.first if defined?(@sources)
end
            
sources() click to toggle source
 
               # File rake/task.rb, line 50
def sources
  @sources ||= []
end
            
task_defined?(task_name) click to toggle source

TRUE if the task name is already defined.

 
               # File rake/task.rb, line 302
def task_defined?(task_name)
  Rake.application.lookup(task_name) != nil
end
            
tasks() click to toggle source

List of all defined tasks.

 
               # File rake/task.rb, line 289
def tasks
  Rake.application.tasks
end
            
timestamp() click to toggle source

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

 
               # File rake/task.rb, line 217
def timestamp
  prerequisite_tasks.collect { |pre| pre.timestamp }.max || Time.now
end
            
to_s() click to toggle source

Return task name

 
               # File rake/task.rb, line 40
def to_s
  name
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus