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;
11 # Temporary to satisfy TempExtlib under tests
12 require DBIx::Class::StartupCheck
22 # NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
23 # This module is to be loaded by Makefile.PM on a pristine system
25 # POD is generated automatically by calling _gen_pod from the
26 # Makefile.PL in $AUTHOR mode
28 # *DELIBERATELY* not making a group for these - they must disappear
29 # forever as optdeps in the first place
32 'MooseX::Types' => '0.21',
33 'MooseX::Types::LoadableClass' => '0.011',
38 # NOTE: the rationale for 2 JSON::Any versions is that
39 # we need the newer only to work around JSON::XS, which
40 # itself is an optional dep
43 'JSON::Any' => '1.23',
47 _json_xs_compatible_json_any => {
49 'JSON::Any' => '1.31',
53 # a common placeholder for engines with IC::DT support based off DT::F::S
54 _ic_dt_strptime_based => {
58 'DateTime::Format::Strptime' => '1.2',
64 _rdbms_generic_odbc => {
70 _rdbms_generic_ado => {
76 # must list any dep used by adhoc testing
77 # this prevents the "skips due to forgotten deps" issue
80 'Class::DBI::Plugin::DeepAbstractSearch' => '0',
81 'Class::DBI' => '3.000005',
82 'Date::Simple' => '3.03',
84 'Class::Unload' => '0.07',
86 'Time::Piece::MySQL' => '0',
87 'DBD::mysql' => '4.023',
94 title => 'Storage::Replicated',
95 desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
100 include => 'replicated',
102 'Test::Moose' => '0',
106 config_file_reader => {
108 title => 'Generic config reader',
109 desc => 'Modules required for generic config file parsing, currently Config::Any (rarely used at runtime)',
112 'Config::Any' => '0.20',
117 include => [qw( _json_any config_file_reader )],
120 'MooseX::Types::Path::Class' => '0.05',
121 'MooseX::Types::JSON' => '0.02',
124 title => 'DBIx::Class::Admin',
125 desc => 'Modules required for the DBIx::Class administrative library',
132 'Getopt::Long::Descriptive' => '0.081',
133 'Text::CSV' => '1.16',
136 title => 'dbicadmin',
137 desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
143 'SQL::Translator' => '0.11018',
146 title => 'Storage::DBI::deploy()',
147 desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
153 'Path::Class' => '0.18',
156 title => 'DBIx::Class::InflateColumn::File (Deprecated)',
157 desc => 'Modules required for the deprecated L<DBIx::Class::InflateColumn::File>',
163 'DateTime' => '0.55',
164 'DateTime::TimeZone::OlsonDB' => 0,
167 title => 'InflateColumn::DateTime support',
169 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
170 . 'Note that this group does not require much on its own, but '
171 . 'instead is augmented by various RDBMS-specific groups. See the '
172 . 'documentation of each C<rbms_*> group for details',
178 'Math::BigInt' => '1.80',
179 'Math::Base36' => '0.07',
185 'Class::Trigger' => '0',
186 'DBIx::ContextualFetch' => '0',
190 title => 'DBIx::Class::CDBICompat support',
191 desc => 'Modules required for L<DBIx::Class::CDBICompat>'
197 'Test::Pod' => '1.42',
199 release_testing_mandatory => 1,
202 test_podcoverage => {
204 'Test::Pod::Coverage' => '1.08',
205 'Pod::Coverage' => '0.20',
207 release_testing_mandatory => 1,
212 'Test::EOL' => '1.0',
213 'Test::NoTabs' => '0.9',
215 release_testing_mandatory => 1,
220 'Test::Strict' => '0.20',
222 release_testing_mandatory => 1,
225 test_prettydebug => {
226 include => '_json_any',
229 test_admin_script => {
230 include => [qw( admin_script _json_xs_compatible_json_any )],
234 'Cpanel::JSON::XS' => 0,
237 # for t/admin/10script.t
238 ? ('Win32::ShellQuote' => 0)
239 # DWIW does not compile (./configure even) on win32
240 : ('JSON::DWIW' => 0 )
245 test_leaks_heavy => {
247 'Class::MethodCache' => '0.02',
248 'PadWalker' => '1.06',
254 title => 'Binary datatype support (certain RDBMS)',
256 'Some RDBMS engines require specific versions of the respective DBD '
257 . 'driver for binary data support. Note that this group does not '
258 . 'require anything on its own, but instead is augmented by various '
259 . 'RDBMS-specific groups. See the documentation of each rbms_* group '
264 # this is just for completeness as SQLite
265 # is a core dep of DBIC for testing
271 title => 'SQLite support',
272 desc => 'Modules required to connect to SQLite',
277 'DateTime::Format::SQLite' => '0',
283 # centralize the specification, as we have ICDT tests which can
284 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
289 'DateTime::Format::Pg' => '0.16004',
296 include => [qw( ic_dt _ic_dt_pg_base )],
300 include => '_ic_dt_pg_base',
305 title => 'PostgreSQL support',
306 desc => 'Modules required to connect to PostgreSQL',
311 'DBD::Pg' => '2.009002'
317 _rdbms_mssql_common => {
318 include => '_ic_dt_strptime_based',
321 rdbms_mssql_odbc => {
322 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
324 title => 'MSSQL support via DBD::ODBC',
325 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
329 rdbms_mssql_sybase => {
330 include => '_rdbms_mssql_common',
335 title => 'MSSQL support via DBD::Sybase',
336 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
341 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
343 title => 'MSSQL support via DBD::ADO (Windows only)',
344 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
348 _rdbms_msaccess_common => {
349 include => '_ic_dt_strptime_based',
352 rdbms_msaccess_odbc => {
353 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
355 title => 'MS Access support via DBD::ODBC',
356 desc => 'Modules required to connect to MS Access via DBD::ODBC',
360 rdbms_msaccess_ado => {
361 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
363 title => 'MS Access support via DBD::ADO (Windows only)',
364 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
368 # centralize the specification, as we have ICDT tests which can
369 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
370 _ic_dt_mysql_base => {
374 'DateTime::Format::MySQL' => '0',
381 include => [qw( ic_dt _ic_dt_mysql_base )],
385 include => '_ic_dt_mysql_base',
390 title => 'MySQL support',
391 desc => 'Modules required to connect to MySQL',
396 include => 'id_shortener',
401 title => 'Oracle support',
402 desc => 'Modules required to connect to Oracle',
407 'DateTime::Format::Oracle' => '0',
414 include => '_ic_dt_strptime_based',
419 title => 'Sybase ASE support',
420 desc => 'Modules required to connect to Sybase ASE',
424 _rdbms_db2_common => {
428 'DateTime::Format::DB2' => '0',
435 include => '_rdbms_db2_common',
440 title => 'DB2 support',
441 desc => 'Modules required to connect to DB2',
446 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
448 title => 'DB2 on AS/400 support',
449 desc => 'Modules required to connect to DB2 on AS/400',
454 include => '_ic_dt_strptime_based',
456 'DBD::Informix' => 0,
459 title => 'Informix support',
460 desc => 'Modules required to connect to Informix',
464 _rdbms_sqlanywhere_common => {
465 include => '_ic_dt_strptime_based',
468 rdbms_sqlanywhere => {
469 include => '_rdbms_sqlanywhere_common',
471 'DBD::SQLAnywhere' => 0,
474 title => 'SQLAnywhere support',
475 desc => 'Modules required to connect to SQLAnywhere',
479 rdbms_sqlanywhere_odbc => {
480 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
482 title => 'SQLAnywhere support via DBD::ODBC',
483 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
487 _rdbms_firebird_common => {
488 include => '_ic_dt_strptime_based',
492 include => '_rdbms_firebird_common',
494 'DBD::Firebird' => 0,
497 title => 'Firebird support',
498 desc => 'Modules required to connect to Firebird',
502 rdbms_firebird_interbase => {
503 include => '_rdbms_firebird_common',
505 'DBD::InterBase' => 0,
508 title => 'Firebird support via DBD::InterBase',
509 desc => 'Modules required to connect to Firebird via DBD::InterBase',
513 rdbms_firebird_odbc => {
514 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
516 title => 'Firebird support via DBD::ODBC',
517 desc => 'Modules required to connect to Firebird via DBD::ODBC',
521 test_rdbms_sqlite => {
522 include => 'rdbms_sqlite',
525 ### IMPORTANT - do not raise this dependency
526 ### even though many bugfixes are present in newer versions, the general DBIC
527 ### rule is to bend over backwards for available DBDs (given upgrading them is
528 ### often *not* easy or even possible)
530 'DBD::SQLite' => '1.29',
535 include => 'rdbms_pg',
537 DBICTEST_PG_DSN => 1,
538 DBICTEST_PG_USER => 0,
539 DBICTEST_PG_PASS => 0,
543 test_rdbms_mssql_odbc => {
544 include => 'rdbms_mssql_odbc',
546 DBICTEST_MSSQL_ODBC_DSN => 1,
547 DBICTEST_MSSQL_ODBC_USER => 0,
548 DBICTEST_MSSQL_ODBC_PASS => 0,
552 test_rdbms_mssql_ado => {
553 include => 'rdbms_mssql_ado',
555 DBICTEST_MSSQL_ADO_DSN => 1,
556 DBICTEST_MSSQL_ADO_USER => 0,
557 DBICTEST_MSSQL_ADO_PASS => 0,
561 test_rdbms_mssql_sybase => {
562 include => 'rdbms_mssql_sybase',
564 DBICTEST_MSSQL_DSN => 1,
565 DBICTEST_MSSQL_USER => 0,
566 DBICTEST_MSSQL_PASS => 0,
570 test_rdbms_msaccess_odbc => {
571 include => 'rdbms_msaccess_odbc',
573 DBICTEST_MSACCESS_ODBC_DSN => 1,
574 DBICTEST_MSACCESS_ODBC_USER => 0,
575 DBICTEST_MSACCESS_ODBC_PASS => 0,
582 test_rdbms_msaccess_ado => {
583 include => 'rdbms_msaccess_ado',
585 DBICTEST_MSACCESS_ADO_DSN => 1,
586 DBICTEST_MSACCESS_ADO_USER => 0,
587 DBICTEST_MSACCESS_ADO_PASS => 0,
594 test_rdbms_mysql => {
595 include => 'rdbms_mysql',
597 DBICTEST_MYSQL_DSN => 1,
598 DBICTEST_MYSQL_USER => 0,
599 DBICTEST_MYSQL_PASS => 0,
603 test_rdbms_oracle => {
604 include => 'rdbms_oracle',
606 DBICTEST_ORA_DSN => 1,
607 DBICTEST_ORA_USER => 0,
608 DBICTEST_ORA_PASS => 0,
611 'DBD::Oracle' => '1.24',
616 include => 'rdbms_ase',
618 DBICTEST_SYBASE_DSN => 1,
619 DBICTEST_SYBASE_USER => 0,
620 DBICTEST_SYBASE_PASS => 0,
625 include => 'rdbms_db2',
627 DBICTEST_DB2_DSN => 1,
628 DBICTEST_DB2_USER => 0,
629 DBICTEST_DB2_PASS => 0,
633 test_rdbms_db2_400 => {
634 include => 'rdbms_db2_400',
636 DBICTEST_DB2_400_DSN => 1,
637 DBICTEST_DB2_400_USER => 0,
638 DBICTEST_DB2_400_PASS => 0,
642 test_rdbms_informix => {
643 include => 'rdbms_informix',
645 DBICTEST_INFORMIX_DSN => 1,
646 DBICTEST_INFORMIX_USER => 0,
647 DBICTEST_INFORMIX_PASS => 0,
651 test_rdbms_sqlanywhere => {
652 include => 'rdbms_sqlanywhere',
654 DBICTEST_SQLANYWHERE_DSN => 1,
655 DBICTEST_SQLANYWHERE_USER => 0,
656 DBICTEST_SQLANYWHERE_PASS => 0,
660 test_rdbms_sqlanywhere_odbc => {
661 include => 'rdbms_sqlanywhere_odbc',
663 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
664 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
665 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
669 test_rdbms_firebird => {
670 include => 'rdbms_firebird',
672 DBICTEST_FIREBIRD_DSN => 1,
673 DBICTEST_FIREBIRD_USER => 0,
674 DBICTEST_FIREBIRD_PASS => 0,
678 test_rdbms_firebird_interbase => {
679 include => 'rdbms_firebird_interbase',
681 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
682 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
683 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
687 test_rdbms_firebird_odbc => {
688 include => 'rdbms_firebird_odbc',
690 DBICTEST_FIREBIRD_ODBC_DSN => 1,
691 DBICTEST_FIREBIRD_ODBC_USER => 0,
692 DBICTEST_FIREBIRD_ODBC_PASS => 0,
698 DBICTEST_MEMCACHED => 1,
701 'Cache::Memcached' => 0,
706 # we need to run the dbicadmin so we can self-generate its POD
707 # also we do not want surprises in case JSON::XS is in the path
708 # so make sure we get an always-working JSON::Any
711 _json_xs_compatible_json_any
720 'ExtUtils::MakeMaker' => '6.64',
721 'Module::Install' => '1.06',
722 'Pod::Inherit' => '0.91',
728 'CPAN::Uploader' => '0.103001',
744 if ($action eq '-die_without') {
748 eval { $class->die_unless_req_ok_for(\@_); 1 }
751 die "\n$err\n" if $err;
753 elsif ($action eq '-list_missing') {
754 print $class->modreq_missing_for(\@_);
758 elsif ($action eq '-skip_all_without') {
760 # sanity check - make sure ->current_test is 0 and no plan has been declared
764 Test::Builder->new->current_test
766 Test::Builder->new->has_plan
768 } and croak("Unable to invoke -skip_all_without after testing has started");
770 if ( my $missing = $class->req_missing_for(\@_) ) {
772 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
773 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
775 print "1..0 # SKIP requirements not satisfied: $missing\n";
779 elsif ($action =~ /^-/) {
780 croak "Unknown import-time action '$action'";
783 croak "$class is not an exporter, unable to import '$action'";
791 croak( __PACKAGE__ . " does not implement unimport" );
794 # OO for (mistakenly considered) ease of extensibility, not due to any need to
795 # carry state of any sort. This API is currently used outside, so leave as-is.
796 # FIXME - make sure to not propagate this further if module is extracted as a
797 # standalone library - keep the stupidity to a DBIC-secific shim!
800 shift->_groups_to_reqs(shift)->{effective_modreqs};
803 sub modreq_list_for {
804 shift->_groups_to_reqs(shift)->{modreqs};
809 { $_ => $_[0]->_groups_to_reqs($_) }
810 grep { $_ !~ /^_/ } keys %$dbic_reqs
814 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
815 sub modreq_errorlist_for {
816 my ($self, $groups) = @_;
817 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
821 shift->req_missing_for(shift) ? 0 : 1;
824 sub req_missing_for {
825 my ($self, $groups) = @_;
827 my $reqs = $self->_groups_to_reqs($groups);
829 my $mods_missing = $reqs->{missing_envvars}
830 ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
831 : $self->modreq_missing_for($groups)
837 ! $reqs->{missing_envvars}
840 my @res = $mods_missing || ();
842 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
843 { __envvar_group_desc($_) }
844 @{$reqs->{missing_envvars}}
845 if $reqs->{missing_envvars};
848 ( join ' as well as ', @res )
850 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
854 sub modreq_missing_for {
855 my ($self, $groups) = @_;
857 my $reqs = $self->_groups_to_reqs($groups);
858 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
862 { $reqs->{modreqs}{$_} ? "$_~$reqs->{modreqs}{$_}" : $_ }
863 sort { lc($a) cmp lc($b) } keys %$modreq_errors
869 my ($self, $groups) = @_;
871 $tb ||= do { local $@; eval { Test::Builder->new } }
872 or croak "Calling skip_without() before loading Test::Builder makes no sense";
874 if ( my $err = $self->req_missing_for($groups) ) {
875 my ($fn, $ln) = (caller(0))[1,2];
876 $tb->skip("block in $fn around line $ln requires $err");
878 BEGIN { ${^WARNING_BITS} = "" }
886 sub die_unless_req_ok_for {
887 if (my $err = shift->req_missing_for(shift) ) {
888 die "Unable to continue due to missing requirements: $err\n";
894 ### Private functions
896 # potentially shorten group desc
897 sub __envvar_group_desc {
900 my (@res, $last_prefix);
901 while (my $ev = shift @envs) {
902 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
904 if ( defined $sep and ($last_prefix||'') eq $pref ) {
905 push @res, "...${sep}${suff}"
911 $last_prefix = $pref if $sep;
917 my $groupname_re = qr/ [a-z_] [0-9_a-z]* /x;
918 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
919 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
921 # Expand includes from a random group in a specific order:
922 # nonvariable groups first, then their includes, then the variable groups,
923 # then their includes.
924 # This allows reliably marking the rest of the mod reqs as variable (this is
925 # also why variable includes are currently not allowed)
926 sub __expand_includes {
927 my ($groups, $seen) = @_;
929 # !! DIFFERENT !! behavior and return depending on invocation mode
930 # (easier to recurse this way)
931 my $is_toplevel = $seen
936 my ($res_per_type, $missing_envvars);
938 # breadth-first evaluation, with non-variable includes on top
939 for my $g (@$groups) {
941 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
942 if $g !~ qr/ \A $groupname_re \z/x;
944 my $r = $dbic_reqs->{$g}
945 or croak "Requirement group '$g' is not defined";
947 # always do this check *before* the $seen check
948 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
949 if ( $r->{env} and ! $is_toplevel );
951 next if $seen->{$g}++;
953 my $req_type = 'static';
955 if ( my @e = @{$r->{env}||[]} ) {
957 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
958 unless $g =~ /^test_/;
960 croak "Unexpected *odd* list in 'env' under group '$g'"
963 # deconstruct the whole thing
964 my (@group_envnames_list, $some_envs_required, $some_required_missing);
966 push @group_envnames_list, my $envname = shift @e;
968 # env required or not
969 next unless shift @e;
971 $some_envs_required ||= 1;
973 $some_required_missing ||= (
974 ! defined $ENV{$envname}
976 ! length $ENV{$envname}
980 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
981 unless $some_envs_required;
983 if ($some_required_missing) {
984 push @{$missing_envvars->{$g}}, \@group_envnames_list;
985 $req_type = 'variable';
989 push @{$res_per_type->{"base_${req_type}"}}, $g;
991 if (my $i = $dbic_reqs->{$g}{include}) {
992 $i = [ $i ] unless ref $i eq 'ARRAY';
994 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
997 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
1002 @{ $res_per_type->{"base_${_}"} || [] },
1003 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
1004 } qw(static variable);
1006 return ! $is_toplevel ? @ret : do {
1009 idx => 1 + keys %$rv,
1010 missing_envvars => $missing_envvars->{$_},
1012 $rv->{$_}{user_requested} = 1 for @$groups;
1018 our %req_unavailability_cache;
1020 # this method is just a lister and envvar/metadata checker - it does not try to load anything
1021 sub _groups_to_reqs {
1022 my ($self, $want) = @_;
1024 $want = [ $want || () ]
1025 unless ref $want eq 'ARRAY';
1027 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
1032 modreqs_fully_documented => 1,
1036 for my $piece (@$want) {
1037 if ($piece =~ qr/ \A $groupname_re \z /x) {
1038 push @$groups, $piece;
1040 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
1041 croak "Ad hoc module specification lists '$mod' twice"
1042 if exists $ret->{modreqs}{$mod};
1044 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
1045 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
1047 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
1050 $ret->{modreqs}{$mod} = $ver;
1051 $ret->{modreqs_fully_documented} = 0;
1054 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1058 my $all_groups = __expand_includes($groups);
1060 # pre-assemble list of augmentations, perform basic sanity checks
1061 # Note that below we *DO NOT* respect the source/target reationship, but
1062 # instead always default to augment the "later" group
1063 # This is done so that the "stable/variable" boundary keeps working as
1066 for my $requesting_group (keys %$all_groups) {
1067 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1068 for my $target_group (keys %$ag) {
1070 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1071 unless $dbic_reqs->{$target_group};
1073 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1074 if $dbic_reqs->{$requesting_group}{env};
1076 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1077 if $dbic_reqs->{$target_group}{env};
1079 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1080 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1083 $ret->{augments}{$target_group} = 1;
1085 # no augmentation for stuff that hasn't been selected
1086 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1087 push @{$augmentations->{
1088 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1097 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1099 my $group_reqs = $dbic_reqs->{$group}{req};
1102 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1103 for (keys %$req_bag) {
1105 $_ =~ / \A $modname_re \z /x
1106 or croak "Requirement '$_' in group '$group' is not a valid module name";
1108 # !!!DO NOT CHANGE!!!
1109 # remember - version.pm may not be available on the system
1110 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1111 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1115 if (my $e = $all_groups->{$group}{missing_envvars}) {
1116 push @{$ret->{missing_envvars}}, @$e;
1119 # assemble into the final ret
1122 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1124 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1125 for my $mod (keys %$req_bag) {
1127 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1129 ! exists $ret->{$type}{$mod}
1131 # we sanitized the version to be numeric above - we can just -gt it
1132 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1139 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1140 if $all_groups->{$group}{user_requested};
1142 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1149 # this method tries to find/load specified modreqs and returns a hashref of
1150 # module/loaderror pairs for anything that failed
1151 sub _errorlist_for_modreqs {
1152 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1153 # safe to eval at will
1154 my ($self, $reqs) = @_;
1158 for my $m ( keys %$reqs ) {
1159 my $v = $reqs->{$m};
1161 if (! exists $req_unavailability_cache{$m}{$v} ) {
1162 # masking this off is important, as it may very well be
1164 local $SIG{__DIE__} if $SIG{__DIE__};
1166 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1167 $req_unavailability_cache{$m}{$v} = $@;
1170 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1171 if $req_unavailability_cache{$m}{$v};
1177 # Unlike the above DO NOT try to load anything
1178 # This is executed when some needed envvars are not available
1179 # which in turn means a module load will never be reached anyway
1180 # This is important because some modules (especially DBDs) can be
1181 # *really* fickle when a require() is attempted, with pretty confusing
1182 # side-effects (especially on windows)
1183 sub _list_physically_missing_modules {
1184 my ($self, $modreqs) = @_;
1186 # in case there is a coderef in @INC there is nothing we can definitively prove
1187 # so short circuit directly
1188 return '' if grep { length ref $_ } @INC;
1190 my @definitely_missing;
1191 for my $mod (keys %$modreqs) {
1192 (my $fn = $mod . '.pm') =~ s|::|/|g;
1194 push @definitely_missing, $mod unless grep
1195 # this should work on any combination of slashes
1196 { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1202 { $modreqs->{$_} ? "$_~$modreqs->{$_}" : $_ }
1203 sort { lc($a) cmp lc($b) } @definitely_missing
1208 # This is to be called by the author only (automatically in Makefile.PL)
1210 my ($class, $distver, $pod_dir) = @_;
1212 die "No POD root dir supplied" unless $pod_dir;
1215 eval { require DBIx::Class; DBIx::Class->VERSION; }
1218 "\n\n---------------------------------------------------------------------\n" .
1219 'Unable to load core DBIx::Class module to determine current version, '.
1220 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1222 "\n\n---------------------------------------------------------------------\n"
1225 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1227 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1229 require DBIx::Class::_Util;
1230 DBIx::Class::_Util::mkdir_p( DBIx::Class::_Util::parent_dir( $podfn ) );
1232 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1233 or die "Hrmm? No sqlt dep?";
1241 push @chunks, <<"EOC";
1242 #########################################################################
1243 ##################### A U T O G E N E R A T E D ########################
1244 #########################################################################
1246 # The contents of this POD file are auto-generated. Any changes you make
1247 # will be lost. If you need to change the generated text edit _gen_pod()
1248 # at the end of $modfn
1253 $class - Optional module dependency specifications (for module authors)
1258 #@@ SYNOPSIS HEADING
1260 push @chunks, <<"EOC";
1263 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1267 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1268 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1269 'DBIx::Class' => '$distver',
1274 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1276 $class->req_list_for([qw( deploy rdbms_oracle ic_dt )]);
1279 \$EUMM_ARGS{PREREQ_PM} = {
1280 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1281 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1286 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1288 B<Note>: The C<eval> protection within the example is due to support for
1289 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1290 not being available on a sufficient portion of production installations of
1291 Perl. Robust support for such dependency requirements is available in the
1292 L<CPAN> installer only since version C<1.94_56> first made available for
1293 production with perl version C<5.12>. It is the belief of the current
1294 maintainer that support for requirements during the C<configure> build phase
1295 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1296 hence the extra care demonstrated above. It should also be noted that some
1297 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1298 with configure requirements independent from the versions of perl and CPAN
1304 #@@ DESCRIPTION HEADING
1306 push @chunks, <<'EOC';
1309 Some of the less-frequently used features of L<DBIx::Class> have external
1310 module dependencies on their own. In order not to burden the average user
1311 with modules they will never use, these optional dependencies are not included
1312 in the base Makefile.PL. Instead an exception with a descriptive message is
1313 thrown when a specific feature can't find one or several modules required for
1314 its operation. This module is the central holding place for the current list
1315 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1318 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1319 group can list one or more required modules, with an optional minimum version
1320 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1321 a set of environment variables, some (or all) of which are marked as required
1322 for the group to be considered by L</req_list_for>
1324 Each group name (or a combination thereof) can be used in the
1325 L<public methods|/METHODS> as described below.
1330 #@@ REQUIREMENT GROUPLIST HEADING
1332 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1334 my $standalone_info;
1336 for my $group (sort keys %$dbic_reqs) {
1338 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1341 $info->{modreqs_fully_documented}
1343 ( $info->{augments} or $info->{modreqs} )
1346 my $p = $dbic_reqs->{$group}{pod};
1349 "=head2 $p->{title}",
1355 if ( keys %{ $info->{modreqs}||{} } ) {
1357 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1358 ( sort keys %{ $info->{modreqs} } )
1362 push @chunks, '=item * No standalone requirements',
1365 push @chunks, '=back';
1367 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1368 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1370 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1371 for (keys %$newreqs) {
1372 delete $newreqs->{$_} if (
1373 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1375 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1379 if (keys %$newreqs) {
1381 "Combined with L</$ag> additionally requires:",
1384 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1385 ( sort keys %$newreqs )
1395 #@@ API DOCUMENTATION HEADING
1397 push @chunks, <<'EOC';
1399 =head1 IMPORT-LIKE ACTIONS
1401 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1402 supplied to its C<import> method.
1404 =head2 -skip_all_without
1408 =item Arguments: @group_names
1412 A convenience wrapper for use during testing:
1415 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1417 push @chunks, 'Roughly equivalent to the following code:';
1419 push @chunks, sprintf <<'EOS', ($class) x 2;
1423 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1424 print "1..0 # SKIP requirements not satisfied: $missing\n";
1430 push @chunks, <<'EOC';
1432 It also takes into account the C<RELEASE_TESTING> environment variable and
1433 behaves like L</-die_without> for any requirement groups marked as
1434 C<release_testing_mandatory>.
1440 =item Arguments: @group_names
1444 A convenience wrapper around L</die_unless_req_ok_for>:
1447 push @chunks, " use $class -die_without => qw(deploy admin);";
1449 push @chunks, <<'EOC';
1451 =head2 -list_missing
1455 =item Arguments: @group_names
1459 A convenience wrapper around L</modreq_missing_for>:
1461 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1465 =head2 req_group_list
1469 =item Arguments: none
1471 =item Return Value: \%list_of_requirement_groups
1475 This method should be used by DBIx::Class packagers, to get a hashref of all
1476 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1477 thereof (as an arrayref) can be supplied to the methods below.
1478 The B<values> of the returned hash are currently a set of options B<without a
1479 well defined structure>. If you have use for any of the contents - contact the
1480 maintainers, instead of treating this as public (left alone stable) API.
1486 =item Arguments: $group_name | \@group_names
1488 =item Return Value: \%set_of_module_version_pairs
1492 This method should be used by DBIx::Class extension authors, to determine the
1493 version of modules a specific set of features requires for this version of
1494 DBIx::Class (regardless of their availability on the system).
1495 See the L</SYNOPSIS> for a real-world example.
1497 When handling C<test_*> groups this method behaves B<differently> from
1498 L</modreq_list_for> below (and is the only such inconsistency among the
1499 C<req_*> methods). If a particular group declares as requirements some
1500 C<environment variables> and these requirements are not satisfied (the envvars
1501 are unset) - then the C<module requirements> of this group are not included in
1504 =head2 modreq_list_for
1508 =item Arguments: $group_name | \@group_names
1510 =item Return Value: \%set_of_module_version_pairs
1514 Same as L</req_list_for> but does not take into consideration any
1515 C<environment variable requirements> - returns just the list of required
1522 =item Arguments: $group_name | \@group_names
1524 =item Return Value: 1|0
1528 Returns true or false depending on whether all modules/envvars required by
1529 the group(s) are loadable/set on the system.
1531 =head2 req_missing_for
1535 =item Arguments: $group_name | \@group_names
1537 =item Return Value: $error_message_string
1541 Returns a single-line string suitable for inclusion in larger error messages.
1542 This method would normally be used by DBIx::Class core features, to indicate to
1543 the user that they need to install specific modules and/or set specific
1544 environment variables before being able to use a specific feature set.
1546 For example if some of the requirements for C<deploy> are not available,
1547 the returned string could look like:
1550 push @chunks, qq{ "SQL::Translator~$sqltver" (see $class documentation for details)};
1552 push @chunks, <<'EOC';
1553 The author is expected to prepend the necessary text to this message before
1554 returning the actual error seen by the user. See also L</modreq_missing_for>
1556 =head2 modreq_missing_for
1560 =item Arguments: $group_name | \@group_names
1562 =item Return Value: $error_message_string
1566 Same as L</req_missing_for> except that the error string is guaranteed to be
1567 either empty, or contain a set of module requirement specifications suitable
1568 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1569 attempt to validate the state of required environment variables (if any).
1571 For instance if some of the requirements for C<deploy> are not available,
1572 the returned string could look like:
1575 push @chunks, qq{ "SQL::Translator~$sqltver"};
1577 push @chunks, <<'EOC';
1579 See also L</-list_missing>.
1585 =item Arguments: $group_name | \@group_names
1589 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1590 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1591 (it is always C<1>, thus mandating unconditional use of
1592 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1593 requirement specifications:
1596 push @chunks, <<EOC;
1598 $class->skip_without([ deploy YAML>=0.90 ]);
1604 push @chunks, <<'EOC';
1606 =head2 die_unless_req_ok_for
1610 =item Arguments: $group_name | \@group_names
1614 Checks if L</req_ok_for> passes for the supplied group(s), and
1615 in case of failure throws an exception including the information
1616 from L</req_missing_for>. See also L</-die_without>.
1618 =head2 modreq_errorlist_for
1622 =item Arguments: $group_name | \@group_names
1624 =item Return Value: \%set_of_loaderrors_per_module
1628 Returns a hashref containing the actual errors that occurred while attempting
1629 to load each module in the requirement group(s).
1631 =head2 req_errorlist_for
1633 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1640 push @chunks, <<'EOC';
1641 =head1 FURTHER QUESTIONS?
1643 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1645 =head1 COPYRIGHT AND LICENSE
1647 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1648 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1649 redistribute it and/or modify it under the same terms as the
1650 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1654 open (my $fh, '>', $podfn) or die;
1655 print $fh join ("\n\n", @chunks) or die;
1656 print $fh "\n" or die;
1658 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );