1 package DBIx::Class::Optional::Dependencies;
3 ### This may look crazy, but it in fact tangibly ( by 50(!)% ) shortens
4 # the skip-test time when everything requested is unavailable
6 if ( $ENV{RELEASE_TESTING} ) {
7 require warnings and warnings->import;
8 require strict and strict->import;
18 # NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
19 # This module is to be loaded by Makefile.PM on a pristine system
21 # POD is generated automatically by calling _gen_pod from the
22 # Makefile.PL in $AUTHOR mode
24 # *DELIBERATELY* not making a group for these - they must disappear
25 # forever as optdeps in the first place
28 'MooseX::Types' => '0.21',
29 'MooseX::Types::LoadableClass' => '0.011',
34 # NOTE: the rationale for 2 JSON::Any versions is that
35 # we need the newer only to work around JSON::XS, which
36 # itself is an optional dep
39 'JSON::Any' => '1.23',
43 _json_xs_compatible_json_any => {
45 'JSON::Any' => '1.31',
49 # a common placeholder for engines with IC::DT support based off DT::F::S
50 _icdt_strptime_based => {
54 'DateTime::Format::Strptime' => '1.2',
60 _rdbms_generic_odbc => {
66 _rdbms_generic_ado => {
72 # must list any dep used by adhoc testing
73 # this prevents the "skips due to forgotten deps" issue
76 'Class::DBI::Plugin::DeepAbstractSearch' => '0',
77 'Class::DBI' => '3.000005',
78 'Date::Simple' => '3.03',
80 'Class::Unload' => '0.07',
82 'Time::Piece::MySQL' => '0',
89 title => 'Storage::Replicated',
90 desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
95 include => 'replicated',
102 include => '_json_any',
105 'MooseX::Types::Path::Class' => '0.05',
106 'MooseX::Types::JSON' => '0.02',
109 title => 'DBIx::Class::Admin',
110 desc => 'Modules required for the DBIx::Class administrative library',
117 'Getopt::Long::Descriptive' => '0.081',
118 'Text::CSV' => '1.16',
121 title => 'dbicadmin',
122 desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
128 'SQL::Translator' => '0.11018',
131 title => 'Storage::DBI::deploy()',
132 desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
138 'DateTime' => '0.55',
141 title => 'InflateColumn::DateTime support',
143 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
144 . 'Note that this group does not require much on its own, but '
145 . 'instead is augmented by various RDBMS-specific groups. See the '
146 . 'documentation of each C<rbms_*> group for details',
152 'Math::BigInt' => '1.80',
153 'Math::Base36' => '0.07',
159 'Class::Data::Inheritable' => '0',
160 'Class::Trigger' => '0',
161 'DBIx::ContextualFetch' => '0',
165 title => 'DBIx::Class::CDBICompat support',
166 desc => 'Modules required for L<DBIx::Class::CDBICompat>'
172 'Test::Pod' => '1.42',
174 release_testing_mandatory => 1,
177 test_podcoverage => {
179 'Test::Pod::Coverage' => '1.08',
180 'Pod::Coverage' => '0.20',
182 release_testing_mandatory => 1,
187 'Test::EOL' => '1.0',
188 'Test::NoTabs' => '0.9',
190 release_testing_mandatory => 1,
195 'Test::Strict' => '0.20',
197 release_testing_mandatory => 1,
200 test_prettydebug => {
201 include => '_json_any',
204 test_admin_script => {
205 include => [qw( admin_script _json_xs_compatible_json_any )],
209 'Cpanel::JSON::XS' => 0,
212 # for t/admin/10script.t
213 ? ('Win32::ShellQuote' => 0)
214 # DWIW does not compile (./configure even) on win32
215 : ('JSON::DWIW' => 0 )
220 test_leaks_heavy => {
222 'Class::MethodCache' => '0.02',
223 'PadWalker' => '1.06',
228 # this is just for completeness as SQLite
229 # is a core dep of DBIC for testing
235 title => 'SQLite support',
236 desc => 'Modules required to connect to SQLite',
241 'DateTime::Format::SQLite' => '0',
247 # centralize the specification, as we have ICDT tests which can
248 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
249 # not _-prefixed so that it will show up under req_group_list
254 'DateTime::Format::Pg' => '0.16004',
261 include => 'icdt_pg',
263 # when changing this list make sure to adjust xt/optional_deps.t
267 title => 'PostgreSQL support',
268 desc => 'Modules required to connect to PostgreSQL',
272 _rdbms_mssql_common => {
273 include => '_icdt_strptime_based',
276 rdbms_mssql_odbc => {
277 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
279 title => 'MSSQL support via DBD::ODBC',
280 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
284 rdbms_mssql_sybase => {
285 include => '_rdbms_mssql_common',
290 title => 'MSSQL support via DBD::Sybase',
291 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
296 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
298 title => 'MSSQL support via DBD::ADO (Windows only)',
299 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
303 _rdbms_msaccess_common => {
304 include => '_icdt_strptime_based',
307 rdbms_msaccess_odbc => {
308 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
310 title => 'MS Access support via DBD::ODBC',
311 desc => 'Modules required to connect to MS Access via DBD::ODBC',
315 rdbms_msaccess_ado => {
316 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
318 title => 'MS Access support via DBD::ADO (Windows only)',
319 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
323 # centralize the specification, as we have ICDT tests which can
324 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
325 # not _-prefixed so that it will show up under req_group_list
330 'DateTime::Format::MySQL' => '0',
337 include => 'icdt_mysql',
342 title => 'MySQL support',
343 desc => 'Modules required to connect to MySQL',
348 include => 'id_shortener',
353 title => 'Oracle support',
354 desc => 'Modules required to connect to Oracle',
359 'DateTime::Format::Oracle' => '0',
366 include => '_icdt_strptime_based',
371 title => 'Sybase ASE support',
372 desc => 'Modules required to connect to Sybase ASE',
376 _rdbms_db2_common => {
380 'DateTime::Format::DB2' => '0',
387 include => '_rdbms_db2_common',
392 title => 'DB2 support',
393 desc => 'Modules required to connect to DB2',
398 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
400 title => 'DB2 on AS/400 support',
401 desc => 'Modules required to connect to DB2 on AS/400',
406 include => '_icdt_strptime_based',
408 'DBD::Informix' => 0,
411 title => 'Informix support',
412 desc => 'Modules required to connect to Informix',
416 _rdbms_sqlanywhere_common => {
417 inclide => '_icdt_strptime_based',
420 rdbms_sqlanywhere => {
421 include => '_rdbms_sqlanywhere_common',
423 'DBD::SQLAnywhere' => 0,
426 title => 'SQLAnywhere support',
427 desc => 'Modules required to connect to SQLAnywhere',
431 rdbms_sqlanywhere_odbc => {
432 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
434 title => 'SQLAnywhere support via DBD::ODBC',
435 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
439 _rdbms_firebird_common => {
440 include => '_icdt_strptime_based',
444 include => '_rdbms_firebird_common',
446 'DBD::Firebird' => 0,
449 title => 'Firebird support',
450 desc => 'Modules required to connect to Firebird',
454 rdbms_firebird_interbase => {
455 include => '_rdbms_firebird_common',
457 'DBD::InterBase' => 0,
460 title => 'Firebird support via DBD::InterBase',
461 desc => 'Modules required to connect to Firebird via DBD::InterBase',
465 rdbms_firebird_odbc => {
466 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
468 title => 'Firebird support via DBD::ODBC',
469 desc => 'Modules required to connect to Firebird via DBD::ODBC',
473 test_rdbms_sqlite => {
474 include => 'rdbms_sqlite',
477 ### IMPORTANT - do not raise this dependency
478 ### even though many bugfixes are present in newer versions, the general DBIC
479 ### rule is to bend over backwards for available DBDs (given upgrading them is
480 ### often *not* easy or even possible)
482 'DBD::SQLite' => '1.29',
487 include => 'rdbms_pg',
489 DBICTEST_PG_DSN => 1,
490 DBICTEST_PG_USER => 0,
491 DBICTEST_PG_PASS => 0,
494 # the order does matter because the rdbms support group might require
495 # a different version that the test group
497 # when changing this list make sure to adjust xt/optional_deps.t
498 'DBD::Pg' => '2.009002', # specific version to test bytea
502 test_rdbms_mssql_odbc => {
503 include => 'rdbms_mssql_odbc',
505 DBICTEST_MSSQL_ODBC_DSN => 1,
506 DBICTEST_MSSQL_ODBC_USER => 0,
507 DBICTEST_MSSQL_ODBC_PASS => 0,
511 test_rdbms_mssql_ado => {
512 include => 'rdbms_mssql_ado',
514 DBICTEST_MSSQL_ADO_DSN => 1,
515 DBICTEST_MSSQL_ADO_USER => 0,
516 DBICTEST_MSSQL_ADO_PASS => 0,
520 test_rdbms_mssql_sybase => {
521 include => 'rdbms_mssql_sybase',
523 DBICTEST_MSSQL_DSN => 1,
524 DBICTEST_MSSQL_USER => 0,
525 DBICTEST_MSSQL_PASS => 0,
529 test_rdbms_msaccess_odbc => {
530 include => 'rdbms_msaccess_odbc',
532 DBICTEST_MSACCESS_ODBC_DSN => 1,
533 DBICTEST_MSACCESS_ODBC_USER => 0,
534 DBICTEST_MSACCESS_ODBC_PASS => 0,
541 test_rdbms_msaccess_ado => {
542 include => 'rdbms_msaccess_ado',
544 DBICTEST_MSACCESS_ADO_DSN => 1,
545 DBICTEST_MSACCESS_ADO_USER => 0,
546 DBICTEST_MSACCESS_ADO_PASS => 0,
553 test_rdbms_mysql => {
554 include => 'rdbms_mysql',
556 DBICTEST_MYSQL_DSN => 1,
557 DBICTEST_MYSQL_USER => 0,
558 DBICTEST_MYSQL_PASS => 0,
562 test_rdbms_oracle => {
563 include => 'rdbms_oracle',
565 DBICTEST_ORA_DSN => 1,
566 DBICTEST_ORA_USER => 0,
567 DBICTEST_ORA_PASS => 0,
570 'DBD::Oracle' => '1.24',
575 include => 'rdbms_ase',
577 DBICTEST_SYBASE_DSN => 1,
578 DBICTEST_SYBASE_USER => 0,
579 DBICTEST_SYBASE_PASS => 0,
584 include => 'rdbms_db2',
586 DBICTEST_DB2_DSN => 1,
587 DBICTEST_DB2_USER => 0,
588 DBICTEST_DB2_PASS => 0,
592 test_rdbms_db2_400 => {
593 include => 'rdbms_db2_400',
595 DBICTEST_DB2_400_DSN => 1,
596 DBICTEST_DB2_400_USER => 0,
597 DBICTEST_DB2_400_PASS => 0,
601 test_rdbms_informix => {
602 include => 'rdbms_informix',
604 DBICTEST_INFORMIX_DSN => 1,
605 DBICTEST_INFORMIX_USER => 0,
606 DBICTEST_INFORMIX_PASS => 0,
610 test_rdbms_sqlanywhere => {
611 include => 'rdbms_sqlanywhere',
613 DBICTEST_SQLANYWHERE_DSN => 1,
614 DBICTEST_SQLANYWHERE_USER => 0,
615 DBICTEST_SQLANYWHERE_PASS => 0,
619 test_rdbms_sqlanywhere_odbc => {
620 include => 'rdbms_sqlanywhere_odbc',
622 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
623 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
624 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
628 test_rdbms_firebird => {
629 include => 'rdbms_firebird',
631 DBICTEST_FIREBIRD_DSN => 1,
632 DBICTEST_FIREBIRD_USER => 0,
633 DBICTEST_FIREBIRD_PASS => 0,
637 test_rdbms_firebird_interbase => {
638 include => 'rdbms_firebird_interbase',
640 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
641 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
642 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
646 test_rdbms_firebird_odbc => {
647 include => 'rdbms_firebird_odbc',
649 DBICTEST_FIREBIRD_ODBC_DSN => 1,
650 DBICTEST_FIREBIRD_ODBC_USER => 0,
651 DBICTEST_FIREBIRD_ODBC_PASS => 0,
657 DBICTEST_MEMCACHED => 1,
660 'Cache::Memcached' => 0,
665 # we need to run the dbicadmin so we can self-generate its POD
666 # also we do not want surprises in case JSON::XS is in the path
667 # so make sure we get an always-working JSON::Any
668 include => [qw( admin_script _json_xs_compatible_json_any )],
670 'ExtUtils::MakeMaker' => '6.64',
671 'Pod::Inherit' => '0.91',
678 'CPAN::Uploader' => '0.103001',
694 if ($action eq '-die_without') {
698 eval { $class->die_unless_req_ok_for(\@_); 1 }
701 die "\n$err\n" if $err;
703 elsif ($action eq '-list_missing') {
704 print $class->modreq_missing_for(\@_);
708 elsif ($action eq '-skip_all_without') {
710 # sanity check - make sure ->current_test is 0 and no plan has been declared
714 Test::Builder->new->current_test
716 Test::Builder->new->has_plan
718 } and croak("Unable to invoke -skip_all_without after testing has started");
720 if ( my $missing = $class->req_missing_for(\@_) ) {
722 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
723 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
725 print "1..0 # SKIP requirements not satisfied: $missing\n";
729 elsif ($action =~ /^-/) {
730 croak "Unknown import-time action '$action'";
733 croak "$class is not an exporter, unable to import '$action'";
741 croak( __PACKAGE__ . " does not implement unimport" );
744 # OO for (mistakenly considered) ease of extensibility, not due to any need to
745 # carry state of any sort. This API is currently used outside, so leave as-is.
746 # FIXME - make sure to not propagate this further if module is extracted as a
747 # standalone library - keep the stupidity to a DBIC-secific shim!
750 shift->_groups_to_reqs(shift)->{effective_modreqs};
753 sub modreq_list_for {
754 shift->_groups_to_reqs(shift)->{modreqs};
759 { $_ => $_[0]->_groups_to_reqs($_) }
760 grep { $_ !~ /^_/ } keys %$dbic_reqs
764 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
765 sub modreq_errorlist_for {
766 my ($self, $groups) = @_;
767 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
771 shift->req_missing_for(shift) ? 0 : 1;
774 sub req_missing_for {
775 my ($self, $groups) = @_;
777 my $reqs = $self->_groups_to_reqs($groups);
779 my $mods_missing = $reqs->{missing_envvars}
780 ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
781 : $self->modreq_missing_for($groups)
787 ! $reqs->{missing_envvars}
790 my @res = $mods_missing || ();
792 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
793 { __envvar_group_desc($_) }
794 @{$reqs->{missing_envvars}}
795 if $reqs->{missing_envvars};
798 ( join ' as well as ', @res )
800 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
804 sub modreq_missing_for {
805 my ($self, $groups) = @_;
807 my $reqs = $self->_groups_to_reqs($groups);
808 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
812 { $reqs->{modreqs}{$_} ? qq("$_~>=$reqs->{modreqs}{$_}") : $_ }
813 sort { lc($a) cmp lc($b) } keys %$modreq_errors
819 my ($self, $groups) = @_;
821 $tb ||= do { local $@; eval { Test::Builder->new } }
822 or croak "Calling skip_without() before loading Test::Builder makes no sense";
824 if ( my $err = $self->req_missing_for($groups) ) {
825 my ($fn, $ln) = (caller(0))[1,2];
826 $tb->skip("block in $fn around line $ln requires $err");
834 sub die_unless_req_ok_for {
835 if (my $err = shift->req_missing_for(shift) ) {
836 die "Unable to continue due to missing requirements: $err\n";
842 ### Private functions
844 # potentially shorten group desc
845 sub __envvar_group_desc {
848 my (@res, $last_prefix);
849 while (my $ev = shift @envs) {
850 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
852 if ( defined $sep and ($last_prefix||'') eq $pref ) {
853 push @res, "...${sep}${suff}"
859 $last_prefix = $pref if $sep;
865 my $groupname_re = qr/ [A-Z_a-z][0-9A-Z_a-z]* /x;
866 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
867 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
869 # Expand includes from a random group in a specific order:
870 # nonvariable groups first, then their includes, then the variable groups,
871 # then their includes.
872 # This allows reliably marking the rest of the mod reqs as variable (this is
873 # also why variable includes are currently not allowed)
874 sub __expand_includes {
875 my ($groups, $seen) = @_;
877 # !! DIFFERENT !! behavior and return depending on invocation mode
878 # (easier to recurse this way)
879 my $is_toplevel = $seen
884 my ($res_per_type, $missing_envvars);
886 # breadth-first evaluation, with non-variable includes on top
887 for my $g (@$groups) {
889 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
890 if $g !~ qr/ \A $groupname_re \z/x;
892 my $r = $dbic_reqs->{$g}
893 or croak "Requirement group '$g' is not defined";
895 # always do this check *before* the $seen check
896 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
897 if ( $r->{env} and ! $is_toplevel );
899 next if $seen->{$g}++;
901 my $req_type = 'static';
903 if ( my @e = @{$r->{env}||[]} ) {
905 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
906 unless $g =~ /^test_/;
908 croak "Unexpected *odd* list in 'env' under group '$g'"
911 # deconstruct the whole thing
912 my (@group_envnames_list, $some_envs_required, $some_required_missing);
914 push @group_envnames_list, my $envname = shift @e;
916 # env required or not
917 next unless shift @e;
919 $some_envs_required ||= 1;
921 $some_required_missing ||= (
922 ! defined $ENV{$envname}
924 ! length $ENV{$envname}
928 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
929 unless $some_envs_required;
931 if ($some_required_missing) {
932 push @{$missing_envvars->{$g}}, \@group_envnames_list;
933 $req_type = 'variable';
937 push @{$res_per_type->{"base_${req_type}"}}, $g;
939 if (my $i = $dbic_reqs->{$g}{include}) {
940 $i = [ $i ] unless ref $i eq 'ARRAY';
942 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
945 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
950 @{ $res_per_type->{"base_${_}"} || [] },
951 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
952 } qw(static variable);
954 return ! $is_toplevel ? @ret : do {
957 idx => 1 + keys %$rv,
958 missing_envvars => $missing_envvars->{$_},
960 $rv->{$_}{user_requested} = 1 for @$groups;
966 our %req_unavailability_cache;
968 # this method is just a lister and envvar/metadata checker - it does not try to load anything
969 sub _groups_to_reqs {
970 my ($self, $want) = @_;
972 $want = [ $want || () ]
973 unless ref $want eq 'ARRAY';
975 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
980 modreqs_fully_documented => 1,
984 for my $piece (@$want) {
985 if ($piece =~ qr/ \A $groupname_re \z /x) {
986 push @$groups, $piece;
988 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
989 croak "Ad hoc module specification lists '$mod' twice"
990 if exists $ret->{modreqs}{$mod};
992 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
993 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
995 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
998 $ret->{modreqs}{$mod} = $ver;
999 $ret->{modreqs_fully_documented} = 0;
1002 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1006 my $all_groups = __expand_includes($groups);
1008 # pre-assemble list of augmentations, perform basic sanity checks
1009 # Note that below we *DO NOT* respect the source/target reationship, but
1010 # instead always default to augment the "later" group
1011 # This is done so that the "stable/variable" boundary keeps working as
1014 for my $requesting_group (keys %$all_groups) {
1015 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1016 for my $target_group (keys %$ag) {
1018 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1019 unless $dbic_reqs->{$target_group};
1021 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1022 if $dbic_reqs->{$requesting_group}{env};
1024 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1025 if $dbic_reqs->{$target_group}{env};
1027 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1028 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1031 $ret->{augments}{$target_group} = 1;
1033 # no augmentation for stuff that hasn't been selected
1034 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1035 push @{$augmentations->{
1036 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1045 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1047 my $group_reqs = $dbic_reqs->{$group}{req};
1050 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1051 for (keys %$req_bag) {
1053 $_ =~ / \A $modname_re \z /x
1054 or croak "Requirement '$_' in group '$group' is not a valid module name";
1056 # !!!DO NOT CHANGE!!!
1057 # remember - version.pm may not be available on the system
1058 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1059 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1063 if (my $e = $all_groups->{$group}{missing_envvars}) {
1064 push @{$ret->{missing_envvars}}, @$e;
1067 # assemble into the final ret
1070 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1072 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1073 for my $mod (keys %$req_bag) {
1075 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1077 ! exists $ret->{$type}{$mod}
1079 # we sanitized the version to be numeric above - we can just -gt it
1080 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1087 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1088 if $all_groups->{$group}{user_requested};
1090 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1097 # this method tries to find/load specified modreqs and returns a hashref of
1098 # module/loaderror pairs for anything that failed
1099 sub _errorlist_for_modreqs {
1100 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1101 # safe to eval at will
1102 my ($self, $reqs) = @_;
1106 for my $m ( keys %$reqs ) {
1107 my $v = $reqs->{$m};
1109 if (! exists $req_unavailability_cache{$m}{$v} ) {
1111 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1112 $req_unavailability_cache{$m}{$v} = $@;
1115 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1116 if $req_unavailability_cache{$m}{$v};
1122 # Unlike the above DO NOT try to load anything
1123 # This is executed when some needed envvars are not available
1124 # which in turn means a module load will never be reached anyway
1125 # This is important because some modules (especially DBDs) can be
1126 # *really* fickle when a require() is attempted, with pretty confusing
1127 # side-effects (especially on windows)
1128 sub _list_physically_missing_modules {
1129 my ($self, $modreqs) = @_;
1131 # in case there is a coderef in @INC there is nothing we can definitively prove
1132 # so short circuit directly
1133 return '' if grep { length ref $_ } @INC;
1135 my @definitely_missing;
1136 for my $mod (keys %$modreqs) {
1137 (my $fn = $mod . '.pm') =~ s|::|/|g;
1139 push @definitely_missing, $mod unless grep
1140 # this should work on any combination of slashes
1141 { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1147 { $modreqs->{$_} ? qq("$_~>=$modreqs->{$_}") : $_ }
1148 sort { lc($a) cmp lc($b) } @definitely_missing
1153 # This is to be called by the author only (automatically in Makefile.PL)
1155 my ($class, $distver, $pod_dir) = @_;
1157 die "No POD root dir supplied" unless $pod_dir;
1160 eval { require DBIx::Class; DBIx::Class->VERSION; }
1163 "\n\n---------------------------------------------------------------------\n" .
1164 'Unable to load core DBIx::Class module to determine current version, '.
1165 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1167 "\n\n---------------------------------------------------------------------\n"
1170 # do not ask for a recent version, use 1.x API calls
1171 # this *may* execute on a smoker with old perl or whatnot
1174 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1176 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1177 (my $dir = $podfn) =~ s|/[^/]+$||;
1179 File::Path::mkpath([$dir]);
1181 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1182 or die "Hrmm? No sqlt dep?";
1190 push @chunks, <<"EOC";
1191 #########################################################################
1192 ##################### A U T O G E N E R A T E D ########################
1193 #########################################################################
1195 # The contents of this POD file are auto-generated. Any changes you make
1196 # will be lost. If you need to change the generated text edit _gen_pod()
1197 # at the end of $modfn
1202 $class - Optional module dependency specifications (for module authors)
1207 #@@ SYNOPSIS HEADING
1209 push @chunks, <<"EOC";
1212 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1216 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1217 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1218 'DBIx::Class' => '$distver',
1223 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1225 $class->req_list_for([qw( deploy rdbms_oracle icdt )]);
1228 \$EUMM_ARGS{PREREQ_PM} = {
1229 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1230 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1235 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1237 B<Note>: The C<eval> protection within the example is due to support for
1238 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1239 not being available on a sufficient portion of production installations of
1240 Perl. Robust support for such dependency requirements is available in the
1241 L<CPAN> installer only since version C<1.94_56> first made available for
1242 production with perl version C<5.12>. It is the belief of the current
1243 maintainer that support for requirements during the C<configure> build phase
1244 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1245 hence the extra care demonstrated above. It should also be noted that some
1246 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1247 with configure requirements independent from the versions of perl and CPAN
1253 #@@ DESCRIPTION HEADING
1255 push @chunks, <<'EOC';
1258 Some of the less-frequently used features of L<DBIx::Class> have external
1259 module dependencies on their own. In order not to burden the average user
1260 with modules they will never use, these optional dependencies are not included
1261 in the base Makefile.PL. Instead an exception with a descriptive message is
1262 thrown when a specific feature can't find one or several modules required for
1263 its operation. This module is the central holding place for the current list
1264 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1267 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1268 group can list one or more required modules, with an optional minimum version
1269 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1270 a set of environment variables, some (or all) of which are marked as required
1271 for the group to be considered by L</req_list_for>
1273 Each group name (or a combination thereof) can be used in the
1274 L<public methods|/METHODS> as described below.
1279 #@@ REQUIREMENT GROUPLIST HEADING
1281 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1283 my $standalone_info;
1285 for my $group (sort keys %$dbic_reqs) {
1287 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1290 $info->{modreqs_fully_documented}
1292 ( $info->{augments} or $info->{modreqs} )
1295 my $p = $dbic_reqs->{$group}{pod};
1298 "=head2 $p->{title}",
1304 if ( keys %{ $info->{modreqs}||{} } ) {
1306 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1307 ( sort keys %{ $info->{modreqs} } )
1311 push @chunks, '=item * No standalone requirements',
1314 push @chunks, '=back';
1316 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1317 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1319 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1320 for (keys %$newreqs) {
1321 delete $newreqs->{$_} if (
1322 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1324 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1328 if (keys %$newreqs) {
1330 "Combined with L</$ag> additionally requires:",
1333 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1334 ( sort keys %$newreqs )
1344 #@@ API DOCUMENTATION HEADING
1346 push @chunks, <<'EOC';
1348 =head1 IMPORT-LIKE ACTIONS
1350 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1351 supplied to its C<import> method.
1353 =head2 -skip_all_without
1357 =item Arguments: @group_names
1361 A convenience wrapper for use during testing:
1364 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1366 push @chunks, 'Roughly equivalent to the following code:';
1368 push @chunks, sprintf <<'EOS', ($class) x 2;
1372 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1373 print "1..0 # SKIP requirements not satisfied: $missing\n";
1379 push @chunks, <<'EOC';
1381 It also takes into account the C<RELEASE_TESTING> environment variable and
1382 behaves like L</-die_without> for any requirement groups marked as
1383 C<release_testing_mandatory>.
1389 =item Arguments: @group_names
1393 A convenience wrapper around L</die_unless_req_ok_for>:
1396 push @chunks, " use $class -die_without => qw(deploy admin);";
1398 push @chunks, <<'EOC';
1400 =head2 -list_missing
1404 =item Arguments: @group_names
1408 A convenience wrapper around L</modreq_missing_for>:
1410 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1414 =head2 req_group_list
1418 =item Arguments: none
1420 =item Return Value: \%list_of_requirement_groups
1424 This method should be used by DBIx::Class packagers, to get a hashref of all
1425 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1426 thereof (as an arrayref) can be supplied to the methods below.
1427 The B<values> of the returned hash are currently a set of options B<without a
1428 well defined structure>. If you have use for any of the contents - contact the
1429 maintainers, instead of treating this as public (left alone stable) API.
1435 =item Arguments: $group_name | \@group_names
1437 =item Return Value: \%set_of_module_version_pairs
1441 This method should be used by DBIx::Class extension authors, to determine the
1442 version of modules a specific set of features requires for this version of
1443 DBIx::Class (regardless of their availability on the system).
1444 See the L</SYNOPSIS> for a real-world example.
1446 When handling C<test_*> groups this method behaves B<differently> from
1447 L</modreq_list_for> below (and is the only such inconsistency among the
1448 C<req_*> methods). If a particular group declares as requirements some
1449 C<environment variables> and these requirements are not satisfied (the envvars
1450 are unset) - then the C<module requirements> of this group are not included in
1453 =head2 modreq_list_for
1457 =item Arguments: $group_name | \@group_names
1459 =item Return Value: \%set_of_module_version_pairs
1463 Same as L</req_list_for> but does not take into consideration any
1464 C<environment variable requirements> - returns just the list of required
1471 =item Arguments: $group_name | \@group_names
1473 =item Return Value: 1|0
1477 Returns true or false depending on whether all modules/envvars required by
1478 the group(s) are loadable/set on the system.
1480 =head2 req_missing_for
1484 =item Arguments: $group_name | \@group_names
1486 =item Return Value: $error_message_string
1490 Returns a single-line string suitable for inclusion in larger error messages.
1491 This method would normally be used by DBIx::Class core features, to indicate to
1492 the user that they need to install specific modules and/or set specific
1493 environment variables before being able to use a specific feature set.
1495 For example if some of the requirements for C<deploy> are not available,
1496 the returned string could look like:
1499 push @chunks, qq{ "SQL::Translator~>=$sqltver" (see $class documentation for details)};
1501 push @chunks, <<'EOC';
1502 The author is expected to prepend the necessary text to this message before
1503 returning the actual error seen by the user. See also L</modreq_missing_for>
1505 =head2 modreq_missing_for
1509 =item Arguments: $group_name | \@group_names
1511 =item Return Value: $error_message_string
1515 Same as L</req_missing_for> except that the error string is guaranteed to be
1516 either empty, or contain a set of module requirement specifications suitable
1517 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1518 attempt to validate the state of required environment variables (if any).
1520 For instance if some of the requirements for C<deploy> are not available,
1521 the returned string could look like:
1524 push @chunks, qq{ "SQL::Translator~>=$sqltver"};
1526 push @chunks, <<'EOC';
1528 See also L</-list_missing>.
1534 =item Arguments: $group_name | \@group_names
1538 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1539 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1540 (it is always C<1>, thus mandating unconditional use of
1541 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1542 requirement specifications:
1545 push @chunks, <<EOC;
1547 $class->skip_without([ deploy YAML>=0.90 ]);
1553 push @chunks, <<'EOC';
1555 =head2 die_unless_req_ok_for
1559 =item Arguments: $group_name | \@group_names
1563 Checks if L</req_ok_for> passes for the supplied group(s), and
1564 in case of failure throws an exception including the information
1565 from L</req_missing_for>. See also L</-die_without>.
1567 =head2 modreq_errorlist_for
1571 =item Arguments: $group_name | \@group_names
1573 =item Return Value: \%set_of_loaderrors_per_module
1577 Returns a hashref containing the actual errors that occurred while attempting
1578 to load each module in the requirement group(s).
1580 =head2 req_errorlist_for
1582 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1589 push @chunks, <<'EOC';
1590 =head1 FURTHER QUESTIONS?
1592 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1594 =head1 COPYRIGHT AND LICENSE
1596 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1597 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1598 redistribute it and/or modify it under the same terms as the
1599 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1603 open (my $fh, '>', $podfn) or die;
1604 print $fh join ("\n\n", @chunks) or die;
1605 print $fh "\n" or die;
1607 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );