File Coverage

blib/lib/Moonshine/Component.pm

Criterion	Covered	Total	%
statement	80	88	90.9
branch	24	34	70.5
condition	5	9	55.5
subroutine	11	11	100.0
pod	0	2	0.0
total	120	144	83.3

package Moonshine::Component;

use strict;
use warnings;

use Moonshine::Element;
use Moonshine::Magic;
use Params::Validate qw(:all);
use Ref::Util qw(:all);
use feature qw/switch/;
no if $] >= 5.017011, warnings => 'experimental::smartmatch';

extends "UNIVERSAL::Object";

our $VERSION = '0.05';

BEGIN {
    my $fields = $Moonshine::Element::HAS{"attribute_list"}->();
    my %html_spec = map { $_ => 0 } @{$fields}, qw/data tag/;

    has (
        html_spec     => sub { \%html_spec },
        modifier_spec => sub { { } },
    );
}

sub validate_build {
    my $self = shift;
    my %args = validate_with(
        params => $_[0],
        spec   => {
            params => { type => HASHREF },
            spec   => { type => HASHREF },
        }
    );

    my %html_spec   = %{ $self->html_spec };
    my %html_params = ();

    my %modifier_spec   = %{ $self->modifier_spec };
    my %modifier_params = ();

    my %combine = ( %{ $args{params} }, %{ $args{'spec'} } );

    for my $key ( keys %combine ) {
        my $spec = $args{spec}->{$key};
        if ( is_hashref($spec) ) {
            defined $spec->{build} and next;
            if ( exists $spec->{base} ) {
                my $param = delete $args{params}->{$key};
                my $spec  = delete $args{spec}->{$key};
                $html_params{$key} = $param if $param;
                $html_spec{$key}   = $spec  if $spec;
                next;
            }
        }

        if ( exists $html_spec{$key} ) {
            if ( defined $spec ) {
                $html_spec{$key} = delete $args{spec}->{$key};
            }
            if ( exists $args{params}->{$key} ) {
                $html_params{$key} = delete $args{params}->{$key};
            }
            next;
        }
        elsif ( exists $modifier_spec{$key} ) {
            if ( defined $spec ) {
                $modifier_spec{$key} = delete $args{spec}->{$key};
            }
            if ( exists $args{params}->{$key} ) {
                my $params = $args{params}->{$key};
                $modifier_params{$key} = delete $args{params}->{$key};
            }
            next;
        }
    }

    my %base = validate_with(
        params => \%html_params,
        spec   => \%html_spec,
    );

    my %build = validate_with(
        params => $args{params},
        spec   => $args{spec},
    );

    my %modifier = validate_with(
        params => \%modifier_params,
        spec   => \%modifier_spec,
    );

    for my $element (qw/before_element after_element children/) {
        if ( defined $modifier{$element} ) {
            my @elements = $self->build_elements( @{ $modifier{$element} } );
            $base{$element} = \@elements;
        }
    }

    if (scalar keys %modifier and $self->can('modify')) {
        return $self->modify(\%base, \%build, \%modifier);
    }

    return \%base, \%build, \%modifier;
}

sub build_elements {
    my $self = shift;
    my @elements_build_instructions = @_;

    my @elements;
    for my $build (@elements_build_instructions) {
        my $element;
        if ( is_blessed_ref($build) and $build->isa('Moonshine::Element') ) {
            $element = $build;
        }
        elsif ( my $action = delete $build->{action} ) {
            $self->can($action) and $element = $self->$action($build)
              or die "cannot find action - $action";
        }
        elsif ( defined $build->{tag} ) {
            $element = Moonshine::Element->new($build);
        }
        else {
            my $error_string =
              join( ", ", map { "$_: $build->{$_}" } keys %{$build} );
            die sprintf "no instructions to build the element: %s",
              $error_string;
        }
        push @elements, $element;
    }

    return @elements;
}

1;

__END__