Merge branch 'develop'

Author: jerowe

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

@@ -13,6 +13,7 @@ use Data::Dumper;
 use Scalar::Util 'blessed';
 use Try::Tiny;
 use Safe;
+use Storable qw(dclone);
 
 # use File::Basename;
 use File::Spec;
@@ -264,6 +265,7 @@ has 'HPC' => (
 ##This is useful for features where we want to do things like
 ##split a file into parts
 ##count by kmers, etc
+
 =head2 Iterables
 
 Lists to iterate by
@@ -272,6 +274,12 @@ Chunks and chroms are included by default
 
 =cut
 
+=head2 chunks
+
+Special iterable. Iterate through a list of numbers
+
+=cut
+
 has 'chunks' => (
     is      => 'rw',
     isa     => 'HashRef',
@@ -286,18 +294,67 @@ has 'use_chunks' => (
     isa     => 'Bool',
     default => 0,
     handles => {
-      'no_chunks' => 'not',
+        'no_chunks' => 'not',
     }
 );
 
+has 'chunk_list' => (
+    traits  => ['Array'],
+    is      => 'rw',
+    isa     => 'ArrayRef',
+    lazy    => 1,
+    default => sub {
+        my $self = shift;
+        if ( !exists $self->chunks->{start} || !exists $self->chunks->{end} ) {
+            return [];
+        }
+        my @array = ();
+        for (
+            my $x = $self->chunks->{start} ;
+            $x <= $self->chunks->{end} ;
+            $x = $x + $self->chunks->{step}
+          )
+        {
+            push( @array, $x );
+        }
+        return \@array;
+    },
+    handles => {
+        'all_chunk_lists' => 'elements',
+    },
+);
+
+=head2 chroms_list
+
+Iterate by chroms. Default is human chromosomes.
+
+To change create a first rule with the template
+
+=cut
+
+has 'chroms_list' => (
+    traits  => ['Array'],
+    is      => 'rw',
+    isa     => 'ArrayRef',
+    default => sub {
+        return [ 1 .. 22, 'X', 'Y', 'MT' ];
+    },
+    handles => {
+        'all_chrom_lists' => 'elements',
+    },
+);
+
+has 'chrom' => ( is => 'rw' );
 
-has 'chroms' => (
-is => 'rw',
-isa => 'ArrayRef',
-default => sub {
-  return [1 .. 22, 'X', 'Y', 'MT'];
-},
-)
+has 'use_chroms' => (
+    is      => 'rw',
+    traits  => ['Bool'],
+    isa     => 'Bool',
+    default => 0,
+    handles => {
+        'no_chroms' => 'not',
+    }
+);
 
 =head2 stash
 
@@ -368,6 +425,9 @@ sub create_attr {
                 if ( $k eq 'stash' ) {
                     $self->merge_stash($v);
                 }
+                elsif ( $k =~ m/_list/ ) {
+                    $self->create_ITERABLE_attr( $meta, $k );
+                }
                 elsif ( ref($v) eq 'HASH' ) {
                     $self->create_HASH_attr( $meta, $k );
                 }
@@ -408,10 +468,10 @@ sub create_ARRAY_attr {
             clearer => "clear_$k",
             default => sub { [] },
             handles => {
-                "all_$k"    => 'elements',
-                "count_$k"  => 'count',
-                "has_$k"    => 'count',
-                "has_no_$k" => 'is_empty',
+                "all_$k" . "s" => 'elements',
+                "count_$k"     => 'count',
+                "has_$k"       => 'count',
+                "has_no_$k"    => 'is_empty',
             },
         )
     );
@@ -439,6 +499,26 @@ sub create_HASH_attr {
     );
 }
 
+sub create_BOOL_attr {
+    my $self = shift;
+    my $meta = shift;
+    my $k    = shift;
+
+    $meta->add_attribute(
+            'use_'
+          . $k
+          . 's' => (
+            traits  => ['Bool'],
+            is      => 'rw',
+            isa     => 'Bool',
+            default => 0,
+            handles => {
+                'no_' . $k . 's' => 'not',
+            }
+          )
+    );
+}
+
 sub create_reg_attr {
     my $self = shift;
     my $meta = shift;
@@ -452,6 +532,54 @@ sub create_reg_attr {
     );
 }
 
+=head3 create_blank_attr
+
+placeholder for ITERABLE
+
+=cut
+
+sub create_blank_attr {
+    my $self = shift;
+    my $meta = shift;
+    my $k    = shift;
+
+    $meta->add_attribute(
+        $k => (
+            is      => 'rw',
+            default => '',
+        )
+    );
+}
+
+=head3 create_ITERABLE_attr
+
+For every argument that ends in _list, create an array, a single val, and a boolean
+
+If iterable is
+
+  some_list
+
+We get an array 'some_list', boolean value 'use_somes', and blank/placeholder of 'some'
+
+The boolean value is set to 0
+
+You can only use one iterable per flow
+
+=cut
+
+sub create_ITERABLE_attr {
+    my $self = shift;
+    my $meta = shift;
+    my $k    = shift;
+
+    my $t = $k;
+    $t =~ s/_list//;
+
+    $self->create_ARRAY_attr( $meta, $k );
+    $self->create_blank_attr( $meta, $t );
+    $self->create_BOOL_attr( $meta, $t );
+}
+
 sub interpol_directive {
     my $self   = shift;
     my $source = shift;
@@ -469,6 +597,9 @@ sub interpol_directive {
     );
 
     my $fill_in = { self => \$self };
+    #TODO reference keys by value instead of $self->
+    # my @keys = keys %{$self};
+    $fill_in->{INPUT} = $self->INPUT;
     $fill_in->{sample} = $self->sample if $self->has_sample;
 
     $text = $template->fill_in( HASH => $fill_in, BROKEN => \&my_broken );

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

@@ -265,6 +265,8 @@ sub set_rule_names {
     $self->app_log->info( 'Found rules:' . "\t" . join( ', ', @rule_names ) );
 }
 
+#TODO This is confusing change names
+
 =head3 set_rule_keys
 
 If we have any select_* or select_match, get those rules before we start processing
@@ -554,8 +556,7 @@ sub template_process {
 
     ##TODO for modify chunks
     foreach my $sample ( $self->all_samples ) {
-
-        $texts = $self->check_chunks( $sample, $texts );
+        $texts = $self->check_iterables( $sample, $texts );
     }
 
     $self->process_obj->{ $self->rule_name }->{text} = $texts;
@@ -573,23 +574,45 @@ sub template_process {
     }
 }
 
-sub check_chunks {
+sub check_iterables {
     my $self   = shift;
     my $sample = shift;
     my $texts  = shift;
 
-    if ( $self->local_attr->no_chunks ) {
+    #First check the global for any lists
+    my $iter     = '';
+    my $use_iter = 0;
+    my @use      = ();
+    map {
+        if ( $_ =~ m/^use_/ ) { push( @use, $_ ) }
+    } @{ $self->rule_keys };
+    map {
+        if ( $_ =~ m/^use_/ ) { push( @use, $_ ) }
+    } @{ $self->local_rule_keys };
+
+
+    my $use = pop(@use);
+
+    if(! $use){
         $texts = $self->in_template_process( $sample, $texts );
         return $texts;
     }
 
-    ##TODO ADD CHECKS
-    my $start = $self->local_attr->chunks->{start} || 0;
-    my $end   = $self->local_attr->chunks->{end};
-    my $step  = $self->local_attr->chunks->{step} || 1;
+    my $base = $use;
+    $base =~ s/use_//;
+
+    my $no = 'no_'.$base;
+    my $elem = $base;
+    $elem =~ s/s$//;
+    my $all  = 'all_'.$elem.'_lists';
+
+    if ( $self->local_attr->$no ) {
+        $texts = $self->in_template_process( $sample, $texts );
+        return $texts;
+    }
 
-    for ( my $x = $start ; $x <= $end ; $x = $x + $step ) {
-        $self->local_attr->chunk($x);
+    foreach my $chunk ( $self->local_attr->$all) {
+        $self->local_attr->$elem($chunk);
         $texts = $self->in_template_process( $sample, $texts );
     }
     return $texts;

t/lib/TestsFor/BioX/Workflow/Command/run/Test002.pm

@@ -166,7 +166,7 @@ sub test_003 : Tags(get_samples) {
 
     ok( $test->global_attr->indir->can('absolute'),
         'Indir has method absolute' );
-    ok( $test->global_attr->can('all_some_array'),  'Array has all method' );
+    ok( $test->global_attr->can('all_some_arrays'),  'Array has all method' );
     ok( $test->global_attr->can('some_hash_pairs'), 'Hash has pairs method' );
 }