use Class::Load 'load_class';
use Encode 2.21 'decode_utf8', 'encode_utf8';
use Scalar::Util;
+use Ref::Util qw(is_plain_arrayref is_plain_coderef is_plain_hashref is_plain_scalarref is_regexpref);
BEGIN { require 5.008003; }
__PACKAGE__->_encode_check(Encode::FB_CROAK | Encode::LEAVE_SRC);
# Remember to update this in Catalyst::Runtime as well!
-our $VERSION = '5.90113';
+our $VERSION = '5.90114';
$VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases
sub import {
sub error {
my $c = shift;
if ( $_[0] ) {
- my $error = ref $_[0] eq 'ARRAY' ? $_[0] : [@_];
+ my $error = is_plain_arrayref($_[0]) ? $_[0] : [@_];
croak @$error unless ref $c;
push @{ $c->{error} }, @$error;
}
# undef for a name will return all
return keys %eligible if !defined $name;
- my $query = $name->$_isa('Regexp') ? $name : qr/^$name$/i;
+ my $query = is_regexpref($name) ? $name : qr/^$name$/i;
my @result = grep { $eligible{$_} =~ m{$query} } keys %eligible;
return @result if @result;
# if we were given a regexp to search against, we're done.
- return if $name->$_isa('Regexp');
+ return if is_regexpref($name);
# skip regexp fallback if configured
return
sub _filter_component {
my ( $c, $comp, @args ) = @_;
- if(ref $comp eq 'CODE') {
+ if(is_plain_coderef($comp)) {
$comp = $comp->();
}
my $appclass = ref($c) || $c;
if( $name ) {
- unless ( $name->$_isa('Regexp') ) { # Direct component hash lookup to avoid costly regexps
+ unless ( is_regexpref($name) ) { # Direct component hash lookup to avoid costly regexps
my $comps = $c->components;
my $check = $appclass."::Controller::".$name;
return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check};
my ( $c, $name, @args ) = @_;
my $appclass = ref($c) || $c;
if( $name ) {
- unless ( $name->$_isa('Regexp') ) { # Direct component hash lookup to avoid costly regexps
+ unless ( is_regexpref($name) ) { # Direct component hash lookup to avoid costly regexps
my $comps = $c->components;
my $check = $appclass."::Model::".$name;
return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check};
my $appclass = ref($c) || $c;
if( $name ) {
- unless ( $name->$_isa('Regexp') ) { # Direct component hash lookup to avoid costly regexps
+ unless ( is_regexpref($name) ) { # Direct component hash lookup to avoid costly regexps
my $comps = $c->components;
my $check = $appclass."::View::".$name;
if( exists $comps->{$check} ) {
}
my @middleware = map {
- ref $_ eq 'CODE' ?
+ is_plain_coderef($_) ?
"Inline Coderef" :
(ref($_) .' '. ($_->can('VERSION') ? $_->VERSION || '' : '')
|| '') } $class->registered_middlewares;
$path .= '/';
}
- my $fragment = ((scalar(@args) && ref($args[-1]) eq 'SCALAR') ? pop @args : undef );
+ my $fragment = ((scalar(@args) && is_plain_scalarref($args[-1])) ? pop @args : undef );
unless(blessed $path) {
if (defined($path) and $path =~ s/#(.+)$//) {
}
my $params =
- ( scalar @args && ref $args[$#args] eq 'HASH' ? pop @args : {} );
+ ( scalar @args && is_plain_hashref($args[$#args]) ? pop @args : {} );
undef($path) if (defined $path && $path eq '');
if ( $path->$_isa('Catalyst::Action') ) { # action object
s|/|%2F|g for @args;
my $captures = [ map { s|/|%2F|g; $_; }
- ( scalar @args && ref $args[0] eq 'ARRAY'
+ ( scalar @args && is_plain_arrayref($args[0])
? @{ shift(@args) }
: ()) ];
$key =~ s/([^A-Za-z0-9\-_.!~*'() ])/$URI::Escape::escapes{$1}/go;
$key =~ s/ /+/g;
- "${key}=$param"; } ( ref $val eq 'ARRAY' ? @$val : $val ));
+ "${key}=$param"; } ( is_plain_arrayref($val) ? @$val : $val ));
} @keys);
}
if(
($res->encodable_response) and
(defined($res->body)) and
- (ref(\$res->body) eq 'SCALAR')
+ (is_plain_scalarref(\$res->body))
) {
$c->res->body( $c->encoding->encode( $c->res->body, $c->_encode_check ) );
for my $key ( sort keys %$params ) {
my $param = $params->{$key};
my $value = defined($param) ? $param : '';
- $t->row( $key, ref $value eq 'ARRAY' ? ( join ', ', @$value ) : $value );
+ $t->row( $key, is_plain_arrayref($value) ? ( join ', ', @$value ) : $value );
}
$c->log->debug( ucfirst($type) . " Parameters are:\n" . $t->draw );
}
);
for my $key ( sort keys %$uploads ) {
my $upload = $uploads->{$key};
- for my $u ( ref $upload eq 'ARRAY' ? @{$upload} : ($upload) ) {
+ for my $u ( is_plain_arrayref($upload) ? @{$upload} : ($upload) ) {
$t->row( $key, $u->filename, $u->type, $u->size );
}
}
# All components are registered, now we need to 'init' them.
foreach my $component_name (@comps, @injected) {
$class->components->{$component_name} = $class->components->{$component_name}->() if
- (ref($class->components->{$component_name}) || '') eq 'CODE';
+ is_plain_coderef($class->components->{$component_name});
}
}
return unless defined $value;
## I think this mess is to support the old nested
- if ( ref $value eq 'ARRAY' ) {
+ if ( is_plain_arrayref($value) ) {
foreach ( @$value ) {
$_ = $self->_handle_unicode_decoding($_);
}
return $value;
}
- elsif ( ref $value eq 'HASH' ) {
+ elsif ( is_plain_hashref($value) ) {
foreach (keys %$value) {
my $encoded_key = $self->_handle_param_unicode_decoding($_);
$value->{$encoded_key} = $self->_handle_unicode_decoding($value->{$_});
if(ref $next) {
if(Scalar::Util::blessed $next && $next->can('wrap')) {
push @middleware, $next;
- } elsif(ref $next eq 'CODE') {
+ } elsif(is_plain_coderef($next)) {
push @middleware, $next;
- } elsif(ref $next eq 'HASH') {
+ } elsif(is_plain_hashref($next)) {
my $namespace = shift @middleware_definitions;
my $mw = $class->Catalyst::Utils::build_middleware($namespace, %$next);
push @middleware, $mw;