Daiku - Make for Perl


    #! perl
    use Daiku;
    use autodie ':all';

    desc 'do all tasks';
    task 'all' => 'foo';
    file 'foo' => 'foo.o' => sub {
        system "gcc -c foo foo.o";
    rule '.o' => '.c' => sub {
        system "gcc -c foo.o foo.c";

    build shift @ARGV || 'all';


Daiku is yet another build system for Perl5.


use Daiku

By declaring use Daiku in your own Perl script, you can use Daiku DSL to write your build procedure.

See "SYNOPSIS" for example of this usage.

daiku command and Daikufile

Daiku comes with daiku command-line tool. Just like make reads Makefile, daiku reads Daikufile and runs the build procedure.

See daiku for detail.


The following functions are exported by default.


desc $desc:Str

Description of the following task.


task $dst:Str, \@deps:ArrayRef[Str]
task $dst:Str, \@deps:ArrayRef[Str], \&code:CodeRef
task $dst:Str, $deps:Str
task $dst:Str, $deps:Str, \&code:CodeRef
task $dst:Str, \&code:CodeRef

Register a .PHONY task.

If \&code is passed, it is executed when Daiku builds this task.

    $code->($task, @args)

where $task is a Daiku::Task object, and @args is the arguments for the task.

You can access attributes of the task via $task object.

    $dst = $task->dst;
    $array_ref_of_deps = $task->deps;

You can pass arguments to a task via build() function. For example,

    task "all", sub { my ($task, @args) = @_; ... };
    build("all[xxx yyy]");

then, @args is ("xxx", "yyy").

As you see in the above example, arguments are specified inside brackets, and they are parsed as if they were command-line arguments (i.e., arguments are separated by spaces).

You can also specify task arguments via daiku command.


file $dst, $deps:Str, \&code:CodeRef
file $dst, \@deps:ArrayRef[Str], \&code:CodeRef

Register a file creation rule.

The \&code is executed when Daiku builds the file. It is supposed to create the file named $dst.


where $file is a Daiku::File object.

You can access attributes of the file task via $file object.

    $dst = $file->dst;
    $array_ref_of_deps = $file->deps;


rule $dst:Str, $src:Str, \&code:CodeRef
rule $dst:Str, \@srcs:ArrayRef[Str], \&code:CodeRef
rule $dst:Str, \&srcs:CodeRef, \&code:CodeRef

Register a suffix rule. It's the same as following code in Make.

        cc -c $<

The \&code is executed when Daiku builds this task.

    $code->($rule, $dst_filename, @src_filenames)

where $rule is a Daiku::SuffixRule object, $dst_filename is the destination filename and @src_filenames are the source filenames. The $code is supposed to create the file named $dst_filename.

If you pass a CodeRef as \&srcs, it is executed to derive source filenames.

    @src_filenames = $srcs->($dst_filename)

For example,

    rule '.o' => sub {
        my ($file) = @_;
        $file =~ s/\.o$//;
        ("$file.h", "$file.c");
    } => sub {
        my ($task, $dst, $src_h, $src_c) = @_;
        compile($src_c, $dst);

You can also return an ArrayRef from \&srcs instead of a list. In that case, the ArrayRef is just flattened.


build $task : Str

Build one object named $task.

Return Value: The number of built jobs.


namespace $namespace:Str, \&codeblock:CodeRef

Declare a namespace of tasks. Namespaces can be nested.

With namespaces, you can organize your tasks in a hierarchical way. For example,

    namespace n1 => sub {
        desc 't1';
        task task1 => sub { };
        namespace n2 => sub {
            desc 't2';
            task task2 => sub { };

The full task name includes all containing namespaces joined with colons (:).

    $ daiku n1:task1
    $ daiku n1:n2:task2


sh @command:List[Str]

Executes the @command.

This is similar to system() built-in function, but it throws an exception when the command returns a non-zero exit value.


This module doesn't detect recursion, but Perl5 can detect it.


Tokuhiro Matsuno <tokuhirom AAJKLFJEF GMAIL COM>


Rake, make(1)


Copyright (C) Tokuhiro Matsuno

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.