#!/usr/bin/perl

use strict;
use warnings;

use Verby::Step::Closure qw/step/;
use Verby::Dispatcher;

my $cfg = Verby::Config::Data->new;
%{ $cfg->data } = (
	untar_dir => "/tmp",
);

my $d = Verby::Dispatcher->new;
$d->config_hub($cfg);

foreach my $tarball (@ARGV){
	my $mkdir = step "Verby::Action::MkPath" => sub {
		my ( $self, $c ) = @_;
		$c->path($c->untar_dir);
	};
	$mkdir->provides_cxt(1);

	my $untar = step "Verby::Action::Untar" => sub {
		my ( $self, $c ) = @_;
		$c->tarball($tarball);
		$c->dest($c->untar_dir);
	}, sub {
		my ( $self, $c ) = @_;
		if ($c->exists("main_dir")) {
			$c->workdir($c->main_dir);
			$c->export("workdir");
		}
	};
	$untar->depends([ $mkdir ]);

	my $plscript = step "Verby::Action::BuildTool";
	$plscript->depends([ $untar ]);

	my $make = step "Verby::Action::Make";
	$make->depends([ $plscript ]);

	my $test = step "Verby::Action::Make" => sub {
		my ( $self, $c ) = @_;
		$c->target("test");
	};
	$test->depends([ $make ]);

	$d->add_step($test);
}

$d->do_all;

__END__

=pod

=head1 NAME

module_builder.pl - A simple demo that unpacks, builds and tests perl module
tarballs.

=head1 SYNOPSIS

	$ module_builder.pl My-Module-0.01.tar.gz Verby-0.01.tar.gz

=head1 DESCRIPTION

As this is not really a useful program, we'll look at how it's written, not how
it's used.

Foreach tarball given on the command line, several steps are created, all of
them L<Verby::Step::Closure> objects. Each step depends on the step before it.

=over 4

=item L<Verby::Action::MkPath>

First the context variable C<untar_dir> is created. This is where all the
tarballs will be unpacked to. Because we're so silly, C<untar_dir> is actually
set by L<Cwd/cwd>, so this is basically a no-op.

It has C<provide_cxt>, meaning that all it's dependant steps and it share a
common L<Verby::Context>, separate from other steps.

=item L<Verby::Action::Untar>

The next step is to unpack the tarball. The C<before> handler in
L<Verby::Step::Closure> will set the C<tarball> context variable to the
argument being processed, and the C<dest> context variable to the C<untar_dir>
context variable.

The C<after> handler sets the C<workdir> variable to the value of the
C<src_dir> variable, and exports C<workdir> so that it's accessible to
subsequent steps.

=item L<Verby::Action::BuildTool>

The next thing to do is run the C<Makefile.PL> file. We set C<workdir> to
C<src_dir> in the previous step, and that's all we need.

=item L<Verby::Action::Make>

After we've finished running C<Makefile.PL> we can run make(1) with no
arguments. This is exactly what this step does. It is also affected by the
previously exported C<workdir>.

=item L<Verby::Action::Make>

Now we run make(1) again, but this time with the C<test> target.

=back

=head1 ASYNC BEHAVIOR

Since most actions are asynchroneous, modules will be built in parallel. Isn't
that cool?

=head1 AUTHOR

Yuval Kogman, E<lt>nothingmuch@woobling.orgE<gt>

=head1 COPYRIGHT AND LICENSE

Copyright 2005-2008 by Infinity Interactive, Inc.

L<http://www.iinteractive.com>

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

=cut