Rake

Rake uses a ThreadPool to manage parallel task execution. When running tasks, the top_level method executes the requested tasks within a run_with_threads block.

If the --job-stats option is used, Rake will display statistics about the thread pool after execution, such as:

• Maximum active threads
• Total threads in play

If --job-stats history is specified, Rake will also display a complete history of the jobs executed using ThreadHistoryDisplay.

A Rake::Task is the fundamental unit of work in a Rakefile. It consists of:

• Actions: One or more blocks of code to execute.
• Prerequisites: A list of tasks that must be completed before this task runs.
• Order-only Prerequisites: Tasks that must run before this task, but whose completion status (e.g., timestamp) does not affect whether this task is considered "needed".

When a task is invoked, Rake ensures all prerequisites are executed first, then runs the task's own actions. Tasks are typically created using the task or file convenience methods rather than calling Rake::Task.new directly.

A Rake::FileList is a specialized collection used for manipulating file paths and patterns. It behaves like an Array but is lazy: when you provide glob patterns, it does not search the file system immediately. Instead, it holds the patterns and only resolves them into actual file names the first time an element is requested (e.g., when calling to_a, each, or an array method).

This allows you to define complex file sets with multiple includes and excludes without the performance penalty of immediate disk scanning.

Once a Rakefile is defined, you can execute tasks from your terminal:

• Run the default task: Execute rake without any arguments. This will trigger the task named default and any of its dependencies.
• Run a specific task: Execute rake <task_name> (e.g., rake test).
• View available options: Run rake --help to see all command-line options.

You can install Rake using the standard Ruby gem installation command.

gem install rake

Rake is a make-like build utility for Ruby where tasks and dependencies are specified using standard Ruby syntax. You can execute specific tasks by providing the task names as arguments.

Synopsis:

rake [options] [rakefile] [targets ...]

To use Rake, you must create a file named Rakefile in your project directory. This file contains build rules defined using standard Ruby syntax.

In a Rakefile, you can define:

• Tasks: Named units of work.
• Prerequisites (Dependencies): Other tasks that must run before the current task.
• Default Task: A task named default that runs automatically when you execute the rake command without arguments.

task default: %w[test]

task :test do
    ruby "test/unittest.rb"
  end

If you want to create your own custom command-line tool that behaves like rake, you can use the Rake::Application class. To do this, follow these three steps:

1. Initialize: Call init(app_name, argv) to parse command-line options and set the application name.
2. Define Tasks: Load your Rakefile or manually define tasks within the application context.
3. Run Tasks: Call top_level to execute the tasks specified on the command line.

Alternatively, you can use the run(argv) method, which performs all three steps (init, load_rakefile, and top_level) in one call.

You can specify which archive formats Rake::PackageTask should generate by setting the corresponding boolean attributes. The resulting filenames follow the pattern <package_dir>/<name>-<version>.<extension>.

The import method loads external Rakefiles. Imported files are loaded after the current file is completely loaded, allowing imported files to depend on objects defined in the importing file.

import ".depend", "my_rules"

Rake provides two convenient top-level constants for common tasks: FileList and RakeFileUtils.

• FileList is a specialized collection for managing sets of files, often used in build scripts to handle patterns and exclusions.
• RakeFileUtils (aliased as RakeFileUtils) extends standard Ruby FileUtils with additional build-oriented methods like cp_r, mkdir_p, etc., optimized for Rake workflows.

FileList = Rake::FileList
RakeFileUtils = Rake::FileUtilsExt