File Coverage

blib/lib/OPTiMaDe/Filter/ListComparison.pm
Criterion Covered Total %
statement 49 52 94.2
branch 10 14 71.4
condition 2 3 66.6
subroutine 11 11 100.0
pod 0 8 0.0
total 72 88 81.8


line stmt bran cond sub pod time code
1             package OPTiMaDe::Filter::ListComparison;
2              
3 5     5   76 use strict;
  5         30  
  5         142  
4 5     5   25 use warnings;
  5         8  
  5         142  
5 5     5   26 use Scalar::Util qw(blessed);
  5         9  
  5         3300  
6              
7             sub new {
8 22     22 0 55 my( $class, $operator ) = @_;
9 22         108 return bless { property => undef,
10             operator => $operator,
11             values => undef }, $class;
12             }
13              
14             sub property {
15 42     42 0 80 my( $self, $property ) = @_;
16 42         68 my $previous_property = $self->{property};
17 42 100       101 $self->{property} = $property if defined $property;
18 42         101 return $previous_property;
19             }
20              
21             sub operator {
22 20     20 0 39 my( $self, $operator ) = @_;
23 20         38 my $previous_operator = $self->{operator};
24 20 50       45 $self->{operator} = $operator if defined $operator;
25 20         46 return $previous_operator;
26             }
27              
28             sub values {
29 42     42 0 120 my( $self, $values ) = @_;
30 42         86 my $previous_values = $self->{values};
31 42 100       104 $self->{values} = $values if defined $values;
32 42         126 return $previous_values;
33             }
34              
35             sub to_filter {
36 20     20 0 853 my( $self ) = @_;
37 20         54 $self->validate;
38              
39 20         36 my @values;
40 20         35 for my $i (0..$#{$self->{values}}) {
  20         59  
41 50         70 my( $operator, $arg ) = @{$self->{values}[$i]};
  50         106  
42 50 100 66     141 if( blessed $arg && $arg->can( 'to_filter' ) ) {
43 2         5 $arg = $arg->to_filter;
44             } else {
45 48         87 $arg =~ s/\\/\\\\/g;
46 48         67 $arg =~ s/"/\\"/g;
47 48         82 $arg = "\"$arg\"";
48             }
49 50         118 push @values, "$operator $arg";
50             }
51              
52             return '(' . join( ' ', $self->{property}->to_filter,
53             $self->{operator},
54 20         59 join( ', ', @values ) ) . ')';
55             }
56              
57             sub to_SQL
58             {
59 10     10 0 112 die "no SQL representation\n";
60             }
61              
62             sub modify {
63 2     2 0 6 my $self = shift;
64 2         4 my $code = shift;
65              
66 2         9 $self->{property} = $code->( $self->{property}, @_ );
67 6         51 $self->{values} = [ map { [ OPTiMaDe::Filter::modify( $_->[0], $code, @_ ),
68             OPTiMaDe::Filter::modify( $_->[1], $code, @_ ) ] }
69 2         26 @{$self->{values}} ];
  2         7  
70 2         21 return $code->( $self, @_ );
71             }
72              
73             sub validate
74             {
75 20     20 0 36 my $self = shift;
76              
77 20 50       36 if( !$self->property ) {
78 0         0 die 'property undefined for OPTiMaDe::Filter::ListComparison';
79             }
80 20 50       54 if( !$self->operator ) {
81 0         0 die 'operator undefined for OPTiMaDe::Filter::ListComparison';
82             }
83 20 50       42 if( !$self->values ) {
84 0           die 'values undefined for OPTiMaDe::Filter::ListComparison';
85             }
86             }
87              
88             1;