File Coverage

blib/lib/Moonshine/Template.pm

Criterion	Covered	Total	%
statement	64	121	52.8
branch	11	52	21.1
condition	5	34	14.7
subroutine	17	22	77.2
pod	1	5	20.0
total	98	234	41.8

package Moonshine::Template;

use strict;
use warnings;

our $VERSION = '0.05';

use Moonshine::Element;
use Ref::Util qw/:all/;
use Hash::Merge qw/merge/;
use Hash::Util qw/unlock_hashref/;
our @ISA;
BEGIN { @ISA = ('UNIVERSAL::Object') }

our %HAS;

BEGIN {
    %HAS = ( base_element => sub { undef } );
}

sub BUILD {
    my ( $self, $build_args ) = @_;

    unlock_hashref($self);

    my $config = $self->_merge_configs( $build_args->{config} // {} );

    my $base_element = $self->add_base_element( $build_args->{base_element}
          // delete $config->{base_element} );

    if ( defined $config ) {
        $config = $self->_process_config( $config, $base_element );
    }

    die "build_html is not defined" unless $self->can('build_html');

    if ( is_blessed_ref($base_element) ) {
        $self->{base_element} = $base_element;
    }

    $base_element =
      $self->build_html( $self->_return_base_element($base_element) );

    $self->{base_element} = $base_element;

    return $self;
}

sub add_base_element {
    my ( $self, $base_element_args ) = @_;

    if ( $self->can('base_element') ) {
        $base_element_args = merge( $self->base_element, $base_element_args );
    }

    if ( is_hashref($base_element_args) ) {
        return
          defined $base_element_args->{template}
          ? $base_element_args->{template}
          ->new( $base_element_args->{template_args} // {} )
          : Moonshine::Element->new($base_element_args);
    }

    return undef;
}

sub render {
    return $_[0]->{base_element}->render;
}

sub children {
    my $element = $_[0]->_return_base_element( $_[0]->{base_element} );
    return $element->{children};
}

sub element {
    return $_[0]->_return_base_element( $_[0]->{base_element} );
}

sub _merge_configs {
    my ( $self, $build_config ) = ( shift, shift );
    my $base_config = $self->can('config') && $self->config // {};
    return merge( $build_config, $base_config );
}

sub _process_config {
    my ( $self, $config, $element ) = @_;

    my $action_config = $self->_config_to_actions($config);

    for ( @{$action_config} ) {
        my $key   = ( keys %{$_} )[0];
        my $value = $_->{$key};

        my $processed_element =
          $self->add_base_element( $value->{build} ? $value->{build} : $value );

        if ( is_blessed_ref($processed_element) ) {
            if ( defined $value->{target} ) {
                my $target =
                    $value->{target} eq 'base_element'
                  ? $self->_return_base_element($element)
                  : $self->_return_base_element(
                    $config->{ $value->{target} } );
                my $action = $value->{action} // 'add_child';
                $target->$action(
                    $self->_return_base_element($processed_element) );
            }
            $config->{$key} = $processed_element;
        }
    }

    for ( keys %{$config} ) {
        _make_shine( $_, $config );
    }

    return $config;
}

sub _config_to_actions {
    my ( $self, $config ) = @_;

    my @configs = ();
    my @keys    = keys %{$config};
    my $previous;
    while (@keys) {
        my $key   = shift @keys;
        my $value = $config->{$key};

        grep { defined $value->{$_} } qw/action target template tag build/
          or next;

        $previous && $previous eq $key
          and die "$key target - $value->{target} does not exist in the spec"
          or $previous = $key;

        my $target = $value->{target}
          or unshift @configs, { $key => $value }
          and next;

        $target eq 'base_element'
          and unshift @configs, { $key => $value }
          and next;

        my $success = 0;
        if ( my $config_count = scalar @configs ) {
            for ( my $index = 0 ; $index < $config_count ; $index++ ) {
                if ( my $target_found = $configs[$index]->{$target} ) {
                    splice @configs, $index + 1, 0, { $key => $value };
                    $success = 1;
                    last;
                }
            }
        }
        unless ($success) {
            push @keys, $key;
        }
    }

    return \@configs;
}

sub _make_shine {
    my ( $key, $config ) = @_;

    {
        no strict 'refs';
        no warnings 'redefine';
        {
            *{"has_$key"} = sub {
                my $val = $config->{$key};
                defined $val or return undef;
                is_arrayref($val) and return scalar @{$val};
                is_hashref($val) and return map { $_; }
                  sort { $a <=> $b or $a cmp $b }
                  keys %{$val};
                return 1;
              }
        };
        {
            *{"$key"} = sub {
                my $val = $config->{$key};
                defined $_[1] or return $val;
                is_arrayref($val) && not is_arrayref( $_[1] )
                  and return push @{$val}, $_[1];
                is_hashref($val) and ( is_hashref( $_[1] )
                    and return
                    map { $config->{$_} = $_[1]->{$_} } keys %{ $_[1] } )
                  or ( is_scalarref( \$_[1] ) and return $val->{ $_[1] } );
                $config->{$key} = $_[1] and return;
              }
        };
    };

    return 1;
}

sub _return_base_element {
    unlock_hashref($_[1]);
    return $_[1]->{base_element} ? $_[1]->{base_element} : $_[1];
}

1;

__END__