use URI;
use Carp qw/croak/;
use Cwd;
-use Class::MOP;
+use Class::Load 'is_class_loaded';
use String::RewritePrefix;
-use List::MoreUtils qw/ any /;
+use Class::Load ();
use namespace::clean;
if ( $create && !-e $tmpdir ) {
- eval { $tmpdir->mkpath };
-
- if ($@) {
+ eval { $tmpdir->mkpath; 1 }
+ or do {
# don't load Catalyst::Exception as a BEGIN in Utils,
# because Utils often gets loaded before MyApp.pm, and if
# Catalyst::Exception is loaded before MyApp.pm, it does
return $tmpdir->stringify;
}
+=head2 home($class)
+
+Returns home directory for given class.
+
=head2 dist_indicator_file_list
-Returns a list of files which can be tested to check if you're inside a checkout
+Returns a list of files which can be tested to check if you're inside
+a CPAN distribution which is not yet installed.
-=cut
+These are:
-sub dist_indicator_file_list {
- qw/ Makefile.PL Build.PL dist.init /;
-}
+=over
-=head2 home($class)
+=item Makefile.PL
-Returns home directory for given class.
+=item Build.PL
+
+=item dist.ini
-Note that the class must be loaded for the home directory to be found using this function.
+=item L<cpanfile>
+
+=back
=cut
+sub dist_indicator_file_list {
+ qw{Makefile.PL Build.PL dist.ini cpanfile};
+}
+
sub home {
my $class = shift;
# find the @INC entry in which $file was found
(my $path = $inc_entry) =~ s/$file$//;
- my $home = find_home_unloaded_in_checkout($path);
- return $home if $home;
+ $path ||= cwd() if !defined $path || !length $path;
+ my $home = dir($path)->absolute->cleanup;
+
+ # pop off /lib and /blib if they're there
+ $home = $home->parent while $home =~ /b?lib$/;
+
+ # only return the dir if it has a Makefile.PL or Build.PL or dist.ini
+ if (grep { -f $home->file($_) } dist_indicator_file_list()) {
+ # clean up relative path:
+ # MyApp/script/.. -> MyApp
+
+ my $dir;
+ my @dir_list = $home->dir_list();
+ while (($dir = pop(@dir_list)) && $dir eq '..') {
+ $home = dir($home)->parent->parent;
+ }
+
+ return $home->stringify;
+ }
}
{
return 0;
}
-=head2 find_home_unloaded_in_checkout ($path)
-
-Tries to determine if C<$path> (or cwd if not supplied)
-looks like a checkout. Any leading lib or blib components
-will be removed, then the directory produced will be checked
-for the existance of a C<< dist_indicator_file_list() >>.
-
-If one is found, the directory will be returned, otherwise false.
-
-=cut
-
-sub find_home_unloaded_in_checkout {
- my ($path) = @_;
- $path ||= cwd() if !defined $path || !length $path;
- my $home = dir($path)->absolute->cleanup;
-
- # pop off /lib and /blib if they're there
- $home = $home->parent while $home =~ /b?lib$/;
-
- # only return the dir if it has a Makefile.PL or Build.PL or dist.ini
- if (any { $_ } map { -f $home->file($_) } dist_indicator_file_list()) {
-
- # clean up relative path:
- # MyApp/script/.. -> MyApp
-
- my $dir;
- my @dir_list = $home->dir_list();
- while (($dir = pop(@dir_list)) && $dir eq '..') {
- $home = dir($home)->parent->parent;
- }
-
- return $home->stringify;
- }
-
-}
-
=head2 prefix($class, $name);
Returns a prefixed action.
# if it already has symbol table entries. This is to support things like Schema::Loader, which
# part-generate classes in memory, but then also load some of their contents from disk.
return if !$opts->{ ignore_loaded }
- && Class::MOP::is_class_loaded($class); # if a symbol entry exists we don't load again
+ && is_class_loaded($class); # if a symbol entry exists we don't load again
# this hack is so we don't overwrite $@ if the load did not generate an error
my $error;
die $error if $error;
warn "require $class was successful but the package is not defined."
- unless Class::MOP::is_class_loaded($class);
+ unless is_class_loaded($class);
return 1;
}
sub term_width {
return $_term_width if $_term_width;
- my $width = eval '
- use Term::Size::Any;
+ my $width;
+ eval '
+ require Term::Size::Any;
my ($columns, $rows) = Term::Size::Any::chars;
- return $columns;
- ';
-
- if ($@) {
+ $width = $columns;
+ 1;
+ ' or do {
$width = $ENV{COLUMNS}
if exists($ENV{COLUMNS})
&& $ENV{COLUMNS} =~ m/^\d+$/;
- }
+ };
$width = 80 unless ($width && $width >= 80);
return $_term_width = $width;
}, @classes);
}
+=head2 build_middleware (@args)
+
+Internal application that converts a single middleware definition (see
+L<Catalyst/psgi_middleware>) into an actual instance of middleware.
+
+=cut
+
+sub build_middleware {
+ my ($class, $namespace, @init_args) = @_;
+
+ if(
+ $namespace =~s/^\+// ||
+ $namespace =~/^Plack::Middleware/ ||
+ $namespace =~/^$class/
+ ) { ## the string is a full namespace
+ return Class::Load::try_load_class($namespace) ?
+ $namespace->new(@init_args) :
+ die "Can't load class $namespace";
+ } else { ## the string is a partial namespace
+ if(Class::Load::try_load_class($class .'::Middleware::'. $namespace)) { ## Load Middleware from Project namespace
+ my $ns = $class .'::Middleware::'. $namespace;
+ return $ns->new(@init_args);
+ } elsif(Class::Load::try_load_class("Plack::Middleware::$namespace")) { ## Act like Plack::Builder
+ return "Plack::Middleware::$namespace"->new(@init_args);
+ }
+ }
+
+ return; ## be sure we can count on a proper return when valid
+}
+
+=head2 apply_registered_middleware ($psgi)
+
+Given a $psgi reference, wrap all the L<Catalyst/registered_middlewares>
+around it and return the wrapped version.
+
+This exists to deal with the fact Catalyst registered middleware can be
+either an object with a wrap method or a coderef.
+
+=cut
+
+sub apply_registered_middleware {
+ my ($class, $psgi) = @_;
+ my $new_psgi = $psgi;
+ foreach my $middleware ($class->registered_middlewares) {
+ $new_psgi = Scalar::Util::blessed $middleware ?
+ $middleware->wrap($new_psgi) :
+ $middleware->($new_psgi);
+ }
+ return $new_psgi;
+}
=head1 AUTHORS