view release on metacpan or  search on metacpan

t/app/Plack/Loader.t  view on Meta::CPAN

use strict;
use warnings;
use Test::More;
use Compiler::Lexer;
use Compiler::Parser;
use Compiler::Parser::AST::Renderer;
use Test::Compiler::Parser;

subtest 'parse Plack/Loader.pm' => sub {
    my $script = do { local $/; <DATA> };
    my $tokens = Compiler::Lexer->new('')->tokenize($script);
    my $ast = Compiler::Parser->new->parse($tokens);
    Compiler::Parser::AST::Renderer->new->render($ast);
    node_ok($ast->root, [
        Test::Compiler::Parser::package { 'Plack::Loader',
        },
        module { 'strict',
        },
        module { 'Carp',
            args => list { '()',
            },
        },
        module { 'Plack::Util',
        },
        module { 'Try::Tiny',
        },
        function { 'new',
            body => [
                branch { '=',
                    left => leaf '$class',
                    right => function_call { 'shift',
                        args => [
                        ],
                    },
                },
                function_call { 'bless',
                    args => [
                        branch { ',',
                            left => hash_ref { '{}',
                            },
                            right => leaf '$class',
                        },
                    ],
                },
            ],
        },
        function { 'watch',
        },
        function { 'auto',
            body => [
                branch { '=',
                    left => list { '()',
                        data => branch { ',',
                            left => leaf '$class',
                            right => leaf '@args',
                        },
                    },
                    right => leaf '@_',
                },
                branch { 'or',
                    left => branch { '=',
                        left => leaf '$backend',
                        right => branch { '->',
                            left => leaf '$class',
                            right => function_call { 'guess',
                                args => [
                                ],
                            },
                        },
                    },
                    right => function_call { 'Carp::croak',
                        args => [
                            leaf 'Couldn\'t auto-guess server server implementation. Set it with PLACK_SERVER',
                        ],
                    },
                },
                branch { '=',
                    left => leaf '$server',
                    right => function_call { 'try',
                        args => [
                            branch { '->',
                                left => leaf '$class',
                                right => function_call { 'load',
                                    args => [
                                        list { '()',

t/app/Plack/Loader.t  view on Meta::CPAN

                                    true_stmt => Test::Compiler::Parser::return { 'return',
                                        body => leaf 'POE',
                                    },
                                    false_stmt => else_stmt { 'else',
                                        stmt => Test::Compiler::Parser::return { 'return',
                                            body => leaf 'Standalone',
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            ],
        },
        function { 'env',
            body => single_term_operator { '\\',
                expr => leaf '%ENV',
            },
        },
        function { 'run',
            body => [
                branch { '=',
                    left => list { '()',
                        data => branch { ',',
                            left => branch { ',',
                                left => leaf '$self',
                                right => leaf '$server',
                            },
                            right => leaf '$builder',
                        },
                    },
                    right => leaf '@_',
                },
                branch { '->',
                    left => leaf '$server',
                    right => function_call { 'run',
                        args => [
                            branch { '->',
                                left => leaf '$self',
                                right => hash_ref { '{}',
                                    data => leaf 'app',
                                },
                            },
                        ],
                    },
                },
            ],
        },
        leaf '1',
    ]);
};

done_testing;

__DATA__
package Plack::Loader;
use strict;
use Carp ();
use Plack::Util;
use Try::Tiny;

sub new {
    my $class = shift;
    bless {}, $class;
}

sub watch {
    # do nothing. Override in subclass
}

sub auto {
    my($class, @args) = @_;

    my $backend = $class->guess
        or Carp::croak("Couldn't auto-guess server server implementation. Set it with PLACK_SERVER");

    my $server = try {
        $class->load($backend, @args);
    } catch {
        if (($ENV{PLACK_ENV}||'') eq 'development' or !/^Can't locate /) {
            warn "Autoloading '$backend' backend failed. Falling back to the Standalone. ",
                "(You might need to install Plack::Handler::$backend from CPAN.  Caught error was: $_)\n"
                    if $ENV{PLACK_ENV} && $ENV{PLACK_ENV} eq 'development';
        }
        $class->load('Standalone' => @args);
    };

    return $server;
}

sub load {
    my($class, $server, @args) = @_;

    my($server_class, $error);
    try {
        $server_class = Plack::Util::load_class($server, 'Plack::Handler');
    } catch {
        $error ||= $_;
    };

    if ($server_class) {
        $server_class->new(@args);
    } else {
        die $error;
    }
}

sub preload_app {
    my($self, $builder) = @_;
    $self->{app} = $builder->();
}

sub guess {
    my $class = shift;

    my $env = $class->env;

    return $env->{PLACK_SERVER} if $env->{PLACK_SERVER};

    if ($env->{PHP_FCGI_CHILDREN} || $env->{FCGI_ROLE} || $env->{FCGI_SOCKET_PATH}) {