diff --git a/DBIx-Class-Schema-Loader-0.04006.diff b/DBIx-Class-Schema-Loader-0.04006.diff new file mode 100644 index 0000000..44a434e --- /dev/null +++ b/DBIx-Class-Schema-Loader-0.04006.diff @@ -0,0 +1,4004 @@ +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/AutoInstall.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/AutoInstall.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/AutoInstall.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/AutoInstall.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,4 +1,3 @@ +-#line 1 + package Module::AutoInstall; + + use strict; +@@ -18,7 +17,9 @@ + + # various lexical flags + my ( @Missing, @Existing, %DisabledTests, $UnderCPAN, $HasCPANPLUS ); +-my ( $Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly ); ++my ( ++ $Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly, $AllDeps ++); + my ( $PostambleActions, $PostambleUsed ); + + # See if it's a testing or non-interactive session +@@ -73,6 +74,9 @@ + elsif ( $arg =~ /^--test(?:only)?$/ ) { + $TestOnly = 1; + } ++ elsif ( $arg =~ /^--all(?:deps)?$/ ) { ++ $AllDeps = 1; ++ } + } + } + +@@ -115,7 +119,12 @@ + )[0] + ); + +- $UnderCPAN = _check_lock(1); # check for $UnderCPAN ++ # We want to know if we're under CPAN early to avoid prompting, but ++ # if we aren't going to try and install anything anyway then skip the ++ # check entirely since we don't want to have to load (and configure) ++ # an old CPAN just for a cosmetic message ++ ++ $UnderCPAN = _check_lock(1) unless $SkipInstall; + + while ( my ( $feature, $modules ) = splice( @args, 0, 2 ) ) { + my ( @required, @tests, @skiptests ); +@@ -165,15 +174,24 @@ + } + + # XXX: check for conflicts and uninstalls(!) them. +- if ( +- defined( my $cur = _version_check( _load($mod), $arg ||= 0 ) ) ) ++ my $cur = _load($mod); ++ if (_version_cmp ($cur, $arg) >= 0) + { + print "loaded. ($cur" . ( $arg ? " >= $arg" : '' ) . ")\n"; + push @Existing, $mod => $arg; + $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; + } + else { +- print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n"; ++ if (not defined $cur) # indeed missing ++ { ++ print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n"; ++ } ++ else ++ { ++ # no need to check $arg as _version_cmp ($cur, undef) would satisfy >= above ++ print "too old. ($cur < $arg)\n"; ++ } ++ + push @required, $mod => $arg; + } + } +@@ -187,6 +205,7 @@ + and ( + $CheckOnly + or ($mandatory and $UnderCPAN) ++ or $AllDeps + or _prompt( + qq{==> Auto-install the } + . ( @required / 2 ) +@@ -235,21 +254,38 @@ + *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main'; + } + ++sub _running_under { ++ my $thing = shift; ++ print <<"END_MESSAGE"; ++*** Since we're running under ${thing}, I'll just let it take care ++ of the dependency's installation later. ++END_MESSAGE ++ return 1; ++} ++ + # Check to see if we are currently running under CPAN.pm and/or CPANPLUS; + # if we are, then we simply let it taking care of our dependencies + sub _check_lock { + return unless @Missing or @_; + ++ my $cpan_env = $ENV{PERL5_CPAN_IS_RUNNING}; ++ + if ($ENV{PERL5_CPANPLUS_IS_RUNNING}) { +- print <<'END_MESSAGE'; ++ return _running_under($cpan_env ? 'CPAN' : 'CPANPLUS'); ++ } + +-*** Since we're running under CPANPLUS, I'll just let it take care +- of the dependency's installation later. +-END_MESSAGE +- return 1; ++ require CPAN; ++ ++ if ($CPAN::VERSION > '1.89') { ++ if ($cpan_env) { ++ return _running_under('CPAN'); ++ } ++ return; # CPAN.pm new enough, don't need to check further + } + +- _load_cpan(); ++ # last ditch attempt, this -will- configure CPAN, very sorry ++ ++ _load_cpan(1); # force initialize even though it's already loaded + + # Find the CPAN lock-file + my $lock = MM->catfile( $CPAN::Config->{cpan_home}, ".lock" ); +@@ -285,7 +321,7 @@ + while ( my ( $pkg, $ver ) = splice( @_, 0, 2 ) ) { + + # grep out those already installed +- if ( defined( _version_check( _load($pkg), $ver ) ) ) { ++ if ( _version_cmp( _load($pkg), $ver ) >= 0 ) { + push @installed, $pkg; + } + else { +@@ -324,7 +360,7 @@ + + # see if we have successfully installed them + while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { +- if ( defined( _version_check( _load($pkg), $ver ) ) ) { ++ if ( _version_cmp( _load($pkg), $ver ) >= 0 ) { + push @installed, $pkg; + } + elsif ( $args{do_once} and open( FAILED, '>> .#autoinstall.failed' ) ) { +@@ -379,7 +415,7 @@ + my $success; + my $obj = $modtree->{$pkg}; + +- if ( $obj and defined( _version_check( $obj->{version}, $ver ) ) ) { ++ if ( $obj and _version_cmp( $obj->{version}, $ver ) >= 0 ) { + my $pathname = $pkg; + $pathname =~ s/::/\\W/; + +@@ -472,7 +508,7 @@ + my $obj = CPAN::Shell->expand( Module => $pkg ); + my $success = 0; + +- if ( $obj and defined( _version_check( $obj->cpan_version, $ver ) ) ) { ++ if ( $obj and _version_cmp( $obj->cpan_version, $ver ) >= 0 ) { + my $pathname = $pkg; + $pathname =~ s/::/\\W/; + +@@ -536,7 +572,7 @@ + my $ver = shift; + + return +- if defined( _version_check( _load($class), $ver ) ); # no need to upgrade ++ if _version_cmp( _load($class), $ver ) >= 0; # no need to upgrade + + if ( + _prompt( "==> A newer version of $class ($ver) is required. Install?", +@@ -633,7 +669,7 @@ + + # Load CPAN.pm and it's configuration + sub _load_cpan { +- return if $CPAN::VERSION; ++ return if $CPAN::VERSION and $CPAN::Config and not @_; + require CPAN; + if ( $CPAN::HandleConfig::VERSION ) { + # Newer versions of CPAN have a HandleConfig module +@@ -645,9 +681,11 @@ + } + + # compare two versions, either use Sort::Versions or plain comparison +-sub _version_check { ++# return values same as <=> ++sub _version_cmp { + my ( $cur, $min ) = @_; +- return unless defined $cur; ++ return -1 unless defined $cur; # if 0 keep comparing ++ return 1 unless $min; + + $cur =~ s/\s+$//; + +@@ -658,16 +696,13 @@ + ) { + + # use version.pm if it is installed. +- return ( +- ( version->new($cur) >= version->new($min) ) ? $cur : undef ); ++ return version->new($cur) <=> version->new($min); + } + elsif ( $Sort::Versions::VERSION or defined( _load('Sort::Versions') ) ) + { + + # use Sort::Versions as the sorting algorithm for a.b.c versions +- return ( ( Sort::Versions::versioncmp( $cur, $min ) != -1 ) +- ? $cur +- : undef ); ++ return Sort::Versions::versioncmp( $cur, $min ); + } + + warn "Cannot reliably compare non-decimal formatted versions.\n" +@@ -676,7 +711,7 @@ + + # plain comparison + local $^W = 0; # shuts off 'not numeric' bugs +- return ( $cur >= $min ? $cur : undef ); ++ return $cur <=> $min; + } + + # nothing; this usage is deprecated. +@@ -766,4 +801,256 @@ + + __END__ + +-#line 1004 ++=pod ++ ++=head1 NAME ++ ++Module::AutoInstall - Automatic install of dependencies via CPAN ++ ++=head1 SYNOPSIS ++ ++In F, with L available on the author's system: ++ ++ use inc::Module::Install; ++ ++ name 'Joe-Hacker'; ++ abstract 'Perl Interface to Joe Hacker'; ++ author 'Joe Hacker '; ++ include 'Module::AutoInstall'; ++ ++ requires 'Module0'; # mandatory modules ++ ++ feature 'Feature1', ++ -default => 0, ++ 'Module2' => '0.1'; ++ ++ feature 'Feature2', ++ -default => 0, ++ 'Module3' => '1.0'; ++ ++ auto_install( ++ make_args => '--hello', # option(s) for CPAN::Config ++ force => 1, # pseudo-option to force install ++ do_once => 1, # skip previously failed modules ++ ); ++ ++ WriteAll; ++ ++Invoking the resulting F: ++ ++ % perl Makefile.PL # interactive behaviour ++ % perl Makefile.PL --defaultdeps # accept default value on prompts ++ % perl Makefile.PL --checkdeps # check only, no Makefile produced ++ % perl Makefile.PL --skipdeps # ignores all dependencies ++ % perl Makefile.PL --testonly # don't write installation targets ++ ++Note that the trailing 'deps' of arguments may be omitted, too. ++ ++Using C<--defaultdeps> will make F behave similarly to a regular ++Makefile.PL file with C dependencies. ++ ++One can use environment variables (see "ENVIRONMENT") below to set a default ++behavior instead of specifying it in the command line for every invocation ++of F. ++ ++Using F (or F): ++ ++ % make [all|test|install] # install dependencies first ++ % make checkdeps # same as the --checkdeps above ++ % make installdeps # install dependencies only ++ ++=head1 DESCRIPTION ++ ++B lets module writers to specify a more ++sophisticated form of dependency information than the C ++option offered by B. ++ ++This module works best with the B framework, ++a drop-in replacement for MakeMaker. However, this module also ++supports F files based on MakeMaker; see L ++for instructions. ++ ++=head2 Prerequisites and Features ++ ++Prerequisites are grouped into B, and the user could choose ++yes/no on each one's dependencies; the module writer may also supply a ++boolean value via C<-default> to specify the default choice. ++ ++The B marked by the name C<-core> will double-check with ++the user, if the user chooses not to install the mandatory modules. ++This differs from the pre-0.26 'silent install' behaviour. ++ ++Starting from version 0.27, if C<-core> is set to the string C ++(case-insensitive), every feature will be considered mandatory. ++ ++The dependencies are expressed as pairs of C => C ++inside an array reference. If the order does not matter, and there ++are no C<-default>, C<-tests> or C<-skiptests> directives for that ++feature, you may also use a hash reference. ++ ++=head2 The Installation Process ++ ++Once B has determined which module(s) are needed, ++it checks whether it's running under the B shell and should ++therefore let B handle the dependency. ++ ++Finally, the C is overridden to perform some additional ++checks, as well as skips tests associated with disabled features by the ++C<-tests> option. ++ ++The actual installation happens at the end of the C target; ++both C and C will trigger the installation of ++required modules. ++ ++If it's not running under B, the installer will probe for an ++active connection by trying to resolve the domain C, and check ++for the user's permission to use B. If all went well, a separate ++ B instance is created to install the required modules. ++ ++If you have the B package installed in your system, it is ++preferred by default over B; it also accepts some extra options ++(e.g. C<-target =E 'skiptest', -skiptest =E 1> to skip testing). ++ ++All modules scheduled to be installed will be deleted from C<%INC> ++first, so B will check the newly installed modules. ++ ++Additionally, you could use the C target to install ++the modules, and the C target to check dependencies ++without actually installing them; the C ++command has an equivalent effect. ++ ++If the F itself needs to use an independent module (e.g. ++B, v1.21 or greater), then use something like below: ++ ++ BEGIN { ++ require Module::AutoInstall; ++ # the first argument is an arrayref of the -config flags ++ Module::AutoInstall->install([], 'Acme::KillerApp' => 1.21); ++ } ++ use Acme::KillerApp 1.21; ++ ++ Module::AutoInstall->import( ++ # ... arguments as usual ... ++ ); ++ ++Note the version test in the use clause; if you are so close to the ++cutting edge that B 1.20 is the latest version on CPAN, ++this will prevent your module from going awry. ++ ++=head2 User-Defined Hooks ++ ++User-defined I and I hooks are ++available via C and C subroutines, ++as shown below: ++ ++ # pre-install handler; takes $module_name and $version ++ sub MY::preinstall { return 1; } # return false to skip install ++ ++ # post-install handler; takes $module_name, $version, $success ++ sub MY::postinstall { return; } # the return value doesn't matter ++ ++Note that since B performs installation at the ++time of C (i.e. before perl parses the remainder of ++F), you have to declare those two handlers I the ++C statement for them to take effect. ++ ++If the user did not choose to install a module or it already exists on ++the system, neither of the handlers is invoked. Both handlers are invoked ++exactly once for each module when installation is attempted. ++ ++C takes two arguments, C<$module_name> and C<$version>; ++if it returns a false value, installation for that module will be ++skipped, and C won't be called at all. ++ ++C takes three arguments, C<$module_name>, C<$version> ++and C<$success>. The last one denotes whether the installation ++succeeded or not: C<1> means installation completed successfully, C<0> ++means failure during install, and C means that the installation ++was not attempted at all, possibly due to connection problems, or that ++module does not exist on CPAN at all. ++ ++=head2 Customized C ++ ++Starting from version 0.43, B supports modules ++that require a C subroutine in their F. ++The user-defined C, if present, is responsible for ++calling C and include the output in ++its return value. ++ ++For example, the B (database driver) modules for the Perl DBI ++are required to include the postamble generated by the function ++C, so their F may contain lines like this: ++ ++ sub MY::postamble { ++ return &Module::AutoInstall::postamble . &dbd_postamble; ++ } ++ ++Note that the B module does not export the ++C function, so the name should always be fully qualified. ++ ++=head1 CAVEATS ++ ++B will add C to your B ++flags if your effective uid is 0 (root), unless you explicitly disable ++it by setting B's C configuration option (or the ++C option of B) to include C. This I ++cause dependency problems if you are using a fine-tuned directory ++structure for your site. Please consult L for an explanation ++in detail. ++ ++If either B or B is available, they will be ++used to compare the required version with the existing module's version ++and the CPAN module's. Otherwise it silently falls back to use I. ++This may cause inconsistent behaviours in pathetic situations. ++ ++=head1 ENVIRONMENT ++ ++B uses a single environment variable, ++C. It is taken as the command line argument ++passed to F; you could set it to C<--alldeps>, C<--defaultdeps> ++or C<--skipdeps> to avoid all interactive behaviour. ++ ++C<--alldeps> will install all features, while ++C<--defaultdeps> will only install features for which the default answer is ++'y'. ++ ++C<--skipdeps> will refrain from loading L and not install anything, unless ++you're running under L or L, in which case required dependencies ++will be installed. ++ ++It also read from the C environment variable if ++C is not defined. ++ ++=head1 SEE ALSO ++ ++L ++ ++L, L, L, L, ++L ++ ++=head1 AUTHORS ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++Matt S Trout Emst@shadowcat.co.uE ++ ++=head1 IF THIS BREAKS ++ ++Report a ticket to bugs-Module-Install rt.cpan.org and cc Matt ++- I appear to have volunteered as primary maintainer for this stuff so ++if you run into any problems please tell me ++ ++=head1 COPYRIGHT ++ ++Copyright 2001, 2002, 2003, 2004, 2005, 2006 by Audrey Tang ++ ++Some parts copyright 2006 Adam Kennedy ++ ++This program is free software; you can redistribute it and/or ++modify it under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Bundle.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Bundle.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Bundle.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Bundle.pm 2009-05-27 18:46:14.000000000 +0200 +@@ -0,0 +1,73 @@ ++package Module::Install::Admin::Bundle; ++ ++use strict; ++use Module::Install::Base; ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++sub bundle { ++ my $self = shift; ++ my $bundle_dir = $self->_top->{bundle}; ++ ++ require Cwd; ++ require CPANPLUS::Backend; ++ ++ my $cwd = Cwd::getcwd(); ++ ++ # This code is what we _should_ be doing, but CPANPLUS doesn't ++ # let you have multiple Backends in one program. ++ # my $cp = CPANPLUS::Backend->new; ++ # ++ # Jos Boumans tells us that this is the best way to do what we want ++ # It still scares me. ++ my $cp = CPANPLUS::Internals->_retrieve_id( CPANPLUS::Internals->_last_id ) ++ || CPANPLUS::Backend->new; ++ my $conf = $cp->configure_object; ++ my $modtree = $cp->module_tree; ++ ++ $conf->set_conf( verbose => 1 ); ++ $conf->set_conf( signature => 0 ); ++ $conf->set_conf( md5 => 0 ); ++ ++ mkdir $bundle_dir; ++ ++ my %bundles; ++ ++ while ( my ( $name, $version ) = splice( @_, 0, 2 ) ) { ++ my $mod = $cp->module_tree($name); ++ next unless $mod; ++ if ( $mod->package_is_perl_core or $self->{already_bundled}{$mod->package} ) { ++ next; ++ } ++ ++ my $where = $mod->fetch( fetchdir => $bundle_dir, ); ++ next unless ($where); ++ my $file = Cwd::abs_path($where); ++ ++ my $extract_result = $mod->extract( ++ files => [ $file ], ++ extractdir => $bundle_dir, ++ ); ++ ++ unlink $file; ++ next unless ($extract_result); ++ $bundles{$name} = $extract_result; ++ $self->{already_bundled}{ $mod->package }++; ++ ++ } ++ ++ chdir $cwd; ++ ++ local *FH; ++ open FH, ">> $bundle_dir.yml" or die "Cannot write to $bundle_dir.yml: $!"; ++ foreach my $name ( sort keys %bundles ) { ++ print FH "$name: '$bundles{$name}'\n"; ++ } ++ close FH; ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Compiler.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Compiler.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Compiler.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Compiler.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,27 @@ ++package Module::Install::Admin::Compiler; ++ ++use strict; ++use Module::Install::Base; ++use File::Remove (); ++use Devel::PPPort (); ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++sub ppport { ++ my $self = shift; ++ my $file = shift || 'ppport.h'; ++ if ( -f $file ) { ++ # Update the file to a newer version ++ File::Remove::remove($file); ++ } ++ ++ # Install the file (and remove on realclean) ++ Devel::PPPort::WriteFile( $file ) or die "Failed to write $file"; ++ $self->realclean_files( $file ); ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Find.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Find.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Find.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Find.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,77 @@ ++package Module::Install::Admin::Find; ++ ++use strict; ++use File::Find (); ++use Module::Install::Base (); ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw(Module::Install::Base); ++} ++ ++sub find_extensions { ++ my $self = shift; ++ $self->_top->find_extensions(@_); ++} ++ ++sub find_in_inc { ++ my ($self, $pkg) = @_; ++ ++ unless ($pkg =~ /\.pm$/) { ++ $pkg =~ s!::!/!g; ++ $pkg = "$pkg.pm"; ++ } ++ ++ my @found; ++ foreach my $inc (@INC) { ++ next if $inc eq $self->_top->{prefix} or ref($inc); ++ push @found, "$inc/$pkg" if -f "$inc/$pkg"; ++ } ++ ++ wantarray ? @found : $found[0]; ++} ++ ++sub glob_in_inc { ++ my ($self, $pkg) = @_; ++ ++ unless ($pkg =~ /\.pm$/) { ++ $pkg =~ s!::!/!g; ++ $pkg = "$pkg.pm"; ++ } ++ ++ my @found; ++ foreach my $inc (@INC) { ++ next if $inc eq $self->_top->{prefix} or ref($inc); ++ push @found, [ do { ++ my $p = $_; ++ $p =~ s!^\Q$inc\E/!!; ++ $p =~ s!/!::!g; ++ $p =~ s!\.pm\Z!!gi; ++ $p ++ }, $_ ] for grep -e, glob("$inc/$pkg"); ++ } ++ ++ wantarray ? @found : $found[0]; ++} ++ ++sub find_files { ++ my ($self, $file, $path) = @_; ++ $path = '' if not defined $path; ++ $file = "$path/$file" if length($path); ++ if (-f $file) { ++ return ($file); ++ } ++ elsif (-d $file) { ++ my @files = (); ++ local *DIR; ++ opendir(DIR, $file) or die "Can't opendir $file"; ++ while (my $new_file = readdir(DIR)) { ++ next if $new_file =~ /^(\.|\.\.)$/; ++ push @files, $self->find_files($new_file, $file); ++ } ++ return @files; ++ } ++ return (); ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Include.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Include.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Include.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Include.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,147 @@ ++package Module::Install::Admin::Include; ++ ++use strict; ++use Module::Install::Base; ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++sub include { ++ my $self = shift; ++ foreach my $rv ( $self->admin->glob_in_inc($_[0]) ) { ++ $self->admin->copy_package(@$rv); ++ } ++} ++ ++sub include_deps { ++ my $self = shift; ++ my $deps = $self->admin->scan_dependencies($_[0]) or return; ++ foreach my $key ( sort keys %$deps ) { ++ $self->include($key); ++ } ++} ++ ++sub auto_include { ++ my $self = shift; ++ foreach my $module ( ++ map { $_->[0] } ++ map { @$_ } ++ grep { $_ } ++ $self->build_requires ++ ) { ++ $self->include($module); ++ } ++} ++ ++sub auto_include_deps { ++ my $self = shift; ++ foreach my $module ( ++ map { $_->[0] } ++ map { @$_ } ++ grep { $_ } ++ $self->build_requires ++ ) { ++ $self->include_deps($module); ++ } ++} ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::Admin::Include ++ ++=head2 auto_include_dependent_dists ++ ++Grabs everything in this module's build_requires and attempts to ++include everything (at the whole distribution level) recursively. ++ ++=cut ++ ++sub auto_include_dependent_dists { ++ my $self = shift; ++ foreach my $module ( ++ map { $_->[0] } ++ map { @$_ } ++ grep { $_ } ++ $self->build_requires ++ ) { ++ $self->include_dependent_dists($module); ++ } ++} ++ ++=pod ++ ++=head2 include_dependent_dists $package ++ ++Given a module package name, recursively include every package that ++module needs. ++ ++=cut ++ ++sub include_dependent_dists { ++ my $self = shift; ++ my $pkg = shift; ++ return unless $pkg; ++ return if $self->{including_dep_dist}->{ $self->_pkg_to_dist($pkg) }++; ++ $self->include_one_dist($pkg); ++ foreach my $mod ( @{ $self->_dist_to_mods( $self->_pkg_to_dist($pkg) ) } ) { ++ my $deps = $self->admin->scan_dependencies($mod) or return; ++ foreach my $key ( sort grep { $_ } keys %$deps ) { ++ $self->include_dependent_dists($key); ++ } ++ } ++} ++ ++=pod ++ ++=head2 include_one_dist $module ++ ++Given a module name, C<$module>, figures out which modules are in the ++dist containing that module and copies all those files to ./inc. I bet ++there's a way to harness smarter logic from L. ++ ++=cut ++ ++sub include_one_dist { ++ my $self = shift; ++ my @mods = $self->_dist_to_mods( $self->_pkg_to_dist($_[0]) ); ++ foreach my $pattern ( grep { $_ } @mods ) { ++ foreach my $rv ( $self->admin->glob_in_inc($pattern) ) { ++ $self->admin->copy_package(@$rv); ++ } ++ } ++} ++ ++=pod ++ ++=for private _pkg_to_dist $modname ++ ++Given a module name, returns the file on CPAN containing ++its latest version. ++ ++=cut ++ ++sub _pkg_to_dist { ++ require CPAN; ++ my $mod = CPAN::Shell->expand( Module => $_[1] ) or return; ++ $mod->cpan_file; ++} ++ ++=pod ++ ++=for private _dist_to_mods $distname ++ ++Takes the output of CPAN::Module->cpan_file and return all the modules ++that CPAN.pm knows are in that dist. There's probably a beter way using CPANPLUS ++ ++=cut ++ ++sub _dist_to_mods { ++ CPAN::Shell->expand( Distribution => $_[1] )->containsmods; ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Makefile.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Makefile.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Makefile.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Makefile.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,53 @@ ++package Module::Install::Admin::Makefile; ++ ++use strict 'vars'; ++use Module::Install::Base; ++use ExtUtils::MakeMaker (); ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++sub postamble { ++ my ($self, $text) = @_; ++ my $class = ref($self); ++ my $top_class = ref($self->_top); ++ my $admin_class = join('::', @{$self->_top}{qw(name dispatch)}); ++ ++ $self->{postamble} ||= << "END_MAKEFILE"; ++# --- $class section: ++ ++realclean purge :: ++\t\$(RM_F) \$(DISTVNAME).tar\$(SUFFIX) ++\t\$(RM_F) MANIFEST.bak _build ++\t\$(PERL) "-Ilib" "-M$admin_class" -e "remove_meta()" ++\t\$(RM_RF) inc ++ ++reset :: purge ++ ++upload :: test dist ++\tcpan-upload -verbose \$(DISTVNAME).tar\$(SUFFIX) ++ ++grok :: ++\tperldoc $top_class ++ ++distsign :: ++\tcpansign -s ++ ++END_MAKEFILE ++ ++ $self->{postamble} .= $text if defined $text; ++ return $self->{postamble}; ++} ++ ++sub preop { ++ my $self = shift; ++ my ($user_preop) = @_; ++ my $admin_class = join('::', @{$self->_top}{qw(name dispatch)}); ++ $user_preop = qq{\$(PERL) -I. "-M$admin_class" -e "dist_preop(q(\$(DISTVNAME)))"} unless $user_preop; ++ return { PREOP => $user_preop }; ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Manifest.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Manifest.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Manifest.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Manifest.pm 2009-05-27 18:46:14.000000000 +0200 +@@ -0,0 +1,162 @@ ++package Module::Install::Admin::Manifest; ++ ++use strict; ++use Module::Install::Base; ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++use Cwd; ++use File::Spec; ++ ++# XXX I really want this method in Module::Install::Admin::Makefile ++# But you can't call across Admin modules. Audrey?? ++sub dist_preop { ++ my ($self, $distdir) = @_; ++ return if $self->check_manifest; ++ print <<"END_MESSAGE"; ++ ++It appears that your MANIFEST does not contain the same components that ++are currently in the 'inc' directory. ++ ++Please try running 'make manifest' and then run 'make dist' again. ++ ++Remember to use the MANIFEST.SKIP file to control things that should not ++end up in your MANIFEST. See 'perldoc ExtUtils::Manifest' for details. ++ ++END_MESSAGE ++ return if $self->prompt( ++ 'Do you *really* want to continue making a distribution?', 'n' ++ ) =~ /^[Yy]/; ++ ++ if ( -d $distdir ) { ++ require File::Path; ++ File::Path::rmtree($distdir); ++ } ++ ++ exit(1); ++} ++ ++# XXX Needs a refactoring. ++sub check_manifest { ++ my $self = shift; ++ my $prefix = $self->_top->{prefix}; ++ my ($manifest, $manifest_path, $relative_path) = $self->_read_manifest or return; ++ my $manifest_skip = "$manifest_path.SKIP"; ++ my @skip; ++ ++ if ( -f "$manifest_path.SKIP" ) { ++ open SKIP, $manifest_skip ++ or die "Can't open $manifest_skip for input:\n$!"; ++ @skip = map {chomp; $_} ; ++ close SKIP; ++ } ++ ++ my %manifest; ++ for ( my $i = 0; $i < @$manifest; $i++ ) { ++ my $path = $manifest->[$i]; ++ $path =~ s/\s.*//; ++ $path =~ s/^\.[\\\/]//; ++ $path =~ s/[\\\/]/\//g; ++ next unless $path =~ m/^\Q$prefix\E\b/i; ++ $manifest{$path} = \$manifest->[$i]; ++ } ++ ++ ADDLOOP: ++ for my $pathname ( sort $self->_find_files($prefix) ) { ++ $pathname = "$relative_path/$pathname" if length($relative_path); ++ $pathname =~ s!//+!/!g; ++ next unless -f $pathname; ++ if ( defined $manifest{$pathname} ) { ++ delete $manifest{$pathname}; ++ } else { ++ for ( @skip ) { ++ next ADDLOOP if $pathname =~ /$_/; ++ } ++ return 0; ++ } ++ } ++ if ( keys %manifest ) { ++ foreach ( keys %manifest ) { ++ print "Found extra file $_\n"; ++ } ++ return 0; ++ } ++ return 1; ++} ++ ++sub _read_manifest { ++ my $manifest = []; ++ my $manifest_path = ''; ++ my $relative_path = ''; ++ my @relative_dirs = (); ++ my $cwd = Cwd::cwd(); ++ my @cwd_dirs = File::Spec->splitdir($cwd); ++ while ( @cwd_dirs ) { ++ last unless -f File::Spec->catfile(@cwd_dirs, 'Makefile.PL'); ++ my $path = File::Spec->catfile(@cwd_dirs, 'MANIFEST'); ++ if ( -f $path ) { ++ $manifest_path = $path; ++ last; ++ } ++ unshift @relative_dirs, pop(@cwd_dirs); ++ } ++ ++ unless ( length($manifest_path) ) { ++ warn "Can't locate the MANIFEST file for '$cwd'\n"; ++ return; ++ } ++ ++ $relative_path = join '/', @relative_dirs if @relative_dirs; ++ ++ local *MANIFEST; ++ open MANIFEST, $manifest_path ++ or die "Can't open $manifest_path for input:\n$!"; ++ @$manifest = map { chomp; $_ } ; ++ close MANIFEST; ++ ++ return ($manifest, $manifest_path, $relative_path); ++} ++ ++# XXX I copied this from M::I::A::Find because I can't call that one. Please ++# refactor/fix. ++sub _find_files { ++ my ($self, $file, $path) = @_; ++ $path = '' if not defined $path; ++ $file = "$path/$file" if length($path); ++ if ( -f $file ) { ++ return ( $file ); ++ } elsif ( -d $file ) { ++ my @files = (); ++ local *DIR; ++ opendir(DIR, $file) or die "Can't opendir $file"; ++ while (defined(my $new_file = readdir(DIR))) { ++ next if $new_file =~ /^(\.|\.\.)$/; ++ push @files, $self->_find_files($new_file, $file); ++ } ++ return @files; ++ } ++ return (); ++} ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 COPYRIGHT ++ ++Copyright 2003, 2004 by ++Audrey Tang Eautrijus@autrijus.orgE, ++Brian Ingerson Eingy@cpan.orgE ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Metadata.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Metadata.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/Metadata.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/Metadata.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,185 @@ ++package Module::Install::Admin::Metadata; ++ ++use strict; ++use YAML::Tiny (); ++use Module::Install::Base; ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = 'Module::Install::Base'; ++} ++ ++sub read_meta { ++ (YAML::Tiny::LoadFile('META.yml'))[0]; ++} ++ ++sub meta_generated_by_us { ++ my $meta = $_[0]->read_meta; ++ my $want = ref($_[0]->_top); ++ if ( defined $_[1] ) { ++ $want .= " version $_[1]"; ++ } ++ return $meta->{generated_by} =~ /^\Q$want\E/; ++} ++ ++sub remove_meta { ++ my $self = shift; ++ my $ver = $self->_top->VERSION; ++ return unless -f 'META.yml'; ++ return unless $self->meta_generated_by_us($ver); ++ unless ( -w 'META.yml' ) { ++ warn "Can't remove META.yml file. Not writable.\n"; ++ return; ++ } ++ # warn "Removing auto-generated META.yml\n"; ++ unless ( unlink 'META.yml' ) { ++ die "Couldn't unlink META.yml:\n$!"; ++ } ++ return; ++} ++ ++sub write_meta { ++ my $self = shift; ++ if ( -f "META.yml" ) { ++ return unless $self->meta_generated_by_us(); ++ } else { ++ $self->clean_files('META.yml'); ++ } ++ print "Writing META.yml\n"; ++ Module::Install::_write("META.yml", $self->dump_meta); ++ return; ++} ++ ++sub dump_meta { ++ my $self = shift; ++ my $pkg = ref( $self->_top ); ++ my $ver = $self->_top->VERSION; ++ my $val = $self->Meta->{values}; ++ ++ delete $val->{sign}; ++ ++ my $perl_version = delete $val->{perl_version}; ++ if ( $perl_version ) { ++ $val->{requires} ||= []; ++ my $requires = $val->{requires}; ++ ++ # Issue warnings for unversioned core modules that are ++ # already satisfied by the Perl version dependency. ++ require Module::CoreList; ++ my $corelist = $Module::CoreList::version{$perl_version}; ++ if ( $corelist ) { ++ my @bad = grep { exists $corelist->{$_} } ++ map { $_->[0] } ++ grep { ! $_->[1] } ++ @$requires; ++ foreach ( @bad ) { ++ # print "WARNING: Unversioned dependency on '$_' is pointless when Perl minimum version is $perl_version\n"; ++ } ++ } ++ ++ # Canonicalize to three-dot version after Perl 5.6 ++ if ( $perl_version >= 5.006 ) { ++ $perl_version =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2||0), int($3||0))}e ++ } ++ unshift @$requires, [ perl => $perl_version ]; ++ } ++ ++ # Set a default 'unknown' license ++ unless ( $val->{license} ) { ++ warn "No license specified, setting license = 'unknown'\n"; ++ $val->{license} = 'unknown'; ++ } ++ ++ # Most distributions are modules ++ $val->{distribution_type} ||= 'module'; ++ ++ # Check and derive names ++ if ( $val->{name} =~ /::/ ) { ++ my $name = $val->{name}; ++ $name =~ s/::/-/g; ++ die "Error in name(): '$val->{name}' should be '$name'!\n"; ++ } ++ if ( $val->{module_name} and ! $val->{name} ) { ++ $val->{name} = $val->{module_name}; ++ $val->{name} =~ s/::/-/g; ++ } ++ ++ # Apply default no_index entries ++ $val->{no_index} ||= {}; ++ $val->{no_index}->{directory} ||= []; ++ SCOPE: { ++ my %seen = (); ++ $val->{no_index}->{directory} = [ ++ sort ++ grep { not $seen{$_}++ } ++ grep { -d $_ } ( ++ @{$val->{no_index}->{directory}}, ++ qw{ ++ share inc t xt test ++ example examples demo ++ }, ++ ) ++ ]; ++ } ++ ++ # Generate the structure we'll be dumping ++ my $meta = { ++ resources => {}, ++ license => $val->{license}, ++ }; ++ foreach my $key ( $self->Meta_ScalarKeys ) { ++ next if $key eq 'installdirs'; ++ next if $key eq 'tests'; ++ $meta->{$key} = $val->{$key} if exists $val->{$key}; ++ } ++ foreach my $key ( $self->Meta_ArrayKeys ) { ++ $meta->{$key} = $val->{$key} if exists $val->{$key}; ++ } ++ foreach my $key ( $self->Meta_TupleKeys ) { ++ next unless exists $val->{$key}; ++ $meta->{$key} = { map { @$_ } @{ $val->{$key} } }; ++ } ++ ++ if ( $self->_cmp( $meta->{configure_requires}->{'ExtUtils::MakeMaker'}, '6.36' ) >= 0 ) { ++ # Starting from this version ExtUtils::MakeMaker requires perl 5.6 ++ unless ( $perl_version && $self->perl_version($perl_version) >= 5.006 ) { ++ $meta->{requires}->{perl} = '5.006'; ++ } ++ } ++ ++ $meta->{provides} = $val->{provides} if $val->{provides}; ++ $meta->{author} &&= [ $meta->{author} ]; ++ $meta->{no_index} = $val->{no_index}; ++ $meta->{generated_by} = "$pkg version $ver"; ++ $meta->{'meta-spec'} = { ++ version => 1.4, ++ url => 'http://module-build.sourceforge.net/META-spec-v1.4.html', ++ }; ++ unless ( scalar keys %{$meta->{resources}} ) { ++ delete $meta->{resources}; ++ } ++ ++ # Support version.pm versions ++ if ( UNIVERSAL::isa($meta->{version}, 'version') ) { ++ $meta->{version} = $meta->{version}->numify; ++ } ++ ++ YAML::Tiny::Dump($meta); ++} ++ ++ ++ ++ ++ ++###################################################################### ++# MYMETA.yml Support ++ ++sub WriteMyMeta { ++ my $self = shift; ++ $self->configure_requires( 'YAML::Tiny' => 1.36 ); ++ $self->write_mymeta; ++ return 1; ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/ScanDeps.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/ScanDeps.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/ScanDeps.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/ScanDeps.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,80 @@ ++package Module::Install::Admin::ScanDeps; ++ ++use strict; ++use Module::Install::Base (); ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw(Module::Install::Base); ++} ++ ++sub scan_dependencies { ++ my ($self, $pkg, $perl_version) = @_; ++ ++ return if $pkg eq 'perl'; ++ ++ $perl_version ||= $self->perl_version or die <<'END_MESSAGE'; ++Please first specify a required perl version, like this: ++ requires( perl => '5.005' ); ++END_MESSAGE ++ $perl_version =~ s{^(\d+)\.(\d+)\.(\d+)}{$1 + $2/1_000 + $3/1_000_000}e; ++ ++ require Module::ScanDeps; ++ require Module::CoreList; ++ ++ die "Module::CoreList has no information on perl $perl_version" ++ unless exists $Module::CoreList::version{$perl_version}; ++ ++ if (my $min_version = Module::CoreList->first_release($pkg)) { ++ return if $min_version <= $perl_version; ++ } ++ ++ my @files = scalar $self->admin->find_in_inc($pkg) ++ or die "Cannot find $pkg in \@INC"; ++ my %result = ($pkg => $files[0]); ++ ++ while (@files) { ++ my $deps = Module::ScanDeps::scan_deps( ++ files => \@files, ++ recurse => 0, ++ ); ++ ++ @files = (); ++ ++ foreach my $key (keys %$deps) { ++ if ($deps->{$key}{type} eq 'shared') { ++ foreach my $used_by (@{$deps->{$key}{used_by}}) { ++ $used_by =~ s!/!::!g; ++ $used_by =~ s!\.pm\Z!!i or next; ++ next if exists $result{$used_by}; ++ $result{$used_by} = undef; ++ my $min_version = Module::CoreList->first_release($used_by); ++ print "skipped $used_by (needs shared library)\n" ++ unless !$min_version || $min_version <= $perl_version; ++ } ++ } ++ } ++ ++ foreach my $key (keys %$deps) { ++ my $dep_pkg = $key; ++ $dep_pkg =~ s!/!::!g; ++ $dep_pkg =~ s!\.pm\Z!!i or next; ++ ++ if (my $min_version = Module::CoreList->first_release($dep_pkg)) { ++ next if $min_version <= $perl_version; ++ } ++ next if $dep_pkg =~ /^(?:DB|(?:Auto|Dyna|XS)Loader|threads|warnings)\b/i; ++ next if exists $result{$dep_pkg}; ++ ++ $result{$dep_pkg} = $deps->{$key}{file}; ++ push @files, $deps->{$key}{file}; ++ } ++ } ++ ++ while (my($k,$v) = each %result) { ++ delete $result{$k} unless defined $v; ++ } ++ return \%result; ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/WriteAll.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/WriteAll.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin/WriteAll.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin/WriteAll.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,20 @@ ++package Module::Install::Admin::WriteAll; ++ ++use strict; ++use Module::Install::Base; ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91';; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++sub WriteAll { ++ my ($self, %args) = @_; ++ $self->load('Makefile'); ++ if ( $args{check_nmake} ) { ++ $self->load($_) for qw(Makefile check_nmake can_run get_file); ++ } ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Admin.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Admin.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,294 @@ ++package Module::Install::Admin; ++ ++use strict 'vars'; ++use File::Path (); ++use inc::Module::Install (); ++ ++use vars qw{$VERSION @ISA}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install'; ++} ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::Admin - Author-side manager for Module::Install ++ ++=head1 SYNOPSIS ++ ++In a B extension module: ++ ++ sub extension_method { ++ my $self = shift; ++ $self->admin->some_method(@args); ++ } ++ ++As an one-liner: ++ ++ % perl "-MModule::Install::Admin" -e'&some_method(@args);' ++ ++The two snippets above are really shorthands for ++ ++ $some_obj->some_method(@args) ++ ++where C<$some_obj> is the singleton object of a class under the ++C namespace that provides the method ++C. See L for a list of built-in methods. ++ ++=head1 DESCRIPTION ++ ++This module implements the internal mechanism for initializing, ++including and managing extensions, and should only be of interest to ++extension developers; it is I included under a distribution's ++F directory, nor are any of the B ++extensions. ++ ++For normal usage of B, please see L ++and L instead. ++ ++=head2 Bootstrapping ++ ++When someone runs a F that has C, ++and there is no F in the current directory, B ++will load this module bootstrap itself, through the steps below: ++ ++=over 4 ++ ++=item * ++ ++First, F is POD-stripped and copied from C<@INC> to ++F. This should only happen on the author's side, never on the ++end-user side. ++ ++=item * ++ ++Reload F if the current file is somewhere else. ++This ensures that the included version of F is ++always preferred over the installed version. ++ ++=item * ++ ++Look at F and load all of them. ++ ++=item * ++ ++Set up a C function to delegate missing function calls ++to C -- again, this should only happen ++at the author's side. ++ ++=item * ++ ++Provide a C function for removing included ++files under F. ++ ++=back ++ ++=head1 METHODS ++ ++=cut ++ ++sub import { ++ my $class = shift; ++ my $self = $class->new( _top => Module::Install->new, @_ ); ++ *{caller(0) . "::AUTOLOAD"} = sub { ++ no strict 'vars'; ++ $AUTOLOAD =~ /([^:]+)$/ or die "Cannot load"; ++ return if uc($1) eq $1; ++ my $obj = $self->load($1) or return; ++ unshift @_, $obj; ++ goto &{$obj->can($1)}; ++ } ++} ++ ++sub new { ++ my ($class, %args) = @_; ++ return $class->SUPER::new( ++ %{$args{_top}}, %args, ++ extensions => undef, ++ pathnames => undef, ++ ); ++} ++ ++sub init { ++ my $self = shift; ++ ++ $self->copy($INC{"$self->{path}.pm"} => $self->{file}); ++ ++ unless ( grep { $_ eq $self->{prefix} } @INC ) { ++ unshift @INC, $self->{prefix}; ++ } ++ ++ delete $INC{"$self->{path}.pm"}; ++ local $^W; ++ do "$self->{path}.pm"; ++} ++ ++sub copy { ++ my ($self, $from, $to) = @_; ++ ++ my @parts = split('/', $to); ++ File::Path::mkpath([ join('/', @parts[ 0 .. $#parts-1 ])]); ++ ++ chomp $to; ++ ++ local (*FROM, *TO, $_); ++ open FROM, "< $from" or die "Can't open $from for input:\n$!"; ++ open TO, "> $to" or die "Can't open $to for output:\n$!"; ++ print TO "#line 1\n"; ++ ++ my $content; ++ my $in_pod; ++ ++ while ( ) { ++ if ( /^=(?:b(?:egin|ack)|head\d|(?:po|en)d|item|(?:ove|fo)r)/ ) { ++ $in_pod = 1; ++ } elsif ( /^=cut\s*\z/ and $in_pod ) { ++ $in_pod = 0; ++ print TO "#line $.\n"; ++ } elsif ( ! $in_pod ) { ++ print TO $_; ++ } ++ } ++ ++ close FROM; ++ close TO; ++ ++ print "include $to\n"; ++} ++ ++# scan through our target to find ++sub load_all_extensions { ++ my $self = shift; ++ unless ($self->{extensions}) { ++ $self->{extensions} = []; ++ foreach my $inc (@INC) { ++ next if ref($inc) or $inc eq $self->{prefix}; ++ $self->load_extensions("$inc/$self->{path}", $self->{_top}); ++ } ++ } ++ return @{$self->{extensions}}; ++} ++ ++sub load { ++ my ($self, $method, $copy) = @_; ++ ++ my @extobj; ++ foreach my $obj ($self->load_all_extensions) { ++ next unless defined &{ref($obj)."::$method"}; ++ my $is_admin = (ref($obj) =~ /^\Q$self->{name}::$self->{dispatch}::/); ++ # Don't ever include admin modules, and vice versa. ++ # $copy = 0 if $XXX and $is_admin; ++ push @extobj, $obj if $copy xor $is_admin; ++ } ++ unless ( @extobj ) { ++ die "Cannot find an extension with method '$method'"; ++ } ++ ++ # XXX - do we need to reload $obj from the new location? ++ my $obj = $self->pick($method, \@extobj); ++ $self->copy_package(ref($obj)) if $copy; ++ ++ return $obj; ++} ++ ++# Copy a package to inc/, with its @ISA tree. $pathname is optional. ++sub copy_package { ++ my ($self, $pkg, $pathname) = @_; ++ return unless ($pathname ||= $self->{pathnames}{$pkg}); ++ ++ my $file = $pkg; $file =~ s!::!/!g; ++ $file = "$self->{prefix}/$file.pm"; ++ return if -f $file; # prevents infinite recursion ++ ++ $self->copy($pathname => $file); ++ foreach my $pkg (@{"$pkg\::ISA"}) { ++ $self->copy_package($pkg); ++ } ++} ++ ++sub pick { ++ # determine which name to load ++ my ($self, $method, $objects) = @_; ++ ++ # XXX this whole thing needs to be discussed ++ return $objects->[0] unless $#{$objects} > 0 and -t STDIN; ++ ++ # sort by last modified time ++ @$objects = map { $_->[0] } ++ sort { $a->[1] <=> $b->[1] } ++ map { [ $_ => -M $self->{pathnames}{ref($_)} ] } @$objects; ++ ++ print "Multiple extensions found for method '$method':\n"; ++ foreach my $i ( 1 .. @$objects ) { ++ print "\t$i. ", ref($objects->[$i-1]), "\n"; ++ } ++ ++ while ( 1 ) { ++ print "Please select one [1]: "; ++ chomp(my $choice = ); ++ $choice ||= 1; ++ return $objects->[$choice-1] if $choice > 0 and $choice <= @$objects; ++ print "Invalid choice. "; ++ } ++} ++ ++sub delete_package { ++ my ($self, $pkg) = @_; ++ ++ # expand to full symbol table name if needed ++ unless ( $pkg =~ /^main::.*::$/ ) { ++ $pkg = "main$pkg" if $pkg =~ /^::/; ++ $pkg = "main::$pkg" unless $pkg =~ /^main::/; ++ $pkg .= '::' unless $pkg =~ /::$/; ++ } ++ ++ my($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/; ++ my $stem_symtab = *{$stem}{HASH}; ++ return unless defined $stem_symtab and exists $stem_symtab->{$leaf}; ++ ++ # free all the symbols in the package ++ my $leaf_symtab = *{$stem_symtab->{$leaf}}{HASH}; ++ foreach my $name (keys %$leaf_symtab) { ++ next if $name eq "$self->{dispatch}::"; ++ undef *{$pkg . $name}; ++ } ++ ++ # delete the symbol table ++ foreach my $name (keys %$leaf_symtab) { ++ next if $name eq "$self->{dispatch}::"; ++ delete $leaf_symtab->{$name}; ++ } ++} ++ ++sub AUTOLOAD { ++ goto &{shift->autoload}; ++} ++ ++sub DESTROY { } ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 SEE ALSO ++ ++L ++ ++=head1 AUTHORS ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++=head1 COPYRIGHT ++ ++Copyright 2003, 2004 by Audrey Tang Eautrijus@autrijus.orgE. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/AutoInstall.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/AutoInstall.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/AutoInstall.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/AutoInstall.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,14 +1,13 @@ +-#line 1 + package Module::Install::AutoInstall; + + use strict; +-use Module::Install::Base; ++use Module::Install::Base (); + +-use vars qw{$VERSION $ISCORE @ISA}; ++use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; +- @ISA = qw{Module::Install::Base}; + } + + sub AutoInstall { $_[0] } +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Base.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Base.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Base.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Base.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,10 +1,9 @@ +-#line 1 + package Module::Install::Base; + + use strict 'vars'; + use vars qw{$VERSION}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91'; + } + + # Suspend handler for "redefined" warnings +@@ -13,42 +12,82 @@ + $SIG{__WARN__} = sub { $w }; + } + +-### This is the ONLY module that shouldn't have strict on +-# use strict; ++=pod + +-#line 45 ++=head1 NAME + +-sub new { +- my ($class, %args) = @_; ++Module::Install::Base - Base class for Module::Install extensions + +- foreach my $method ( qw(call load) ) { +- next if defined &{"$class\::$method"}; +- *{"$class\::$method"} = sub { +- shift()->_top->$method(@_); +- }; +- } ++=head1 SYNOPSIS ++ ++In a B extension: ++ ++ use Module::Install::Base (); ++ @ISA = qw(Module::Install::Base); ++ ++=head1 DESCRIPTION ++ ++This module provide essential methods for all B ++extensions, in particular the common constructor C and method ++dispatcher C. ++ ++=head1 METHODS ++ ++=over 4 ++ ++=item new(%args) + +- bless( \%args, $class ); ++Constructor -- need to preserve at least _top ++ ++=cut ++ ++sub new { ++ my $class = shift; ++ unless ( defined &{"${class}::call"} ) { ++ *{"${class}::call"} = sub { shift->_top->call(@_) }; ++ } ++ unless ( defined &{"${class}::load"} ) { ++ *{"${class}::load"} = sub { shift->_top->load(@_) }; ++ } ++ bless { @_ }, $class; + } + +-#line 66 ++=pod ++ ++=item AUTOLOAD ++ ++The main dispatcher - copy extensions if missing ++ ++=cut + + sub AUTOLOAD { +- my $self = shift; + local $@; +- my $autoload = eval { +- $self->_top->autoload +- } or return; +- goto &$autoload; ++ my $func = eval { shift->_top->autoload } or return; ++ goto &$func; + } + +-#line 83 ++=pod ++ ++=item _top() ++ ++Returns the top-level B object. ++ ++=cut + + sub _top { + $_[0]->{_top}; + } + +-#line 98 ++=pod ++ ++=item admin() ++ ++Returns the C<_top> object's associated B object ++on the first run (i.e. when there was no F when the program ++started); on subsequent (user-side) runs, returns a fake admin object ++with an empty C method that does nothing at all. ++ ++=cut + + sub admin { + $_[0]->_top->{admin} +@@ -56,7 +95,15 @@ + Module::Install::Base::FakeAdmin->new; + } + +-#line 114 ++=pod ++ ++=item is_admin() ++ ++Tells whether this is the first run of the installer (on ++author's side). That is when there was no F at ++program start. True if that's the case. False, otherwise. ++ ++=cut + + sub is_admin { + $_[0]->admin->VERSION; +@@ -83,4 +130,25 @@ + + 1; + +-#line 162 ++=pod ++ ++=back ++ ++=head1 SEE ALSO ++ ++L ++ ++=head1 AUTHORS ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++=head1 COPYRIGHT ++ ++Copyright 2003, 2004 by Audrey Tang Eautrijus@autrijus.orgE. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Bundle.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Bundle.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Bundle.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Bundle.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,195 @@ ++package Module::Install::Bundle; ++ ++use strict; ++use Cwd (); ++use File::Find (); ++use File::Copy (); ++use File::Basename (); ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++sub auto_bundle { ++ my $self = shift; ++ ++ # Flatten array of arrays into a single array ++ my @core = map @$_, map @$_, grep ref, $self->requires; ++ ++ $self->bundle(@core); ++} ++ ++sub bundle { ++ my $self = shift; ++ $self->admin->bundle(@_) if $self->is_admin; ++ ++ my $cwd = Cwd::cwd(); ++ my $bundles = $self->read_bundles; ++ my $bundle_dir = $self->_top->{bundle}; ++ $bundle_dir =~ s/\W+/\\W+/g; ++ ++ while (my ($name, $version) = splice(@_, 0, 2)) { ++ $version ||= 0; ++ ++ my $source = $bundles->{$name} or die "Cannot find bundle source for $name"; ++ my $target = File::Basename::basename($source); ++ $self->bundles($name, $target); ++ ++ next if eval "use $name $version; 1"; ++ mkdir $target or die $! unless -d $target; ++ ++ # XXX - clean those directories upon "make clean"? ++ File::Find::find({ ++ wanted => sub { ++ my $out = $_; ++ $out =~ s/$bundle_dir/./i; ++ mkdir $out if -d; ++ File::Copy::copy($_ => $out) unless -d; ++ }, ++ no_chdir => 1, ++ }, $source); ++ } ++ ++ chdir $cwd; ++} ++ ++sub read_bundles { ++ my $self = shift; ++ my %map; ++ ++ local *FH; ++ open FH, $self->_top->{bundle} . ".yml" or return {}; ++ while () { ++ /^(.*?): (['"])?(.*?)\2$/ or next; ++ $map{$1} = $3; ++ } ++ close FH; ++ ++ return \%map; ++} ++ ++ ++sub auto_bundle_deps { ++ my $self = shift; ++ ++ # Flatten array of arrays into a single array ++ my @core = map @$_, map @$_, grep ref, $self->requires; ++ while (my ($name, $version) = splice(@core, 0, 2)) { ++ next unless $name; ++ $self->bundle_deps($name, $version); ++ $self->bundle($name, $version); ++ } ++} ++ ++sub bundle_deps { ++ my ($self, $pkg, $version) = @_; ++ my $deps = $self->admin->scan_dependencies($pkg) or return; ++ ++ foreach my $key (sort keys %$deps) { ++ $self->bundle($key, ($key eq $pkg) ? $version : 0); ++ } ++} ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::Bundle - Bundle distributions along with your distribution ++ ++=head1 SYNOPSIS ++ ++Have your Makefile.PL read as follows: ++ ++ use inc::Module::Install; ++ ++ name 'Foo-Bar'; ++ all_from 'lib/Foo/Bar.pm'; ++ requires 'Baz' => '1.60'; ++ ++ # one of either: ++ bundle 'Baz' => '1.60'; ++ # OR: ++ auto_bundle; ++ ++ WriteAll; ++ ++=head1 DESCRIPTION ++ ++Module::Install::Bundle allows you to bundle a CPAN distribution within your ++distribution. When your end-users install your distribution, the bundled ++distribution will be installed along with yours, unless a newer version of ++the bundled distribution already exists on their local filesystem. ++ ++While bundling will increase the size of your distribution, it has several ++benefits: ++ ++ Allows installation of bundled distributions when CPAN is unavailable ++ Allows installation of bundled distributions when networking is unavailable ++ Allows everything your distribution needs to be packaged in one place ++ ++Bundling differs from auto-installation in that when it comes time to ++install, a bundled distribution will be installed based on the distribution ++bundled with your distribution, whereas with auto-installation the distibution ++to be installed will be acquired from CPAN and then installed. ++ ++=head1 METHODS ++ ++=over 4 ++ ++=item * auto_bundle() ++ ++Takes no arguments, will bundle every distribution specified by a C. ++When you, as a module author, do a C the latest versions of ++the distributions to be bundled will be acquired from CPAN and placed in ++F. ++ ++=item * bundle($name, $version) ++ ++Takes a list of key/value pairs specifying a distribution name and version ++number. When you, as a module author, do a perl Makefile.PL the distributions ++that you specified with C will be acquired from CPAN and placed in ++F. ++ ++=item * bundle_deps($name, $version) ++ ++Same as C, except that all dependencies of the bundled modules are ++also detected and bundled. To use this function, you need to declare the ++minimum supported perl version first, like this: ++ ++ requires( perl => 5.005 ); ++ ++=item * auto_bundle_deps ++ ++Same as C, except that all dependencies of the bundled ++modules are also detected and bundled. This function has the same constraints as bundle_deps. ++ ++=back ++ ++=head1 BUGS ++ ++Please report any bugs to (patches welcome): ++ ++ http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Module-Install ++ ++=head1 AUTHORS ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++Documentation by Adam Foxson Eafoxson@pobox.comE ++ ++=head1 COPYRIGHT ++ ++Copyright 2003, 2004, 2005 by Audrey Tang Eautrijus@autrijus.orgE. ++ ++This program is free software; you can redistribute it and/or modify it under ++the same terms as Perl itself. ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Can.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Can.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Can.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Can.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,17 +1,16 @@ +-#line 1 + package Module::Install::Can; + + use strict; +-use Module::Install::Base; +-use Config (); +-use File::Spec (); +-use ExtUtils::MakeMaker (); ++use Config (); ++use File::Spec (); ++use ExtUtils::MakeMaker (); ++use Module::Install::Base (); + +-use vars qw{$VERSION $ISCORE @ISA}; ++use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; +- @ISA = qw{Module::Install::Base}; + } + + # check if we can load some module +@@ -78,4 +77,80 @@ + + __END__ + +-#line 156 ++=pod ++ ++=head1 NAME ++ ++Module::Install::Can - Utility functions for capability detection ++ ++=head1 DESCRIPTION ++ ++C contains a number of functions for authors to use ++when creating customised smarter installers. The functions simplify ++standard tests so that you can express your dependencies and conditions ++much more simply, and make your installer much easier to maintain. ++ ++=head1 COMMANDS ++ ++=head2 can_use ++ ++ can_use('Module::Name'); ++ can_use('Module::Name', 1.23); ++ ++The C function tests the ability to load a specific named ++module. Currently it will also actually load the module in the ++process, although this may change in the future. ++ ++Takes an optional second param of a version number. The currently ++installed version of the module will be tested to make sure it is ++equal to or greater than the specified version. ++ ++Returns true if the module can be loaded, or false (in both scalar or ++list context) if not. ++ ++=head2 can_run ++ ++ can_run('cvs'); ++ ++The C function tests the ability to run a named command or ++program on the local system. ++ ++Returns true if so, or false (both in scalar and list context) if not. ++ ++=head2 can_cc ++ ++ can_cc(); ++ ++The C function test the ability to locate a C compiler on the ++local system. Returns true if the C compiler can be found, or false ++(both in scalar and list context) if not. ++ ++=head1 TO DO ++ ++Currently, the use of a C command in a single problem domain ++(for example C) results in the inclusion of additional ++functionality from different problem domains (for example C). ++ ++This module should ultimately be broken up, and the individual ++functions redestributed to different domain-specific extensions. ++ ++=head1 AUTHORS ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++=head1 SEE ALSO ++ ++L, L ++ ++=head1 COPYRIGHT ++ ++Copyright 2006 Audrey Tang, Adam Kennedy. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Compiler.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Compiler.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Compiler.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Compiler.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,123 @@ ++package Module::Install::Compiler; ++ ++use strict; ++use File::Basename (); ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++sub ppport { ++ my $self = shift; ++ if ( $self->is_admin ) { ++ return $self->admin->ppport(@_); ++ } else { ++ # Fallback to just a check ++ my $file = shift || 'ppport.h'; ++ unless ( -f $file ) { ++ die "Packaging error, $file is missing"; ++ } ++ } ++} ++ ++sub cc_files { ++ require Config; ++ my $self = shift; ++ $self->makemaker_args( ++ OBJECT => join ' ', map { substr($_, 0, -2) . $Config::Config{_o} } @_ ++ ); ++} ++ ++sub cc_inc_paths { ++ my $self = shift; ++ $self->makemaker_args( ++ INC => join ' ', map { "-I$_" } @_ ++ ); ++} ++ ++sub cc_lib_paths { ++ my $self = shift; ++ $self->makemaker_args( ++ LIBS => join ' ', map { "-L$_" } @_ ++ ); ++} ++ ++sub cc_lib_links { ++ my $self = shift; ++ $self->makemaker_args( ++ LIBS => join ' ', $self->makemaker_args->{LIBS}, map { "-l$_" } @_ ++ ); ++} ++ ++sub cc_optimize_flags { ++ my $self = shift; ++ $self->makemaker_args( ++ OPTIMIZE => join ' ', @_ ++ ); ++} ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::Compiler - Commands for interacting with the C compiler ++ ++=head1 SYNOPSIS ++ ++ To be completed ++ ++=head1 DESCRIPTION ++ ++Many Perl modules that contains C and XS code have fiendishly complex ++F files, because L doesn't itself provide ++a huge amount of assistance and automation in this area. ++ ++B provides a number of commands that take care ++of common utility tasks, and try to take some of intricacy out of creating ++C and XS modules. ++ ++=head1 COMMANDS ++ ++To be completed ++ ++=head1 TO DO ++ ++The current implementation is relatively fragile and minimalistic. ++ ++It only handles some very basic wrapper around L. ++ ++It is currently undergoing extensive refactoring to provide a more ++generic compiler flag generation capability. This may take some time, ++and if anyone who maintains a Perl module that makes use of the compiler ++would like to help out, your assistance would be greatly appreciated. ++ ++=head1 SEE ALSO ++ ++L, L ++ ++=head1 AUTHORS ++ ++Refactored by Adam Kennedy Eadamk@cpan.orgE ++ ++Mostly by Audrey Tang Eautrijus@autrijus.orgE ++ ++Based on original works by Brian Ingerson Eingy@cpan.orgE ++ ++=head1 COPYRIGHT ++ ++Copyright 2002, 2003, 2004, 2006 by Adam Kennedy, Audrey Tang, Brian Ingerson. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Deprecated.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Deprecated.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Deprecated.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Deprecated.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,115 @@ ++package Module::Install::Deprecated; ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++ ++ ++ ++ ++##################################################################### ++# Previous API for Module::Install::Compoler ++ ++sub c_files { ++ warn "c_files has been changed to cc_files to reduce confusion and keep all compiler commands as cc_"; ++ shift()->cc_files(@_); ++} ++ ++sub inc_paths { ++ warn "inc_paths has been changed to cc_inc_paths due to confusion between Perl and C"; ++ shift()->cc_inc_paths(@_); ++} ++ ++sub lib_paths { ++ warn "lib_paths has been changed to cc_lib_paths due to confusion between Perl and C"; ++ shift()->cc_lib_paths(@_); ++} ++ ++sub lib_links { ++ warn "lib_links has been changed to cc_lib_links due to confusion between Perl and C"; ++ shift()->cc_lib_links(@_); ++} ++ ++sub optimize_flags { ++ warn "optimize_flags has been changed to cc_optimize_flags for consistency reasons"; ++ shift()->cc_optimize_flags(@_); ++} ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::Deprecated - Warnings and help for deprecated commands ++ ++=head1 DESCRIPTION ++ ++One of the nicest features of L is that as it improves, ++there is no need to take into account user compatibility, because users do ++not need to install L itself. ++ ++As a result, the L API changes at a faster rate than usual, ++and this results in deprecated commands. ++ ++C provides implementations of the deprecated ++commands, so that when an author is upgrading their L and ++they are using a deprecated command they will be told that the command has ++been deprecated, and what the author should use instead. ++ ++This extension should NEVER end up bundled into the distribution tarball. ++ ++=head1 COMMANDS ++ ++=head2 c_files ++ ++The C command has been changed to C to reduce confusion ++and keep all compiler commands within a consistent C naming scheme. ++ ++=head2 inc_paths ++ ++The C command has been changed to C due to ++confusion between Perl and C. ++ ++=head2 lib_paths ++ ++The C command has been changed to C due to confusion ++between Perl and C. ++ ++=head2 lib_links ++ ++The C command has been changed to C due to confusion ++between Perl and C. ++ ++=head2 optimize_flags ++ ++The C command has been changed to C for ++consistency reasons. ++ ++=head1 AUTHORS ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++=head1 SEE ALSO ++ ++L ++ ++=head1 COPYRIGHT ++ ++Copyright 2006 Adam Kennedy. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/DSL.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/DSL.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/DSL.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/DSL.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,91 @@ ++package Module::Install::DSL; ++ ++use strict; ++use vars qw{$VERSION $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ $ISCORE = 1; ++ *inc::Module::Install::DSL::VERSION = *VERSION; ++ @inc::Module::Install::DSL::ISA = __PACKAGE__; ++} ++ ++sub import { ++ # Read in the rest of the Makefile.PL ++ open 0 or die "Couldn't open $0: $!"; ++ my $dsl; ++ SCOPE: { ++ local $/ = undef; ++ $dsl = join "", <0>; ++ } ++ ++ # Change inc::Module::Install::DSL to the regular one. ++ # Remove anything before the use inc::... line. ++ $dsl =~ s/.*?^\s*use\s+(?:inc::)?Module::Install::DSL(\b[^;]*);\s*\n//sm; ++ ++ # Load inc::Module::Install as we would in a regular Makefile.Pl ++ SCOPE: { ++ package main; ++ require inc::Module::Install; ++ inc::Module::Install->import; ++ } ++ ++ # Add the ::DSL plugin to the list of packages in /inc ++ my $admin = $Module::Install::MAIN->{admin}; ++ if ( $admin ) { ++ my $from = $INC{"$admin->{path}/DSL.pm"}; ++ my $to = "$admin->{base}/$admin->{prefix}/$admin->{path}/DSL.pm"; ++ $admin->copy( $from => $to ); ++ } ++ ++ # Convert the basic syntax to code ++ my $code = "package main;\n\n" ++ . dsl2code($dsl) ++ . "\n\nWriteAll();\n"; ++ ++ # Execute the script ++ eval $code; ++ print STDERR "Failed to execute the generated code" if $@; ++ ++ exit(0); ++} ++ ++sub dsl2code { ++ my $dsl = shift; ++ ++ # Split into lines and strip blanks ++ my @lines = grep { /\S/ } split /[\012\015]+/, $dsl; ++ ++ # Each line represents one command ++ my @code = (); ++ foreach my $line ( @lines ) { ++ # Split the lines into tokens ++ my @tokens = split /\s+/, $line; ++ ++ # The first word is the command ++ my $command = shift @tokens; ++ my @params = (); ++ my @suffix = (); ++ while ( @tokens ) { ++ my $token = shift @tokens; ++ if ( $token eq 'if' or $token eq 'unless' ) { ++ # This is the beginning of a suffix ++ push @suffix, $token; ++ push @suffix, @tokens; ++ last; ++ } else { ++ # Convert to a string ++ $token =~ s/([\\\'])/\\$1/g; ++ push @params, "'$token'"; ++ } ++ }; ++ ++ # Merge to create the final line of code ++ @tokens = ( $command, @params ? join( ', ', @params ) : (), @suffix ); ++ push @code, join( ' ', @tokens ) . ";\n"; ++ } ++ ++ # Join into the complete code block ++ return join( '', @code ); ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/External.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/External.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/External.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/External.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,138 @@ ++package Module::Install::External; ++ ++# Provides dependency declarations for external non-Perl things ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION $ISCORE @ISA}; ++BEGIN { ++ $VERSION = '0.91'; ++ $ISCORE = 1; ++ @ISA = qw{Module::Install::Base}; ++} ++ ++sub requires_external_cc { ++ my $self = shift; ++ ++ # We need a C compiler, use the can_cc method for this ++ unless ( $self->can_cc ) { ++ print "Unresolvable missing external dependency.\n"; ++ print "This package requires a C compiler.\n"; ++ print STDERR "NA: Unable to build distribution on this platform.\n"; ++ exit(0); ++ } ++ ++ # Unlike some of the other modules, while we need to specify a ++ # C compiler as a dep, it needs to be a build-time dependency. ++ ++ 1; ++} ++ ++sub requires_external_bin { ++ my ($self, $bin, $version) = @_; ++ if ( $version ) { ++ die "requires_external_bin does not support versions yet"; ++ } ++ ++ # Load the package containing can_run early, ++ # to avoid breaking the message below. ++ $self->load('can_run'); ++ ++ # Locate the bin ++ print "Locating required external dependency bin:$bin..."; ++ my $found_bin = $self->can_run( $bin ); ++ if ( $found_bin ) { ++ print " found at $found_bin.\n"; ++ } else { ++ print " missing.\n"; ++ print "Unresolvable missing external dependency.\n"; ++ print "Please install '$bin' seperately and try again.\n"; ++ print STDERR "NA: Unable to build distribution on this platform.\n"; ++ exit(0); ++ } ++ ++ # Once we have some way to specify external deps, do it here. ++ # In the mean time, continue as normal. ++ ++ 1; ++} ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::External - Specify dependencies on external non-Perl things ++ ++=head1 DESCRIPTION ++ ++C provides command that allow you to ++declaratively specify a dependency on a program or system that is not ++Perl. ++ ++The commands it provides are similar to those in L, ++except that they implement an explicit dependency, in addition to just ++working out if the particular thing is available. ++ ++=head1 COMMANDS ++ ++=head2 requires_external_cc ++ ++ requires_external_cc; ++ ++The C command explicitly specifies that a C compiler ++is required in order to build (at F-time) the distribution. ++ ++It does not take any params, and aborts the F execution ++in a way that an automated installation or testing system will interpret ++as a C ("not applicable to this platform") result. ++ ++This maybe be changed to an alternative abort result at a later time. ++ ++Returns true as a convenience. ++ ++=head2 requires_external_bin ++ ++ requires_external_bin 'cvs'; ++ ++The C command takes the name of a system command ++or program, similar to the C command, except that ++C checks in a way that is a declarative explicit ++dependency. ++ ++The takes a single param of the command/program name, and aborts the ++C execution in a way that an automated installation or ++testing system will interpret as a C ("not applicable to this ++platform") result. ++ ++Returns true as a convenience. ++ ++=head1 TO DO ++ ++Work out how to save the external dependency metadata, in agreement with ++the larger Perl community. ++ ++Implement the agreed external dependency metadata solution. ++ ++=head1 AUTHORS ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++=head1 SEE ALSO ++ ++L ++ ++=head1 COPYRIGHT ++ ++Copyright 2006 Adam Kennedy. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Fetch.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Fetch.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Fetch.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Fetch.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,14 +1,13 @@ +-#line 1 + package Module::Install::Fetch; + + use strict; +-use Module::Install::Base; ++use Module::Install::Base (); + +-use vars qw{$VERSION $ISCORE @ISA}; ++use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; +- @ISA = qw{Module::Install::Base}; + } + + sub get_file { +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Include.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Include.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Include.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Include.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,14 +1,13 @@ +-#line 1 + package Module::Install::Include; + + use strict; +-use Module::Install::Base; ++use Module::Install::Base (); + +-use vars qw{$VERSION $ISCORE @ISA}; ++use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; +- @ISA = qw{Module::Install::Base}; + } + + sub include { +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Inline.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Inline.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Inline.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Inline.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,49 @@ ++package Module::Install::Inline; ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++sub Inline { $_[0] } ++ ++sub write { ++ my $self = shift; ++ my $name = $self->module_name || $self->name ++ or die "Please set name() before calling &Inline->write\n"; ++ $name =~ s/-/::/g; ++ my $object = (split(/::/, $name))[-1] or return; ++ my $version = $self->version ++ or die "Please set version() or version_from() before calling &Inline->write\n"; ++ ++ $version =~ /^\d\.\d\d$/ or die <<"END_MESSAGE"; ++Invalid version '$version' for $name. ++Must be of the form '#.##'. (For instance '1.23') ++END_MESSAGE ++ ++ $self->clean_files('_Inline', "$object.inl"); ++ $self->build_requires('Inline' => 0.44); # XXX: check for existing? yagni? ++ ++ my $class = ref($self); ++ my $prefix = $self->_top->{prefix}; ++ $self->postamble(<<"MAKEFILE"); ++# --- $class section: ++ ++.SUFFIXES: .pm .inl ++ ++.pm.inl: ++\t\$(PERL) -I$prefix "-Mblib" "-MInline=NOISY,_INSTALL_" "-M$name" -e1 $version \$(INST_ARCHLIB) ++ ++pure_all :: $object.inl ++ ++MAKEFILE ++ ++ $self->Makefile->write; ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Makefile.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Makefile.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Makefile.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Makefile.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,15 +1,14 @@ +-#line 1 + package Module::Install::Makefile; + + use strict 'vars'; +-use Module::Install::Base; +-use ExtUtils::MakeMaker (); ++use ExtUtils::MakeMaker (); ++use Module::Install::Base (); + +-use vars qw{$VERSION $ISCORE @ISA}; ++use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; +- @ISA = qw{Module::Install::Base}; + } + + sub Makefile { $_[0] } +@@ -265,4 +264,131 @@ + + __END__ + +-#line 394 ++=pod ++ ++=head1 NAME ++ ++Module::Install::MakeMaker - Extension Rules for ExtUtils::MakeMaker ++ ++=head1 SYNOPSIS ++ ++In your F: ++ ++ use inc::Module::Install; ++ WriteMakefile(); ++ ++=head1 DESCRIPTION ++ ++This module is a wrapper around B. It exports ++two functions: C (an alias for C) ++and C. ++ ++The C function will pass on keyword/value pair functions ++to C. The required parameters ++C and C (or C) are not necessary if ++it can find them unambiguously in your code. ++ ++=head1 CONFIGURATION OPTIONS ++ ++This module also adds some Configuration parameters of its own: ++ ++=head2 NAME ++ ++The NAME parameter is required by B. If you have a ++single module in your distribution, or if the module name indicated by ++the current directory exists under F, this module will use the ++guessed package name as the default. ++ ++If this module can't find a default for C it will ask you to specify ++it manually. ++ ++=head2 VERSION ++ ++B requires either the C or C ++parameter. If this module can guess the package's C, it will attempt ++to parse the C from it. ++ ++If this module can't find a default for C it will ask you to ++specify it manually. ++ ++=head1 MAKE TARGETS ++ ++B provides you with many useful C targets. A ++C B is the word you specify after C, like C ++for C. Some of the more useful targets are: ++ ++=over 4 ++ ++=item * all ++ ++This is the default target. When you type C it is the same as ++entering C. This target builds all of your code and stages it ++in the C directory. ++ ++=item * test ++ ++Run your distribution's test suite. ++ ++=item * install ++ ++Copy the contents of the C directory into the appropriate ++directories in your Perl installation. ++ ++=item * dist ++ ++Create a distribution tarball, ready for uploading to CPAN or sharing ++with a friend. ++ ++=item * clean distclean purge ++ ++Remove the files created by C and C. ++ ++=item * help ++ ++Same as typing C. ++ ++=back ++ ++This module modifies the behaviour of some of these targets, depending ++on your requirements, and also adds the following targets to your Makefile: ++ ++=over 4 ++ ++=item * cpurge ++ ++Just like purge, except that it also deletes the files originally added ++by this module itself. ++ ++=item * chelp ++ ++Short cut for typing C. ++ ++=item * distsign ++ ++Short cut for typing C, for B users to ++sign the distribution before release. ++ ++=back ++ ++=head1 SEE ALSO ++ ++L, L, L ++ ++=head1 AUTHORS ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++Brian Ingerson EINGY@cpan.orgE ++ ++=head1 COPYRIGHT ++ ++Some parts copyright 2008 - 2009 Adam Kennedy. ++ ++Copyright 2002, 2003, 2004 Audrey Tang and Brian Ingerson. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/MakeMaker.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/MakeMaker.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/MakeMaker.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/MakeMaker.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,49 @@ ++package Module::Install::MakeMaker; ++ ++use strict; ++use ExtUtils::MakeMaker (); ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++my $makefile; ++ ++sub WriteMakefile { ++ my ($self, %args) = @_; ++ $makefile = $self->load('Makefile'); ++ ++ # mapping between MakeMaker and META.yml keys ++ $args{MODULE_NAME} = $args{NAME}; ++ unless ( $args{NAME} = $args{DISTNAME} or ! $args{MODULE_NAME} ) { ++ $args{NAME} = $args{MODULE_NAME}; ++ $args{NAME} =~ s/::/-/g; ++ } ++ ++ foreach my $key ( qw{name module_name version version_from abstract author installdirs} ) { ++ my $value = delete($args{uc($key)}) or next; ++ $self->$key($value); ++ } ++ ++ if (my $prereq = delete($args{PREREQ_PM})) { ++ while (my($k,$v) = each %$prereq) { ++ $self->requires($k,$v); ++ } ++ } ++ ++ # put the remaining args to makemaker_args ++ $self->makemaker_args(%args); ++} ++ ++END { ++ if ( $makefile ) { ++ $makefile->write; ++ $makefile->Meta->write; ++ } ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Metadata.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Metadata.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Metadata.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Metadata.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,19 +1,17 @@ +-#line 1 + package Module::Install::Metadata; + + use strict 'vars'; +-use Module::Install::Base; ++use Module::Install::Base (); + + use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; +- @ISA = qw{Module::Install::Base}; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; + } + + my @boolean_keys = qw{ + sign +- mymeta + }; + + my @scalar_keys = qw{ +@@ -440,21 +438,21 @@ + /ixms ) { + my $license_text = $1; + my @phrases = ( +- 'under the same (?:terms|license) as perl 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, ++ '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; +@@ -506,17 +504,29 @@ + } + } + ++sub test_requires_from { ++ my $self = shift; ++ my $content = Module::Install::_readperl($_[0]); ++ my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg; ++ while ( @requires ) { ++ my $module = shift @requires; ++ my $version = shift @requires; ++ $self->test_requires( $module => $version ); ++ } ++} ++ + # Convert triple-part versions (eg, 5.6.1 or 5.8.9) to + # numbers (eg, 5.006001 or 5.008009). + # Also, convert double-part versions (eg, 5.8) + sub _perl_version { + my $v = $_[-1]; +- $v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e; ++ $v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e; + $v =~ s/^([1-9])\.([1-9]\d?\d?)\.(0|[1-9]\d?\d?)$/sprintf("%d.%03d%03d",$1,$2,$3 || 0)/e; + $v =~ s/(\.\d\d\d)000$/$1/; + $v =~ s/_.+$//; + if ( ref($v) ) { +- $v = $v + 0; # Numify ++ # Numify ++ $v = $v + 0; + } + return $v; + } +@@ -526,23 +536,58 @@ + + + ###################################################################### +-# MYMETA.yml Support ++# MYMETA Support + + sub WriteMyMeta { + die "WriteMyMeta has been deprecated"; + } + +-sub write_mymeta { ++sub write_mymeta_yaml { + my $self = shift; +- +- # If there's no existing META.yml there is nothing we can do +- return unless -f 'META.yml'; + + # We need YAML::Tiny to write the MYMETA.yml file + unless ( eval { require YAML::Tiny; 1; } ) { + return 1; + } + ++ # Generate the data ++ my $meta = $self->_write_mymeta_data or return 1; ++ ++ # Save as the MYMETA.yml file ++ print "Writing MYMETA.yml\n"; ++ YAML::Tiny::DumpFile('MYMETA.yml', $meta); ++} ++ ++sub write_mymeta_json { ++ my $self = shift; ++ ++ # We need JSON to write the MYMETA.json file ++ unless ( eval { require JSON; 1; } ) { ++ return 1; ++ } ++ ++ # Generate the data ++ my $meta = $self->_write_mymeta_data or return 1; ++ ++ # Save as the MYMETA.yml file ++ print "Writing MYMETA.json\n"; ++ Module::Install::_write( ++ 'MYMETA.json', ++ JSON->new->pretty(1)->canonical->encode($meta), ++ ); ++} ++ ++sub _write_mymeta_data { ++ my $self = shift; ++ ++ # If there's no existing META.yml there is nothing we can do ++ return undef unless -f 'META.yml'; ++ ++ # We need Parse::CPAN::Meta to load the file ++ unless ( eval { require Parse::CPAN::Meta; 1; } ) { ++ return undef; ++ } ++ + # Merge the perl version into the dependencies + my $val = $self->Meta->{values}; + my $perl = delete $val->{perl_version}; +@@ -558,7 +603,7 @@ + } + + # Load the advisory META.yml file +- my @yaml = YAML::Tiny::LoadFile('META.yml'); ++ my @yaml = Parse::CPAN::Meta::LoadFile('META.yml'); + my $meta = $yaml[0]; + + # Overwrite the non-configure dependency hashs +@@ -572,9 +617,7 @@ + $meta->{build_requires} = { map { @$_ } @{ $val->{build_requires} } }; + } + +- # Save as the MYMETA.yml file +- print "Writing MYMETA.yml\n"; +- YAML::Tiny::DumpFile('MYMETA.yml', $meta); ++ return $meta; + } + + 1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/PAR.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/PAR.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/PAR.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/PAR.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,274 @@ ++package Module::Install::PAR; ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++=head1 NAME ++ ++Module::Install::PAR - Module::Install Support for PAR::Dist packages ++ ++=head1 SYNOPSIS ++ ++To offer your users the possibility to install binaries if no C ++compiler was found, you could use this simplistic stub: ++ ++ use inc::Module::Install; ++ ++ name 'Foo'; ++ all_from 'lib/Foo.pm'; ++ ++ # Which CPAN directory do we fetch binaries from? ++ par_base 'SMUELLER'; ++ ++ unless ( can_cc() ) { ++ my $okay = extract_par( fetch_par ); ++ if (not $okay) { ++ die "No compiler and no binary package found. Aborting.\n"; ++ } ++ } ++ ++ WriteAll; ++ ++=head1 DESCRIPTION ++ ++This module adds a couple of directives to Module::Install ++related to installing and creating PAR::Dist distributions. ++ ++=head2 par_base ++ ++This directive sets the CPAN ID from whose CPAN directory to ++fetch binaries from. For example, you can choose to download ++binaries from http://www.cpan.org/authors/id/S/SM/SMUELLER/ ++or its ftp counterpart by writing: ++ ++ par_base 'SMUELLER'; ++ ++By default, the name of the file to fetch is generated from ++the distribution name, its version, your platform name and your ++perl version concatenated with dashes. ++ ++The directive, however, takes an optional second ++argument which specifies the name of the file to fetch. ++(Though C does not fetch files itself, see below.) ++ ++ par_base 'SMUELLER', 'foo'; ++ ++Once C is called, the file 'foo' will be downloaded ++from SMUELLER's CPAN directory. (It doesn't exist.) ++ ++The second argument could be used to fetch platform-agnostic ++binaries: ++ ++ par_base 'SMUELLER', "Some-Distribution-0.01.par"; ++ ++(Documentation TODO: Use the previously defined distribution ++name and version in example.) ++ ++=cut ++ ++sub par_base { ++ my ($self, $base, $file) = @_; ++ my $class = ref($self); ++ my $inc_class = join('::', @{$self->_top}{qw(prefix name)}); ++ my $ftp_base; ++ ++ if ( defined $base and length $base ) { ++ if ( $base =~ m!^(([A-Z])[A-Z])[-_A-Z]+\Z! ) { ++ $self->{mailto} = "$base\@cpan.org"; ++ $ftp_base = "ftp://ftp.cpan.org/pub/CPAN/authors/id/$2/$1/$base"; ++ $base = "http://www.cpan.org/authors/id/$2/$1/$base"; ++ } elsif ( $base !~ m!^(\w+)://! ) { ++ die "Cannot recognize path '$base'; please specify an URL or CPAN ID"; ++ } ++ $base .= '/' unless $base =~ m!/\Z!; ++ $ftp_base .= '/' unless $ftp_base =~ m!/\Z!; ++ } ++ ++ require Config; ++ my $suffix = "$Config::Config{archname}-$Config::Config{version}.par"; ++ ++ unless ( $file ||= $self->{file} ) { ++ my $name = $self->name or return; ++ my $version = $self->version or return; ++ $name =~ s!::!-!g; ++ $self->{file} = $file = "$name-$version-$suffix"; ++ } ++ ++ my $perl = $^X; ++ $perl = Win32::GetShortPathName($perl) ++ if $perl =~ / / and defined &Win32::GetShortPathName; ++ ++ $self->preamble(<<"END_MAKEFILE") if $base; ++# --- $class section: ++ ++all :: ++\t\$(NOECHO) $perl "-M$inc_class" -e "extract_par(q($file))" ++ ++END_MAKEFILE ++ ++ $self->postamble(<<"END_MAKEFILE"); ++# --- $class section: ++ ++$file: all test ++\t\$(NOECHO) \$(PERL) "-M$inc_class" -e "make_par(q($file))" ++ ++par :: $file ++\t\$(NOECHO) \$(NOOP) ++ ++par-upload :: $file ++\tcpan-upload -verbose $file ++ ++END_MAKEFILE ++ ++ $self->{url} = $base; ++ $self->{ftp_url} = $ftp_base; ++ $self->{suffix} = $suffix; ++ ++ return $self; ++} ++ ++=head2 fetch_par ++ ++Fetches the .par file previously referenced in the documentation ++of the C directive. ++ ++C can be used without arguments given the C ++directive was used before. It will return the name of the file it ++fetched. ++ ++If the first argument is an URL or a CPAN user ID, the file is ++fetched from that directory unless an URL has been previously set. ++(Read that again.) ++ ++If the second argument is a file name ++it is used as the name of the file to download. ++ ++If the file could not be fetched, a suitable error message ++about no package being available, yada yada yada, is printed. ++You can turn this off by specifying a true third argument. ++ ++ # Try to fetch the package (see par_base) but ++ # don't be verbose about failures ++ my $file = fetch_par('', '', undef); ++ ++=cut ++ ++sub fetch_par { ++ my ($self, $url, $file, $quiet) = @_; ++ $url = '' if not defined $url; ++ $file = '' if not defined $file; ++ ++ $url = $self->{url} || $self->par_base($url)->{url}; ++ my $ftp_url = $self->{ftp_url}; ++ $file ||= $self->{file}; ++ ++ return $file if -f $file or $self->get_file( ++ url => "$url$file", ++ ftp_url => "$ftp_url$file" ++ ); ++ ++ require Config; ++ print <<"END_MESSAGE" if $self->{mailto} and ! $quiet; ++*** No installation package available for your architecture. ++However, you may wish to generate one with '$Config::Config{make} par' and send ++it to <$self->{mailto}>, so other people on the same platform ++can benefit from it. ++*** Proceeding with normal installation... ++END_MESSAGE ++ return; ++} ++ ++=head2 extract_par ++ ++Takes the name of a PAR::Dist archive file as first argument. The 'blib/' ++directory of this archive is extracted and the 'pm_to_blib' is created. ++ ++Typical shorthand usage: ++ ++ extract_par( fetch_par ) or die "Could not install PAR::Dist archive."; ++ ++=cut ++ ++sub extract_par { ++ my ($self, $file) = @_; ++ return unless -f $file; ++ ++ if ( eval { require Archive::Zip; 1 } ) { ++ my $zip = Archive::Zip->new; ++ return unless $zip->read($file) == Archive::Zip::AZ_OK() ++ and $zip->extractTree('', 'blib/') == Archive::Zip::AZ_OK(); ++ } elsif ( $self->can_run('unzip') ) { ++ return if system( unzip => $file, qw(-d blib) ); ++ } ++ else { ++ die <<'HERE'; ++Could not extract .par archive because neither Archive::Zip nor a ++working 'unzip' binary are available. Please consider installing ++Archive::Zip. ++HERE ++ } ++ ++ local *PM_TO_BLIB; ++ open PM_TO_BLIB, '> pm_to_blib' or die $!; ++ close PM_TO_BLIB or die $!; ++ ++ return 1; ++} ++ ++=head2 make_par ++ ++This directive requires PAR::Dist (version 0.03 or up) on your system. ++(And checks that it is available before continuing.) ++ ++Creates a PAR::Dist archive from the 'blib/' subdirectory. ++ ++First argument must be the name of the PAR::Dist archive to create. ++ ++If your Makefile.PL has a C directive, the C ++make target will be available. It uses this C directive ++internally, so on your development system, you can do this to create ++a .par binary archive for your platform: ++ ++ perl Makefile.PL ++ make ++ make par ++ ++=cut ++ ++sub make_par { ++ my ($self, $file) = @_; ++ unlink $file if -f $file; ++ ++ unless ( eval { require PAR::Dist; PAR::Dist->VERSION >= 0.03 } ) { ++ warn "Please install PAR::Dist 0.03 or above first."; ++ return; ++ } ++ ++ return PAR::Dist::blib_to_par( dist => $file ); ++} ++ ++1; ++ ++=head1 AUTHOR ++ ++Audrey Tang ++ ++With documentation from Steffen Mueller ++ ++=head1 COPYRIGHT ++ ++Copyright (c) 2006. Audrey Tang. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Philosophy.pod DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Philosophy.pod +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Philosophy.pod 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Philosophy.pod 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,187 @@ ++=head1 NAME ++ ++Module::Install::Philosophy - The concepts behind Module::Install ++ ++=head1 SYNOPSIS ++ ++This document describes the personal philosophy behind the creation of ++B (the predecessor of B). The views ++expressed here belong to Brian Ingerson; if they are not of interest to ++you, you can safely ignore this document. ++ ++=head1 I HAVE A DREAM ++ ++I say to you today, my friends, that in spite of the difficulties and ++frustrations of the moment, I still have a dream. It is a dream deeply ++rooted in the Perl Module dream. ++ ++I have a dream that one day this community will rise up and live out the ++true meaning of its creed: "We hold these truths to be self-evident: ++that all Perl authors are created equal." ++ ++I have a dream that one day even the state of the C namespace, a ++desert state, sweltering with the heat of injustice and oppression, will ++be transformed into an oasis of freedom and justice. ++ ++I have a dream that my four modules will one day live in an archive ++where they will not be judged by the number of their prerequisites but ++by the content of their source code. ++ ++I have a dream today. ++ ++=head1 DESCRIPTION ++ ++The above is obviously a mutation of the monumental speech by great ++Martin Luther King (L). ++While the contexts are vastly different, I feel that there are some ++serious parallelisms. ++ ++The CPAN has become a place that is not free of injustice. This ++situation has arisen not out of directed oppression, but from a failure ++of our community to keep its tools sharp. It is the culmination of many ++small decisions made in the name of practicality. This is a sad state ++for an institution that was created to allow all interested people to ++contribute equally to the best of their ability. ++ ++This assertion is rooted in my personal experience as an author. When I ++created my first Perl module, Inline.pm, I knew that I had done ++something important. But how was I to make a dent in vast Perl ++community? ++ ++As a complete unknown in the Perl community, my voice did not travel ++far. I repeatedly tried to get even an acknowledgment from the gurus ++familiar with XS. No success. I resorted to sending messages with ++ridiculous subjects to C. ++(L) ++No response. Through sheer determination and shameless self-promotion I ++eventually got the word out, and I hope the world is a slightly better ++place for it. ++ ++Since then, Inline has won awards and I have had the privilege to meet almost ++all of Perl's finest. But I still remember the pain of starting out, and ++want to help invite more people into this wonderful world. ++ ++One thing I have learned from experience is that the Perl community (and ++throw in the Python and Ruby people as well) is a small drop in the vast ++ocean of programming. It's a giant pot of Java out there; and a sea of ++C. Perl may not be the biggest fish, but with some care and cunning we ++could become a much bigger school. ++ ++These are the current problems that I see with CPAN and the core modules: ++ ++=over 4 ++ ++=item * New Modules don't help Older Perls ++ ++If I were to guess what percent of all Perl5 installations were at the ++current release level (5.8.0 in October 2002) I would say 3-5%. That may ++even be generous. I'd say that over 40% of installations might still be ++at 5.005 or earlier. ++ ++The biggest problem with adding a module to the core is that it only ++helps a small subset of Perl users for a long long time. Worse yet, a ++good module author will still probably avoid using the core additions as ++prerequisites, because they want their new module to work as well on ++5.005 as on 5.8. ++ ++CPAN::MakeMaker should be able to help in this regard. For example, ++instead of putting Inline.pm into the core for 5.9, I can now ++effectively get it into the core for every version of Perl that ++Inline supports. ++ ++=item * Author Exclusiveness ++ ++Not just anybody can get a module into the core. It seems you have to ++know people in high places. If I were a brilliant new talent with a ++great new module, it would have a harder time getting the ear of the ++pumpking, then if I were, say, Damian Conway. In fact, I probably ++wouldn't even know where to start. ++ ++=item * Reduced Competition ++ ++One comment I've heard from some very good Perl programmers is ++"Everything important has already been done". Their feeling is that ++even though a module is suboptimal, it would be a waste of time to ++write a competing module. Who would use it instead of the one already ++in the core? ++ ++When I write a competing module, I know that I have to make it at least ++twice as good as the existing one to even get noticed. That's not a bad ++thing, but should everybody be forced into that situation? ++ ++For example, let's say that you have created a really useful CGI script. ++Let's also say that it makes use of your own B module, ++because B doesn't meet your needs. Even though your script might be ++generally useful and worth sharing, the fact that it requires a ++non-standard module can only negatively affect its acceptance. Trying to ++get general acceptance for the superior B module will be ++harder still. ++ ++Core modules are assumed by the general public to be "Best of Breed". ++While this may be true for some modules at some point in time, it keeps ++talented people from attempting to "breed" something better. ++ ++=item * Core Bloat ++ ++Every time we add a module to the core it gets bigger and bigger. And we ++can't ever remove modules from the core, once they've been added. ++ ++If I had my druthers, we'd remove all modules from the core that weren't ++necessary for either running Perl or installing modules. Of course, we'd ++need to set things up so that installing modules was so easy, that it ++could be done on the fly if necessary. Is this easily accomplishable? ++Nope. Is it impossible? Nope. We have the best language in the world to ++help us do it! ++ ++=item * Maintenance Bitrot ++ ++Believe it or not, Perl authors can sometimes acquire a "Life Beyond ++Perl". They get families or new hobbies or even hit by a bus. (This ++would be a "Death Beyond Perl".) The fact is, that once somebody writes ++a piece of code and shares it with the world, they are expected to ++maintain it for all time. ++ ++That is being generous. There are others that think that once their ++module has become popular or made it into the core, they don't need to ++keep fixing and improving it. I have personally been guilty of this sin. ++ ++And then there's the Damian Conway Effect. This plagues the exceptional ++authors who are so innovative and prolific they simply don't have time ++to maintain everything they have written. ++ ++=back ++ ++I initially formalized these opinions at the YAPC (Yet Another Perl ++Conference) in June 2001. Since then I have been trying to think of ++technological solutions to fix these social problems. ++ ++One idea was dubbed NAPC. NAPC is CPAN backwards. It is a large system ++of precompiled modules that can be installed on the fly, with the goal ++of reducing the number of modules in the core. NAPC hasn't got started ++yet. I'd still like to do it someday, but it's a big problem with a lot ++of issues. ++ ++B (and now B) on the other hand, is ++simple and ultimately flexible. It should work with all of the existing ++CPAN processes without requiring any changes from them. And new features ++can be continuously added. Even though it doesn't scratch all of my ++philosophical CPAN itches, it's a good start. ++ ++=head1 CONCLUSION ++ ++This is all just food for thought. Take it with a pinch of salt. ++ ++=head1 AUTHOR ++ ++Brian Ingerson EINGY@cpan.orgE ++ ++=head1 COPYRIGHT ++ ++Copyright (c) 2002. Brian Ingerson. ++ ++This document is free documentation; you can redistribute it and/or ++modify it under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Run.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Run.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Run.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Run.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,15 @@ ++package Module::Install::Run; ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++# eventually move the ipc::run / open3 stuff here. ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Scripts.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Scripts.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Scripts.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Scripts.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,28 @@ ++package Module::Install::Scripts; ++ ++use strict 'vars'; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++sub install_script { ++ my $self = shift; ++ my $args = $self->makemaker_args; ++ my $exe = $args->{EXE_FILES} ||= []; ++ foreach ( @_ ) { ++ if ( -f $_ ) { ++ push @$exe, $_; ++ } elsif ( -d 'script' and -f "script/$_" ) { ++ push @$exe, "script/$_"; ++ } else { ++ die("Cannot find script '$_'"); ++ } ++ } ++} ++ ++1; +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Share.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Share.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Share.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Share.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,125 @@ ++package Module::Install::Share; ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++sub install_share { ++ my $self = shift; ++ my $dir = @_ ? pop : 'share'; ++ my $type = @_ ? shift : 'dist'; ++ unless ( defined $type and $type eq 'module' or $type eq 'dist' ) { ++ die "Illegal or invalid share dir type '$type'"; ++ } ++ unless ( defined $dir and -d $dir ) { ++ die "Illegal or missing directory install_share param"; ++ } ++ ++ # Split by type ++ my $S = ($^O eq 'MSWin32') ? "\\" : "\/"; ++ if ( $type eq 'dist' ) { ++ die "Too many parameters to install_share" if @_; ++ ++ # Set up the install ++ $self->postamble(<<"END_MAKEFILE"); ++config :: ++\t\$(NOECHO) \$(MOD_INSTALL) \\ ++\t\t"$dir" \$(INST_LIB)${S}auto${S}share${S}dist${S}\$(DISTNAME) ++ ++END_MAKEFILE ++ } else { ++ my $module = Module::Install::_CLASS($_[0]); ++ unless ( defined $module ) { ++ die "Missing or invalid module name '$_[0]'"; ++ } ++ $module =~ s/::/-/g; ++ ++ # Set up the install ++ $self->postamble(<<"END_MAKEFILE"); ++config :: ++\t\$(NOECHO) \$(MOD_INSTALL) \\ ++\t\t"$dir" \$(INST_LIB)${S}auto${S}share${S}module${S}$module ++ ++END_MAKEFILE ++ } ++ ++ # The above appears to behave incorrectly when used with old versions ++ # of ExtUtils::Install (known-bad on RHEL 3, with 5.8.0) ++ # So when we need to install a share directory, make sure we add a ++ # dependency on a moderately new version of ExtUtils::MakeMaker. ++ $self->build_requires( 'ExtUtils::MakeMaker' => '6.11' ); ++ ++ # 99% of the time we don't want to index a shared dir ++ $self->no_index( directory => $dir ); ++} ++ ++1; ++ ++__END__ ++ ++=pod ++ ++=head1 NAME ++ ++Module::Install::Share - Install non-code files for use during run-time ++ ++=head1 SYNOPSIS ++ ++ # Put everything inside ./share/ into the distribution 'auto' path ++ install_share 'share'; ++ ++ # Same thing as above using the default directory name ++ install_share; ++ ++=head1 DESCRIPTION ++ ++As well as Perl modules and Perl binary applications, some distributions ++need to install read-only data files to a location on the file system ++for use at run-time. ++ ++XML Schemas, L data files, and L databases are examples of ++the sort of things distributions might typically need to have available ++after installation. ++ ++C is a L extension that provides ++commands to allow these files to be installed to the applicable location ++on disk. ++ ++To locate the files after installation so they can be used inside your ++module, see this extension's companion module L. ++ ++=head1 TO DO ++ ++Currently C installs not only the files you want, but ++if called by the author will also copy F<.svn> and other source-control ++directories, and other junk. ++ ++Enhance this to copy only files under F that are in the ++F, or possibly those not in F. ++ ++=head1 AUTHORS ++ ++Audrey Tang Eautrijus@autrijus.orgE ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++=head1 SEE ALSO ++ ++L, L ++ ++=head1 COPYRIGHT ++ ++Copyright 2006 Audrey Tang, Adam Kennedy. ++ ++This program is free software; you can redistribute it and/or modify it ++under the same terms as Perl itself. ++ ++See L ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Win32.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Win32.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/Win32.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/Win32.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,13 +1,12 @@ +-#line 1 + package Module::Install::Win32; + + use strict; +-use Module::Install::Base; ++use Module::Install::Base (); + + use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; +- @ISA = qw{Module::Install::Base}; ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; + $ISCORE = 1; + } + +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/With.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/With.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/With.pm 1970-01-01 01:00:00.000000000 +0100 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/With.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -0,0 +1,159 @@ ++package Module::Install::With; ++ ++# See POD at end for docs ++ ++use strict; ++use Module::Install::Base (); ++ ++use vars qw{$VERSION @ISA $ISCORE}; ++BEGIN { ++ $VERSION = '0.91'; ++ @ISA = 'Module::Install::Base'; ++ $ISCORE = 1; ++} ++ ++ ++ ++ ++ ++##################################################################### ++# Installer Target ++ ++# Are we targeting ExtUtils::MakeMaker (running as Makefile.PL) ++sub eumm { ++ !! ($0 =~ /Makefile.PL$/i); ++} ++ ++# You should not be using this, but we'll keep the hook anyways ++sub mb { ++ !! ($0 =~ /Build.PL$/i); ++} ++ ++ ++ ++ ++ ++##################################################################### ++# Testing and Configuration Contexts ++ ++=pod ++ ++=head2 interactive ++ ++The C function tests for an install that has a user present ++(or at least, one in which it is reasonable for us to present prompts ++and other similar types of things). ++ ++Returns true if in an interactive environment, or false otherwise. ++ ++=cut ++ ++sub interactive { ++ # Treat things interactively ONLY based on input ++ !! (-t STDIN and ! automated_testing()); ++} ++ ++=pod ++ ++=head2 automated_testing ++ ++Are we currently running in an automated testing environment, such as ++CPAN Testers. ++ ++This is primarily a cleaner and more human-readable equivalent of ++checking $ENV{AUTOMATED_TESTING} yourself, but may be improved in line ++with best practices at a later date. ++ ++=cut ++ ++sub automated_testing { ++ !! $ENV{AUTOMATED_TESTING}; ++} ++ ++=pod ++ ++=head2 release_testing ++ ++Are we currently running in an release testing environment. That is, ++are we in the process of running in a potential highly-intensive and ++high dependency bloat testing process prior to packaging a module for ++release. ++ ++This is primarily a cleaner and more human-readable equivalent of ++checking $ENV{RELEASE_TESTING} yourself, but may be improved in line ++with best practices at a later date. ++ ++=cut ++ ++sub release_testing { ++ !! $ENV{RELEASE_TESTING}; ++} ++ ++sub author_context { ++ !! $Module::Install::AUTHOR; ++} ++ ++ ++ ++ ++ ++##################################################################### ++# Operating System Convenience ++ ++=pod ++ ++=head2 win32 ++ ++The C function tests if the Makefile.PL is currently running in a ++native Microsoft Windows Perl, such as ActivePerl or Strawberry Perl. ++ ++This is primarily a cleaner and more human-readable equivalent of ++checking C<$^O eq 'MSWin32'> yourself, but may be improved in line ++with best practices at a later date. ++ ++=cut ++ ++sub win32 { ++ !! ($^O eq 'MSWin32'); ++} ++ ++=pod ++ ++=head2 winlike ++ ++The C function tests if the Makefile.PL is currently running ++in a Microsoft Windows Perl, under either cygwin or a native Win32 Perl. ++ ++This is primarily a cleaner and more human-readable equivalent of ++checking C<$^O eq 'MSWin32' or $^O eq 'cygwin'>yourself, but may be ++improved in line with best practices at a later date. ++ ++=cut ++ ++sub winlike { ++ !! ($^O eq 'MSWin32' or $^O eq 'cygwin'); ++} ++ ++1; ++ ++=pod ++ ++=head1 SEE ALSO ++ ++L ++ ++=head1 AUTHORS ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++=head1 COPYRIGHT ++ ++Copyright 2007 - 2009 Adam Kennedy. ++ ++This program is free software; you can redistribute ++it and/or modify it under the same terms as Perl itself. ++ ++The full text of the license can be found in the ++LICENSE file included with this module. ++ ++=cut +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/WriteAll.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/WriteAll.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install/WriteAll.pm 2009-05-01 22:10:12.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install/WriteAll.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,12 +1,11 @@ +-#line 1 + package Module::Install::WriteAll; + + use strict; +-use Module::Install::Base; ++use Module::Install::Base (); + + use vars qw{$VERSION @ISA $ISCORE}; + BEGIN { +- $VERSION = '0.85'; ++ $VERSION = '0.91';; + @ISA = qw{Module::Install::Base}; + $ISCORE = 1; + } +@@ -41,8 +40,18 @@ + + # The Makefile write process adds a couple of dependencies, + # so write the META.yml files after the Makefile. +- $self->Meta->write if $args{meta}; +- $self->Meta->write_mymeta if $self->mymeta; ++ if ( $args{meta} ) { ++ $self->Meta->write; ++ } ++ ++ # Experimental support for MYMETA ++ if ( $ENV{X_MYMETA} ) { ++ if ( $ENV{X_MYMETA} eq 'JSON' ) { ++ $self->Meta->write_mymeta_json; ++ } else { ++ $self->Meta->write_mymeta_yaml; ++ } ++ } + + return 1; + } +diff -Naur DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install.pm DBIx-Class-Schema-Loader-0.04006/inc/Module/Install.pm +--- DBIx-Class-Schema-Loader-0.04006.orig/inc/Module/Install.pm 2009-05-01 22:10:11.000000000 +0200 ++++ DBIx-Class-Schema-Loader-0.04006/inc/Module/Install.pm 2009-05-27 18:46:13.000000000 +0200 +@@ -1,4 +1,3 @@ +-#line 1 + package Module::Install; + + # For any maintainers: +@@ -28,7 +27,7 @@ + # 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.85'; ++ $VERSION = '0.91'; + + # Storage for the pseudo-singleton + $MAIN = undef; +@@ -353,7 +352,7 @@ + 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]): $!"; + } + my $string = do { local $/; }; + close FH or die "close($_[0]): $!"; +@@ -384,7 +383,7 @@ + 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]): $!"; + } + foreach ( 1 .. $#_ ) { + print FH $_[$_] or die "print($_[0]): $!"; diff --git a/perl-DBIx-Class-Schema-Loader.spec b/perl-DBIx-Class-Schema-Loader.spec index 89b7311..6bcbc6d 100644 --- a/perl-DBIx-Class-Schema-Loader.spec +++ b/perl-DBIx-Class-Schema-Loader.spec @@ -1,11 +1,14 @@ Name: perl-DBIx-Class-Schema-Loader Version: 0.04006 -Release: 3%{?dist} +Release: 4%{?dist} Summary: Dynamic definition of a DBIx::Class::Schema License: GPL+ or Artistic Group: Development/Libraries URL: http://search.cpan.org/dist/DBIx-Class-Schema-Loader/ Source0: http://search.cpan.org/CPAN/authors/id/I/IL/ILMARI/DBIx-Class-Schema-Loader-%{version}.tar.gz + +# Broken Module-Install, replace with Module-Install-0.91 +Patch0: DBIx-Class-Schema-Loader-0.04006.diff BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) BuildArch: noarch Requires: perl(:MODULE_COMPAT_%(eval "`%{__perl} -V:version`"; echo $version)) @@ -18,6 +21,7 @@ BuildRequires: perl(File::Spec) BuildRequires: perl(Scalar::Util) BuildRequires: perl(Test::More) >= 0.47 BuildRequires: perl(Text::Balanced) +BuildRequires: perl(YAML::Tiny), perl(File::Remove) # cpan BuildRequires: perl(Carp::Clan) @@ -49,6 +53,7 @@ and setting up the columns, primary keys, and relationships. %prep %setup -q -n DBIx-Class-Schema-Loader-%{version} +%patch0 -p1 # make sure doc/tests don't generate provides # note we first filter out the bits in _docdir... @@ -69,7 +74,7 @@ EOF chmod +x %{__perl_requires} %build -echo n | %{__perl} Makefile.PL INSTALLDIRS=vendor +%{__perl} Makefile.PL INSTALLDIRS=vendor --skipdeps make %{?_smp_mflags} %install @@ -95,6 +100,11 @@ rm -rf %{buildroot} %{_mandir}/man3/* %changelog +* Wed Aug 05 2009 Ralf Corsépius - 0.04006-4 +- Fix mass rebuild breakdown: + Replace bundled Module-Install with Module-Install-0.91. + Add --skipdeps. + * Sat Jul 25 2009 Fedora Release Engineering - 0.04006-3 - Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild