Websites/bugs.webkit.org/Bugzilla/Search/Clause.pm

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.

package Bugzilla::Search::Clause;

use 5.10.1;
use strict;
use warnings;

use Bugzilla::Error;
use Bugzilla::Search::Condition qw(condition);
use Bugzilla::Util qw(trick_taint);

sub new {
    my ($class, $joiner) = @_;
    if ($joiner and $joiner ne 'OR' and $joiner ne 'AND') {
        ThrowCodeError('search_invalid_joiner', { joiner => $joiner });
    }
    # This will go into SQL directly so needs to be untainted.
    trick_taint($joiner) if $joiner;
    bless { joiner => $joiner || 'AND' }, $class;
}

sub children {
    my ($self) = @_;
    $self->{children} ||= [];
    return $self->{children};
}

sub update_search_args {
    my ($self, $search_args) = @_;
    # abstract
}

sub joiner { return $_[0]->{joiner} }

sub has_translated_conditions {
    my ($self) = @_;
    my $children = $self->children;
    return 1 if grep { $_->isa('Bugzilla::Search::Condition')
                       && $_->translated } @$children;
    foreach my $child (@$children) {
        next if $child->isa('Bugzilla::Search::Condition');
        return 1 if $child->has_translated_conditions;
    }
    return 0;
}

sub add {
    my $self = shift;
    my $children = $self->children;
    if (@_ == 3) {
        push(@$children, condition(@_));
        return;
    }
    
    my ($child) = @_;
    return if !defined $child;
    $child->isa(__PACKAGE__) || $child->isa('Bugzilla::Search::Condition')
        || die 'child not the right type: ' . $child;
    push(@{ $self->children }, $child);
}

sub negate {
    my ($self, $value) = @_;
    if (@_ == 2) {
        $self->{negate} = $value ? 1 : 0;
    }
    return $self->{negate};
}

sub walk_conditions {
    my ($self, $callback) = @_;
    foreach my $child (@{ $self->children }) {
        if ($child->isa('Bugzilla::Search::Condition')) {
            $callback->($self, $child);
        }
        else {
            $child->walk_conditions($callback);
        }
    }
}

sub as_string {
    my ($self) = @_;
    if (!$self->{sql}) {
        my @strings;
        foreach my $child (@{ $self->children }) {
            next if $child->isa(__PACKAGE__) && !$child->has_translated_conditions;
            next if $child->isa('Bugzilla::Search::Condition')
                    && !$child->translated;

            my $string = $child->as_string;
            next unless $string;
            if ($self->joiner eq 'AND') {
                $string = "( $string )" if $string =~ /OR/;
            }
            else {
                $string = "( $string )" if $string =~ /AND/;
            }
            push(@strings, $string);
        }

        my $sql = join(' ' . $self->joiner . ' ', @strings);
        $sql = "NOT( $sql )" if $sql && $self->negate;
        $self->{sql} = $sql;
    }
    return $self->{sql};
}

# Search.pm converts URL parameters to Clause objects. This helps do the
# reverse.
sub as_params {
    my ($self) = @_;
    my @params;
    foreach my $child (@{ $self->children }) {
        if ($child->isa(__PACKAGE__)) {
            my %open_paren = (f => 'OP', n => scalar $child->negate,
                              j => $child->joiner);
            push(@params, \%open_paren);
            push(@params, $child->as_params);
            my %close_paren =  (f => 'CP');
            push(@params, \%close_paren);
        }
        else {
            push(@params, $child->as_params);
        }
    }
    return @params;
}

1;

=head1 B<Methods in need of POD>

=over

=item has_translated_conditions

=item as_string

=item add

=item children

=item negate

=item update_search_args

=item walk_conditions

=item joiner

=item as_params

=back