Merge branch 'master' into develop

Author: jerowe

lib/BioX/Workflow/Command.pm

@@ -12,6 +12,7 @@ use File::Path qw(make_path);
 app_strict 0;
 
 # TODO move this after I have a better idea of where it is going
+# TODO nope
 option 'cache_dir' => (
     is      => 'rw',
     isa     => Path,
@@ -32,8 +33,8 @@ sub BUILD {
 before 'BUILD' => sub {
     my $self = shift;
 
-    make_path( $self->cache_dir );
-    make_path(File::Spec->catdir($self->cache_dir, 'logs'));
+    # make_path( $self->cache_dir );
+    # make_path(File::Spec->catdir($self->cache_dir, 'logs'));
 };
 
 no Moose;

lib/BioX/Workflow/Command/file_log.pm

@@ -57,6 +57,7 @@ sub execute {
             next;
         }
 
+        ##TODO Make this a table
         my $details = File::Details->new($file);
         my $mtime   = ctime( stat($file)->mtime );
         # $self->track_files->{$file}->{mtime} = $mtime;

lib/BioX/Workflow/Command/run/Utils/Directives.pm

@@ -592,14 +592,14 @@ sub interpol_directive {
     my $source = shift;
     my $text   = '';
 
-    if ( exists $self->interpol_directive_cache->{$source} ) {
-        return $self->interpol_directive_cache->{$source};
-    }
-
-    if ( $source !~ m/{\$/ ) {
-        $self->interpol_directive_cache->{$source} = $source;
-        return $source;
-    }
+    # if ( exists $self->interpol_directive_cache->{$source} && $source !~ m/{\$/ ) {
+    #     return $self->interpol_directive_cache->{$source};
+    # }
+
+    # if ( $source !~ m/{\$/ ) {
+    #     $self->interpol_directive_cache->{$source} = $source;
+    #     return $source;
+    # }
 
     my $template = Text::Template->new(
         TYPE   => 'STRING',

lib/BioX/Workflow/Command/run/Utils/Rules.pm

@@ -7,6 +7,7 @@ use Data::Walk;
 use Data::Dumper;
 use File::Path qw(make_path remove_tree);
 use Try::Tiny;
+use Path::Tiny;
 
 with 'BioX::Workflow::Command::Utils::Files::TrackChanges';
 use BioX::Workflow::Command::Utils::Traits qw(ArrayRefOfStrs);
@@ -519,37 +520,6 @@ EOF
     $self->app_log->fatal($rule_example);
 }
 
-=head3 carry_directives
-
-At the beginning of each rule the previous outdir should be the new indir, and the previous OUTPUT should be the new INPUT
-
-Stash should be carried over
-
-Outdir should be global_attr->outdir/rule_name
-
-=cut
-
-sub carry_directives {
-    my $self = shift;
-
-    $self->local_attr->outdir(
-        $self->global_attr->outdir . '/' . $self->rule_name );
-
-    return unless $self->has_p_rule_name;
-
-    $self->local_attr->indir( dclone( $self->p_local_attr->outdir ) );
-
-    if ( $self->p_local_attr->has_OUTPUT ) {
-        if ( ref( $self->p_local_attr->OUTPUT ) ) {
-            $self->local_attr->INPUT( dclone( $self->p_local_attr->OUTPUT ) );
-        }
-        else {
-            $self->local_attr->INPUT( $self->p_local_attr->OUTPUT );
-        }
-    }
-
-    $self->local_attr->stash( dclone( $self->p_local_attr->stash ) );
-}
 
 =head3 template_process
 
@@ -570,6 +540,7 @@ sub template_process {
 
     my $dummy_sample = $self->dummy_sample;
     my $dummy_texts = $self->check_iterables( $dummy_sample, [] );
+
     foreach my $sample ( $self->all_samples ) {
         foreach my $text ( @{$dummy_texts} ) {
             my $new_text = $text;
@@ -582,15 +553,6 @@ sub template_process {
 
     $self->process_obj->{ $self->rule_name }->{meta} =
       $self->write_rule_meta('before_meta');
-
-   # return unless $self->use_timestamps;
-   # if ( $self->local_attr->{_modified} ) {
-   #     $self->app_log->info(
-   #         'One or more files were modified or are not logged for this rule');
-   # }
-   # else {
-   #     $self->app_log->info('Zero files were modified for this rule');
-   # }
 }
 
 sub use_iterables {
@@ -632,12 +594,14 @@ sub check_iterables {
     #First check the global for any lists
     my $use_iters = $self->use_iterables;
 
-    if ( ! $use_iters ) {
+    $self->walk_indir_outdir($use_iters);
+
+    if ( !$use_iters ) {
         $texts = $self->in_template_process( $sample, $texts );
         return $texts;
     }
 
-    my $all = $use_iters->[0];
+    my $all  = $use_iters->[0];
     my $elem = $use_iters->[1];
 
     ##TODO This should be a separate function
@@ -653,7 +617,6 @@ sub check_iterables {
             push( @$texts, $new_text );
         }
     }
-    ##
 
     return $texts;
 }
@@ -673,6 +636,35 @@ sub in_template_process {
     return $texts;
 }
 
+sub walk_attr {
+    my $self = shift;
+
+    my $attr = dclone( $self->local_attr );
+    $self->check_indir_outdir($attr);
+
+    $DB::single = 2;
+
+    $attr->walk_process_data( $self->rule_keys );
+
+    return $attr;
+}
+
+sub eval_process {
+    my $self = shift;
+
+    my $attr = $self->walk_attr;
+    $attr->sample( $self->sample ) if $self->has_sample;
+
+    my $process = $self->local_rule->{ $self->rule_name }->{process};
+    my $text    = $attr->interpol_directive($process);
+    $text = clean_text($text);
+
+    $self->walk_FILES($attr);
+    $self->clear_files;
+
+    return $text;
+}
+
 sub get_global_keys {
     my $self        = shift;
     my @global_keys = ();
@@ -709,45 +701,68 @@ sub get_keys {
     $self->rule_keys( \@global_keys );
 }
 
-sub walk_attr {
-    my $self = shift;
+##TODO Clean this up and merge with the other walk_iterables
+##TODO Write more tests
+sub walk_indir_outdir {
+    my $self      = shift;
+    my $use_iters = shift;
 
+    ##TODO This is redundant...
     my $attr = dclone( $self->local_attr );
-    $self->check_indir_outdir($attr);
-
-    $DB::single = 2;
+    my $dummy_sample = $self->dummy_sample;
+    $attr->sample($dummy_sample);
 
-    $attr->walk_process_data( $self->rule_keys );
+    if ( $attr->outdir =~ m/\{\$/ ) {
+        $attr->walk_process_data( $self->rule_keys );
+    }
 
-    if ( $attr->create_outdir && !$attr->outdir->is_dir ) {
+    my $text = $attr->interpol_directive( $self->local_attr->outdir );
 
-        try {
-            $attr->outdir->mkpath;
+    if ( !$use_iters ) {
+        foreach my $sample ( $attr->all_samples ) {
+            my $new_text = $text;
+            $new_text =~ s/$dummy_sample/$sample/g;
+            $new_text = path($new_text)->absolute if $attr->coerce_abs_dir;
+            $new_text = path($new_text)           if !$attr->coerce_abs_dir;
+            $self->decide_create_outdir( $attr, $new_text );
         }
-        catch {
-            $self->app_log->fatal( "We were not able to make the directory.\n\t"
-                  . $attr->outdir
-                  . "\n\tError: $!" );
-        };
+        return;
     }
 
-    return $attr;
-}
+    my $all  = $use_iters->[0];
+    my $elem = $use_iters->[1];
 
-sub eval_process {
-    my $self = shift;
+    ##TODO This should be a separate function
+    my $dummy_iter = $self->dummy_iterable;
+    $attr->$elem($dummy_iter);
 
-    my $attr = $self->walk_attr;
-    $attr->sample( $self->sample ) if $self->has_sample;
+    ##BUG FIX - If outdirs have iterables this will be bad
 
-    my $process = $self->local_rule->{ $self->rule_name }->{process};
-    my $text    = $attr->interpol_directive($process);
-    $text = clean_text($text);
+    foreach my $chunk ( $self->local_attr->$all ) {
+        my $new_text = $text;
+        $new_text =~ s/$dummy_iter/$chunk/g;
+        $new_text = path($new_text)->absolute if $attr->coerce_abs_dir;
+        $new_text = path($new_text)           if !$attr->coerce_abs_dir;
+        $self->decide_create_outdir( $attr, $new_text );
+    }
+}
 
-    $self->walk_FILES($attr);
-    $self->clear_files;
+sub decide_create_outdir {
+    my $self = shift;
+    my $attr = shift;
+    my $dir  = shift;
 
-    return $text;
+    return unless $attr->create_outdir;
+    return unless $dir;
+
+    try {
+        $dir->mkpath;
+    }
+    catch {
+        $self->app_log->fatal( "We were not able to make the directory.\n\t"
+              . $attr->outdir
+              . "\n\tError: $!" );
+    };
 }
 
 sub clean_text {
@@ -812,6 +827,8 @@ sub print_rule {
     return $print_rule;
 }
 
+##This is not necessary without the use_timestamps
+##But I will leave it in as a placeholder
 sub print_within_rule {
     my $self = shift;
 
@@ -851,6 +868,7 @@ sub check_indir_outdir {
 
     # If indir/outdir is specified in the local config
     # then we don't evaluate it
+
     foreach my $dir ( ( 'indir', 'outdir' ) ) {
         if ( grep /$dir/, @{ $self->local_rule_keys } ) {
             next;
@@ -875,4 +893,36 @@ sub check_indir_outdir {
 
 }
 
+=head3 carry_directives
+
+At the beginning of each rule the previous outdir should be the new indir, and the previous OUTPUT should be the new INPUT
+
+Stash should be carried over
+
+Outdir should be global_attr->outdir/rule_name
+
+=cut
+
+sub carry_directives {
+    my $self = shift;
+
+    $self->local_attr->outdir(
+        $self->global_attr->outdir . '/' . $self->rule_name );
+
+    return unless $self->has_p_rule_name;
+
+    $self->local_attr->indir( dclone( $self->p_local_attr->outdir ) );
+
+    if ( $self->p_local_attr->has_OUTPUT ) {
+        if ( ref( $self->p_local_attr->OUTPUT ) ) {
+            $self->local_attr->INPUT( dclone( $self->p_local_attr->OUTPUT ) );
+        }
+        else {
+            $self->local_attr->INPUT( $self->p_local_attr->OUTPUT );
+        }
+    }
+
+    $self->local_attr->stash( dclone( $self->p_local_attr->stash ) );
+}
+
 1;

lib/BioX/Workflow/Command/run/Utils/Samples.pm

@@ -162,8 +162,8 @@ sub get_samples {
     #But we don't keep it around, because that would be madness
     #TODO Fix this we should process these the same way we process rule names
     $attr       = dclone( $self->global_attr );
-    $DB::single = 2;
-    if ( $attr->indir =~ m/\{\$self/ ) {
+    # $DB::single = 2;
+    if ( $attr->indir =~ m/\{\$/ ) {
         $attr->walk_process_data( $self->global_keys );
     }