File Coverage

blib/lib/Nephia/Core.pm

Criterion	Covered	Total	%
statement	135	135	100.0
branch	22	26	84.6
condition	8	12	66.6
subroutine	31	31	100.0
pod	9	11	81.8
total	205	215	95.3

package Nephia::Core;
use strict;
use warnings;
use Nephia::Request;
use Nephia::Response;
use Nephia::Context;
use Nephia::Chain;
use Scalar::Util ();
use Module::Load ();

our $AUTOLOAD;

sub AUTOLOAD {
    my $self = shift;
    my ($class, $method) = $AUTOLOAD =~ /^(.+)::(.+?)$/;
    return if $method =~ /^[A-Z]/;
    $self->{dsl}{$method}->(@_);
}

sub new {
    my ($class, %opts) = @_;
    $opts{caller}       ||= caller();
    $opts{plugins}      ||= [];
    $opts{config}       ||= {};
    $opts{action_chain}   = Nephia::Chain->new(namespace => 'Nephia::Action');
    $opts{filter_chain}   = Nephia::Chain->new(namespace => 'Nephia::Filter');
    $opts{builder_chain}  = Nephia::Chain->new(namespace => 'Nephia::Builder');
    $opts{loaded_plugins} = Nephia::Chain->new(namespace => 'Nephia::Plugin', name_normalize => 0);
    $opts{dsl}            = {};
    $opts{external_classes} = {};
    my $self = bless {%opts}, $class;
    $self->action_chain->append(Core => $class->can('_action'));
    $self->_load_plugins;
    return $self;
}

sub export_dsl {
    my $self = shift;
    my $dummy_context = Nephia::Context->new;
    $self->_load_dsl($dummy_context);
    my $class = $self->caller_class;
    no strict   qw/refs subs/;
    no warnings qw/redefine/;
    *{$class.'::run'} = sub (;%)  { my $subclass = shift; $self->run(@_) };
    *{$class.'::app'} = sub (&) {
        my $app = shift;
        $self->{app} = $app;
    };
}

sub _load_plugins {
    my $self = shift;
    my @plugins = (qw/Basic Cookie/, @{$self->{plugins}});
    while ($plugins[0]) {
        my $plugin_class = 'Nephia::Plugin::'. shift(@plugins);
        my $conf = {};
        if ($plugins[0]) {
            $conf = shift(@plugins) if ref($plugins[0]) eq 'HASH';
        }
        $self->loaded_plugins->append($self->_load_plugin($plugin_class, $conf));
    }
}

sub loaded_plugins {
    my $self = shift;
    return wantarray ? $self->{loaded_plugins}->as_array : $self->{loaded_plugins};
}

sub _load_plugin {
    my ($self, $plugin, $opts) = @_;
    $opts ||= {};
    Module::Load::load($plugin) unless $plugin->isa('Nephia::Plugin');
    my $obj = $plugin->new(app => $self, %$opts);
    return $obj;
}

sub app {
    my ($self, $code) = @_;
    $self->{app} = $code if defined $code;
    return $self->{app};
}

sub caller_class {
    my $self = shift;
    return $self->{caller};
}

sub action_chain {
    my $self = shift;
    return $self->{action_chain};
}

sub filter_chain {
    my $self = shift;
    return $self->{filter_chain};
}

sub builder_chain {
    my $self = shift;
    return $self->{builder_chain};
}

sub _action {
    my ($self, $context) = @_;
    $context->set(res => $self->app->($self, $context));
    return $context;
}

sub dsl {
    my ($self, $key) = @_;
    return $key ? $self->{dsl}{$key} : $self->{dsl};
}

sub call {
    my ($self, $codepath) = @_;
    my ($class, $method) = $codepath =~ /^(.+)\#(.+)$/;
    $class = sprintf('%s::%s', $self->caller_class, $class) unless $class =~ /^\+/;
    $class =~ s/^\+//;
    unless ($self->{external_classes}{$class}) {
        Module::Load::load($class) unless $class->isa($class);
        $self->{external_classes}{$class} = 1;
    }
    $class->can($method);
}

sub _load_dsl {
    my ($self, $context) = @_;
    my $class = $self->caller_class;
    no strict   qw/refs subs/;
    no warnings qw/redefine/;
    for my $plugin ( $self->loaded_plugins->as_array ) {
        for my $dsl ($plugin->exports) {
            *{$class.'::'.$dsl} = $plugin->$dsl($context);
            $self->{dsl}{$dsl} = $plugin->$dsl($context);
        }
    }
}

sub run {
    my ($self, %config) = @_;
    $self->{config} = { %{$self->{config}}, %config };
    my $class = $self->{caller};
    my $app = sub {
        my $env     = shift;
        my $req     = Nephia::Request->new($env);
        my $context = Nephia::Context->new(req => $req, config => $self->{config});
        $self->_load_dsl($context);
        my $res;
        for my $action ($self->{action_chain}->as_array) {
            ($context, $res) = $action->($self, $context);
            last if $res;
        }
        $res ||= $context->get('res');
        $res = Scalar::Util::blessed($res) ? $res : Nephia::Response->new(@$res);
        for my $filter ($self->{filter_chain}->as_array) {
            my $body = ref($res->body) eq 'ARRAY' ? $res->body->[0] : $res->body;
            $res->body($filter->($self, $body));
        }
        return $res->finalize;
    };
    for my $builder ($self->builder_chain->as_array) {
        $app = $builder->($self, $app);
    }
    return $app;
}

1;

__END__