This is an automated email from the git hooks/post-receive script.

gregoa pushed a commit to branch master
in repository libfilehandle-unget-perl.

commit 4c1f76405b82fb4df9f3e2cdf36438984381b3a8
Author: gregor herrmann <gre...@debian.org>
Date:   Mon Jun 29 20:40:00 2015 +0200

    Imported Upstream version 0.1628
---
 CHANGES                                            |  40 +++
 LICENSE                                            |  45 ++--
 MANIFEST                                           |  11 +
 META.yml                                           |  23 +-
 Makefile.PL                                        |  30 ++-
 README                                             |  24 +-
 TODO                                               |   4 +
 inc/Module/Install.pm                              | 240 ++++++++++-------
 inc/Module/Install/AutoLicense.pm                  |  63 +++++
 inc/Module/Install/AutomatedTester.pm              |  24 ++
 inc/Module/Install/Base.pm                         |  11 +-
 inc/Module/Install/Bugtracker.pm                   |  28 ++
 inc/Module/Install/Can.pm                          |  85 +++++-
 inc/Module/Install/Fetch.pm                        |   2 +-
 inc/Module/Install/GithubMeta.pm                   |  53 ++++
 inc/Module/Install/Include.pm                      |  34 +++
 inc/Module/Install/Makefile.pm                     | 244 +++++++++++++----
 inc/Module/Install/Metadata.pm                     | 292 ++++++++++++++-------
 .../Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm |  47 ++++
 inc/Module/Install/Win32.pm                        |   2 +-
 inc/Module/Install/WriteAll.pm                     |   7 +-
 lib/FileHandle/Unget.pm                            |  64 +++--
 .../Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm |  46 ++++
 t/binmode_bug.t                                    |  23 +-
 t/buffer.t                                         |  17 +-
 t/eof.t                                            |  17 +-
 t/filehandle.t                                     |  27 +-
 t/fileno.t                                         |   9 +-
 t/gensym.t                                         |  35 ++-
 t/input_record_separator.t                         |  25 +-
 t/loop_bug.t                                       |  19 +-
 t/memory_leak.t                                    |   2 +-
 t/multiple_handles.t                               |  19 +-
 t/new.t                                            |  25 +-
 t/pod.t                                            |  10 +
 t/seek.t                                           |  18 +-
 t/stdin_tell_bug.t                                 |  63 ++---
 t/tell.t                                           |  20 +-
 t/ungetc.t                                         |  19 +-
 t/ungets.t                                         |  21 +-
 40 files changed, 1253 insertions(+), 535 deletions(-)

diff --git a/CHANGES b/CHANGES
index c00f929..d37ba7c 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,43 @@
+Version 0.1628: Sat May 2 2015
+- Prevent CPAN from indexing private-lib
+
+Version 0.1627: Mon Apr 20 2015
+- Clarify licensing terms
+- Move verbose testing to a private module, and implement it in a way that
+  doesn't require editing the Makefile after it is generated.
+- Require File::Slurp instead of including it, to avoid potential problems 
+  like this: 
+  http://www.cpantesters.org/cpan/report/86a0145a-e52b-11e4-a1d1-8536eb4f9f07 
+- Fix tests so that they don't prematurely delete the temp file
+  See for example:
+  http://www.cpantesters.org/cpan/report/3adcb600-6bf9-1014-8336-f8616735162a
+- Fix tests on Windows.
+  http://www.cpantesters.org/cpan/report/482c4765-af8d-1014-8ca5-91062b825c07
+
+Version 0.1626: Sun Apr 12 2015
+- Enable verbose testing for CPAN-testers
+- Consolidate issue tracking at rt.cpan.org
+
+Version 0.1625: Sat Apr 4 2015
+- Modify the memory leak test to check for <= 0 bytes. I'm not sure how this
+  scenario happens, but test failures like this indicate that it can:
+  http://www.cpantesters.org/cpan/report/bdd0e36c-d0dd-11e4-954f-5702e0bfc7aa
+- Attempt to fix loss of lines when $/ is undef. Thanks to Nigel Horne for the
+  automated testing that found the failure.
+  http://www.cpantesters.org/cpan/report/60452d60-d3cc-11e4-b60b-c2157e3e1735
+
+Version 0.1624: Sun Mar 22 2015
+- Moved code to github
+- Added POD test
+- Improve testability of binmode_bug.t, stdin_tell_bug.t
+- Implement a potential fix for test failures where FileHandle::getline()
+       seems to be reading a single line even though $/ is undef. 
Unfortunately I
+       can't reproduce this failure, so I'll submit and check the CPAN Testers
+       reports.
+- Use "local $/" instead of reassigning global $/. Perhaps this is somehow
+       related to the test failures above?
+- Improve documentation for input_record_separator()
+
 Version 0.1623: Sun Aug 9 2009
 - Fixed a bug where files with binary data would sometimes cause an
        unitialized value warning at line 394 as well as incorrect behavior. 
(Thanks
diff --git a/LICENSE b/LICENSE
index 5b6e7c6..d3b1738 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,12 +1,18 @@
-                   GNU GENERAL PUBLIC LICENSE
-                      Version 2, June 1991
+This software is Copyright (c) 2015 by David Coppit.
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+This is free software, licensed under:
+
+  The GNU General Public License, Version 2, June 1991
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-                           Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -15,7 +21,7 @@ software--to make sure the software is free for all its 
users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
+the GNU Lesser General Public License instead.)  You can apply it to
 your programs, too.
 
   When we speak of free software, we are referring to freedom, not
@@ -55,8 +61,8 @@ patent must be licensed for everyone's free use or not 
licensed at all.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
-
-                   GNU GENERAL PUBLIC LICENSE
+
+                    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -110,7 +116,7 @@ above, provided that you also meet all of these conditions:
     License.  (Exception: if the Program itself is interactive but
     does not normally print such an announcement, your work based on
     the Program is not required to print an announcement.)
-
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -168,7 +174,7 @@ access to copy from a designated place, then offering 
equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
+
   4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -225,7 +231,7 @@ impose that choice.
 
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
+
   8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -255,7 +261,7 @@ make exceptions for this.  Our decision will be guided by 
the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-                           NO WARRANTY
+                            NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +283,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE 
WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-                    END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Programs
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
@@ -303,10 +309,9 @@ the "copyright" line and a pointer to where the full 
notice is found.
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -336,5 +341,5 @@ necessary.  Here is a sample; alter the names:
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
+library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.
diff --git a/MANIFEST b/MANIFEST
index 0e73b54..3031873 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -3,6 +3,7 @@ LICENSE
 MANIFEST
 Makefile.PL
 README
+TODO
 
 # The module files
 lib/FileHandle/Unget.pm
@@ -24,6 +25,7 @@ t/memory_leak.t
 t/multiple_handles.t
 t/new.t
 t/overridden_pipe.t
+t/pod.t
 t/seek.t
 t/tell.t
 t/ungetc.t
@@ -31,12 +33,21 @@ t/ungets.t
 
 # Module::Install extensions
 inc/Module/Install.pm
+inc/Module/Install/AutoLicense.pm
+inc/Module/Install/AutomatedTester.pm
 inc/Module/Install/Base.pm
+inc/Module/Install/Bugtracker.pm
 inc/Module/Install/Can.pm
 inc/Module/Install/Fetch.pm
+inc/Module/Install/GithubMeta.pm
+inc/Module/Install/Include.pm
 inc/Module/Install/Makefile.pm
 inc/Module/Install/Metadata.pm
 inc/Module/Install/Win32.pm
 inc/Module/Install/WriteAll.pm
+inc/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm
+
+# Private Module::Install extensions
+private-lib/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm
 
 META.yml
diff --git a/META.yml b/META.yml
index d35b371..01a1267 100644
--- a/META.yml
+++ b/META.yml
@@ -3,14 +3,17 @@ abstract: 'FileHandle which supports multi-byte unget'
 author:
   - 'David Coppit <da...@coppit.org>.'
 build_requires:
-  ExtUtils::MakeMaker: 6.42
+  ExtUtils::MakeMaker: 6.36
+  File::Slurp: 0
   File::Spec::Functions: 0
   Test::More: 0
 configure_requires:
-  ExtUtils::MakeMaker: 6.42
+  ExtUtils::MakeMaker: 6.36
+  URI::Escape: 0
 distribution_type: module
-generated_by: 'Module::Install version 0.91'
-license: gpl
+dynamic_config: 1
+generated_by: 'Module::Install version 1.14'
+license: gpl2
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
   version: 1.4
@@ -19,10 +22,14 @@ name: FileHandle-Unget
 no_index:
   directory:
     - inc
+    - private-lib
     - t
 requires:
-  Scalar::Util: 1.14
-  perl: 5.005
+  Scalar::Util: '1.14'
+  perl: '5.005'
 resources:
-  license: http://opensource.org/licenses/gpl-license.php
-version: 0.1623
+  bugtracker: http://rt.cpan.org/Public/Dist/Display.html?Name=FileHandle-Unget
+  homepage: https://github.com/coppit/filehandle-unget/
+  license: http://opensource.org/licenses/gpl-2.0.php
+  repository: https://github.com/coppit/filehandle-unget.git
+version: '0.1628'
diff --git a/Makefile.PL b/Makefile.PL
index 4107a03..fac5ae7 100755
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -1,19 +1,31 @@
 #!/usr/bin/perl
 
 use strict;
+
+# For PRIVATE Module::Install extensions
+use lib 'private-lib';
+
 use inc::Module::Install;
 
-all_from        ('lib/FileHandle/Unget.pm');
+all_from('lib/FileHandle/Unget.pm');
+
+auto_set_bugtracker;
+githubmeta;
+
+requires(
+  'Scalar::Util' => '1.14',
+);
 
-requires        (
-                  'Scalar::Util' => '1.14',
-                );
+test_requires(
+  'File::Slurp' => 0,
+  'Test::More' => 0,
+  'File::Spec::Functions' => 0,
+);
 
-test_requires   (
-                  'Test::More' => 0,
-                  'File::Spec::Functions' => 0,
-                );
+license 'gpl2';
+auto_license(holder => 'David Coppit');
+no_index 'directory' => 'private-lib';
 
-clean_files     ('t/temp');
+enable_verbose_cpan_testing();
 
 WriteAll();
diff --git a/README b/README
index 1472263..068003d 100644
--- a/README
+++ b/README
@@ -73,31 +73,23 @@ Just "perldoc FileHandle::Unget". After installation on 
Unix systems,
 you can also do "man FileHandle::Unget".
 
 
-HOMEPAGE
+RESOURCES
 
 The CPAN Page:
 http://search.cpan.org/dist/FileHandle-Unget/
 
-The Google Code page:
-http://code.google.com/p/filehandle-unget/
+The GitHub page:
+https://github.com/coppit/filehandle-unget/
 
-
-REPORTING BUGS
-
-http://code.google.com/p/filehandle-unget/issues/entry
+Bug and feature tracking:
+http://rt.cpan.org/Public/Dist/Display.html?Name=FileHandle-Unget
 
 
 COPYRIGHT
 
-Copyright (c) 1998-Sep 1 2000 Broc Seib. Copyright (c) Sep 1 2000-2004 David
-Coppit. All rights reserved, save those granted by the license.
-
-
-LICENSE
-
-This code is distributed under the GNU General Public License (GPL). See the
-file LICENSE in the distribution, http://www.opensource.org/gpl-license.html,
-and http://www.opensource.org/.
+Copyright (c) 1998-Sep 1 2000 Broc Seib. Copyright (c) Sep 1 2000-2015 David
+Coppit. All rights reserved, save those granted by the license. See the file
+LICENSE for licensing terms.
 
 
 AUTHOR
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..324b4fd
--- /dev/null
+++ b/TODO
@@ -0,0 +1,4 @@
+- After Module::Install support CPAN::Meta 2.0, specify gpl_2 as the license.
+  Suggested by Paul Howarth <p...@city-fan.org>
+- After Module::Install support CPAN::Meta 2.0, add info for repository URL
+  and bug tracker. Suggested by Paul Howarth <p...@city-fan.org>
diff --git a/inc/Module/Install.pm b/inc/Module/Install.pm
index 51eda5d..ff767fa 100644
--- a/inc/Module/Install.pm
+++ b/inc/Module/Install.pm
@@ -17,8 +17,11 @@ package Module::Install;
 #     3. The ./inc/ version of Module::Install loads
 # }
 
-use 5.005;
+use 5.006;
 use strict 'vars';
+use Cwd        ();
+use File::Find ();
+use File::Path ();
 
 use vars qw{$VERSION $MAIN};
 BEGIN {
@@ -28,7 +31,7 @@ BEGIN {
        # This is not enforced yet, but will be some time in the next few
        # releases once we can make sure it won't clash with custom
        # Module::Install extensions.
-       $VERSION = '0.91';
+       $VERSION = '1.14';
 
        # Storage for the pseudo-singleton
        $MAIN    = undef;
@@ -38,18 +41,25 @@ BEGIN {
 
 }
 
+sub import {
+       my $class = shift;
+       my $self  = $class->new(@_);
+       my $who   = $self->_caller;
 
-
-
-
-# Whether or not inc::Module::Install is actually loaded, the
-# $INC{inc/Module/Install.pm} is what will still get set as long as
-# the caller loaded module this in the documented manner.
-# If not set, the caller may NOT have loaded the bundled version, and thus
-# they may not have a MI version that works with the Makefile.PL. This would
-# result in false errors or unexpected behaviour. And we don't want that.
-my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
-unless ( $INC{$file} ) { die <<"END_DIE" }
+       #-------------------------------------------------------------
+       # all of the following checks should be included in import(),
+       # to allow "eval 'require Module::Install; 1' to test
+       # installation of Module::Install. (RT #51267)
+       #-------------------------------------------------------------
+
+       # Whether or not inc::Module::Install is actually loaded, the
+       # $INC{inc/Module/Install.pm} is what will still get set as long as
+       # the caller loaded module this in the documented manner.
+       # If not set, the caller may NOT have loaded the bundled version, and 
thus
+       # they may not have a MI version that works with the Makefile.PL. This 
would
+       # result in false errors or unexpected behaviour. And we don't want 
that.
+       my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
+       unless ( $INC{$file} ) { die <<"END_DIE" }
 
 Please invoke ${\__PACKAGE__} with:
 
@@ -61,26 +71,28 @@ not:
 
 END_DIE
 
-
-
-
-
-# If the script that is loading Module::Install is from the future,
-# then make will detect this and cause it to re-run over and over
-# again. This is bad. Rather than taking action to touch it (which
-# is unreliable on some platforms and requires write permissions)
-# for now we should catch this and refuse to run.
-if ( -f $0 ) {
-       my $s = (stat($0))[9];
-
-       # If the modification time is only slightly in the future,
-       # sleep briefly to remove the problem.
-       my $a = $s - time;
-       if ( $a > 0 and $a < 5 ) { sleep 5 }
-
-       # Too far in the future, throw an error.
-       my $t = time;
-       if ( $s > $t ) { die <<"END_DIE" }
+       # This reportedly fixes a rare Win32 UTC file time issue, but
+       # as this is a non-cross-platform XS module not in the core,
+       # we shouldn't really depend on it. See RT #24194 for detail.
+       # (Also, this module only supports Perl 5.6 and above).
+       eval "use Win32::UTCFileTime" if $^O eq 'MSWin32' && $] >= 5.006;
+
+       # If the script that is loading Module::Install is from the future,
+       # then make will detect this and cause it to re-run over and over
+       # again. This is bad. Rather than taking action to touch it (which
+       # is unreliable on some platforms and requires write permissions)
+       # for now we should catch this and refuse to run.
+       if ( -f $0 ) {
+               my $s = (stat($0))[9];
+
+               # If the modification time is only slightly in the future,
+               # sleep briefly to remove the problem.
+               my $a = $s - time;
+               if ( $a > 0 and $a < 5 ) { sleep 5 }
+
+               # Too far in the future, throw an error.
+               my $t = time;
+               if ( $s > $t ) { die <<"END_DIE" }
 
 Your installer $0 has a modification time in the future ($s > $t).
 
@@ -89,15 +101,12 @@ This is known to create infinite loops in make.
 Please correct this, then run $0 again.
 
 END_DIE
-}
-
-
-
+       }
 
 
-# Build.PL was formerly supported, but no longer is due to excessive
-# difficulty in implementing every single feature twice.
-if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" }
+       # Build.PL was formerly supported, but no longer is due to excessive
+       # difficulty in implementing every single feature twice.
+       if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" }
 
 Module::Install no longer supports Build.PL.
 
@@ -107,36 +116,69 @@ Please remove all Build.PL files and only use the 
Makefile.PL installer.
 
 END_DIE
 
+       #-------------------------------------------------------------
 
+       # To save some more typing in Module::Install installers, every...
+       # use inc::Module::Install
+       # ...also acts as an implicit use strict.
+       $^H |= strict::bits(qw(refs subs vars));
 
+       #-------------------------------------------------------------
 
+       unless ( -f $self->{file} ) {
+               foreach my $key (keys %INC) {
+                       delete $INC{$key} if $key =~ /Module\/Install/;
+               }
 
-# To save some more typing in Module::Install installers, every...
-# use inc::Module::Install
-# ...also acts as an implicit use strict.
-$^H |= strict::bits(qw(refs subs vars));
-
+               local $^W;
+               require "$self->{path}/$self->{dispatch}.pm";
+               File::Path::mkpath("$self->{prefix}/$self->{author}");
+               $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top 
=> $self );
+               $self->{admin}->init;
+               @_ = ($class, _self => $self);
+               goto &{"$self->{name}::import"};
+       }
 
+       local $^W;
+       *{"${who}::AUTOLOAD"} = $self->autoload;
+       $self->preload;
 
+       # Unregister loader and worker packages so subdirs can use them again
+       delete $INC{'inc/Module/Install.pm'};
+       delete $INC{'Module/Install.pm'};
 
+       # Save to the singleton
+       $MAIN = $self;
 
-use Cwd        ();
-use File::Find ();
-use File::Path ();
-use FindBin;
+       return 1;
+}
 
 sub autoload {
        my $self = shift;
        my $who  = $self->_caller;
-       my $cwd  = Cwd::cwd();
+       my $cwd  = Cwd::getcwd();
        my $sym  = "${who}::AUTOLOAD";
        $sym->{$cwd} = sub {
-               my $pwd = Cwd::cwd();
+               my $pwd = Cwd::getcwd();
                if ( my $code = $sym->{$pwd} ) {
                        # Delegate back to parent dirs
                        goto &$code unless $cwd eq $pwd;
                }
-               $$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
+               unless ($$sym =~ s/([^:]+)$//) {
+                       # XXX: it looks like we can't retrieve the missing 
function
+                       # via $$sym (usually $main::AUTOLOAD) in this case.
+                       # I'm still wondering if we should slurp Makefile.PL to
+                       # get some context or not ...
+                       my ($package, $file, $line) = caller;
+                       die <<"EOT";
+Unknown function is found at $file line $line.
+Execution of $file aborted due to runtime errors.
+
+If you're a contributor to a project, you may need to install
+some Module::Install extensions from CPAN (or other repository).
+If you're a user of a module, please contact the author.
+EOT
+               }
                my $method = $1;
                if ( uc($method) eq $method ) {
                        # Do nothing
@@ -152,33 +194,6 @@ sub autoload {
        };
 }
 
-sub import {
-       my $class = shift;
-       my $self  = $class->new(@_);
-       my $who   = $self->_caller;
-
-       unless ( -f $self->{file} ) {
-               require "$self->{path}/$self->{dispatch}.pm";
-               File::Path::mkpath("$self->{prefix}/$self->{author}");
-               $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top 
=> $self );
-               $self->{admin}->init;
-               @_ = ($class, _self => $self);
-               goto &{"$self->{name}::import"};
-       }
-
-       *{"${who}::AUTOLOAD"} = $self->autoload;
-       $self->preload;
-
-       # Unregister loader and worker packages so subdirs can use them again
-       delete $INC{"$self->{file}"};
-       delete $INC{"$self->{path}.pm"};
-
-       # Save to the singleton
-       $MAIN = $self;
-
-       return 1;
-}
-
 sub preload {
        my $self = shift;
        unless ( $self->{extensions} ) {
@@ -204,6 +219,7 @@ sub preload {
 
        my $who = $self->_caller;
        foreach my $name ( sort keys %seen ) {
+               local $^W;
                *{"${who}::$name"} = sub {
                        ${"${who}::AUTOLOAD"} = "${who}::$name";
                        goto &{"${who}::AUTOLOAD"};
@@ -214,12 +230,18 @@ sub preload {
 sub new {
        my ($class, %args) = @_;
 
+       delete $INC{'FindBin.pm'};
+       {
+               # to suppress the redefine warning
+               local $SIG{__WARN__} = sub {};
+               require FindBin;
+       }
+
        # ignore the prefix on extension modules built from top level.
        my $base_path = Cwd::abs_path($FindBin::Bin);
-       unless ( Cwd::abs_path(Cwd::cwd()) eq $base_path ) {
+       unless ( Cwd::abs_path(Cwd::getcwd()) eq $base_path ) {
                delete $args{prefix};
        }
-
        return $args{_self} if $args{_self};
 
        $args{dispatch} ||= 'Admin';
@@ -272,8 +294,10 @@ END_DIE
 sub load_extensions {
        my ($self, $path, $top) = @_;
 
+       my $should_reload = 0;
        unless ( grep { ! ref $_ and lc $_ eq lc $self->{prefix} } @INC ) {
                unshift @INC, $self->{prefix};
+               $should_reload = 1;
        }
 
        foreach my $rv ( $self->find_extensions($path) ) {
@@ -281,12 +305,13 @@ sub load_extensions {
                next if $self->{pathnames}{$pkg};
 
                local $@;
-               my $new = eval { require $file; $pkg->can('new') };
+               my $new = eval { local $^W; require $file; $pkg->can('new') };
                unless ( $new ) {
                        warn $@ if $@;
                        next;
                }
-               $self->{pathnames}{$pkg} = delete $INC{$file};
+               $self->{pathnames}{$pkg} =
+                       $should_reload ? delete $INC{$file} : $INC{$file};
                push @{$self->{extensions}}, &{$new}($pkg, _top => $top );
        }
 
@@ -313,7 +338,7 @@ sub find_extensions {
                if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) {
                        my $content = Module::Install::_read($subpath . '.pm');
                        my $in_pod  = 0;
-                       foreach ( split //, $content ) {
+                       foreach ( split /\n/, $content ) {
                                $in_pod = 1 if /^=\w/;
                                $in_pod = 0 if /^=cut/;
                                next if ($in_pod || /^=cut/);  # skip pod text
@@ -348,17 +373,26 @@ sub _caller {
        return $call;
 }
 
+# Done in evals to avoid confusing Perl::MinimumVersion
+eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@;
 sub _read {
        local *FH;
-       if ( $] >= 5.006 ) {
-               open( FH, '<', $_[0] ) or die "open($_[0]): $!";
-       } else {
-               open( FH, "< $_[0]"  ) or die "open($_[0]): $!";
-       }
+       open( FH, '<', $_[0] ) or die "open($_[0]): $!";
+       binmode FH;
+       my $string = do { local $/; <FH> };
+       close FH or die "close($_[0]): $!";
+       return $string;
+}
+END_NEW
+sub _read {
+       local *FH;
+       open( FH, "< $_[0]"  ) or die "open($_[0]): $!";
+       binmode FH;
        my $string = do { local $/; <FH> };
        close FH or die "close($_[0]): $!";
        return $string;
 }
+END_OLD
 
 sub _readperl {
        my $string = Module::Install::_read($_[0]);
@@ -379,22 +413,32 @@ sub _readpod {
        return $string;
 }
 
+# Done in evals to avoid confusing Perl::MinimumVersion
+eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@;
 sub _write {
        local *FH;
-       if ( $] >= 5.006 ) {
-               open( FH, '>', $_[0] ) or die "open($_[0]): $!";
-       } else {
-               open( FH, "> $_[0]"  ) or die "open($_[0]): $!";
+       open( FH, '>', $_[0] ) or die "open($_[0]): $!";
+       binmode FH;
+       foreach ( 1 .. $#_ ) {
+               print FH $_[$_] or die "print($_[0]): $!";
        }
+       close FH or die "close($_[0]): $!";
+}
+END_NEW
+sub _write {
+       local *FH;
+       open( FH, "> $_[0]"  ) or die "open($_[0]): $!";
+       binmode FH;
        foreach ( 1 .. $#_ ) {
                print FH $_[$_] or die "print($_[0]): $!";
        }
        close FH or die "close($_[0]): $!";
 }
+END_OLD
 
 # _version is for processing module versions (eg, 1.03_05) not
 # Perl versions (eg, 5.8.1).
-sub _version ($) {
+sub _version {
        my $s = shift || 0;
        my $d =()= $s =~ /(\.)/g;
        if ( $d >= 2 ) {
@@ -410,12 +454,12 @@ sub _version ($) {
        return $l + 0;
 }
 
-sub _cmp ($$) {
-       _version($_[0]) <=> _version($_[1]);
+sub _cmp {
+       _version($_[1]) <=> _version($_[2]);
 }
 
 # Cloned from Params::Util::_CLASS
-sub _CLASS ($) {
+sub _CLASS {
        (
                defined $_[0]
                and
@@ -427,4 +471,4 @@ sub _CLASS ($) {
 
 1;
 
-# Copyright 2008 - 2009 Adam Kennedy.
+# Copyright 2008 - 2012 Adam Kennedy.
diff --git a/inc/Module/Install/AutoLicense.pm 
b/inc/Module/Install/AutoLicense.pm
new file mode 100644
index 0000000..97cc1fd
--- /dev/null
+++ b/inc/Module/Install/AutoLicense.pm
@@ -0,0 +1,63 @@
+#line 1
+package Module::Install::AutoLicense;
+
+use strict;
+use warnings;
+use base qw(Module::Install::Base);
+use vars qw($VERSION);
+
+$VERSION = '0.08';
+
+my %licenses = (
+    perl         => 'Software::License::Perl_5',
+    apache       => 'Software::License::Apache_2_0',
+    artistic     => 'Software::License::Artistic_1_0',
+    artistic_2   => 'Software::License::Artistic_2_0',
+    lgpl2        => 'Software::License::LGPL_2_1',
+    lgpl3        => 'Software::License::LGPL_3_0',
+    bsd          => 'Software::License::BSD',
+    gpl          => 'Software::License::GPL_1',
+    gpl2         => 'Software::License::GPL_2',
+    gpl3         => 'Software::License::GPL_3',
+    mit          => 'Software::License::MIT',
+    mozilla      => 'Software::License::Mozilla_1_1',
+);
+
+sub auto_license {
+  my $self = shift;
+  return unless $Module::Install::AUTHOR;
+  my %opts = @_;
+  $opts{lc $_} = delete $opts{$_} for keys %opts;
+  my $holder = $opts{holder} || _get_authors( $self );
+  #my $holder = $opts{holder} || $self->author;
+  my $license = $self->license();
+  unless ( defined $licenses{ $license } ) {
+     warn "No license definition for '$license', aborting\n";
+     return 1;
+  }
+  my $class = $licenses{ $license };
+  eval "require $class";
+  my $sl = $class->new( { holder => $holder } );
+  open LICENSE, '>LICENSE' or die "$!\n";
+  print LICENSE $sl->fulltext;
+  close LICENSE;
+  $self->postamble(<<"END");
+distclean :: license_clean
+
+license_clean:
+\t\$(RM_F) LICENSE
+END
+
+  return 1;
+}
+
+sub _get_authors {
+  my $self = shift;
+  my $joined = join ', ', @{ $self->author() || [] };
+  return $joined;
+}
+
+'Licensed to auto';
+__END__
+
+#line 125
diff --git a/inc/Module/Install/AutomatedTester.pm 
b/inc/Module/Install/AutomatedTester.pm
new file mode 100644
index 0000000..3a12e6f
--- /dev/null
+++ b/inc/Module/Install/AutomatedTester.pm
@@ -0,0 +1,24 @@
+#line 1
+package Module::Install::AutomatedTester;
+
+use strict;
+use warnings;
+use base qw(Module::Install::Base);
+use vars qw($VERSION);
+
+$VERSION = '0.02';
+
+sub auto_tester {
+  return if $Module::Install::AUTHOR;
+  return $ENV{AUTOMATED_TESTING};
+}
+
+sub cpan_tester {
+  &auto_tester;
+}
+
+'ARE WE BEING SMOKED?';
+
+__END__
+
+#line 78
diff --git a/inc/Module/Install/Base.pm b/inc/Module/Install/Base.pm
index 60a74d2..4206347 100644
--- a/inc/Module/Install/Base.pm
+++ b/inc/Module/Install/Base.pm
@@ -4,7 +4,7 @@ package Module::Install::Base;
 use strict 'vars';
 use vars qw{$VERSION};
 BEGIN {
-       $VERSION = '0.91';
+       $VERSION = '1.14';
 }
 
 # Suspend handler for "redefined" warnings
@@ -51,13 +51,18 @@ sub admin {
 #line 106
 
 sub is_admin {
-       $_[0]->admin->VERSION;
+       ! $_[0]->admin->isa('Module::Install::Base::FakeAdmin');
 }
 
 sub DESTROY {}
 
 package Module::Install::Base::FakeAdmin;
 
+use vars qw{$VERSION};
+BEGIN {
+       $VERSION = $Module::Install::Base::VERSION;
+}
+
 my $fake;
 
 sub new {
@@ -75,4 +80,4 @@ BEGIN {
 
 1;
 
-#line 154
+#line 159
diff --git a/inc/Module/Install/Bugtracker.pm b/inc/Module/Install/Bugtracker.pm
new file mode 100644
index 0000000..1d077d8
--- /dev/null
+++ b/inc/Module/Install/Bugtracker.pm
@@ -0,0 +1,28 @@
+#line 1
+package Module::Install::Bugtracker;
+use 5.006;
+use strict;
+use warnings;
+use URI::Escape;
+use base qw(Module::Install::Base);
+
+our $VERSION = sprintf "%d.%02d%02d", q/0.3.0/ =~ /(\d+)/g;
+
+sub auto_set_bugtracker {
+    my $self = shift;
+    if ($self->name) {
+        $self->configure_requires('URI::Escape', 0);
+
+        $self->bugtracker(
+            sprintf 'http://rt.cpan.org/Public/Dist/Display.html?Name=%s',
+            uri_escape($self->name),
+        );
+    } else {
+        warn "can't set bugtracker if 'name' is not set\n";
+    }
+}
+1;
+__END__
+
+#line 100
+
diff --git a/inc/Module/Install/Can.pm b/inc/Module/Install/Can.pm
index e65e4f6..9929b1b 100644
--- a/inc/Module/Install/Can.pm
+++ b/inc/Module/Install/Can.pm
@@ -3,13 +3,12 @@ package Module::Install::Can;
 
 use strict;
 use Config                ();
-use File::Spec            ();
 use ExtUtils::MakeMaker   ();
 use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-       $VERSION = '0.91';
+       $VERSION = '1.14';
        @ISA     = 'Module::Install::Base';
        $ISCORE  = 1;
 }
@@ -29,7 +28,7 @@ sub can_use {
        eval { require $mod; $pkg->VERSION($ver || 0); 1 };
 }
 
-# check if we can run some command
+# Check if we can run some command
 sub can_run {
        my ($self, $cmd) = @_;
 
@@ -38,14 +37,88 @@ sub can_run {
 
        for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') {
                next if $dir eq '';
-               my $abs = File::Spec->catfile($dir, $_[1]);
+               require File::Spec;
+               my $abs = File::Spec->catfile($dir, $cmd);
                return $abs if (-x $abs or $abs = MM->maybe_command($abs));
        }
 
        return;
 }
 
-# can we locate a (the) C compiler
+# Can our C compiler environment build XS files
+sub can_xs {
+       my $self = shift;
+
+       # Ensure we have the CBuilder module
+       $self->configure_requires( 'ExtUtils::CBuilder' => 0.27 );
+
+       # Do we have the configure_requires checker?
+       local $@;
+       eval "require ExtUtils::CBuilder;";
+       if ( $@ ) {
+               # They don't obey configure_requires, so it is
+               # someone old and delicate. Try to avoid hurting
+               # them by falling back to an older simpler test.
+               return $self->can_cc();
+       }
+
+       # Do we have a working C compiler
+       my $builder = ExtUtils::CBuilder->new(
+               quiet => 1,
+       );
+       unless ( $builder->have_compiler ) {
+               # No working C compiler
+               return 0;
+       }
+
+       # Write a C file representative of what XS becomes
+       require File::Temp;
+       my ( $FH, $tmpfile ) = File::Temp::tempfile(
+               "compilexs-XXXXX",
+               SUFFIX => '.c',
+       );
+       binmode $FH;
+       print $FH <<'END_C';
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+int main(int argc, char **argv) {
+    return 0;
+}
+
+int boot_sanexs() {
+    return 1;
+}
+
+END_C
+       close $FH;
+
+       # Can the C compiler access the same headers XS does
+       my @libs   = ();
+       my $object = undef;
+       eval {
+               local $^W = 0;
+               $object = $builder->compile(
+                       source => $tmpfile,
+               );
+               @libs = $builder->link(
+                       objects     => $object,
+                       module_name => 'sanexs',
+               );
+       };
+       my $result = $@ ? 0 : 1;
+
+       # Clean up all the build files
+       foreach ( $tmpfile, $object, @libs ) {
+               next unless defined $_;
+               1 while unlink;
+       }
+
+       return $result;
+}
+
+# Can we locate a (the) C compiler
 sub can_cc {
        my $self   = shift;
        my @chunks = split(/ /, $Config::Config{cc}) or return;
@@ -78,4 +151,4 @@ if ( $^O eq 'cygwin' ) {
 
 __END__
 
-#line 156
+#line 236
diff --git a/inc/Module/Install/Fetch.pm b/inc/Module/Install/Fetch.pm
index 05f2079..3d8de76 100644
--- a/inc/Module/Install/Fetch.pm
+++ b/inc/Module/Install/Fetch.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-       $VERSION = '0.91';
+       $VERSION = '1.14';
        @ISA     = 'Module::Install::Base';
        $ISCORE  = 1;
 }
diff --git a/inc/Module/Install/GithubMeta.pm b/inc/Module/Install/GithubMeta.pm
new file mode 100644
index 0000000..1379e25
--- /dev/null
+++ b/inc/Module/Install/GithubMeta.pm
@@ -0,0 +1,53 @@
+#line 1
+package Module::Install::GithubMeta;
+
+use strict;
+use warnings;
+use Cwd;
+use base qw(Module::Install::Base);
+use vars qw($VERSION);
+
+$VERSION = '0.30';
+
+sub githubmeta {
+  my $self = shift;
+  return unless $Module::Install::AUTHOR;
+  return unless _under_git();
+  return unless $self->can_run('git');
+  my $remote = shift || 'origin';
+  local $ENV{LC_ALL}='C';
+  local $ENV{LANG}='C';
+  return unless my ($git_url) = `git remote show -n $remote` =~ /URL: (.*)$/m;
+  return unless $git_url =~ /github\.com/; # Not a Github repository
+  my $http_url = $git_url;
+  $git_url =~ s![\w\-]+\@([^:]+):!git://$1/!;
+  $http_url =~ s![\w\-]+\@([^:]+):!https://$1/!;
+  $http_url =~ s!\.git$!/!;
+  $self->repository( $git_url );
+  $self->homepage( $http_url ) unless $self->homepage();
+  return 1;
+}
+
+sub _under_git {
+  return 1 if -e '.git';
+  my $cwd = getcwd;
+  my $last = $cwd;
+  my $found = 0;
+  while (1) {
+    chdir '..' or last;
+    my $current = getcwd;
+    last if $last eq $current;
+    $last = $current;
+    if ( -e '.git' ) {
+       $found = 1;
+       last;
+    }
+  }
+  chdir $cwd;
+  return $found;
+}
+
+'Github';
+__END__
+
+#line 113
diff --git a/inc/Module/Install/Include.pm b/inc/Module/Install/Include.pm
new file mode 100644
index 0000000..f274f87
--- /dev/null
+++ b/inc/Module/Install/Include.pm
@@ -0,0 +1,34 @@
+#line 1
+package Module::Install::Include;
+
+use strict;
+use Module::Install::Base ();
+
+use vars qw{$VERSION @ISA $ISCORE};
+BEGIN {
+       $VERSION = '1.14';
+       @ISA     = 'Module::Install::Base';
+       $ISCORE  = 1;
+}
+
+sub include {
+       shift()->admin->include(@_);
+}
+
+sub include_deps {
+       shift()->admin->include_deps(@_);
+}
+
+sub auto_include {
+       shift()->admin->auto_include(@_);
+}
+
+sub auto_include_deps {
+       shift()->admin->auto_include_deps(@_);
+}
+
+sub auto_include_dependent_dists {
+       shift()->admin->auto_include_dependent_dists(@_);
+}
+
+1;
diff --git a/inc/Module/Install/Makefile.pm b/inc/Module/Install/Makefile.pm
index 98779db..66993af 100644
--- a/inc/Module/Install/Makefile.pm
+++ b/inc/Module/Install/Makefile.pm
@@ -4,10 +4,11 @@ package Module::Install::Makefile;
 use strict 'vars';
 use ExtUtils::MakeMaker   ();
 use Module::Install::Base ();
+use Fcntl qw/:flock :seek/;
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-       $VERSION = '0.91';
+       $VERSION = '1.14';
        @ISA     = 'Module::Install::Base';
        $ISCORE  = 1;
 }
@@ -25,8 +26,8 @@ sub prompt {
                die "Caught an potential prompt infinite loop 
($c[1]|$c[2]|$_[0])";
        }
 
-       # In automated testing, always use defaults
-       if ( $ENV{AUTOMATED_TESTING} and ! $ENV{PERL_MM_USE_DEFAULT} ) {
+       # In automated testing or non-interactive session, always use defaults
+       if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! 
$ENV{PERL_MM_USE_DEFAULT} ) {
                local $ENV{PERL_MM_USE_DEFAULT} = 1;
                goto &ExtUtils::MakeMaker::prompt;
        } else {
@@ -34,21 +35,112 @@ sub prompt {
        }
 }
 
+# Store a cleaned up version of the MakeMaker version,
+# since we need to behave differently in a variety of
+# ways based on the MM version.
+my $makemaker = eval $ExtUtils::MakeMaker::VERSION;
+
+# If we are passed a param, do a "newer than" comparison.
+# Otherwise, just return the MakeMaker version.
+sub makemaker {
+       ( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0
+}
+
+# Ripped from ExtUtils::MakeMaker 6.56, and slightly modified
+# as we only need to know here whether the attribute is an array
+# or a hash or something else (which may or may not be appendable).
+my %makemaker_argtype = (
+ C                  => 'ARRAY',
+ CONFIG             => 'ARRAY',
+# CONFIGURE          => 'CODE', # ignore
+ DIR                => 'ARRAY',
+ DL_FUNCS           => 'HASH',
+ DL_VARS            => 'ARRAY',
+ EXCLUDE_EXT        => 'ARRAY',
+ EXE_FILES          => 'ARRAY',
+ FUNCLIST           => 'ARRAY',
+ H                  => 'ARRAY',
+ IMPORTS            => 'HASH',
+ INCLUDE_EXT        => 'ARRAY',
+ LIBS               => 'ARRAY', # ignore ''
+ MAN1PODS           => 'HASH',
+ MAN3PODS           => 'HASH',
+ META_ADD           => 'HASH',
+ META_MERGE         => 'HASH',
+ PL_FILES           => 'HASH',
+ PM                 => 'HASH',
+ PMLIBDIRS          => 'ARRAY',
+ PMLIBPARENTDIRS    => 'ARRAY',
+ PREREQ_PM          => 'HASH',
+ CONFIGURE_REQUIRES => 'HASH',
+ SKIP               => 'ARRAY',
+ TYPEMAPS           => 'ARRAY',
+ XS                 => 'HASH',
+# VERSION            => ['version',''],  # ignore
+# _KEEP_AFTER_FLUSH  => '',
+
+ clean      => 'HASH',
+ depend     => 'HASH',
+ dist       => 'HASH',
+ dynamic_lib=> 'HASH',
+ linkext    => 'HASH',
+ macro      => 'HASH',
+ postamble  => 'HASH',
+ realclean  => 'HASH',
+ test       => 'HASH',
+ tool_autosplit => 'HASH',
+
+ # special cases where you can use makemaker_append
+ CCFLAGS   => 'APPENDABLE',
+ DEFINE    => 'APPENDABLE',
+ INC       => 'APPENDABLE',
+ LDDLFLAGS => 'APPENDABLE',
+ LDFROM    => 'APPENDABLE',
+);
+
 sub makemaker_args {
-       my $self = shift;
+       my ($self, %new_args) = @_;
        my $args = ( $self->{makemaker_args} ||= {} );
-       %$args = ( %$args, @_ );
+       foreach my $key (keys %new_args) {
+               if ($makemaker_argtype{$key}) {
+                       if ($makemaker_argtype{$key} eq 'ARRAY') {
+                               $args->{$key} = [] unless defined $args->{$key};
+                               unless (ref $args->{$key} eq 'ARRAY') {
+                                       $args->{$key} = [$args->{$key}]
+                               }
+                               push @{$args->{$key}},
+                                       ref $new_args{$key} eq 'ARRAY'
+                                               ? @{$new_args{$key}}
+                                               : $new_args{$key};
+                       }
+                       elsif ($makemaker_argtype{$key} eq 'HASH') {
+                               $args->{$key} = {} unless defined $args->{$key};
+                               foreach my $skey (keys %{ $new_args{$key} }) {
+                                       $args->{$key}{$skey} = 
$new_args{$key}{$skey};
+                               }
+                       }
+                       elsif ($makemaker_argtype{$key} eq 'APPENDABLE') {
+                               $self->makemaker_append($key => 
$new_args{$key});
+                       }
+               }
+               else {
+                       if (defined $args->{$key}) {
+                               warn qq{MakeMaker attribute "$key" is 
overriden; use "makemaker_append" to append values\n};
+                       }
+                       $args->{$key} = $new_args{$key};
+               }
+       }
        return $args;
 }
 
-# For mm args that take multiple space-seperated args,
+# For mm args that take multiple space-separated args,
 # append an argument to the current list.
 sub makemaker_append {
-       my $self = sShift;
+       my $self = shift;
        my $name = shift;
        my $args = $self->makemaker_args;
-       $args->{name} = defined $args->{$name}
-               ? join( ' ', $args->{name}, @_ )
+       $args->{$name} = defined $args->{$name}
+               ? join( ' ', $args->{$name}, @_ )
                : join( ' ', @_ );
 }
 
@@ -89,25 +181,22 @@ sub inc {
        $self->makemaker_args( INC => shift );
 }
 
-my %test_dir = ();
-
 sub _wanted_t {
-       /\.t$/ and -f $_ and $test_dir{$File::Find::dir} = 1;
 }
 
 sub tests_recursive {
        my $self = shift;
-       if ( $self->tests ) {
-               die "tests_recursive will not work if tests are already 
defined";
-       }
        my $dir = shift || 't';
        unless ( -d $dir ) {
                die "tests_recursive dir '$dir' does not exist";
        }
-       %test_dir = ();
+       my %tests = map { $_ => 1 } split / /, ($self->tests || '');
        require File::Find;
-       File::Find::find( \&_wanted_t, $dir );
-       $self->tests( join ' ', map { "$_/*.t" } sort keys %test_dir );
+       File::Find::find(
+        sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 },
+        $dir
+    );
+       $self->tests( join ' ', sort keys %tests );
 }
 
 sub write {
@@ -126,76 +215,136 @@ sub write {
        require ExtUtils::MakeMaker;
 
        if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) {
-               # MakeMaker can complain about module versions that include
-               # an underscore, even though its own version may contain one!
-               # Hence the funny regexp to get rid of it.  See RT #35800
-               # for details.
-               $self->build_requires( 'ExtUtils::MakeMaker' => 
$ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/ );
-               $self->configure_requires( 'ExtUtils::MakeMaker' => 
$ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/ );
+               # This previous attempted to inherit the version of
+               # ExtUtils::MakeMaker in use by the module author, but this
+               # was found to be untenable as some authors build releases
+               # using future dev versions of EU:MM that nobody else has.
+               # Instead, #toolchain suggests we use 6.59 which is the most
+               # stable version on CPAN at time of writing and is, to quote
+               # ribasushi, "not terminally fucked, > and tested enough".
+               # TODO: We will now need to maintain this over time to push
+               # the version up as new versions are released.
+               $self->build_requires(     'ExtUtils::MakeMaker' => 6.59 );
+               $self->configure_requires( 'ExtUtils::MakeMaker' => 6.59 );
        } else {
                # Allow legacy-compatibility with 5.005 by depending on the
                # most recent EU:MM that supported 5.005.
-               $self->build_requires( 'ExtUtils::MakeMaker' => 6.42 );
-               $self->configure_requires( 'ExtUtils::MakeMaker' => 6.42 );
+               $self->build_requires(     'ExtUtils::MakeMaker' => 6.36 );
+               $self->configure_requires( 'ExtUtils::MakeMaker' => 6.36 );
        }
 
        # Generate the MakeMaker params
        my $args = $self->makemaker_args;
        $args->{DISTNAME} = $self->name;
        $args->{NAME}     = $self->module_name || $self->name;
-       $args->{VERSION}  = $self->version;
        $args->{NAME}     =~ s/-/::/g;
+       $args->{VERSION}  = $self->version or die <<'EOT';
+ERROR: Can't determine distribution version. Please specify it
+explicitly via 'version' in Makefile.PL, or set a valid $VERSION
+in a module, and provide its file path via 'version_from' (or
+'all_from' if you prefer) in Makefile.PL.
+EOT
+
        if ( $self->tests ) {
-               $args->{test} = { TESTS => $self->tests };
+               my @tests = split ' ', $self->tests;
+               my %seen;
+               $args->{test} = {
+                       TESTS => (join ' ', grep {!$seen{$_}++} @tests),
+               };
+    } elsif ( $Module::Install::ExtraTests::use_extratests ) {
+        # Module::Install::ExtraTests doesn't set $self->tests and does its 
own tests via harness.
+        # So, just ignore our xt tests here.
+       } elsif ( -d 'xt' and ($Module::Install::AUTHOR or 
$ENV{RELEASE_TESTING}) ) {
+               $args->{test} = {
+                       TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ 
t xt } ),
+               };
        }
        if ( $] >= 5.005 ) {
                $args->{ABSTRACT} = $self->abstract;
-               $args->{AUTHOR}   = $self->author;
+               $args->{AUTHOR}   = join ', ', @{$self->author || []};
        }
-       if ( eval($ExtUtils::MakeMaker::VERSION) >= 6.10 ) {
-               $args->{NO_META} = 1;
+       if ( $self->makemaker(6.10) ) {
+               $args->{NO_META}   = 1;
+               #$args->{NO_MYMETA} = 1;
        }
-       if ( eval($ExtUtils::MakeMaker::VERSION) > 6.17 and $self->sign ) {
+       if ( $self->makemaker(6.17) and $self->sign ) {
                $args->{SIGN} = 1;
        }
        unless ( $self->is_admin ) {
                delete $args->{SIGN};
        }
+       if ( $self->makemaker(6.31) and $self->license ) {
+               $args->{LICENSE} = $self->license;
+       }
 
-       # Merge both kinds of requires into prereq_pm
        my $prereq = ($args->{PREREQ_PM} ||= {});
        %$prereq = ( %$prereq,
-               map { @$_ }
+               map { @$_ } # flatten [module => version]
                map { @$_ }
                grep $_,
-               ($self->configure_requires, $self->build_requires, 
$self->requires)
+               ($self->requires)
        );
 
        # Remove any reference to perl, PREREQ_PM doesn't support it
        delete $args->{PREREQ_PM}->{perl};
 
-       # merge both kinds of requires into prereq_pm
-       my $subdirs = ($args->{DIR} ||= []);
+       # Merge both kinds of requires into BUILD_REQUIRES
+       my $build_prereq = ($args->{BUILD_REQUIRES} ||= {});
+       %$build_prereq = ( %$build_prereq,
+               map { @$_ } # flatten [module => version]
+               map { @$_ }
+               grep $_,
+               ($self->configure_requires, $self->build_requires)
+       );
+
+       # Remove any reference to perl, BUILD_REQUIRES doesn't support it
+       delete $args->{BUILD_REQUIRES}->{perl};
+
+       # Delete bundled dists from prereq_pm, add it to Makefile DIR
+       my $subdirs = ($args->{DIR} || []);
        if ($self->bundles) {
+               my %processed;
                foreach my $bundle (@{ $self->bundles }) {
-                       my ($file, $dir) = @$bundle;
-                       push @$subdirs, $dir if -d $dir;
-                       delete $prereq->{$file};
+                       my ($mod_name, $dist_dir) = @$bundle;
+                       delete $prereq->{$mod_name};
+                       $dist_dir = File::Basename::basename($dist_dir); # dir 
for building this module
+                       if (not exists $processed{$dist_dir}) {
+                               if (-d $dist_dir) {
+                                       # List as sub-directory to be processed 
by make
+                                       push @$subdirs, $dist_dir;
+                               }
+                               # Else do nothing: the module is already 
present on the system
+                               $processed{$dist_dir} = undef;
+                       }
                }
        }
 
+       unless ( $self->makemaker('6.55_03') ) {
+               %$prereq = (%$prereq,%$build_prereq);
+               delete $args->{BUILD_REQUIRES};
+       }
+
        if ( my $perl_version = $self->perl_version ) {
                eval "use $perl_version; 1"
                        or die "ERROR: perl: Version $] is installed, "
                        . "but we need version >= $perl_version";
+
+               if ( $self->makemaker(6.48) ) {
+                       $args->{MIN_PERL_VERSION} = $perl_version;
+               }
        }
 
-       $args->{INSTALLDIRS} = $self->installdirs;
+       if ($self->installdirs) {
+               warn qq{old INSTALLDIRS (probably set by makemaker_args) is 
overriden by installdirs\n} if $args->{INSTALLDIRS};
+               $args->{INSTALLDIRS} = $self->installdirs;
+       }
 
-       my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_})} 
keys %$args;
+       my %args = map {
+               ( $_ => $args->{$_} ) } grep {defined($args->{$_} )
+       } keys %$args;
 
        my $user_preop = delete $args{dist}->{PREOP};
-       if (my $preop = $self->admin->preop($user_preop)) {
+       if ( my $preop = $self->admin->preop($user_preop) ) {
                foreach my $key ( keys %$preop ) {
                        $args{dist}->{$key} = $preop->{$key};
                }
@@ -219,9 +368,9 @@ sub fix_up_makefile {
                . ($self->postamble || '');
 
        local *MAKEFILE;
-       open MAKEFILE, "< $makefile_name" or die "fix_up_makefile: Couldn't 
open $makefile_name: $!";
+       open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't 
open $makefile_name: $!";
+       eval { flock MAKEFILE, LOCK_EX };
        my $makefile = do { local $/; <MAKEFILE> };
-       close MAKEFILE or die $!;
 
        $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /;
        $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g;
@@ -241,7 +390,8 @@ sub fix_up_makefile {
        # XXX - This is currently unused; not sure if it breaks other MM-users
        # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg;
 
-       open  MAKEFILE, "> $makefile_name" or die "fix_up_makefile: Couldn't 
open $makefile_name: $!";
+       seek MAKEFILE, 0, SEEK_SET;
+       truncate MAKEFILE, 0;
        print MAKEFILE  "$preamble$makefile$postamble" or die $!;
        close MAKEFILE  or die $!;
 
@@ -265,4 +415,4 @@ sub postamble {
 
 __END__
 
-#line 394
+#line 544
diff --git a/inc/Module/Install/Metadata.pm b/inc/Module/Install/Metadata.pm
index 653193d..e547fa0 100644
--- a/inc/Module/Install/Metadata.pm
+++ b/inc/Module/Install/Metadata.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-       $VERSION = '0.91';
+       $VERSION = '1.14';
        @ISA     = 'Module::Install::Base';
        $ISCORE  = 1;
 }
@@ -19,7 +19,6 @@ my @scalar_keys = qw{
        name
        module_name
        abstract
-       author
        version
        distribution_type
        tests
@@ -43,8 +42,11 @@ my @resource_keys = qw{
 
 my @array_keys = qw{
        keywords
+       author
 };
 
+*authors = \&author;
+
 sub Meta              { shift          }
 sub Meta_BooleanKeys  { @boolean_keys  }
 sub Meta_ScalarKeys   { @scalar_keys   }
@@ -149,15 +151,21 @@ sub install_as_site   { $_[0]->installdirs('site')   }
 sub install_as_vendor { $_[0]->installdirs('vendor') }
 
 sub dynamic_config {
-       my $self = shift;
-       unless ( @_ ) {
-               warn "You MUST provide an explicit true/false value to 
dynamic_config\n";
-               return $self;
+       my $self  = shift;
+       my $value = @_ ? shift : 1;
+       if ( $self->{values}->{dynamic_config} ) {
+               # Once dynamic we never change to static, for safety
+               return 0;
        }
-       $self->{values}->{dynamic_config} = $_[0] ? 1 : 0;
+       $self->{values}->{dynamic_config} = $value ? 1 : 0;
        return 1;
 }
 
+# Convenience command
+sub static_config {
+       shift->dynamic_config(0);
+}
+
 sub perl_version {
        my $self = shift;
        return $self->{values}->{perl_version} unless @_;
@@ -168,7 +176,7 @@ sub perl_version {
        # Normalize the version
        $version = $self->_perl_version($version);
 
-       # We don't support the reall old versions
+       # We don't support the really old versions
        unless ( $version >= 5.005 ) {
                die "Module::Install only supports 5.005 or newer (use 
ExtUtils::MakeMaker)\n";
        }
@@ -176,43 +184,6 @@ sub perl_version {
        $self->{values}->{perl_version} = $version;
 }
 
-#Stolen from M::B
-my %license_urls = (
-    perl         => 'http://dev.perl.org/licenses/',
-    apache       => 'http://apache.org/licenses/LICENSE-2.0',
-    artistic     => 'http://opensource.org/licenses/artistic-license.php',
-    artistic_2   => 'http://opensource.org/licenses/artistic-license-2.0.php',
-    lgpl         => 'http://opensource.org/licenses/lgpl-license.php',
-    lgpl2        => 'http://opensource.org/licenses/lgpl-2.1.php',
-    lgpl3        => 'http://opensource.org/licenses/lgpl-3.0.html',
-    bsd          => 'http://opensource.org/licenses/bsd-license.php',
-    gpl          => 'http://opensource.org/licenses/gpl-license.php',
-    gpl2         => 'http://opensource.org/licenses/gpl-2.0.php',
-    gpl3         => 'http://opensource.org/licenses/gpl-3.0.html',
-    mit          => 'http://opensource.org/licenses/mit-license.php',
-    mozilla      => 'http://opensource.org/licenses/mozilla1.1.php',
-    open_source  => undef,
-    unrestricted => undef,
-    restrictive  => undef,
-    unknown      => undef,
-);
-
-sub license {
-       my $self = shift;
-       return $self->{values}->{license} unless @_;
-       my $license = shift or die(
-               'Did not provide a value to license()'
-       );
-       $self->{values}->{license} = $license;
-
-       # Automatically fill in license URLs
-       if ( $license_urls{$license} ) {
-               $self->resources( license => $license_urls{$license} );
-       }
-
-       return 1;
-}
-
 sub all_from {
        my ( $self, $file ) = @_;
 
@@ -230,6 +201,8 @@ sub all_from {
                die("The path '$file' does not exist, or is not a file");
        }
 
+       $self->{values}{all_from} = $file;
+
        # Some methods pull from POD instead of code.
        # If there is a matching .pod, use that instead
        my $pod = $file;
@@ -240,7 +213,7 @@ sub all_from {
        $self->name_from($file)         unless $self->name;
        $self->version_from($file)      unless $self->version;
        $self->perl_version_from($file) unless $self->perl_version;
-       $self->author_from($pod)        unless $self->author;
+       $self->author_from($pod)        unless @{$self->author || []};
        $self->license_from($pod)       unless $self->license;
        $self->abstract_from($pod)      unless $self->abstract;
 
@@ -350,6 +323,9 @@ sub version_from {
        require ExtUtils::MM_Unix;
        my ( $self, $file ) = @_;
        $self->version( ExtUtils::MM_Unix->parse_version($file) );
+
+       # for version integrity check
+       $self->makemaker_args( VERSION_FROM => $file );
 }
 
 sub abstract_from {
@@ -360,7 +336,7 @@ sub abstract_from {
                        { DISTNAME => $self->name },
                        'ExtUtils::MM_Unix'
                )->parse_abstract($file)
-        );
+       );
 }
 
 # Add both distribution and module name
@@ -371,7 +347,7 @@ sub name_from {
                ^ \s*
                package \s*
                ([\w:]+)
-               \s* ;
+               [\s|;]*
                /ixms
        ) {
                my ($name, $module_name) = ($1, $1);
@@ -385,11 +361,10 @@ sub name_from {
        }
 }
 
-sub perl_version_from {
-       my $self = shift;
+sub _extract_perl_version {
        if (
-               Module::Install::_read($_[0]) =~ m/
-               ^
+               $_[0] =~ m/
+               ^\s*
                (?:use|require) \s*
                v?
                ([\d_\.]+)
@@ -398,6 +373,16 @@ sub perl_version_from {
        ) {
                my $perl_version = $1;
                $perl_version =~ s{_}{}g;
+               return $perl_version;
+       } else {
+               return;
+       }
+}
+
+sub perl_version_from {
+       my $self = shift;
+       my $perl_version=_extract_perl_version(Module::Install::_read($_[0]));
+       if ($perl_version) {
                $self->perl_version($perl_version);
        } else {
                warn "Cannot determine perl version info from $_[0]\n";
@@ -417,59 +402,165 @@ sub author_from {
                ([^\n]*)
        /ixms) {
                my $author = $1 || $2;
-               $author =~ s{E<lt>}{<}g;
-               $author =~ s{E<gt>}{>}g;
+
+               # XXX: ugly but should work anyway...
+               if (eval "require Pod::Escapes; 1") {
+                       # Pod::Escapes has a mapping table.
+                       # It's in core of perl >= 5.9.3, and should be installed
+                       # as one of the Pod::Simple's prereqs, which is a prereq
+                       # of Pod::Text 3.x (see also below).
+                       $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> }
+                       {
+                               defined $2
+                               ? chr($2)
+                               : defined 
$Pod::Escapes::Name2character_number{$1}
+                               ? chr($Pod::Escapes::Name2character_number{$1})
+                               : do {
+                                       warn "Unknown escape: E<$1>";
+                                       "E<$1>";
+                               };
+                       }gex;
+               }
+               elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
+                       # Pod::Text < 3.0 has yet another mapping table,
+                       # though the table name of 2.x and 1.x are different.
+                       # (1.x is in core of Perl < 5.6, 2.x is in core of
+                       # Perl < 5.9.3)
+                       my $mapping = ($Pod::Text::VERSION < 2)
+                               ? \%Pod::Text::HTML_Escapes
+                               : \%Pod::Text::ESCAPES;
+                       $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> }
+                       {
+                               defined $2
+                               ? chr($2)
+                               : defined $mapping->{$1}
+                               ? $mapping->{$1}
+                               : do {
+                                       warn "Unknown escape: E<$1>";
+                                       "E<$1>";
+                               };
+                       }gex;
+               }
+               else {
+                       $author =~ s{E<lt>}{<}g;
+                       $author =~ s{E<gt>}{>}g;
+               }
                $self->author($author);
        } else {
                warn "Cannot determine author info from $_[0]\n";
        }
 }
 
-sub license_from {
+#Stolen from M::B
+my %license_urls = (
+    perl         => 'http://dev.perl.org/licenses/',
+    apache       => 'http://apache.org/licenses/LICENSE-2.0',
+    apache_1_1   => 'http://apache.org/licenses/LICENSE-1.1',
+    artistic     => 'http://opensource.org/licenses/artistic-license.php',
+    artistic_2   => 'http://opensource.org/licenses/artistic-license-2.0.php',
+    lgpl         => 'http://opensource.org/licenses/lgpl-license.php',
+    lgpl2        => 'http://opensource.org/licenses/lgpl-2.1.php',
+    lgpl3        => 'http://opensource.org/licenses/lgpl-3.0.html',
+    bsd          => 'http://opensource.org/licenses/bsd-license.php',
+    gpl          => 'http://opensource.org/licenses/gpl-license.php',
+    gpl2         => 'http://opensource.org/licenses/gpl-2.0.php',
+    gpl3         => 'http://opensource.org/licenses/gpl-3.0.html',
+    mit          => 'http://opensource.org/licenses/mit-license.php',
+    mozilla      => 'http://opensource.org/licenses/mozilla1.1.php',
+    open_source  => undef,
+    unrestricted => undef,
+    restrictive  => undef,
+    unknown      => undef,
+);
+
+sub license {
        my $self = shift;
-       if (
-               Module::Install::_read($_[0]) =~ m/
-               (
-                       =head \d \s+
-                       (?:licen[cs]e|licensing|copyright|legal)\b
-                       .*?
-               )
-               (=head\\d.*|=cut.*|)
-               \z
-       /ixms ) {
-               my $license_text = $1;
-               my @phrases      = (
-                       'under the same (?:terms|license) as (?:perl|the perl 
programming language) itself' => 'perl', 1,
-                       'GNU general public license'         => 'gpl',         
1,
-                       'GNU public license'                 => 'gpl',         
1,
-                       'GNU lesser general public license'  => 'lgpl',        
1,
-                       'GNU lesser public license'          => 'lgpl',        
1,
-                       'GNU library general public license' => 'lgpl',        
1,
-                       'GNU library public license'         => 'lgpl',        
1,
-                       'BSD license'                        => 'bsd',         
1,
-                       'Artistic license'                   => 'artistic',    
1,
-                       'GPL'                                => 'gpl',         
1,
-                       'LGPL'                               => 'lgpl',        
1,
-                       'BSD'                                => 'bsd',         
1,
-                       'Artistic'                           => 'artistic',    
1,
-                       'MIT'                                => 'mit',         
1,
-                       'proprietary'                        => 'proprietary', 
0,
-               );
-               while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) 
) {
-                       $pattern =~ s{\s+}{\\s+}g;
-                       if ( $license_text =~ /\b$pattern\b/i ) {
-                               $self->license($license);
-                               return 1;
-                       }
+       return $self->{values}->{license} unless @_;
+       my $license = shift or die(
+               'Did not provide a value to license()'
+       );
+       $license = __extract_license($license) || lc $license;
+       $self->{values}->{license} = $license;
+
+       # Automatically fill in license URLs
+       if ( $license_urls{$license} ) {
+               $self->resources( license => $license_urls{$license} );
+       }
+
+       return 1;
+}
+
+sub _extract_license {
+       my $pod = shift;
+       my $matched;
+       return __extract_license(
+               ($matched) = $pod =~ m/
+                       (=head \d \s+ L(?i:ICEN[CS]E|ICENSING)\b.*?)
+                       (=head \d.*|=cut.*|)\z
+               /xms
+       ) || __extract_license(
+               ($matched) = $pod =~ m/
+                       (=head \d \s+ (?:C(?i:OPYRIGHTS?)|L(?i:EGAL))\b.*?)
+                       (=head \d.*|=cut.*|)\z
+               /xms
+       );
+}
+
+sub __extract_license {
+       my $license_text = shift or return;
+       my @phrases      = (
+               '(?:under )?the same (?:terms|license) as (?:perl|the perl 
(?:\d )?programming language)' => 'perl', 1,
+               '(?:under )?the terms of (?:perl|the perl programming language) 
itself' => 'perl', 1,
+               'Artistic and GPL'                   => 'perl',         1,
+               'GNU general public license'         => 'gpl',          1,
+               'GNU public license'                 => 'gpl',          1,
+               'GNU lesser general public license'  => 'lgpl',         1,
+               'GNU lesser public license'          => 'lgpl',         1,
+               'GNU library general public license' => 'lgpl',         1,
+               'GNU library public license'         => 'lgpl',         1,
+               'GNU Free Documentation license'     => 'unrestricted', 1,
+               'GNU Affero General Public License'  => 'open_source',  1,
+               '(?:Free)?BSD license'               => 'bsd',          1,
+               'Artistic license 2\.0'              => 'artistic_2',   1,
+               'Artistic license'                   => 'artistic',     1,
+               'Apache (?:Software )?license'       => 'apache',       1,
+               'GPL'                                => 'gpl',          1,
+               'LGPL'                               => 'lgpl',         1,
+               'BSD'                                => 'bsd',          1,
+               'Artistic'                           => 'artistic',     1,
+               'MIT'                                => 'mit',          1,
+               'Mozilla Public License'             => 'mozilla',      1,
+               'Q Public License'                   => 'open_source',  1,
+               'OpenSSL License'                    => 'unrestricted', 1,
+               'SSLeay License'                     => 'unrestricted', 1,
+               'zlib License'                       => 'open_source',  1,
+               'proprietary'                        => 'proprietary',  0,
+       );
+       while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) {
+               $pattern =~ s#\s+#\\s+#gs;
+               if ( $license_text =~ /\b$pattern\b/i ) {
+                       return $license;
                }
        }
+       return '';
+}
 
-       warn "Cannot determine license info from $_[0]\n";
-       return 'unknown';
+sub license_from {
+       my $self = shift;
+       if (my $license=_extract_license(Module::Install::_read($_[0]))) {
+               $self->license($license);
+       } else {
+               warn "Cannot determine license info from $_[0]\n";
+               return 'unknown';
+       }
 }
 
 sub _extract_bugtracker {
-       my @links   = $_[0] =~ m#L<(\Qhttp://rt.cpan.org/\E[^>]+)>#g;
+       my @links   = $_[0] =~ m#L<(
+        https?\Q://rt.cpan.org/\E[^>]+|
+        https?\Q://github.com/\E[\w_]+/[\w_]+/issues|
+        https?\Q://code.google.com/p/\E[\w_\-]+/issues/list
+        )>#gx;
        my %links;
        @links{@links}=();
        @links=keys %links;
@@ -485,7 +576,7 @@ sub bugtracker_from {
                return 0;
        }
        if ( @links > 1 ) {
-               warn "Found more than on rt.cpan.org link in $_[0]\n";
+               warn "Found more than one bugtracker link in $_[0]\n";
                return 0;
        }
 
@@ -497,7 +588,7 @@ sub bugtracker_from {
 sub requires_from {
        my $self     = shift;
        my $content  = Module::Install::_readperl($_[0]);
-       my @requires = $content =~ 
m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg;
+       my @requires = $content =~ 
m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+(v?[\d\.]+)/mg;
        while ( @requires ) {
                my $module  = shift @requires;
                my $version = shift @requires;
@@ -532,8 +623,15 @@ sub _perl_version {
        return $v;
 }
 
-
-
+sub add_metadata {
+    my $self = shift;
+    my %hash = @_;
+    for my $key (keys %hash) {
+        warn "add_metadata: $key is not prefixed with 'x_'.\n" .
+             "Use appopriate function to add non-private metadata.\n" unless 
$key =~ /^x_/;
+        $self->{values}->{$key} = $hash{$key};
+    }
+}
 
 
 ######################################################################
@@ -607,7 +705,7 @@ sub _write_mymeta_data {
        my @yaml = Parse::CPAN::Meta::LoadFile('META.yml');
        my $meta = $yaml[0];
 
-       # Overwrite the non-configure dependency hashs
+       # Overwrite the non-configure dependency hashes
        delete $meta->{requires};
        delete $meta->{build_requires};
        delete $meta->{recommends};
diff --git a/inc/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm 
b/inc/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm
new file mode 100644
index 0000000..2768e5f
--- /dev/null
+++ b/inc/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm
@@ -0,0 +1,47 @@
+#line 1
+package Module::Install::PRIVATE::Enable_Verbose_CPAN_Testing;
+
+use strict;
+use warnings;
+
+use lib 'inc';
+use Module::Install::AutomatedTester();
+
+use vars qw( @ISA $VERSION );
+
+use Module::Install::Base;
+@ISA = qw( Module::Install::Base );
+
+$VERSION = sprintf "%d.%02d%02d", q/0.1.0/ =~ /(\d+)/g;
+
+our( $ORIG_TEST_VIA_HARNESS );
+
+# ---------------------------------------------------------------------------
+
+sub enable_verbose_cpan_testing {
+  my ($self, @args) = @_;
+
+  # Tell Module::Install to include this, since we use it.
+  $self->perl_version('5.005');
+  $self->include_deps('Module::Install::AutomatedTester', 0);
+
+  return unless Module::Install::AutomatedTester::auto_tester();
+
+  unless(defined $ORIG_TEST_VIA_HARNESS) {
+    $ORIG_TEST_VIA_HARNESS = MY->can('test_via_harness');
+    no warnings 'redefine';
+    *MY::test_via_harness = \&_force_verbose;
+  }
+}
+
+sub _force_verbose {
+  my($self, $perl, $tests) = @_;
+
+  my $command = MY->$ORIG_TEST_VIA_HARNESS($perl || '$(FULLPERLRUN)', $tests);
+
+  $command =~ s/\$\(TEST_VERBOSE\)/1/;
+
+  return $command;
+} 
+
+1;
diff --git a/inc/Module/Install/Win32.pm b/inc/Module/Install/Win32.pm
index f2f99df..9706e5f 100644
--- a/inc/Module/Install/Win32.pm
+++ b/inc/Module/Install/Win32.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-       $VERSION = '0.91';
+       $VERSION = '1.14';
        @ISA     = 'Module::Install::Base';
        $ISCORE  = 1;
 }
diff --git a/inc/Module/Install/WriteAll.pm b/inc/Module/Install/WriteAll.pm
index 12471e5..dbedc00 100644
--- a/inc/Module/Install/WriteAll.pm
+++ b/inc/Module/Install/WriteAll.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-       $VERSION = '0.91';;
+       $VERSION = '1.14';
        @ISA     = qw{Module::Install::Base};
        $ISCORE  = 1;
 }
@@ -26,7 +26,10 @@ sub WriteAll {
 
        $self->check_nmake if $args{check_nmake};
        unless ( $self->makemaker_args->{PL_FILES} ) {
-               $self->makemaker_args( PL_FILES => {} );
+               # XXX: This still may be a bit over-defensive...
+               unless ($self->makemaker(6.25)) {
+                       $self->makemaker_args( PL_FILES => {} ) if -f 
'Build.PL';
+               }
        }
 
        # Until ExtUtils::MakeMaker support MYMETA.yml, make sure
diff --git a/lib/FileHandle/Unget.pm b/lib/FileHandle/Unget.pm
old mode 100755
new mode 100644
index ed2d89f..c109b59
--- a/lib/FileHandle/Unget.pm
+++ b/lib/FileHandle/Unget.pm
@@ -12,7 +12,7 @@ use vars qw( @ISA $VERSION $AUTOLOAD @EXPORT @EXPORT_OK );
 
 @ISA = qw( Exporter FileHandle );
 
-$VERSION = sprintf "%d.%02d%02d", q/0.16.23/ =~ /(\d+)/g;
+$VERSION = sprintf "%d.%02d%02d", q/0.16.28/ =~ /(\d+)/g;
 
 @EXPORT = @FileHandle::EXPORT;
 @EXPORT_OK = @FileHandle::EXPORT_OK;
@@ -183,7 +183,6 @@ sub input_record_separator
   if(@_)
   {
     tied(*$self)->{'input_record_separator'} = shift;
-    tied(*$self)->{'input_record_separator_specified'} = 1;
   }
 
   return undef unless exists tied(*$self)->{'input_record_separator'};
@@ -367,8 +366,7 @@ sub getline
 
   my $line;
 
-  my $old_input_record_separator = $/;
-  $/ = $self->{'input_record_separator'}
+  local $/ = $self->{'input_record_separator'}
     if exists $self->{'input_record_separator'};
   my $input_record_separator = $/;
 
@@ -378,6 +376,31 @@ sub getline
     $line = $1;
     substr($self->{'filehandle_unget_buffer'},0,length $line) = '';
   }
+  # My best guess at a fix for failures like these:
+  # http://www.cpantesters.org/cpan/report/2185d342-b14c-11e4-9727-fcccf9ba27bb
+  # http://www.cpantesters.org/cpan/report/74a6f9b6-95db-11e4-8169-9f55a5948d86
+  # It seems like even though $/ == undef, we're not reading all the rest of
+  # the file. Unfortunately I can't repro this, so I'll change it and see if
+  # the CPAN-Testers tests start passing.
+  elsif (!defined($input_record_separator))
+  {
+    $line = $self->{'filehandle_unget_buffer'};
+    $self->{'filehandle_unget_buffer'} = '';
+    my @other_lines = $self->{'fh'}->getlines(@_);
+
+    # Not sure if this is necessary. The code in getlines() below seems to
+    # suggest so.
+    @other_lines = () if @other_lines && !defined($other_lines[0]);
+
+    if ($line eq '' && !@other_lines)
+    {
+      $line = undef;
+    }
+    else
+    {
+      $line .= join('', @other_lines);
+    }
+  }
   else
   {
     $line = $self->{'filehandle_unget_buffer'};
@@ -393,7 +416,6 @@ sub getline
       $line .= $templine;
     }
   }
-  $/ = $old_input_record_separator;
 
   tie *{$self->{'fh'}}, __PACKAGE__, $self;
 
@@ -417,8 +439,7 @@ sub getlines
 
   my @buffer_lines;
 
-  my $old_input_record_separator = $/;
-  $/ = $self->{'input_record_separator'}
+  local $/ = $self->{'input_record_separator'}
     if exists $self->{'input_record_separator'};
   my $input_record_separator = $/;
 
@@ -451,18 +472,23 @@ sub getlines
   else
   {
     $buffer_lines[0] = $self->{'filehandle_unget_buffer'};
-    my $templine = ($self->{'fh'}->getlines(@_))[0];
+    $self->{'filehandle_unget_buffer'} = '';
+    # Not sure why this isn't working for some platforms. If $/ is undef, then
+    # all the lines should be in [0].
+#    my $templine = ($self->{'fh'}->getlines(@_))[0];
+    my @other_lines = $self->{'fh'}->getlines(@_);
 
-    if ($buffer_lines[0] eq '' && !defined $templine)
+    if ($buffer_lines[0] eq '' && !defined $other_lines[0])
     {
+      # Should this really be "(undef)" and not just "undef"? Leaving it for
+      # now, to avoid changing the API until I know the answer.
       $buffer_lines[0] = undef;
     }
     else
     {
-      $buffer_lines[0] .= $templine;
+      $buffer_lines[0] .= join('', @other_lines);
     }
   }
-  $/ = $old_input_record_separator;
 
   tie *{$self->{'fh'}}, __PACKAGE__, $self;
 
@@ -784,10 +810,14 @@ Get or set the pushback buffer directly.
 
 =item $fh->input_record_separator ( STRING )
 
-Get or set the per-filehandle input record separator. After it is called, the
-input record separator for the filehandle is independent of the global $/.
-Until this method is called (and after clear_input_record_separator is called)
-the global $/ is used.
+Get or set the per-filehandle input record separator. If an argument is
+specified, the input record separator for the filehandle is made independent of
+the global $/. Until this method is called (and after
+clear_input_record_separator is called) the global $/ is used.
+
+Note that a return value of "undef" is ambiguous. It can either mean that this
+method has never been called with an argument, or it can mean that it was 
called
+with an argument of "undef".
 
 
 =item $fh->clear_input_record_separator ()
@@ -867,8 +897,8 @@ David Coppit <da...@coppit.org>.
 
 =head1 LICENSE
 
-This software is distributed under the terms of the GPL. See the file
-"LICENSE" for more information.
+This code is distributed under the GNU General Public License (GPL) Version 2.
+See the file LICENSE in the distribution for details.
 
 
 =head1 SEE ALSO
diff --git a/private-lib/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm 
b/private-lib/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm
new file mode 100644
index 0000000..aa7a935
--- /dev/null
+++ b/private-lib/Module/Install/PRIVATE/Enable_Verbose_CPAN_Testing.pm
@@ -0,0 +1,46 @@
+package Module::Install::PRIVATE::Enable_Verbose_CPAN_Testing;
+
+use strict;
+use warnings;
+
+use lib 'inc';
+use Module::Install::AutomatedTester();
+
+use vars qw( @ISA $VERSION );
+
+use Module::Install::Base;
+@ISA = qw( Module::Install::Base );
+
+$VERSION = sprintf "%d.%02d%02d", q/0.1.0/ =~ /(\d+)/g;
+
+our( $ORIG_TEST_VIA_HARNESS );
+
+# ---------------------------------------------------------------------------
+
+sub enable_verbose_cpan_testing {
+  my ($self, @args) = @_;
+
+  # Tell Module::Install to include this, since we use it.
+  $self->perl_version('5.005');
+  $self->include_deps('Module::Install::AutomatedTester', 0);
+
+  return unless Module::Install::AutomatedTester::auto_tester();
+
+  unless(defined $ORIG_TEST_VIA_HARNESS) {
+    $ORIG_TEST_VIA_HARNESS = MY->can('test_via_harness');
+    no warnings 'redefine';
+    *MY::test_via_harness = \&_force_verbose;
+  }
+}
+
+sub _force_verbose {
+  my($self, $perl, $tests) = @_;
+
+  my $command = MY->$ORIG_TEST_VIA_HARNESS($perl || '$(FULLPERLRUN)', $tests);
+
+  $command =~ s/\$\(TEST_VERBOSE\)/1/;
+
+  return $command;
+} 
+
+1;
diff --git a/t/binmode_bug.t b/t/binmode_bug.t
index be74ba6..41d477c 100755
--- a/t/binmode_bug.t
+++ b/t/binmode_bug.t
@@ -2,6 +2,10 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 2;
+use Config;
+use File::Temp;
+
+my $path_to_perl = $Config{perlpath};
 
 TODO:
 {
@@ -18,23 +22,20 @@ TODO:
     }
   }
 
-  my $filename = catfile('t','temp', 'output.txt');
+  my $tmp = File::Temp->new();
 
   {
-    mkdir catfile('t','temp'), 0700;
-    unlink $filename;
-
-    my $fh = new FileHandle(">$filename");
-    binmode $fh;
-    print $fh "first line\n";
-    print $fh "second line\n";
-    print $fh "a line\n" x 1000;
-    close $fh;
+    binmode $tmp;
+    print $tmp "first line\n";
+    print $tmp "second line\n";
+    print $tmp "a line\n" x 1000;
+    close $tmp;
   }
 
   # Test eof followed by binmode for streams (fails under Windows)
   {
-    my $fh = new FileHandle::Unget("$^X -e \"open F, '$filename';binmode 
STDOUT;print <F>\" |");
+    my $fh = new FileHandle::Unget("$path_to_perl -e \"open F, '" . 
$tmp->filename .
+      "';binmode STDOUT;print <F>\" |");
 
     print '' if eof($fh);
     binmode $fh;
diff --git a/t/buffer.t b/t/buffer.t
index 3306afa..772eb76 100755
--- a/t/buffer.t
+++ b/t/buffer.t
@@ -3,24 +3,19 @@ use FileHandle;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 3;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  print "Writing file\n";
-
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test ungetc'ing and reading a line of data
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
 
diff --git a/t/eof.t b/t/eof.t
index 68ec99f..8ff8217 100755
--- a/t/eof.t
+++ b/t/eof.t
@@ -2,22 +2,19 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 4;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test getline on the end of the file
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line;
   
@@ -38,7 +35,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test getlines on the end of the file
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line;
   
diff --git a/t/filehandle.t b/t/filehandle.t
index 9ac3ed3..e223a9f 100755
--- a/t/filehandle.t
+++ b/t/filehandle.t
@@ -2,26 +2,23 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 13;
+use File::Temp;
+use File::Slurp ();
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
+close $tmp;
 
 # Test "print" and "syswrite" to write/append a file, close $fh
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle::Unget(">$filename");
+  my $fh = new FileHandle::Unget(">" . $tmp->filename);
   print $fh "first line\n";
   close $fh;
 
-  $fh = new FileHandle::Unget(">>$filename");
+  $fh = new FileHandle::Unget(">>" . $tmp->filename);
   syswrite $fh, "second line\n";
   FileHandle::Unget::close($fh);
 
-  $fh = new FileHandle($filename);
-  local $/ = undef;
-  my $results = <$fh>;
-  close $fh;
+  my $results = File::Slurp::read_file($tmp->filename);
 
   # 1
   is($results, "first line\nsecond line\n",'No eol separator');
@@ -29,7 +26,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test input_line_number and scalar line reading, $fh->close
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   # 2
   is($fh->input_line_number(),0,'Input line number at start');
@@ -47,7 +44,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test array line reading, eof $fh
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my @lines = <$fh>;
   # 5
@@ -65,7 +62,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test byte reading
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $buf;
   my $result = read($fh, $buf, 8);
@@ -80,7 +77,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test byte ->reading
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $buf;
   my $result = $fh->read($buf, 8);
@@ -95,7 +92,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test new_from_fd
 {
-  open FILE, "$filename";
+  open FILE, $tmp->filename;
   my $fh = FileHandle::Unget->new_from_fd(\*FILE,'r');
 
   my $line = <$fh>;
diff --git a/t/fileno.t b/t/fileno.t
index 06831dc..e1a89ef 100755
--- a/t/fileno.t
+++ b/t/fileno.t
@@ -2,15 +2,14 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 1;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
+close $tmp;
 
 # Test "print" and "syswrite" to write/append a file, close $fh
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle::Unget(">$filename");
+  my $fh = new FileHandle::Unget(">" . $tmp->filename);
   print $fh "first line\n";
 
   # 1
diff --git a/t/gensym.t b/t/gensym.t
index 4520397..6c660ac 100755
--- a/t/gensym.t
+++ b/t/gensym.t
@@ -2,33 +2,30 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 12;
+use File::Temp;
+use File::Slurp ();
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
+close $tmp;
 
 # Test "print" and "syswrite" to write/append a file, close $fh
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-#  my $fh1 = new FileHandle(">$filename");
+#  my $fh1 = new FileHandle(">" . $tmp->filename);
 
   use Symbol;
   my $fh1 = gensym;
-  open $fh1, ">$filename";
+  open $fh1, ">" . $tmp->filename;
 
   my $fh = new FileHandle::Unget($fh1);
   print $fh "first line\n";
   close $fh;
 
-  $fh1 = new FileHandle(">>$filename");
+  $fh1 = new FileHandle(">>" . $tmp->filename);
   $fh = new FileHandle::Unget($fh1);
   syswrite $fh, "second line\n";
   FileHandle::Unget::close($fh);
 
-  $fh = new FileHandle($filename);
-  local $/ = undef;
-  my $results = <$fh>;
-  close $fh;
+  my $results = File::Slurp::read_file($tmp->filename);
 
   # 1
   is($results, "first line\nsecond line\n",'syswrite()');
@@ -36,11 +33,11 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test input_line_number and scalar line reading, $fh->close
 {
-#  my $fh1 = new FileHandle($filename);
+#  my $fh1 = new FileHandle($tmp->filename);
 
   use Symbol;
   my $fh1 = gensym;
-  open $fh1, "<$filename";
+  open $fh1, "<" . $tmp->filename;
 
   my $fh = new FileHandle::Unget($fh1);
 
@@ -60,11 +57,11 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test array line reading, eof $fh
 {
-#  my $fh1 = new FileHandle($filename);
+#  my $fh1 = new FileHandle($tmp->filename);
 
   use Symbol;
   my $fh1 = gensym;
-  open $fh1, "<$filename";
+  open $fh1, "<" . $tmp->filename;
 
   my $fh = new FileHandle::Unget($fh1);
 
@@ -84,11 +81,11 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test byte reading
 {
-#  my $fh1 = new FileHandle($filename);
+#  my $fh1 = new FileHandle($tmp->filename);
 
   use Symbol;
   my $fh1 = gensym;
-  open $fh1, "<$filename";
+  open $fh1, "<" . $tmp->filename;
 
   my $fh = new FileHandle::Unget($fh1);
 
@@ -105,11 +102,11 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test byte ->reading
 {
-#  my $fh1 = new FileHandle($filename);
+#  my $fh1 = new FileHandle($tmp->filename);
 
   use Symbol;
   my $fh1 = gensym;
-  open $fh1, "<$filename";
+  open $fh1, "<" . $tmp->filename;
 
   my $fh = new FileHandle::Unget($fh1);
 
diff --git a/t/input_record_separator.t b/t/input_record_separator.t
index 4f11db7..2000d6c 100755
--- a/t/input_record_separator.t
+++ b/t/input_record_separator.t
@@ -2,25 +2,20 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 7;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  print "Writing file\n";
-
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  print $fh "third line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  print $tmp "third line\n";
+  close $tmp;
 }
 
 # Test normal semantics for input record separators
 {
-  my $fh1 = new FileHandle::Unget($filename);
+  my $fh1 = new FileHandle::Unget($tmp->filename);
 
   local $/ = "\n";
   my $line1 = <$fh1>;
@@ -39,7 +34,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test per-filehandle input record separator for 1 filehandle
 {
-  my $fh1 = new FileHandle::Unget($filename);
+  my $fh1 = new FileHandle::Unget($tmp->filename);
 
   local $/ = "\n";
   my $line1 = <$fh1>;
@@ -68,8 +63,8 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test per-filehandle input record separator for 2 filehandles
 {
-  my $fh1 = new FileHandle::Unget($filename);
-  my $fh2 = new FileHandle::Unget($filename);
+  my $fh1 = new FileHandle::Unget($tmp->filename);
+  my $fh2 = new FileHandle::Unget($tmp->filename);
 
   local $/ = ' ';
 
diff --git a/t/loop_bug.t b/t/loop_bug.t
index 9660632..ba58234 100755
--- a/t/loop_bug.t
+++ b/t/loop_bug.t
@@ -2,22 +2,19 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 1;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test getline on the end of the file
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   binmode $fh;
 
@@ -33,11 +30,11 @@ my $filename = catfile('t','temp', 'output.txt');
   {
     $bytes_read += length $line;
 
-    last if $bytes_read > -s $filename;
+    last if $bytes_read > -s $tmp->filename;
   }
 
   # 1
-  is($bytes_read,-s $filename, 'Loop bug');
+  is($bytes_read,-s $tmp->filename, 'Loop bug');
 
   $fh->close;
 }
diff --git a/t/memory_leak.t b/t/memory_leak.t
index 43de1df..fc13ddc 100755
--- a/t/memory_leak.t
+++ b/t/memory_leak.t
@@ -22,5 +22,5 @@ SKIP:
   my $end_fhu = Devel::Leak::NoteSV($fhu_handle);
 
   # 1
-  is($end_fhu - $start_fhu,0, 'Memory leak');
+  cmp_ok($end_fhu - $start_fhu, '<=', 0, 'Memory leak');
 }
diff --git a/t/multiple_handles.t b/t/multiple_handles.t
index 6933f9c..dd268c3 100755
--- a/t/multiple_handles.t
+++ b/t/multiple_handles.t
@@ -2,25 +2,20 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 4;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  print "Writing file\n";
-
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test ungets'ing and reading a line of data
 {
-  my $fh1 = new FileHandle::Unget($filename);
-  my $fh2 = new FileHandle::Unget($filename);
+  my $fh1 = new FileHandle::Unget($tmp->filename);
+  my $fh2 = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh1>;
   $line = <$fh2>;
diff --git a/t/new.t b/t/new.t
index bf452e6..70bf4f1 100755
--- a/t/new.t
+++ b/t/new.t
@@ -2,28 +2,25 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 12;
+use File::Temp;
+use File::Slurp ();
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
+close $tmp;
 
 # Test "print" and "syswrite" to write/append a file, close $fh
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh1 = new FileHandle(">$filename");
+  my $fh1 = new FileHandle(">" . $tmp->filename);
   my $fh = new FileHandle::Unget($fh1);
   print $fh "first line\n";
   close $fh;
 
-  $fh1 = new FileHandle(">>$filename");
+  $fh1 = new FileHandle(">>" . $tmp->filename);
   $fh = new FileHandle::Unget($fh1);
   syswrite $fh, "second line\n";
   FileHandle::Unget::close($fh);
 
-  $fh = new FileHandle($filename);
-  local $/ = undef;
-  my $results = <$fh>;
-  close $fh;
+  my $results = File::Slurp::read_file($tmp->filename);
 
   # 1
   is($results, "first line\nsecond line\n", 'syswrite()');
@@ -31,7 +28,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test input_line_number and scalar line reading, $fh->close
 {
-  my $fh1 = new FileHandle($filename);
+  my $fh1 = new FileHandle($tmp->filename);
   my $fh = new FileHandle::Unget($fh1);
 
   # 2
@@ -50,7 +47,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test array line reading, eof $fh
 {
-  my $fh1 = new FileHandle($filename);
+  my $fh1 = new FileHandle($tmp->filename);
   my $fh = new FileHandle::Unget($fh1);
 
   my @lines = <$fh>;
@@ -69,7 +66,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test byte reading
 {
-  my $fh1 = new FileHandle($filename);
+  my $fh1 = new FileHandle($tmp->filename);
   my $fh = new FileHandle::Unget($fh1);
 
   my $buf;
@@ -85,7 +82,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test byte ->reading
 {
-  my $fh1 = new FileHandle($filename);
+  my $fh1 = new FileHandle($tmp->filename);
   my $fh = new FileHandle::Unget($fh1);
 
   my $buf;
diff --git a/t/pod.t b/t/pod.t
new file mode 100644
index 0000000..8cd11de
--- /dev/null
+++ b/t/pod.t
@@ -0,0 +1,10 @@
+#!/usr/bin/perl
+
+use strict;
+use Test::More;
+
+eval "use Test::Pod 1.00";
+
+plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
+
+all_pod_files_ok();
diff --git a/t/seek.t b/t/seek.t
index aef15da..24bc91f 100755
--- a/t/seek.t
+++ b/t/seek.t
@@ -2,24 +2,20 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 3;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
-# Test "print" and "syswrite" to write/append a file, close $fh
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  binmode $fh;
-  print $fh "this is the first line\n";
-  print $fh "second line\n";
-  close $fh;
+  binmode $tmp;
+  print $tmp "this is the first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test seek($fh,###,0) and ungets
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   seek($fh,23,0);
   my $line = <$fh>;
diff --git a/t/stdin_tell_bug.t b/t/stdin_tell_bug.t
index 19c6d3f..5147b1d 100755
--- a/t/stdin_tell_bug.t
+++ b/t/stdin_tell_bug.t
@@ -2,6 +2,9 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 3;
+use Config;
+use File::Temp;
+use File::Slurp ();
 
 # 
-------------------------------------------------------------------------------
 
@@ -22,24 +25,29 @@ else
 
 # 
-------------------------------------------------------------------------------
 
-my $test_program = catfile 't','temp', 'test_program.pl';
+my $path_to_perl = $Config{perlpath};
 
-mkdir catfile('t','temp'), 0700;
-Write_Test_Program($test_program);
+my $test_program;
+{
+  my $fh;
+  ($fh, $test_program) = File::Temp::tempfile(UNLINK => 1);
+  print $fh File::Slurp::read_file(\*DATA);
+  close $fh;
+}
 
 # Note: No space before the pipe because on Windows it is passed to the test
 # program
-my $test = "echo hello| $test_program";
+my $test = "echo hello| $path_to_perl $test_program";
 my $expected_stdout = qr/Starting at position (-1|0)\ngot: hello\ngot: 
world\n/;
 my $expected_stderr = '';
 
 {
-  my @standard_inc = split /###/, `perl -e '\$" = "###";print "\@INC"'`;
+  my @standard_inc = split /###/, `$path_to_perl -e "\$\\" = '###';print 
\\"\@INC\\""`;
   my @extra_inc;
   foreach my $inc (@INC)
   {
     push @extra_inc, "$single_quote$inc$single_quote"
-      unless grep { /^$inc$/ } @standard_inc;
+      unless grep { /^\Q$inc\E$/ } @standard_inc;
   }
 
   my $test_program_pattern = $test_program;
@@ -47,32 +55,26 @@ my $expected_stderr = '';
   if (@extra_inc)
   {
     local $" = ' -I';
-    $test =~ s#\b$test_program_pattern\b#$^X -I@extra_inc $test_program#g;
-  }
-  else
-  {
-    $test =~ s#\b$test_program_pattern\b#$^X $test_program#g;
+    $test =~ s#\b\Q$path_to_perl\E\b#$path_to_perl -I@extra_inc#g;
   }
 }
 
-my $test_stdout = catfile('t','temp',"test_program.stdout");
-my $test_stderr = catfile('t','temp',"test_program.stderr");
+my ($test_stdout, $test_stderr);
+{
+  my $fh;
+  ($fh, $test_stdout) = File::Temp::tempfile(UNLINK => 1);
+  close $fh;
+  ($fh, $test_stderr) = File::Temp::tempfile(UNLINK => 1);
+  close $fh;
+}
 
 system "$test 1>$test_stdout 2>$test_stderr";
 
 #1
 ok(!$?,'Executing external program');
 
-local $/ = undef;
-my $actual_stdout;
-open ACTUAL_STDOUT, $test_stdout;
-$actual_stdout = <ACTUAL_STDOUT>;
-close ACTUAL_STDOUT;
-
-my $actual_stderr;
-open ACTUAL_STDERR, $test_stderr;
-$actual_stderr = <ACTUAL_STDERR>;
-close ACTUAL_STDERR;
+my $actual_stdout = File::Slurp::read_file($test_stdout);
+my $actual_stderr = File::Slurp::read_file($test_stderr);
 
 #2
 like($actual_stdout,$expected_stdout,'Output matches');
@@ -84,21 +86,6 @@ exit;
 
 # 
-------------------------------------------------------------------------------
 
-sub Write_Test_Program
-{
-  my $filename = shift;
-
-  local $/ = undef;
-
-  my $program = <DATA>;
-
-  open PROGRAM, ">$filename";
-  print PROGRAM $program;
-  close PROGRAM;
-}
-
-# 
-------------------------------------------------------------------------------
-
 __DATA__
 use strict;
 use FileHandle::Unget;
diff --git a/t/tell.t b/t/tell.t
index c11fae2..f4087d0 100755
--- a/t/tell.t
+++ b/t/tell.t
@@ -2,24 +2,20 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 5;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
-# Test "print" and "syswrite" to write/append a file, close $fh
 {
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  binmode $fh;
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  binmode $tmp;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test tell($fh) and scalar line reading
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
   # 1
@@ -34,7 +30,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test tell($fh) and ungets
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
   # 3
diff --git a/t/ungetc.t b/t/ungetc.t
index cf592c1..71d69ca 100755
--- a/t/ungetc.t
+++ b/t/ungetc.t
@@ -3,24 +3,19 @@ use FileHandle;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 5;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  print "Writing file\n";
-
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test ungetc'ing and reading a line of data
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
 
@@ -48,7 +43,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test ungetc'ing and read'ing some bytes of data
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
 
diff --git a/t/ungets.t b/t/ungets.t
index 4fe0fa7..4b415ab 100755
--- a/t/ungets.t
+++ b/t/ungets.t
@@ -2,24 +2,19 @@ use strict;
 use FileHandle::Unget;
 use File::Spec::Functions qw(:ALL);
 use Test::More tests => 9;
+use File::Temp;
 
-my $filename = catfile('t','temp', 'output.txt');
+my $tmp = File::Temp->new();
 
 {
-  print "Writing file\n";
-
-  mkdir catfile('t','temp'), 0700;
-  unlink $filename;
-
-  my $fh = new FileHandle(">$filename");
-  print $fh "first line\n";
-  print $fh "second line\n";
-  close $fh;
+  print $tmp "first line\n";
+  print $tmp "second line\n";
+  close $tmp;
 }
 
 # Test ungets'ing and reading a line of data
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
 
@@ -39,7 +34,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test ungets'ing and read'in some bytes of data
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
 
@@ -63,7 +58,7 @@ my $filename = catfile('t','temp', 'output.txt');
 
 # Test ungets'ing and reading multiple lines of data
 {
-  my $fh = new FileHandle::Unget($filename);
+  my $fh = new FileHandle::Unget($tmp->filename);
 
   my $line = <$fh>;
 

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-perl/packages/libfilehandle-unget-perl.git

_______________________________________________
Pkg-perl-cvs-commits mailing list
Pkg-perl-cvs-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits

Reply via email to