Commits

Burak Gürsoy committed ccf76cb

Split author/extra tests into xt and be sure that they are run.
Split constants and utility functions into modules.
Clean up.

Comments (0)

Files changed (9)

     if ( -e 'Build.PL' && !$O{nomb} ) {
         call("$PERL_EXE Build.PL");
         call("$PERL_EXE Build");
+        call("$PERL_EXE Build extratest");
         call("$PERL_EXE Build dist");
         call("$PERL_EXE Build disttest");
         call("$PERL_EXE Build clean");
         _print tts( L('build.buildpl'), [ target => $target ] );
     }
 
-    if ( -e 'Makefile.PL' && !$O{nomm} ) {
-        call("$PERL_EXE Makefile.PL");
-        call($MAKE);
+    if ( -e 'Makefile.PL' && ! $O{nomm} ) {
+        call( "$PERL_EXE Makefile.PL");
+        call( $MAKE );
         call( $MAKE . ' test' );
         if ( ! $build_pl && $ALIEN ) {
             call( $MAKE . ' dist'     );

builder/builder/Build.pm

 
 ## no critic (InputOutput::ProhibitBacktickOperators)
 
-our $VERSION = '0.72';
-
-use constant TAINT_SHEBANG   => "#!perl -Tw\nuse constant TAINTMODE => 1;\n";
-use constant RE_VERSION_LINE => qr{
-   \A (our\s+)? \$VERSION \s+ = \s+ ["'] (.+?) ['"] ; (.+?) \z
-}xms;
-use constant RE_POD_LINE => qr{
-\A =head1 \s+ DESCRIPTION \s+ \z
-}xms;
-use constant VTEMP  => q{%s$VERSION = '%s';};
-use constant MONTHS => qw(
-   January February March     April   May      June
-   July    August   September October November December
-);
-use constant MONOLITH_TEST_FAIL =>
-   "\nFAILED! Building the monolithic version failed during unit testing\n\n";
-
-use constant NO_INDEX => qw(
-    monolithic_version
-    builder
-    t
-);
-use constant DEFAULTS => qw(
-   license          perl
-   create_license   1
-   sign             0
-);
-use constant YEAR_ADD  => 1900;
-use constant YEAR_SLOT =>    5;
+our $VERSION = '0.80';
 
 use File::Find;
 use File::Spec;
 use File::Path;
 use Carp qw( croak );
 
+use Build::Constants qw( :all );
 use Build::Spec;
+use Build::Util qw( slurp trim );
 
-__PACKAGE__->add_property( build_monolith                   => 0  );
-__PACKAGE__->add_property( change_versions                  => 0  );
-__PACKAGE__->add_property( vanilla_makefile_pl              => 1  );
-__PACKAGE__->add_property( monolith_add_to_top              => [] );
-__PACKAGE__->add_property( taint_mode_tests                 => 0  );
-__PACKAGE__->add_property( add_pod_author_copyright_license => 0 );
-__PACKAGE__->add_property( copyright_first_year             => 0 );
-__PACKAGE__->add_property( initialization_hook              => q() );
+BEGIN {
+    my %default = (
+        add_pod_author_copyright_license => 0,
+        build_monolith                   => 0,
+        change_versions                  => 0,
+        copyright_first_year             => 0,
+        initialization_hook              => q(),
+        monolith_add_to_top              => [],
+        taint_mode_tests                 => 0,
+        vanilla_makefile_pl              => 1,
+    );
+    foreach my $meth ( keys %default ) {
+        __PACKAGE__->add_property( $meth => $default{ $meth } );
+    }
+}
 
 sub new {
-   my $class = shift;
-   my %opt   = spec;
-   my %def   = DEFAULTS;
-   foreach my $key ( keys %def ) {
-      $opt{ $key } = $def{ $key } if ! defined $opt{ $key };
-   }
-   $opt{no_index}            ||= {};
-   $opt{no_index}{directory} ||= [];
-   push @{ $opt{no_index}{directory} }, NO_INDEX;
-   return $class->SUPER::new( %opt );
+    my $class = shift;
+    my %opt   = spec;
+    my %def   = DEFAULTS;
+    foreach my $key ( keys %def ) {
+        $opt{ $key } = $def{ $key } if ! defined $opt{ $key };
+    }
+    $opt{no_index}            ||= {};
+    $opt{no_index}{directory} ||= [];
+    push @{ $opt{no_index}{directory} }, NO_INDEX;
+    return $class->SUPER::new( %opt );
 }
 
 sub create_build_script {
-   my $self = shift;
-   $self->_add_vanilla_makefile_pl if $self->vanilla_makefile_pl;
-   my $hook = $self->initialization_hook;
-   if ( $hook ) {
-      my $eok = eval $hook;
-      croak "Error compiling initialization_hook: $@" if $@;
-   }
-   return $self->SUPER::create_build_script( @_ );
-}
+    my $self = shift;
+    $self->_add_vanilla_makefile_pl if $self->vanilla_makefile_pl;
 
-sub mytrim {
-   my $self = shift;
-   my $s    = shift;
-   return $s if ! $s; # false or undef
-   my $extra = shift || q{};
-      $s =~ s{\A \s+   }{$extra}xms;
-      $s =~ s{   \s+ \z}{$extra}xms;
-   return $s;
+    if ( my $hook = $self->initialization_hook ) {
+        my $eok = eval $hook;
+        croak "Error compiling initialization_hook: $@" if $@;
+    }
+
+    return $self->SUPER::create_build_script( @_ );
 }
 
 sub ACTION_dist { ## no critic (NamingConventions::Capitalization)
-   my $self = shift;
-   my $msg  = sprintf q{RUNNING 'dist' Action from subclass %s v%s},
-                      ref($self),
-                      $VERSION;
-   warn "$msg\n";
-   my @modules;
-   find {
-      wanted => sub {
-         my $file = $_;
-         return if $file !~ m{ [.] pm \z }xms;
-         $file = File::Spec->catfile( $file );
-         push @modules, $file;
-         warn "FOUND Module: $file\n";
-      },
-      no_chdir => 1,
-   }, 'lib';
-   $self->_create_taint_mode_tests      if $self->taint_mode_tests;
-   $self->_change_versions( \@modules ) if $self->change_versions;
-   $self->_build_monolith(  \@modules ) if $self->build_monolith;
-   return $self->SUPER::ACTION_dist( @_ );
+    my $self = shift;
+    my $msg  = sprintf q{RUNNING 'dist' Action from subclass %s v%s},
+                       ref($self),
+                       $VERSION;
+    warn "$msg\n";
+    my @modules;
+    find {
+        wanted => sub {
+            my $file = $_;
+            return if $file !~ m{ [.] pm \z }xms;
+            $file = File::Spec->catfile( $file );
+            push @modules, $file;
+            warn "FOUND Module: $file\n";
+        },
+        no_chdir => 1,
+    }, 'lib';
+
+    $self->_create_taint_mode_tests      if $self->taint_mode_tests;
+    $self->_change_versions( \@modules ) if $self->change_versions;
+    $self->_build_monolith(  \@modules ) if $self->build_monolith;
+
+    return $self->SUPER::ACTION_dist( @_ );
+}
+
+sub ACTION_extratest {
+    # Stolen from
+    # http://elliotlovesperl.com/2009/11/24/explicitly-running-author-tests
+    #
+    my($self) = @_;
+    $self->depends_on( 'build'    );
+    $self->depends_on( 'manifest' );
+    $self->depends_on( 'distmeta' );
+
+    $self->test_files( qw< xt > );
+    $self->recursive_test_files(1);
+
+    $self->depends_on( 'test' );
+
+    return;
+}
+
+sub ACTION_distdir {
+    my ($self) = @_;
+
+    $self->depends_on( 'extratest' );
+
+    return $self->SUPER::ACTION_distdir();
 }
 
 sub _create_taint_mode_tests {
-   my $self   = shift;
-   my @tests  = glob 't/*.t';
-   my @taints;
-   require File::Basename;
-   foreach my $t ( @tests ) {
-      my($num,$rest) = split /\-/xms, File::Basename::basename( $t ), 2;
-      push @taints, "t/$num-taint-mode-$rest";
-   }
+    my $self   = shift;
+    my @tests  = glob 't/*.t';
+    my @taints;
+    require File::Basename;
+    foreach my $t ( @tests ) {
+        my($num,$rest) = split /\-/xms, File::Basename::basename( $t ), 2;
+        push @taints, "t/$num-taint-mode-$rest";
+    }
 
-   for my $i ( 0..$#tests ) {
-      next if $tests[$i] =~ m{ pod[.]t           \z }xms;
-      next if $tests[$i] =~ m{ pod\-coverage[.]t \z }xms;
-      next if $tests[$i] =~ m{ all\-modules\-have\-the\-same\-version[.]t \z }xms;
+    for my $i ( 0..$#tests ) {
+        next if $tests[$i] =~ m{ pod[.]t           \z }xms;
+        next if $tests[$i] =~ m{ pod\-coverage[.]t \z }xms;
+        next if $tests[$i] =~ m{ all\-modules\-have\-the\-same\-version[.]t \z }xms;
 
-      next if -e $taints[$i]; # already created!
+        next if -e $taints[$i]; # already created!
 
-      open my $ORIG, '<:raw', $tests[$i]  or croak "Can not open file($tests[$i]): $!";
-      open my $DEST, '>:raw', $taints[$i] or croak "Can not open file($taints[$i]): $!";
-      print {$DEST} TAINT_SHEBANG or croak "Can not print to destination: $!";
-      while ( my $line = readline $ORIG ) {
-         print {$DEST} $line or croak "Can not print to destination: $!";
-      }
-      close $ORIG or croak "Can not close original: $!";
-      close $DEST or croak "Can not close destination: $!";
-      $self->_write_file( '>>', 'MANIFEST', "$taints[$i]\n");
-   }
-   return;
+        open my $ORIG, '<:raw', $tests[$i]  or croak "Can not open file($tests[$i]): $!";
+        open my $DEST, '>:raw', $taints[$i] or croak "Can not open file($taints[$i]): $!";
+        print {$DEST} TAINT_SHEBANG or croak "Can not print to destination: $!";
+
+        while ( defined( my $line = readline $ORIG ) ) {
+            print {$DEST} $line or croak "Can not print to destination: $!";
+        }
+
+        close $ORIG or croak "Can not close original: $!";
+        close $DEST or croak "Can not close destination: $!";
+
+        $self->_write_file( '>>', 'MANIFEST', "$taints[$i]\n");
+    }
+
+    return;
 }
 
 sub _change_versions_pod {
-   my($self, $mod) = @_;
-   my $dver = $self->dist_version;
-   my(undef, undef, undef, $mday, $mon, $year) = localtime time;
-   my $date = join q{ }, $mday, [MONTHS]->[$mon], $year + YEAR_ADD;
+    my($self, $mod) = @_;
+    my $dver = $self->dist_version;
+    my($mday, $mon, $year) = (localtime time)[3..5];
+    my $date = join q{ }, $mday, [MONTHS]->[$mon], $year + YEAR_ADD;
 
-   my $ns  = $mod;
-      $ns  =~ s{ [\\/]     }{::}xmsg;
-      $ns  =~ s{ \A lib :: }{}xms;
-      $ns  =~ s{ [.] pm \z }{}xms;
-   my $pod = "\nThis document describes version C<$dver> of C<$ns>\n"
-           . "released on C<$date>.\n"
-           ;
+    my $ns = $mod;
+    $ns  =~ s{ [\\/]     }{::}xmsg;
+    $ns  =~ s{ \A lib :: }{}xms;
+    $ns  =~ s{ [.] pm \z }{}xms;
+    my $pod = "\nThis document describes version C<$dver> of C<$ns>\n"
+            . "released on C<$date>.\n"
+            ;
 
-   if ( $dver =~ m{[_]}xms ) {
-      $pod .= "\nB<WARNING>: This version of the module is part of a\n"
-           .  "developer (beta) release of the distribution and it is\n"
-           .  "not suitable for production use.\n";
-   }
+    if ( $dver =~ m{[_]}xms ) {
+        $pod .= join qq{\n},
+                    "\nB<WARNING>: This version of the module is part of a",
+                    "developer (beta) release of the distribution and it is",
+                    "not suitable for production use.",
+                ;
+    }
 
-   return $pod;
+    return $pod;
 }
 
 sub _change_versions {
-   my($self, $files) = @_;
-   my $dver = $self->dist_version;
+    my($self, $files) = @_;
+    my $dver = $self->dist_version;
 
-   warn "CHANGING VERSIONS\n";
-   warn "\tDISTRO Version: $dver\n";
+    warn "CHANGING VERSIONS\n";
+    warn "\tDISTRO Version: $dver\n";
 
-   foreach my $mod ( @{ $files } ) {
-      warn "\tPROCESSING $mod\n";
-      my $new = $mod . '.new';
-      open my $RO_FH, '<:raw', $mod or croak "Can not open file($mod): $!";
-      open my $W_FH , '>:raw', $new or croak "Can not open file($new): $!";
+    foreach my $mod ( @{ $files } ) {
+        warn "\tPROCESSING $mod\n";
+        my $new = $mod . '.new';
 
-      CHANGE_VERSION: while ( my $line = readline $RO_FH ) {
-         if ( $line =~ RE_VERSION_LINE ) {
-            my $prefix    = $1 || q{};
-            my $oldv      = $2;
-            my $remainder = $3;
-            warn "\tCHANGED Version from $oldv to $dver\n";
-            printf {$W_FH} VTEMP . $remainder, $prefix, $dver;
-            last CHANGE_VERSION;
-         }
-         print {$W_FH} $line or croak "Unable to print to FH: $!";
-      }
+        open my $RO_FH, '<:raw', $mod or croak "Can not open file($mod): $!";
+        open my $W_FH , '>:raw', $new or croak "Can not open file($new): $!";
 
-      $self->_change_pod( $RO_FH, $W_FH, $mod );
+        CHANGE_VERSION: while ( defined( my $line = readline $RO_FH ) ) {
+            if ( $line =~ RE_VERSION_LINE ) {
+                my $prefix    = $1 || q{};
+                my $oldv      = $2;
+                my $remainder = $3;
+                warn "\tCHANGED Version from $oldv to $dver\n";
+                printf {$W_FH} VTEMP . $remainder, $prefix, $dver;
+                last CHANGE_VERSION;
+            }
+            print {$W_FH} $line or croak "Unable to print to FH: $!";
+        }
 
-      close $RO_FH or croak "Can not close file($mod): $!";
-      close $W_FH  or croak "Can not close file($new): $!";
+        $self->_change_pod( $RO_FH, $W_FH, $mod );
 
-      unlink($mod) || croak "Can not remove original module($mod): $!";
-      rename( $new, $mod ) || croak "Can not rename( $new, $mod ): $!";
-      warn "\tRENAME Successful!\n";
-   }
+        close $RO_FH or croak "Can not close file($mod): $!";
+        close $W_FH  or croak "Can not close file($new): $!";
 
-   return;
+        unlink($mod) || croak "Can not remove original module($mod): $!";
+        rename( $new, $mod ) || croak "Can not rename( $new, $mod ): $!";
+        warn "\tRENAME Successful!\n";
+    }
+
+    return;
 }
 
 sub _change_pod {
-   my($self, $RO_FH, $W_FH, $mod) = @_;
-   my $acl = $self->add_pod_author_copyright_license;
-   my $acl_buf;
+    my($self, $RO_FH, $W_FH, $mod) = @_;
+    my $acl = $self->add_pod_author_copyright_license;
+    my $acl_buf;
 
-   CHANGE_POD: while ( my $line = readline $RO_FH ) {
-      if ( $acl && $line =~ m{ \A =cut }xms ) {
-         $acl_buf = $line; # buffer the last line
-         last;
-      }
-      print {$W_FH} $line or croak "Unable to print to FH: $!";
-      if ( $line =~ RE_POD_LINE ) {
-         print {$W_FH} $self->_change_versions_pod( $mod )
-             or croak "Unable to print to FH: $!";
-      }
-   }
+    CHANGE_POD: while ( defined( my $line = readline $RO_FH ) ) {
+        if ( $acl && $line =~ m{ \A =cut }xms ) {
+            $acl_buf = $line; # buffer the last line
+            last;
+        }
 
-   if ( $acl && defined $acl_buf ) {
-      warn "\tADDING AUTHOR COPYRIGHT LICENSE TO POD\n";
-      print {$W_FH} $self->_pod_author_copyright_license, $acl_buf
-         or croak "Unable to print to FH: $!";
-      while ( my $line = readline $RO_FH ) {
-         print {$W_FH} $line or croak "Unable to print to FH: $!";
-      }
-   }
+        print {$W_FH} $line or croak "Unable to print to FH: $!";
 
-   return;
+        if ( $line =~ RE_POD_LINE ) {
+            print {$W_FH} $self->_change_versions_pod( $mod )
+                or croak "Unable to print to FH: $!";
+        }
+    }
+
+    if ( $acl && defined $acl_buf ) {
+        warn "\tADDING AUTHOR COPYRIGHT LICENSE TO POD\n";
+        print {$W_FH} $self->_pod_author_copyright_license, $acl_buf
+            or croak "Unable to print to FH: $!";
+
+        while ( defined( my $line = readline $RO_FH ) ) {
+            print {$W_FH} $line or croak "Unable to print to FH: $!";
+        }
+    }
+
+    return;
 }
 
 sub _build_monolith {
-   my $self   = shift;
-   my $files  = shift;
-   my @mono_dir = ( monolithic_version => split /::/xms, $self->module_name );
-   my $mono_file = pop(@mono_dir) . '.pm';
-   my $dir    = File::Spec->catdir( @mono_dir );
-   my $mono   = File::Spec->catfile( $dir, $mono_file );
-   my $buffer = File::Spec->catfile( $dir, 'buffer.txt' );
-   my $readme = File::Spec->catfile( qw( monolithic_version README ) );
-   my $copy   = $mono . '.tmp';
+    my $self      = shift;
+    my $files     = shift;
+    my @mono_dir  = ( monolithic_version => split /::/xms, $self->module_name );
+    my $mono_file = pop(@mono_dir) . '.pm';
+    my $dir       = File::Spec->catdir( @mono_dir );
+    my $mono      = File::Spec->catfile( $dir, $mono_file );
+    my $buffer    = File::Spec->catfile( $dir, 'buffer.txt' );
+    my $readme    = File::Spec->catfile( qw( monolithic_version README ) );
+    my $copy      = $mono . '.tmp';
 
-   mkpath $dir;
+    mkpath $dir;
 
-   warn "STARTING TO BUILD MONOLITH\n";
+    warn "STARTING TO BUILD MONOLITH\n";
 
-   my @files;
-   my $c;
-   foreach my $f ( @{ $files }) {
-      my(undef, undef, $base) = File::Spec->splitpath($f);
-      if ( $base eq 'Constants.pm' ) {
-         $c = $f;
-         next;
-      }
-      push @files, $f;
-   }
-   push @files, $c;
+    my(@files, $c);
+    foreach my $f ( @{ $files }) {
+        my(undef, undef, $base) = File::Spec->splitpath($f);
+        if ( $base eq 'Constants.pm' ) {
+            $c = $f;
+            next;
+        }
+        push @files, $f;
+    }
 
-   my $POD = $self->_monolith_merge(\@files, $mono_file, $mono, $buffer);
+    push @files, $c;
 
-   $self->_monolith_add_pre( $mono, $copy, \@files, $buffer );
+    my $POD = $self->_monolith_merge(\@files, $mono_file, $mono, $buffer);
+    $self->_monolith_add_pre( $mono, $copy, \@files, $buffer );
 
-   if ( $POD ) {
-      open my $MONOX, '>>:raw', $mono or croak "Can not open file($mono): $!";
-      foreach my $line ( split /\n/xms, $POD ) {
-         print {$MONOX} $line, "\n" or croak "Unable to print to FH: $!";
-         if ( "$line\n" =~ RE_POD_LINE ) {
-            print {$MONOX} $self->_monolith_pod_warning
-               or croak "Unable to print to FH: $!";
-         }
-      }
-      close $MONOX or croak "Unable to close FH: $!";;
-   }
+    if ( $POD ) {
+        open my $MONOX, '>>:raw', $mono or croak "Can not open file($mono): $!";
+        foreach my $line ( split /\n/xms, $POD ) {
+            print {$MONOX} $line, "\n" or croak "Unable to print to FH: $!";
+            if ( "$line\n" =~ RE_POD_LINE ) {
+                print {$MONOX} $self->_monolith_pod_warning
+                    or croak "Unable to print to FH: $!";
+            }
+        }
+        close $MONOX or croak "Unable to close FH: $!";;
+    }
 
-   unlink $buffer or croak "Can not delete $buffer $!";
-   unlink $copy   or croak "Can not delete $copy $!";
+    unlink $buffer or croak "Can not delete $buffer $!";
+    unlink $copy   or croak "Can not delete $copy $!";
 
-   print "\t" or croak "Unable to print to STDOUT: $!";
-   system( $^X, '-wc', $mono ) && die "$mono does not compile!\n";
+    print "\t" or croak "Unable to print to STDOUT: $!";
+    system( $^X, '-wc', $mono ) && die "$mono does not compile!\n";
 
-   $self->_monolith_prove();
+    $self->_monolith_prove();
 
-   warn "\tADD README\n";
-   $self->_write_file('>', $readme, $self->_monolith_readme);
+    warn "\tADD README\n";
+    $self->_write_file('>', $readme, $self->_monolith_readme);
 
-   warn "\tADD TO MANIFEST\n";
-   (my $monof   = $mono  ) =~ s{\\}{/}xmsg;
-   (my $readmef = $readme) =~ s{\\}{/}xmsg;
-   my $name = $self->module_name;
-   $self->_write_file( '>>', 'MANIFEST',
-      "$readmef\n",
-      "$monof\tThe monolithic version of $name",
-      " to ease dropping into web servers. Generated automatically.\n"
-   );
-   return;
+    warn "\tADD TO MANIFEST\n";
+
+    (my $monof   = $mono  ) =~ s{\\}{/}xmsg;
+    (my $readmef = $readme) =~ s{\\}{/}xmsg;
+    my $name = $self->module_name;
+
+    $self->_write_file( '>>', 'MANIFEST',
+        "$readmef\n",
+        "$monof\tThe monolithic version of $name",
+        " to ease dropping into web servers. Generated automatically.\n"
+    );
+
+    return;
 }
 
 sub _monolith_merge {
-   my($self, $files, $mono_file, $mono, $buffer) = @_;
-   my %add_pod;
-   my $POD = q{};
+    my($self, $files, $mono_file, $mono, $buffer) = @_;
+    my %add_pod;
+    my $pod = q{};
 
-   open my $MONO  , '>:raw', $mono   or croak "Can not open file($mono): $!";
-   open my $BUFFER, '>:raw', $buffer or croak "Can not open file($buffer): $!";
+    open my $MONO  , '>:raw', $mono   or croak "Can't open file($mono): $!";
+    open my $BUFFER, '>:raw', $buffer or croak "Can't open file($buffer): $!";
 
-   MONO_FILES: foreach my $mod ( reverse @{ $files } ) {
-      my(undef, undef, $base) = File::Spec->splitpath($mod);
-      warn "\tMERGE $mod\n";
-      my $is_eof = 0;
-      my $is_pre = $self->_monolith_add_to_top( $base );
-      open my $RO_FH, '<:raw', $mod or croak "Can not open file($mod): $!";
-      MONO_MERGE: while ( my $line = readline $RO_FH ) {
-         #print $MONO "{\n" if ! $curly_top{ $mod }++;
-         my $chomped  = $line;
-         chomp $chomped;
-         $is_eof++ if $chomped eq '1;';
-         my $no_pod   = $is_eof && $base ne $mono_file;
-         $no_pod ? last MONO_MERGE
-                 : do {
-                     warn "\tADD POD FROM $mod\n"
-                        if $is_eof && ! $add_pod{ $mod }++;
-                  };
-         $is_eof ? do { $POD .= $line; }
-                 : do {
-                     print { $is_pre ? $BUFFER : $MONO } $line
-                        or croak "Unable to print to FH: $!";
-                  };
-      }
-      close $RO_FH or croak "Unable to close FH: $!";
-      #print $MONO "}\n";
-   }
+    MONO_FILES: foreach my $mod ( reverse @{ $files } ) {
+        warn "\tMERGE $mod\n";
+        my(undef, undef, $base) = File::Spec->splitpath( $mod );
+        my $is_eof = 0;
+        my $is_pre = $self->_monolith_add_to_top( $base );
+        my $TARGET = $is_pre ? $BUFFER : $MONO;
+        open my $RO_FH, '<:raw', $mod or croak "Can not open file($mod): $!";
 
-   close $MONO   or croak "Unable to close FH: $!";
-   close $BUFFER or croak "Unable to close FH: $!";
+        MONO_MERGE: while ( defined( my $line = readline $RO_FH ) ) {
+            chomp( my $chomped = $line );
+            $is_eof++ if $chomped eq '1;';
+            last MONO_MERGE if $is_eof && $base ne $mono_file;
 
-   return $POD;
+            if ( $is_eof ) {
+                warn "\tADD POD FROM $mod\n" if ! $add_pod{ $mod }++;
+                $pod .= $line;
+                next;
+            }
+
+            print { $TARGET } $line or croak "Unable to print to FH: $!";
+        }
+
+        close $RO_FH or croak "Unable to close FH: $!";
+    }
+
+    close $MONO   or croak "Unable to close FH: $!";
+    close $BUFFER or croak "Unable to close FH: $!";
+
+    return $pod;
 }
 
 sub _monolith_prove {
-   my($self) = @_;
+    my($self) = @_;
 
-   warn "\tTESTING MONOLITH\n";
-   local $ENV{AUTHOR_TESTING_MONOLITH_BUILD} = 1;
-   require File::Basename;
-   require File::Spec;
-   my $pbase = File::Basename::dirname( $^X );
+    warn "\tTESTING MONOLITH\n";
+    local $ENV{AUTHOR_TESTING_MONOLITH_BUILD} = 1;
 
-   my $prove;
-   find {
-      wanted => sub {
-         my $file = $_;
-         return if $file !~ m{ prove }xms;
-         $prove = $file;
-      },
-      no_chdir => 1,
-   }, $pbase;
+    require File::Basename;
+    require File::Spec;
 
-   if ( ! $prove || ! -e $prove ) {
-       croak "No `prove command found related to $^X`";
-   }
+    my $pbase = File::Basename::dirname( $^X );
+    my $prove;
+    find {
+        wanted => sub {
+            my $file = $_;
+            return if $file !~ m{ prove }xms;
+            $prove = $file;
+        },
+        no_chdir => 1,
+    }, $pbase;
 
-   warn "\n\tFOUND `prove` at $prove\n\n";
+    if ( ! $prove || ! -e $prove ) {
+        croak "No `prove command found related to $^X`";
+    }
 
-   my @output = qx($prove -Imonolithic_version);
-   for my $line ( @output ) {
-      print "\t$line" or croak "Unable to print to STDOUT: $!";
-   }
-   chomp(my $result = pop @output);
-   croak MONOLITH_TEST_FAIL if $result ne 'Result: PASS';
-   return;
+    warn "\n\tFOUND `prove` at $prove\n\n";
 
+    my @output = qx($prove -Imonolithic_version -r t xt);
+    for my $line ( @output ) {
+        print "\t$line" or croak "Unable to print to STDOUT: $!";
+    }
+    chomp(my $result = pop @output);
+    croak MONOLITH_TEST_FAIL if $result ne 'Result: PASS';
+    return;
 }
 
 sub _monolith_add_pre {
-   my($self, $mono, $copy, $files, $buffer) = @_;
-   require File::Copy;
-   File::Copy::copy( $mono, $copy ) or croak "Copy failed: $!";
+    my($self, $mono, $copy, $files, $buffer) = @_;
+    require File::Copy;
+    File::Copy::copy( $mono, $copy ) or croak "Copy failed: $!";
 
-   my $clean_file = sub {
-      my $f = shift;
-      $f =~ s{    \\   }{/}xmsg;
-      $f =~ s{ \A lib/ }{}xms;
-      return $f;
-   };
+    my $clean_file = sub {
+        my $f = shift;
+        $f =~ s{    \\   }{/}xmsg;
+        $f =~ s{ \A lib/ }{}xms;
+        return $f;
+    };
 
-   my $clean_module = sub {
-      my $m = shift;
-      $m =~ s{ [.]pm \z }{}xms;
-      $m =~ s{  /       }{::}xmsg;
-      return $m;
-   };
+    my $clean_module = sub {
+        my $m = shift;
+        $m =~ s{ [.]pm \z }{}xms;
+        $m =~ s{  /       }{::}xmsg;
+        return $m;
+    };
 
-   my @inc_files = map { $clean_file->(   $_ ) } @{ $files };
-   my @packages  = map { $clean_module->( $_ ) } @inc_files;
+    my @inc_files = map { $clean_file->(   $_ ) } @{ $files };
+    my @packages  = map { $clean_module->( $_ ) } @inc_files;
 
-   open my $W, '>:raw', $mono or croak "Can not open file($mono): $!";
+    open my $W, '>:raw', $mono or croak "Can not open file($mono): $!";
 
-   printf {$W} q/BEGIN { $INC{$_} = 1 for qw(%s); }/, join q{ }, @inc_files
-           or croak "Can not print to MONO file: $!";
-   print  {$W} "\n" or croak "Can not print to MONO file: $!";
+    printf {$W} q/BEGIN { $INC{$_} = 1 for qw(%s); }/, join q{ }, @inc_files
+            or croak "Can not print to MONO file: $!";
+    print  {$W} "\n" or croak "Can not print to MONO file: $!";
 
-   foreach my $name ( @packages ) {
-      print {$W} qq/package $name;\nsub ________monolith {}\n/
-            or croak "Can not print to MONO file: $!";
-   }
+    foreach my $name ( @packages ) {
+       print {$W} qq/package $name;\nsub ________monolith {}\n/
+             or croak "Can not print to MONO file: $!";
+    }
 
-   open my $TOP,  '<:raw', $buffer or croak "Can not open file($buffer): $!";
-   while ( my $line = <$TOP> ) {
-      print {$W} $line or croak "Can not print to BUFFER file: $!";
-   }
-   close $TOP or croak 'Can not close BUFFER file';
+    open my $TOP,  '<:raw', $buffer or croak "Can not open file($buffer): $!";
+    while ( defined( my $line = <$TOP> ) ) {
+       print {$W} $line or croak "Can not print to BUFFER file: $!";
+    }
+    close $TOP or croak 'Can not close BUFFER file';
 
-   open my $COPY, '<:raw', $copy or croak "Can not open file($copy): $!";
-   while ( my $line = <$COPY> ) {
-      print {$W} $line or croak "Can not print to COPY file: $!";
-   }
+    open my $COPY, '<:raw', $copy or croak "Can not open file($copy): $!";
+    while ( defined( my $line = <$COPY> ) ) {
+        print {$W} $line or croak "Can not print to COPY file: $!";
+    }
 
-   close $COPY or croak "Can not close COPY file: $!";
-   close $W    or croak "Can not close MONO file: $!";
+    close $COPY or croak "Can not close COPY file: $!";
+    close $W    or croak "Can not close MONO file: $!";
 
-   return;
-
+    return;
 }
 
 sub _write_file {
-   my($self, $mode, $file, @data) = @_;
-   $mode = $mode . ':raw';
-   open my $FH, $mode, $file or croak "Can not open file($file): $!";
-   foreach my $content ( @data ) {
-      print {$FH} $content or croak "Can not print to FH: $!";
-   }
-   close $FH or croak "Can not close $file $!";
-   return;
+    my($self, $mode, $file, @data) = @_;
+    $mode = $mode . ':raw';
+    open my $FH, $mode, $file or croak "Can not open file($file): $!";
+    foreach my $content ( @data ) {
+        print {$FH} $content or croak "Can not print to FH: $!";
+    }
+    close $FH or croak "Can not close $file $!";
+    return;
 }
 
 sub _monolith_add_to_top {
-   my $self = shift;
-   my $base = shift;
-   my $list = $self->monolith_add_to_top || croak 'monolith_add_to_top not set';
-   croak 'monolith_add_to_top is not an ARRAY' if ref $list ne 'ARRAY';
-   foreach my $test ( @{ $list } ) {
-      return 1 if $test eq $base;
-   }
-   return 0;
+    my $self = shift;
+    my $base = shift;
+    my $list = $self->monolith_add_to_top || croak 'monolith_add_to_top not set';
+    croak 'monolith_add_to_top is not an ARRAY' if ref $list ne 'ARRAY';
+    foreach my $test ( @{ $list } ) {
+        return 1 if $test eq $base;
+    }
+    return 0;
 }
 
 sub _monolith_readme {
-   my $self = shift;
-   my $pod  = $self->_monolith_pod_warning;
-   $pod =~ s{B<(.+?)>}{$1}xmsg;
-   return $pod;
+    my $self = shift;
+    my $pod  = $self->_monolith_pod_warning;
+    $pod =~ s{B<(.+?)>}{$1}xmsg;
+    return $pod;
 }
 
 sub _monolith_pod_warning {
-   my $self = shift;
-   my $name = $self->module_name;
-   return <<"MONOLITH_POD_WARNING";
+    my $self = shift;
+    my $name = $self->module_name;
+    return <<"MONOLITH_POD_WARNING";
 
 B<WARNING>! This is the monolithic version of $name
 generated with an automatic build tool. If you experience problems
 }
 
 sub _add_automatic_build_pl {
-   my $self = shift;
-   my $file = 'Build.PL';
-   return if -e $file; # do not overwrite
-   $self->_write_file(  '>', $file    =>  $self->_automatic_build_pl       );
-   $self->_write_file( '>>', MANIFEST => "$file\tGenerated automatically\n");
-   warn "ADDED AUTOMATIC $file\n";
-   return;
+    my $self = shift;
+    my $file = 'Build.PL';
+    return if -e $file; # do not overwrite
+    $self->_write_file(  '>', $file    =>  $self->_automatic_build_pl       );
+    $self->_write_file( '>>', MANIFEST => "$file\tGenerated automatically\n");
+    warn "ADDED AUTOMATIC $file\n";
+    return;
 }
 
 sub _automatic_build_pl {
 }
 
 sub _add_vanilla_makefile_pl {
-   my $self = shift;
-   my $file = 'Makefile.PL';
-   return if -e $file; # do not overwrite
-   $self->_write_file(  '>', $file    => $self->_vanilla_makefile_pl       );
-   $self->_write_file( '>>', MANIFEST => "$file\tGenerated automatically\n");
-   warn "ADDED VANILLA $file\n";
-   return;
+    my $self = shift;
+    my $file = 'Makefile.PL';
+    return if -e $file; # do not overwrite
+    $self->_write_file(  '>', $file    => $self->_vanilla_makefile_pl       );
+    $self->_write_file( '>>', MANIFEST => "$file\tGenerated automatically\n");
+    warn "ADDED VANILLA $file\n";
+    return;
 }
 
 sub _vanilla_makefile_pl {
-   my $self = shift;
-   my $hook = $self->initialization_hook;
-   my $extra = ! $hook ? q() : <<'HOOK';
+    my $self = shift;
+    my $hook = $self->initialization_hook;
+    my $extra = ! $hook ? q() : <<'HOOK';
 
 my $eok = eval <<'THIS_IS_SOME_IDENTIFIER';
 <%HOOK%>
 
 HOOK
 
-   $extra =~ s{<%HOOK%>}{$hook}xmsg if $extra;
+    $extra =~ s{<%HOOK%>}{$hook}xmsg if $extra;
 
-   my $code = $self->_automatic_build_file_header;
-   $code .= <<'VANILLA_MAKEFILE_PL';
+    my $code = $self->_automatic_build_file_header;
+    $code .= <<'VANILLA_MAKEFILE_PL';
 use Build::Spec qw( mm_spec );
 use ExtUtils::MakeMaker;
 
     ) : ()),
 );
 VANILLA_MAKEFILE_PL
-   $code =~ s{<%EXTRA%>}{$extra}xmsg;
-   return $code;
+    $code =~ s{<%EXTRA%>}{$extra}xmsg;
+    return $code;
 }
 
 sub _pod_author_copyright_license {
-   my $self = shift;
-   my $da   = $self->dist_author; # support only 1 author for now
-   my($author, $email) = $da->[0] =~ m{ (.+?) < ( .+?) > }xms;
-   $author = $self->mytrim( $author );
-   $email  = $self->mytrim( $email );
-   my $cfy = $self->copyright_first_year;
-   my $year = (localtime time)[YEAR_SLOT] + YEAR_ADD;
-   $year = "$cfy - $year" if $cfy && $cfy != $year && $cfy < $year;
-   my $perl = sprintf '%vd', $^V;
-   return <<"POD";
+    my $self = shift;
+    my $da   = $self->dist_author; # support only 1 author for now
+    my($author, $email) = $da->[0] =~ m{ (.+?) < ( .+?) > }xms;
+    $author = trim( $author );
+    $email  = trim( $email );
+    my $cfy = $self->copyright_first_year;
+    my $year = (localtime time)[YEAR_SLOT] + YEAR_ADD;
+    $year = "$cfy - $year" if $cfy && $cfy != $year && $cfy < $year;
+    my $perl = sprintf '%vd', $^V;
+    return <<"POD";
 =head1 AUTHOR
 
 $author <$email>.

builder/builder/Build/Constants.pm

+package Build::Constants;
+use strict;
+use warnings;
+
+our $VERSION = '0.80';
+
+use base qw( Exporter );
+
+use constant TAINT_SHEBANG   => "#!perl -Tw\nuse constant TAINTMODE => 1;\n";
+use constant RE_VERSION_LINE => qr{
+   \A (our\s+)? \$VERSION \s+ = \s+ ["'] (.+?) ['"] ; (.+?) \z
+}xms;
+use constant RE_POD_LINE => qr{
+    \A
+        =head1 \s+ DESCRIPTION \s+
+    \z
+}xms;
+use constant VTEMP  => q{%s$VERSION = '%s';};
+use constant MONTHS => qw(
+   January February March     April   May      June
+   July    August   September October November December
+);
+use constant MONOLITH_TEST_FAIL =>
+   "\nFAILED! Building the monolithic version failed during unit testing\n\n";
+
+use constant NO_INDEX => qw(
+    monolithic_version
+    builder
+    t
+);
+use constant DEFAULTS => qw(
+   license          perl
+   create_license   1
+   sign             0
+);
+use constant YEAR_ADD  => 1900;
+use constant YEAR_SLOT =>    5;
+
+our @EXPORT_OK = qw(
+    TAINT_SHEBANG
+    RE_VERSION_LINE
+    RE_POD_LINE
+    VTEMP
+    MONTHS
+    MONOLITH_TEST_FAIL
+    NO_INDEX
+    DEFAULTS
+    YEAR_ADD
+    YEAR_SLOT
+);
+our %EXPORT_TAGS = (
+    all => \@EXPORT_OK,
+);
+
+1;
+
+__END__

builder/builder/Build/Spec.pm

 ## no critic (RequireUseWarnings)
 
 BEGIN {
-   our $VERSION   = '0.71';
+   our $VERSION   = '0.80';
    our @EXPORT    = qw( spec    );
    our @EXPORT_OK = qw( mm_spec );
 }

builder/builder/Build/Util.pm

+package Build::Util;
+use strict;
+use warnings;
+use base qw( Exporter );
+use Carp ();
+
+our $VERSION   = '0.80';
+our @EXPORT_OK = qw( slurp trim );
+
+sub slurp {
+    my $path = shift || Carp::croak( 'No file path specified' );
+    if ( ! -e $path ) {
+        Carp::croak( "The specified file path $path does not exist" );
+    }
+    open my $FH, '<', $path  or Carp::croak( "Can not open file($path): $!" );
+    my $rv = do { local $/; <$FH> };
+    close { $FH } || Carp::croak( "Can't close($path): $!" );
+    return $rv;
+}
+
+sub trim {
+    my($s, $extra) = @_;
+    return $s if ! $s;
+    $extra ||= q{};
+    $s =~ s{\A \s+   }{$extra}xms;
+    $s =~ s{   \s+ \z}{$extra}xms;
+    return $s;
+}
+
+1;
+
+__END__

builder/t/201-pod.t

-#!/usr/bin/env perl -w
-use strict;
-use warnings;
-use Test::More;
-use constant NEW_PERL => 5.008;
-use constant MIN_TPV => 1.26;
-use constant MIN_PSV => 3.05;
-
-my(@errors, $eok);
-$eok = eval { require Test::Pod;   1; };
-push @errors, 'Test::Pod is required for testing POD'   if $@ || ! $eok;
-$eok = eval { require Pod::Simple; 1; };
-push @errors, 'Pod::Simple is required for testing POD' if $@ || ! $eok;
-
-if ( not @errors ) {
-   my $tpv = Test::Pod->VERSION;
-   my $psv = Pod::Simple->VERSION;
-
-   if ( $tpv < MIN_TPV ) {
-      push @errors, 'Upgrade Test::Pod to 1.26 to run this test. '
-                   ."Detected version is: $tpv";
-   }
-
-   if ( $psv < MIN_PSV ) {
-      push @errors, 'Upgrade Pod::Simple to 3.05 to run this test. '
-                   ."Detected version is: $psv";
-   }
-}
-
-if ( $] < NEW_PERL ) {
-   # Any older perl does not have Encode.pm. Thus, Pod::Simple
-   # can not handle utf8 encoding and it will die, the tests
-   # will fail. This skip part, skips an inevitable failure.
-   push @errors, '"=encoding utf8" directives in Pods don\'t work '
-                .'with legacy perl.';
-}
-
-if ( @errors ) {
-   plan skip_all => "Errors detected: @errors";
-}
-else {
-   Test::Pod::all_pod_files_ok();
-}

builder/t/202-pod-coverage.t

-#!/usr/bin/env perl -w
-use strict;
-use warnings;
-use Test::More;
-
-# build tool runs the whole test suite on the monolithic version.
-# Don't bother testing it if exists
-plan skip_all => 'Skipping for monolith build test' if $ENV{AUTHOR_TESTING_MONOLITH_BUILD};
-
-my $eok = eval 'use Test::Pod::Coverage;1;';
-my $e   = $@ || ! $eok;
-
-eval {
-    $e ? plan( skip_all => 'Test::Pod::Coverage required for testing pod coverage' )
-       : all_pod_coverage_ok();
-    1;
-} or do {
-    diag( "Some error happened in somewhere, which I don't care: $@" );
-    ok( 1, 'Fake test' );
-}

builder/xt/author/201-pod.t

+#!/usr/bin/env perl -w
+use strict;
+use warnings;
+use Test::More;
+use constant NEW_PERL => 5.008;
+use constant MIN_TPV => 1.26;
+use constant MIN_PSV => 3.05;
+
+my(@errors, $eok);
+$eok = eval { require Test::Pod;   1; };
+push @errors, 'Test::Pod is required for testing POD'   if $@ || ! $eok;
+$eok = eval { require Pod::Simple; 1; };
+push @errors, 'Pod::Simple is required for testing POD' if $@ || ! $eok;
+
+if ( not @errors ) {
+   my $tpv = Test::Pod->VERSION;
+   my $psv = Pod::Simple->VERSION;
+
+   if ( $tpv < MIN_TPV ) {
+      push @errors, 'Upgrade Test::Pod to 1.26 to run this test. '
+                   ."Detected version is: $tpv";
+   }
+
+   if ( $psv < MIN_PSV ) {
+      push @errors, 'Upgrade Pod::Simple to 3.05 to run this test. '
+                   ."Detected version is: $psv";
+   }
+}
+
+if ( $] < NEW_PERL ) {
+   # Any older perl does not have Encode.pm. Thus, Pod::Simple
+   # can not handle utf8 encoding and it will die, the tests
+   # will fail. This skip part, skips an inevitable failure.
+   push @errors, '"=encoding utf8" directives in Pods don\'t work '
+                .'with legacy perl.';
+}
+
+if ( @errors ) {
+   plan skip_all => "Errors detected: @errors";
+}
+else {
+   Test::Pod::all_pod_files_ok();
+}

builder/xt/author/202-pod-coverage.t

+#!/usr/bin/env perl -w
+use strict;
+use warnings;
+use Test::More;
+
+# build tool runs the whole test suite on the monolithic version.
+# Don't bother testing it if exists
+plan skip_all => 'Skipping for monolith build test' if $ENV{AUTHOR_TESTING_MONOLITH_BUILD};
+
+my $eok = eval 'use Test::Pod::Coverage;1;';
+my $e   = $@ || ! $eok;
+
+eval {
+    $e ? plan( skip_all => 'Test::Pod::Coverage required for testing pod coverage' )
+       : all_pod_coverage_ok();
+    1;
+} or do {
+    diag( "Some error happened in somewhere, which I don't care: $@" );
+    ok( 1, 'Fake test' );
+}