module Rake::DSL - rake-13.4.2 Documentation

# module Rake::DSL

`DSL` is a module that provides `task`, `desc`, `namespace`, etc. Use this when you’d like to use rake outside the top level scope.

For a Rakefile you run from the command line this module is automatically included.

### Private Instance Methods

desc(description) click to toggle source

Describes the next rake task. Duplicate descriptions are discarded. Descriptions are shown with `rake -T` (up to the first sentence) and `rake -D` (the entire description).

Example:

    desc "Run the Unit Tests"
    task test: [:build] do
      # ... run tests
    end

    # File lib/rake/dsl_definition.rb, line 166
    def desc(description) # :doc:
      Rake.application.last_description = description
    end

directory(*args, &block) click to toggle source

Declare a set of files tasks to create the given directories on demand.

Example:

    directory "testdata/doc"

    # File lib/rake/dsl_definition.rb, line 92
    def directory(*args, &block) # :doc:
      args = args.flat_map { |arg| arg.is_a?(FileList) ? arg.to_a.flatten : arg }
      result = file_create(*args, &block)
      dir, _ = *Rake.application.resolve_args(args)
      dir = Rake.from_pathname(dir)
      Rake.each_dir_parent(dir) do |d|
        file_create d do |t|
          mkdir_p t.name unless File.exist?(t.name)
        end
      end
      result
    end

file(*args, &block) click to toggle source

Declare a file task.

Example:

     file "config.cfg" => ["config.template"] do
       open("config.cfg", "w") do |outfile|
         open("config.template") do |infile|
           while line = infile.gets
             outfile.puts line
           end
         end
       end
    end

    # File lib/rake/dsl_definition.rb, line 76
    def file(*args, &block) # :doc:
      Rake::FileTask.define_task(*args, &block)
    end

file_create(*args, &block) click to toggle source

Declare a file creation task. (Mainly used for the directory command).

    # File lib/rake/dsl_definition.rb, line 82
    def file_create(*args, &block)
      Rake::FileCreationTask.define_task(*args, &block)
    end

import(*fns) click to toggle source

Import the partial Rakefiles `fn`. Imported files are loaded after the current file is completely loaded. This allows the import statement to appear anywhere in the importing file, and yet allowing the imported files to depend on objects defined in the importing file.

A common use of the import statement is to include files containing dependency declarations.

See also the –rakelibdir command line option.

Example:

    import ".depend", "my_rules"

    # File lib/rake/dsl_definition.rb, line 184
    def import(*fns) # :doc:
      fns.each do |fn|
        Rake.application.add_import(fn)
      end
    end

multitask(*args, &block) click to toggle source

Declare a task that performs its prerequisites in parallel. Multitasks does not guarantee that its prerequisites will execute in any given order (which is obvious when you think about it)

Example:

    multitask deploy: %w[deploy_gem deploy_rdoc]

    # File lib/rake/dsl_definition.rb, line 113
    def multitask(*args, &block) # :doc:
      Rake::MultiTask.define_task(*args, &block)
    end

namespace(name=nil, &block) click to toggle source

Create a new rake namespace and use it for evaluating the given block. Returns a `NameSpace` object that can be used to lookup tasks defined in the namespace.

Example:

    ns = namespace "nested" do
      # the "nested:run" task
      task :run
    end
    task_run = ns[:run] # find :run in the given namespace.

Tasks can also be defined in a namespace by using a “:” in the task name:

    task "nested:test" do
      # ...
    end

    # File lib/rake/dsl_definition.rb, line 136
    def namespace(name=nil, &block) # :doc:
      name = name.to_s if name.kind_of?(Symbol)
      name = name.to_str if name.respond_to?(:to_str)
      unless name.kind_of?(String) || name.nil?
        raise ArgumentError, "Expected a String or Symbol for a namespace name"
      end
      Rake.application.in_namespace(name, &block)
    end

rule(*args, &block) click to toggle source

Declare a rule for auto-tasks.

Example:

    rule '.o' => '.c' do |t|
      sh 'cc', '-c', '-o', t.name, t.source
    end

    # File lib/rake/dsl_definition.rb, line 152
    def rule(*args, &block) # :doc:
      Rake::Task.create_rule(*args, &block)
    end

task(task_name) click to toggle source
task(task_name: dependencies)
task(task_name, arguments → dependencies)

Declare a basic task. The `task_name` is always the first argument. If the task name contains a “:” it is defined in that namespace.

The `dependencies` may be a single task name or an Array of task names. The `argument` (a single name) or `arguments` (an Array of names) define the arguments provided to the task.

The task, argument and dependency names may be either symbols or strings.

A task with a single dependency:

    task clobber: %w[clean] do
      rm_rf "html"
    end

A task with an argument and a dependency:

    task :package, [:version] => :test do |t, args|
      # ...
    end

To invoke this task from the command line:

    $ rake package[1.2.3]

    # File lib/rake/dsl_definition.rb, line 59
    def task(*args, &block) # :doc:
      Rake::Task.define_task(*args, &block)
    end