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]): $!";