Fix merge conflicts, remove extra files, match upstream perl-5.20.1

ok deraadt@ sthen@ espie@ miod@

2 files changed, 0 insertions, 862 deletions

diff --git a/gnu/usr.bin/perl/cpan/Module-Pluggable/lib/Module/Pluggable.pm b/gnu/usr.bin/perl/cpan/Module-Pluggable/lib/Module/Pluggable.pm
deleted file mode 100644
index 9e7962efab7..00000000000
--- a/gnu/usr.bin/perl/cpan/Module-Pluggable/lib/Module/Pluggable.pm
+++ /dev/null
@@ -1,457 +0,0 @@
-package Module::Pluggable;
-
-use strict;
-use vars qw($VERSION $FORCE_SEARCH_ALL_PATHS);
-use Module::Pluggable::Object;
-
-use if $] > 5.017, 'deprecate';
-
-# ObQuote:
-# Bob Porter: Looks like you've been missing a lot of work lately. 
-# Peter Gibbons: I wouldn't say I've been missing it, Bob! 
-
-
-$VERSION = '4.7';
-$FORCE_SEARCH_ALL_PATHS = 0;
-
-sub import {
-    my $class        = shift;
-    my %opts         = @_;
-
-    my ($pkg, $file) = caller; 
-    # the default name for the method is 'plugins'
-    my $sub          = $opts{'sub_name'}  || 'plugins';
-    # get our package 
-    my ($package)    = $opts{'package'} || $pkg;
-    $opts{filename}  = $file;
-    $opts{package}   = $package;
-    $opts{force_search_all_paths} = $FORCE_SEARCH_ALL_PATHS unless exists $opts{force_search_all_paths};
-
-
-    my $finder       = Module::Pluggable::Object->new(%opts);
-    my $subroutine   = sub { my $self = shift; return $finder->plugins(@_) };
-
-    my $searchsub = sub {
-              my $self = shift;
-              my ($action,@paths) = @_;
-
-              $finder->{'search_path'} = ["${package}::Plugin"] if ($action eq 'add'  and not   $finder->{'search_path'} );
-              push @{$finder->{'search_path'}}, @paths      if ($action eq 'add');
-              $finder->{'search_path'}       = \@paths      if ($action eq 'new');
-              return $finder->{'search_path'};
-    };
-
-
-    my $onlysub = sub {
-        my ($self, $only) = @_;
-
-        if (defined $only) {
-            $finder->{'only'} = $only;
-        };
-        
-        return $finder->{'only'};
-    };
-
-    my $exceptsub = sub {
-        my ($self, $except) = @_;
-
-        if (defined $except) {
-            $finder->{'except'} = $except;
-        };
-        
-        return $finder->{'except'};
-    };
-
-
-    no strict 'refs';
-    no warnings qw(redefine prototype);
-    
-    *{"$package\::$sub"}        = $subroutine;
-    *{"$package\::search_path"} = $searchsub;
-    *{"$package\::only"}        = $onlysub;
-    *{"$package\::except"}      = $exceptsub;
-
-}
-
-1;
-
-=pod
-
-=head1 NAME
-
-Module::Pluggable - automatically give your module the ability to have plugins
-
-=head1 SYNOPSIS
-
-
-Simple use Module::Pluggable -
-
-    package MyClass;
-    use Module::Pluggable;
-    
-
-and then later ...
-
-    use MyClass;
-    my $mc = MyClass->new();
-    # returns the names of all plugins installed under MyClass::Plugin::*
-    my @plugins = $mc->plugins(); 
-
-=head1 EXAMPLE
-
-Why would you want to do this? Say you have something that wants to pass an
-object to a number of different plugins in turn. For example you may 
-want to extract meta-data from every email you get sent and do something
-with it. Plugins make sense here because then you can keep adding new 
-meta data parsers and all the logic and docs for each one will be 
-self contained and new handlers are easy to add without changing the 
-core code. For that, you might do something like ...
-
-    package Email::Examiner;
-
-    use strict;
-    use Email::Simple;
-    use Module::Pluggable require => 1;
-
-    sub handle_email {
-        my $self  = shift;
-        my $email = shift;
-
-        foreach my $plugin ($self->plugins) {
-            $plugin->examine($email);
-        }
-
-        return 1;
-    }
-
-
-
-.. and all the plugins will get a chance in turn to look at it.
-
-This can be trivally extended so that plugins could save the email
-somewhere and then no other plugin should try and do that. 
-Simply have it so that the C<examine> method returns C<1> if 
-it has saved the email somewhere. You might also wnat to be paranoid
-and check to see if the plugin has an C<examine> method.
-
-        foreach my $plugin ($self->plugins) {
-            next unless $plugin->can('examine');
-            last if     $plugin->examine($email);
-        }
-
-
-And so on. The sky's the limit.
-
-
-=head1 DESCRIPTION
-
-Provides a simple but, hopefully, extensible way of having 'plugins' for 
-your module. Obviously this isn't going to be the be all and end all of
-solutions but it works for me.
-
-Essentially all it does is export a method into your namespace that 
-looks through a search path for .pm files and turn those into class names. 
-
-Optionally it instantiates those classes for you.
-
-=head1 ADVANCED USAGE
-
-Alternatively, if you don't want to use 'plugins' as the method ...
-
-    package MyClass;
-    use Module::Pluggable sub_name => 'foo';
-
-
-and then later ...
-
-    my @plugins = $mc->foo();
-
-
-Or if you want to look in another namespace
-
-    package MyClass;
-    use Module::Pluggable search_path => ['Acme::MyClass::Plugin', 'MyClass::Extend'];
-
-or directory 
-
-    use Module::Pluggable search_dirs => ['mylibs/Foo'];
-
-
-Or if you want to instantiate each plugin rather than just return the name
-
-    package MyClass;
-    use Module::Pluggable instantiate => 'new';
-
-and then
-
-    # whatever is passed to 'plugins' will be passed 
-    # to 'new' for each plugin 
-    my @plugins = $mc->plugins(@options); 
-
-
-alternatively you can just require the module without instantiating it
-
-    package MyClass;
-    use Module::Pluggable require => 1;
-
-since requiring automatically searches inner packages, which may not be desirable, you can turn this off
-
-
-    package MyClass;
-    use Module::Pluggable require => 1, inner => 0;
-
-
-You can limit the plugins loaded using the except option, either as a string,
-array ref or regex
-
-    package MyClass;
-    use Module::Pluggable except => 'MyClass::Plugin::Foo';
-
-or
-
-    package MyClass;
-    use Module::Pluggable except => ['MyClass::Plugin::Foo', 'MyClass::Plugin::Bar'];
-
-or
-
-    package MyClass;
-    use Module::Pluggable except => qr/^MyClass::Plugin::(Foo|Bar)$/;
-
-
-and similarly for only which will only load plugins which match.
-
-Remember you can use the module more than once
-
-    package MyClass;
-    use Module::Pluggable search_path => 'MyClass::Filters' sub_name => 'filters';
-    use Module::Pluggable search_path => 'MyClass::Plugins' sub_name => 'plugins';
-
-and then later ...
-
-    my @filters = $self->filters;
-    my @plugins = $self->plugins;
-    
-=head1 PLUGIN SEARCHING
-
-Every time you call 'plugins' the whole search path is walked again. This allows 
-for dynamically loading plugins even at run time. However this can get expensive 
-and so if you don't expect to want to add new plugins at run time you could do
-
-
-  package Foo;
-  use strict;
-  use Module::Pluggable sub_name => '_plugins';
-
-  our @PLUGINS;
-  sub plugins { @PLUGINS ||= shift->_plugins }
-  1;
-
-=head1 INNER PACKAGES
-
-If you have, for example, a file B<lib/Something/Plugin/Foo.pm> that
-contains package definitions for both C<Something::Plugin::Foo> and 
-C<Something::Plugin::Bar> then as long as you either have either 
-the B<require> or B<instantiate> option set then we'll also find 
-C<Something::Plugin::Bar>. Nifty!
-
-=head1 OPTIONS
-
-You can pass a hash of options when importing this module.
-
-The options can be ...
-
-=head2 sub_name
-
-The name of the subroutine to create in your namespace. 
-
-By default this is 'plugins'
-
-=head2 search_path
-
-An array ref of namespaces to look in. 
-
-=head2 search_dirs 
-
-An array ref of directorys to look in before @INC.
-
-=head2 instantiate
-
-Call this method on the class. In general this will probably be 'new'
-but it can be whatever you want. Whatever arguments are passed to 'plugins' 
-will be passed to the method.
-
-The default is 'undef' i.e just return the class name.
-
-=head2 require
-
-Just require the class, don't instantiate (overrides 'instantiate');
-
-=head2 inner
-
-If set to 0 will B<not> search inner packages. 
-If set to 1 will override C<require>.
-
-=head2 only
-
-Takes a string, array ref or regex describing the names of the only plugins to 
-return. Whilst this may seem perverse ... well, it is. But it also 
-makes sense. Trust me.
-
-=head2 except
-
-Similar to C<only> it takes a description of plugins to exclude 
-from returning. This is slightly less perverse.
-
-=head2 package
-
-This is for use by extension modules which build on C<Module::Pluggable>:
-passing a C<package> option allows you to place the plugin method in a
-different package other than your own.
-
-=head2 file_regex
-
-By default C<Module::Pluggable> only looks for I<.pm> files.
-
-By supplying a new C<file_regex> then you can change this behaviour e.g
-
-    file_regex => qr/\.plugin$/
-
-=head2 include_editor_junk
-
-By default C<Module::Pluggable> ignores files that look like they were
-left behind by editors. Currently this means files ending in F<~> (~),
-the extensions F<.swp> or F<.swo>, or files beginning with F<.#>.
-
-Setting C<include_editor_junk> changes C<Module::Pluggable> so it does
-not ignore any files it finds.
-
-=head2 follow_symlinks
-
-Whether, when searching directories, to follow symlinks.
-
-Defaults to 1 i.e do follow symlinks.
-
-=head2 min_depth, max_depth
-
-This will allow you to set what 'depth' of plugin will be allowed.
-
-So, for example, C<MyClass::Plugin::Foo> will have a depth of 3 and 
-C<MyClass::Plugin::Foo::Bar> will have a depth of 4 so to only get the former 
-(i.e C<MyClass::Plugin::Foo>) do
-
-        package MyClass;
-        use Module::Pluggable max_depth => 3;
-        
-and to only get the latter (i.e C<MyClass::Plugin::Foo::Bar>)
-
-        package MyClass;
-        use Module::Pluggable min_depth => 4;
-
-
-=head1 TRIGGERS
-
-Various triggers can also be passed in to the options.
-
-If any of these triggers return 0 then the plugin will not be returned.
-
-=head2 before_require <plugin>
-
-Gets passed the plugin name. 
-
-If 0 is returned then this plugin will not be required either.
-
-=head2 on_require_error <plugin> <err>
-
-Gets called when there's an error on requiring the plugin.
-
-Gets passed the plugin name and the error. 
-
-The default on_require_error handler is to C<carp> the error and return 0.
-
-=head2 on_instantiate_error <plugin> <err>
-
-Gets called when there's an error on instantiating the plugin.
-
-Gets passed the plugin name and the error. 
-
-The default on_instantiate_error handler is to C<carp> the error and return 0.
-
-=head2 after_require <plugin>
-
-Gets passed the plugin name. 
-
-If 0 is returned then this plugin will be required but not returned as a plugin.
-
-=head1 METHODs
-
-=head2 search_path
-
-The method C<search_path> is exported into you namespace as well. 
-You can call that at any time to change or replace the 
-search_path.
-
-    $self->search_path( add => "New::Path" ); # add
-    $self->search_path( new => "New::Path" ); # replace
-
-=head1 BEHAVIOUR UNDER TEST ENVIRONMENT
-
-In order to make testing reliable we exclude anything not from blib if blib.pm is 
-in %INC. 
-
-However if the module being tested used another module that itself used C<Module::Pluggable> 
-then the second module would fail. This was fixed by checking to see if the caller 
-had (^|/)blib/ in their filename.
-
-There's an argument that this is the wrong behaviour and that modules should explicitly
-trigger this behaviour but that particular code has been around for 7 years now and I'm 
-reluctant to change the default behaviour.
-
-You can now (as of version 4.1) force Module::Pluggable to look outside blib in a test environment by doing either
-
-        require Module::Pluggable;
-        $Module::Pluggable::FORCE_SEARCH_ALL_PATHS = 1;
-        import Module::Pluggable;
-
-or
-
-        use Module::Pluggable force_search_all_paths => 1;
-        
-
-=head1 FUTURE PLANS
-
-This does everything I need and I can't really think of any other 
-features I want to add. Famous last words of course
-
-Recently tried fixed to find inner packages and to make it 
-'just work' with PAR but there are still some issues.
-
-
-However suggestions (and patches) are welcome.
-
-=head1 DEVELOPMENT
-
-The master repo for this module is at
-
-https://github.com/simonwistow/Module-Pluggable
-
-=head1 AUTHOR
-
-Simon Wistow <simon@thegestalt.org>
-
-=head1 COPYING
-
-Copyright, 2006 Simon Wistow
-
-Distributed under the same terms as Perl itself.
-
-=head1 BUGS
-
-None known.
-
-=head1 SEE ALSO
-
-L<File::Spec>, L<File::Find>, L<File::Basename>, L<Class::Factory::Util>, L<Module::Pluggable::Ordered>
-
-=cut 
-
-
diff --git a/gnu/usr.bin/perl/cpan/Module-Pluggable/lib/Module/Pluggable/Object.pm b/gnu/usr.bin/perl/cpan/Module-Pluggable/lib/Module/Pluggable/Object.pm
deleted file mode 100644
index 6b1d265456c..00000000000
--- a/gnu/usr.bin/perl/cpan/Module-Pluggable/lib/Module/Pluggable/Object.pm
+++ /dev/null
@@ -1,405 +0,0 @@
-package Module::Pluggable::Object;
-
-use strict;
-use File::Find ();
-use File::Basename;
-use File::Spec::Functions qw(splitdir catdir curdir catfile abs2rel);
-use Carp qw(croak carp confess);
-use Devel::InnerPackage;
-use vars qw($VERSION);
-
-use if $] > 5.017, 'deprecate';
-
-$VERSION = '4.6';
-
-
-sub new {
-    my $class = shift;
-    my %opts  = @_;
-
-    return bless \%opts, $class;
-
-}
-
-### Eugggh, this code smells 
-### This is what happens when you keep adding patches
-### *sigh*
-
-
-sub plugins {
-    my $self = shift;
-    my @args = @_;
-
-    # override 'require'
-    $self->{'require'} = 1 if $self->{'inner'};
-
-    my $filename   = $self->{'filename'};
-    my $pkg        = $self->{'package'};
-
-    # Get the exception params instantiated
-    $self->_setup_exceptions;
-
-    # automatically turn a scalar search path or namespace into a arrayref
-    for (qw(search_path search_dirs)) {
-        $self->{$_} = [ $self->{$_} ] if exists $self->{$_} && !ref($self->{$_});
-    }
-
-    # default search path is '<Module>::<Name>::Plugin'
-    $self->{'search_path'} ||= ["${pkg}::Plugin"]; 
-
-    # default error handler
-    $self->{'on_require_error'} ||= sub { my ($plugin, $err) = @_; carp "Couldn't require $plugin : $err"; return 0 };
-    $self->{'on_instantiate_error'} ||= sub { my ($plugin, $err) = @_; carp "Couldn't instantiate $plugin: $err"; return 0 };
-
-    # default whether to follow symlinks
-    $self->{'follow_symlinks'} = 1 unless exists $self->{'follow_symlinks'};
-
-    # check to see if we're running under test
-    my @SEARCHDIR = exists $INC{"blib.pm"} && defined $filename && $filename =~ m!(^|/)blib/! && !$self->{'force_search_all_paths'} ? grep {/blib/} @INC : @INC;
-
-    # add any search_dir params
-    unshift @SEARCHDIR, @{$self->{'search_dirs'}} if defined $self->{'search_dirs'};
-
-    # set our @INC up to include and prefer our search_dirs if necessary
-    my @tmp = @INC;
-    unshift @tmp, @{$self->{'search_dirs'} || []};
-    local @INC = @tmp if defined $self->{'search_dirs'};
-
-    my @plugins = $self->search_directories(@SEARCHDIR);
-    push(@plugins, $self->handle_innerpackages($_)) for @{$self->{'search_path'}};
-    
-    # return blank unless we've found anything
-    return () unless @plugins;
-
-    # remove duplicates
-    # probably not necessary but hey ho
-    my %plugins;
-    for(@plugins) {
-        next unless $self->_is_legit($_);
-        $plugins{$_} = 1;
-    }
-
-    # are we instantiating or requring?
-    if (defined $self->{'instantiate'}) {
-        my $method = $self->{'instantiate'};
-        my @objs   = ();
-        foreach my $package (sort keys %plugins) {
-            next unless $package->can($method);
-            my $obj = eval { $package->$method(@_) };
-            $self->{'on_instantiate_error'}->($package, $@) if $@;
-            push @objs, $obj if $obj;           
-        }
-        return @objs;
-    } else { 
-        # no? just return the names
-        my @objs= sort keys %plugins;
-        return @objs;
-    }
-}
-
-sub _setup_exceptions {
-    my $self = shift;
-
-    my %only;   
-    my %except; 
-    my $only;
-    my $except;
-
-    if (defined $self->{'only'}) {
-        if (ref($self->{'only'}) eq 'ARRAY') {
-            %only   = map { $_ => 1 } @{$self->{'only'}};
-        } elsif (ref($self->{'only'}) eq 'Regexp') {
-            $only = $self->{'only'}
-        } elsif (ref($self->{'only'}) eq '') {
-            $only{$self->{'only'}} = 1;
-        }
-    }
-        
-
-    if (defined $self->{'except'}) {
-        if (ref($self->{'except'}) eq 'ARRAY') {
-            %except   = map { $_ => 1 } @{$self->{'except'}};
-        } elsif (ref($self->{'except'}) eq 'Regexp') {
-            $except = $self->{'except'}
-        } elsif (ref($self->{'except'}) eq '') {
-            $except{$self->{'except'}} = 1;
-        }
-    }
-    $self->{_exceptions}->{only_hash}   = \%only;
-    $self->{_exceptions}->{only}        = $only;
-    $self->{_exceptions}->{except_hash} = \%except;
-    $self->{_exceptions}->{except}      = $except;
-        
-}
-
-sub _is_legit {
-    my $self   = shift;
-    my $plugin = shift;
-    my %only   = %{$self->{_exceptions}->{only_hash}||{}};
-    my %except = %{$self->{_exceptions}->{except_hash}||{}};
-    my $only   = $self->{_exceptions}->{only};
-    my $except = $self->{_exceptions}->{except};
-    my $depth  = () = split '::', $plugin, -1;
-
-    return 0 if     (keys %only   && !$only{$plugin}     );
-    return 0 unless (!defined $only || $plugin =~ m!$only!     );
-
-    return 0 if     (keys %except &&  $except{$plugin}   );
-    return 0 if     (defined $except &&  $plugin =~ m!$except! );
-    
-    return 0 if     defined $self->{max_depth} && $depth>$self->{max_depth};
-    return 0 if     defined $self->{min_depth} && $depth<$self->{min_depth};
-
-    return 1;
-}
-
-sub search_directories {
-    my $self      = shift;
-    my @SEARCHDIR = @_;
-
-    my @plugins;
-    # go through our @INC
-    foreach my $dir (@SEARCHDIR) {
-        push @plugins, $self->search_paths($dir);
-    }
-    return @plugins;
-}
-
-
-sub search_paths {
-    my $self = shift;
-    my $dir  = shift;
-    my @plugins;
-
-    my $file_regex = $self->{'file_regex'} || qr/\.pm$/;
-
-
-    # and each directory in our search path
-    foreach my $searchpath (@{$self->{'search_path'}}) {
-        # create the search directory in a cross platform goodness way
-        my $sp = catdir($dir, (split /::/, $searchpath));
-
-        # if it doesn't exist or it's not a dir then skip it
-        next unless ( -e $sp && -d _ ); # Use the cached stat the second time
-
-        my @files = $self->find_files($sp);
-
-        # foreach one we've found 
-        foreach my $file (@files) {
-            # untaint the file; accept .pm only
-            next unless ($file) = ($file =~ /(.*$file_regex)$/); 
-            # parse the file to get the name
-            my ($name, $directory, $suffix) = fileparse($file, $file_regex);
-
-            next if (!$self->{include_editor_junk} && $self->_is_editor_junk($name));
-
-            $directory = abs2rel($directory, $sp);
-
-            # If we have a mixed-case package name, assume case has been preserved
-            # correctly.  Otherwise, root through the file to locate the case-preserved
-            # version of the package name.
-            my @pkg_dirs = ();
-            if ( $name eq lc($name) || $name eq uc($name) ) {
-                my $pkg_file = catfile($sp, $directory, "$name$suffix");
-                open PKGFILE, "<$pkg_file" or die "search_paths: Can't open $pkg_file: $!";
-                my $in_pod = 0;
-                while ( my $line = <PKGFILE> ) {
-                    $in_pod = 1 if $line =~ m/^=\w/;
-                    $in_pod = 0 if $line =~ /^=cut/;
-                    next if ($in_pod || $line =~ /^=cut/);  # skip pod text
-                    next if $line =~ /^\s*#/;               # and comments
-                    if ( $line =~ m/^\s*package\s+(.*::)?($name)\s*;/i ) {
-                        @pkg_dirs = split /::/, $1 if defined $1;;
-                        $name = $2;
-                        last;
-                    }
-                }
-                close PKGFILE;
-            }
-
-            # then create the class name in a cross platform way
-            $directory =~ s/^[a-z]://i if($^O =~ /MSWin32|dos/);       # remove volume
-            my @dirs = ();
-            if ($directory) {
-                ($directory) = ($directory =~ /(.*)/);
-                @dirs = grep(length($_), splitdir($directory)) 
-                    unless $directory eq curdir();
-                for my $d (reverse @dirs) {
-                    my $pkg_dir = pop @pkg_dirs; 
-                    last unless defined $pkg_dir;
-                    $d =~ s/\Q$pkg_dir\E/$pkg_dir/i;  # Correct case
-                }
-            } else {
-                $directory = "";
-            }
-            my $plugin = join '::', $searchpath, @dirs, $name;
-
-            next unless $plugin =~ m!(?:[a-z\d]+)[a-z\d]!i;
-
-            $self->handle_finding_plugin($plugin, \@plugins)
-        }
-
-        # now add stuff that may have been in package
-        # NOTE we should probably use all the stuff we've been given already
-        # but then we can't unload it :(
-        push @plugins, $self->handle_innerpackages($searchpath);
-    } # foreach $searchpath
-
-    return @plugins;
-}
-
-sub _is_editor_junk {
-    my $self = shift;
-    my $name = shift;
-
-    # Emacs (and other Unix-y editors) leave temp files ending in a
-    # tilde as a backup.
-    return 1 if $name =~ /~$/;
-    # Emacs makes these files while a buffer is edited but not yet
-    # saved.
-    return 1 if $name =~ /^\.#/;
-    # Vim can leave these files behind if it crashes.
-    return 1 if $name =~ /\.sw[po]$/;
-
-    return 0;
-}
-
-sub handle_finding_plugin {
-    my $self    = shift;
-    my $plugin  = shift;
-    my $plugins = shift;
-    my $no_req  = shift || 0;
-    
-    return unless $self->_is_legit($plugin);
-    unless (defined $self->{'instantiate'} || $self->{'require'}) {
-        push @$plugins, $plugin;
-        return;
-    } 
-
-    $self->{before_require}->($plugin) || return if defined $self->{before_require};
-    unless ($no_req) {
-        my $tmp = $@;
-        my $res = eval { $self->_require($plugin) };
-        my $err = $@;
-        $@      = $tmp;
-        if ($err) {
-            if (defined $self->{on_require_error}) {
-                $self->{on_require_error}->($plugin, $err) || return; 
-            } else {
-                return;
-            }
-        }
-    }
-    $self->{after_require}->($plugin) || return if defined $self->{after_require};
-    push @$plugins, $plugin;
-}
-
-sub find_files {
-    my $self         = shift;
-    my $search_path  = shift;
-    my $file_regex   = $self->{'file_regex'} || qr/\.pm$/;
-
-
-    # find all the .pm files in it
-    # this isn't perfect and won't find multiple plugins per file
-    #my $cwd = Cwd::getcwd;
-    my @files = ();
-    { # for the benefit of perl 5.6.1's Find, localize topic
-        local $_;
-        File::Find::find( { no_chdir => 1, 
-                            follow   => $self->{'follow_symlinks'}, 
-                            wanted   => sub { 
-                             # Inlined from File::Find::Rule C< name => '*.pm' >
-                             return unless $File::Find::name =~ /$file_regex/;
-                             (my $path = $File::Find::name) =~ s#^\\./##;
-                             push @files, $path;
-                           }
-                      }, $search_path );
-    }
-    #chdir $cwd;
-    return @files;
-
-}
-
-sub handle_innerpackages {
-    my $self = shift;
-    return () if (exists $self->{inner} && !$self->{inner});
-
-    my $path = shift;
-    my @plugins;
-
-    foreach my $plugin (Devel::InnerPackage::list_packages($path)) {
-        $self->handle_finding_plugin($plugin, \@plugins, 1);
-    }
-    return @plugins;
-
-}
-
-
-sub _require {
-    my $self   = shift;
-    my $pack   = shift;
-    eval "CORE::require $pack";
-    die ($@) if $@;
-    return 1;
-}
-
-
-1;
-
-=pod
-
-=head1 NAME
-
-Module::Pluggable::Object - automatically give your module the ability to have plugins
-
-=head1 SYNOPSIS
-
-
-Simple use Module::Pluggable -
-
-    package MyClass;
-    use Module::Pluggable::Object;
-    
-    my $finder = Module::Pluggable::Object->new(%opts);
-    print "My plugins are: ".join(", ", $finder->plugins)."\n";
-
-=head1 DESCRIPTION
-
-Provides a simple but, hopefully, extensible way of having 'plugins' for 
-your module. Obviously this isn't going to be the be all and end all of
-solutions but it works for me.
-
-Essentially all it does is export a method into your namespace that 
-looks through a search path for .pm files and turn those into class names. 
-
-Optionally it instantiates those classes for you.
-
-This object is wrapped by C<Module::Pluggable>. If you want to do something
-odd or add non-general special features you're probably best to wrap this
-and produce your own subclass.
-
-=head1 OPTIONS
-
-See the C<Module::Pluggable> docs.
-
-=head1 AUTHOR
-
-Simon Wistow <simon@thegestalt.org>
-
-=head1 COPYING
-
-Copyright, 2006 Simon Wistow
-
-Distributed under the same terms as Perl itself.
-
-=head1 BUGS
-
-None known.
-
-=head1 SEE ALSO
-
-L<Module::Pluggable>
-
-=cut 
-