File Coverage

blib/lib/HTML/FormStructure.pm

Criterion	Covered	Total	%
statement	82	104	78.8
branch	21	42	50.0
condition	1	3	33.3
subroutine	18	21	85.7
pod	12	13	92.3
total	134	183	73.2

package HTML::FormStructure;

use strict;
use vars qw($VERSION);
$VERSION = '0.04';

use HTML::FormStructure::Query;
use HTML::FormStructure::Validation;

use base qw(Class::Accessor);

sub _my_accessors {
    qw(action method enctype r validator);
}

sub _init {
    my $opt = shift;
    $opt->{form_accessors} = defined $opt->{form_accessors} ?
	$opt->{form_accessors} : [];
    __PACKAGE__->mk_accessors(
	&_my_accessors,@{$opt->{form_accessors}}
    );
}

sub new {
    my($class, $form, $r, $opt) = @_;
    _init($opt);
    my @query;
    for my $query (@{$form}) {
	if (ref $query->{consist} eq 'ARRAY') {
	    my @tmp_query;
	    for my $q (@{$query->{consist}}) {
		my $tmp_q = HTML::FormStructure::Query->new($q,$opt);
		push @tmp_query, $tmp_q;
	    }
	    $query->{consist} = \@tmp_query;
	    push @query, HTML::FormStructure::Query->new($query,$opt);
	}
	else {
	    push @query, HTML::FormStructure::Query->new($query,$opt);
	}
    }
    my $self = bless { _form_data => \@query }, $class;
    $self->r($r) if defined $r;
    return $self;
}

sub list_as_array {
    return @{shift->{_form_data}};
}

sub list_as_arrayref {
    return shift->{_form_data};
}

sub have {
    my $self = shift;
    my $meth = shift;
    my @wanted;
    for my $query ($self->list_as_array) {
	if ($query->$meth()) {
	    push @wanted, $query if defined $query->$meth();
	}
	next unless ($query->consist);
	for my $q ($query->array_of('consist')) {
	    next unless $q->$meth();
	    push @wanted, $q if defined $q->$meth();
	}
    }
    return @wanted;
}

sub _do_search {
    my $self = shift;
    my $key  = shift;
    my $val  = shift;
    my $type = shift;
    my @ret;
    for my $query ($self->list_as_array) {
	if (defined $type && $type eq 'like') {
	    push @ret,$query if $query->$key() =~ /$val/;
	}
	else {
	    push @ret,$query if $query->$key() eq $val;
	}
	for my $q ($query->array_of('consist')) {
	    push @ret, $q if $q->$key() eq $val;
	}
    }
    return @ret;
}

sub search { shift->_do_search(@_)}

sub search_like { shift->_do_search(@_,'like')}

sub fetch {
    my $self = shift;
    my $target = ($self->search('name',shift))[0];
    return $target ? $target : '';
}

sub group {
    my $self = shift;
    my $key = shift;
    my $ret = {};
    for my $query ($self->have($key)) {
	push @{$ret->{$query->$key()}}, $query;
    }
    return map { $ret->{$_}} keys %{$ret};
}

sub param {
    my $self = shift;
    my $target = ($self->search('name',shift))[0];
    return $target ? $target->store : '';
}

sub store_request {
    my $self = shift;
    for my $query ($self->list_as_array) {
	if (defined $query->storef) {
	    $query->store(
		sprintf $query->storef,
		$self->r->param($query->name)
	    );
	}
	else {
	    $query->store($self->r->param($query->name));
	}
	for my $q ($query->array_of('consist')) {
	    $q->store($self->r->param($q->name));
	}
    }
}

sub hashref {
    my $self = shift;
    my ($key,$val,$situation) = @_;
    my $hashref = {};
    for ($self->have($key)) {
	if ($situation) {
	    next unless defined $_->$situation();
	}
	$hashref->{$_->name} = $_->$val() if defined $_->$val();
    }
    return $hashref;
}

sub query_combine { shift->consist_query }

sub consist_query {
    my $self = shift;
    for my $query ($self->have('consist')) {
	my $value;
	if (defined $query->consistf) {
	    $value = sprintf $query->consistf,
		map $self->r->param($_->name),$query->array_of('consist');
	}
	else {
	    for my $q ($query->array_of('consist')) {
		$value .= defined $self->r->param($q->name) ?
		    $self->r->param($q->name) : '';
	    }
	}
	$self->r->param($query->name => $value) if defined $value;
    }
}

1;

__END__