App-Dothe

 view release on metacpan or  search on metacpan

lib/App/Dothe.pm  view on Meta::CPAN

has vars => (
    is => 'ro',
    lazy => 1,
    isa => 'HashRef',
    builder => '_build_vars',
    init_arg => undef,
);

use Ref::Util qw/ is_arrayref is_hashref /;

sub render($self,$template,$vars) {
    if( is_arrayref $template ) {
        return [ map { $self->render($_,$vars) } @$template ];
    }

    if( is_hashref $template ) {
        return { pairmap { $a => $self->render($b,$vars) } %$template }
    }

    return $self->template($template)->fill_in(HASH => $vars );
}

sub _build_vars($self) {
    my %vars;

    %vars = (
        %vars,
        pairmap { $a => $self->render( $b, \%vars ) } $self->raw_vars->%*
    );

    return \%vars;
}

has tasks => (
    is => 'ro',
    lazy => 1,
    traits => [ 'Hash' ],
    default => sub($self) { +{} },
);

sub task($self,$name) {
    return $self->{tasks}{$name} ||= App::Dothe::Task->new(
        name => $name, tasks => $self, $self->config->{tasks}{$name}->%* );
}

option file => (
    is => 'ro',
    documentation => 'configuration file',
    isa => 'Str',
    default => './Dothe.yml',
);

has config => (
    is => 'ro',
    lazy => 1,
    default => sub($self) { LoadFile( $self->file ) },
);

sub run( $self ) {

    if ( my $code = $self->config->{code} ) {
        eval join '', 'package App::Dothe::Sandbox;', @$code;
    }

    $self->task($self->target)->run;

}

sub template ($self,$source) {

lib/App/Dothe/Task.pm  view on Meta::CPAN

has generates => (
    is => 'ro',
    init_arg => undef,
    lazy => 1,
    default => sub ($self){
        $self->vars->{generates} = $self->expand_files( $self->raw_generates )
    },
);

sub expand_files($self, $list ) {
    $list = [ $list ] unless ref $list;

    [
    map { File::Wildcard->new( path=> $_ )->all }
    map { s!\*\*!/!gr }
    map { $self->render( $_, $self->vars ) }
    @$list ]
}


has tasks => (
    is	    => 'ro',
    required => 1,
);



sub latest_source_mod($self) {
    return min map { -M "".$_ } $self->sources->@*;
}

sub latest_generate_mod($self) {
    return min map { -M "".$_ } $self->generates->@*;
}

sub is_uptodate ($self) {
    return 0 if $self->tasks->force;

    my $source = $self->latest_source_mod;
    my $gen = $self->latest_generate_mod;

    return ( $gen and $source >= $gen );

lib/App/Dothe/Task.pm  view on Meta::CPAN

has vars => (
    is => 'ro',
    lazy => 1,
    init_arg => undef,
    isa => 'HashRef',
    builder => '_build_vars',
);


sub render($self,$template,$vars) {
    if( is_arrayref $template ) {
        return [ map { $self->render($_,$vars) } @$template ];
    }

    if( is_hashref $template ) {
        return { pairmap { $a => $self->render($b,$vars) } %$template }
    }

    no warnings 'uninitialized';
    $self->template( $template )->fill_in( HASH => $vars,
        PACKAGE => 'App::Dothe::Sandbox',
    );
}

sub _build_vars($self) {
    my %vars = ( $self->tasks->vars->%*, $self->raw_vars->%* );

    %vars = (
        %vars,
        pairmap { $a => $self->render( $b, \%vars ) }
            $self->raw_vars->%*
    );

    return \%vars;
}

has foreach => (
    is	    => 'ro',
    isa 	=> 'Str',
);

sub foreach_vars($self) {
    my $foreach = $self->foreach or return;

    $self->sources;
    $self->generates;

    return map { +{ item => $_ } } $self->vars->{$foreach}->@*;
}

has deps => (
    is	    => 'ro',
    isa 	=> 'ArrayRef',
    default => sub {
        []
    },
);

sub dependency_tree($self, $graph = undef ) {
    require Graph::Directed;

    $graph ||= Graph::Directed->new;

    return $graph
        if $graph->get_vertex_attribute( $self->name, 'done' );

    $graph->set_vertex_attribute( $self->name, 'done', 1 );

    for my $dep ( $self->deps->@* ) {
        $graph->add_edge( $dep => $self->name );
        $self->tasks->task($dep)->dependency_tree($graph);
    }

    return $graph;
}

sub dependencies($self) {
    return grep { $_ ne $self->name } $self->dependency_tree->topological_sort;
}

sub run($self) {
    my @deps = $self->dependencies;

    $self->tasks->task($_)->run for @deps;

    $log->infof( "running task %s", $self->name );

    if ( $self->is_uptodate ) {
        $log->infof( '%s is up-to-date', $self->name );
        return;
    }

lib/App/Dothe/Task.pm  view on Meta::CPAN

        }
        return;
    }

    for my $command ( $self->commands ) {
            $self->run_command( $command, $vars );
    }

}

sub run_command($self,$command,$vars) {

    if( !ref $command ) {
        $command = { cmd => $command };
    }

    if( my $subtask = $command->{task} ) {
            my $t = $self->tasks->task($subtask);
            my $newt = App::Dothe::Task->new(
                name => $t->name,
                tasks => $t->tasks,