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 _ic_dt_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',
83 'DBD::mysql' => '4.023',
90 title => 'Storage::Replicated',
91 desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
96 include => 'replicated',
102 config_file_reader => {
104 title => 'Generic config reader',
105 desc => 'Modules required for generic config file parsing, currently Config::Any (rarely used at runtime)',
108 'Config::Any' => '0.20',
113 include => [qw( _json_any config_file_reader )],
116 'MooseX::Types::Path::Class' => '0.05',
117 'MooseX::Types::JSON' => '0.02',
120 title => 'DBIx::Class::Admin',
121 desc => 'Modules required for the DBIx::Class administrative library',
128 'Getopt::Long::Descriptive' => '0.081',
129 'Text::CSV' => '1.16',
132 title => 'dbicadmin',
133 desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
139 'SQL::Translator' => '0.11018',
142 title => 'Storage::DBI::deploy()',
143 desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
149 'Path::Class' => '0.18',
152 title => 'DBIx::Class::InflateColumn::File (Deprecated)',
153 desc => 'Modules required for the deprecated L<DBIx::Class::InflateColumn::File>',
159 'DateTime' => '0.55',
160 'DateTime::TimeZone::OlsonDB' => 0,
163 title => 'InflateColumn::DateTime support',
165 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
166 . 'Note that this group does not require much on its own, but '
167 . 'instead is augmented by various RDBMS-specific groups. See the '
168 . 'documentation of each C<rbms_*> group for details',
174 'Math::BigInt' => '1.80',
175 'Math::Base36' => '0.07',
181 'Class::Trigger' => '0',
182 'DBIx::ContextualFetch' => '0',
186 title => 'DBIx::Class::CDBICompat support',
187 desc => 'Modules required for L<DBIx::Class::CDBICompat>'
193 'Test::Pod' => '1.42',
195 release_testing_mandatory => 1,
198 test_podcoverage => {
200 'Test::Pod::Coverage' => '1.08',
201 'Pod::Coverage' => '0.20',
203 release_testing_mandatory => 1,
208 'Test::EOL' => '1.0',
209 'Test::NoTabs' => '0.9',
211 release_testing_mandatory => 1,
216 'Test::Strict' => '0.20',
218 release_testing_mandatory => 1,
221 test_prettydebug => {
222 include => '_json_any',
225 test_admin_script => {
226 include => [qw( admin_script _json_xs_compatible_json_any )],
230 'Cpanel::JSON::XS' => 0,
233 # for t/admin/10script.t
234 ? ('Win32::ShellQuote' => 0)
235 # DWIW does not compile (./configure even) on win32
236 : ('JSON::DWIW' => 0 )
241 test_leaks_heavy => {
243 'Class::MethodCache' => '0.02',
244 'PadWalker' => '1.06',
250 title => 'Binary datatype support (certain RDBMS)',
252 'Some RDBMS engines require specific versions of the respective DBD '
253 . 'driver for binary data support. Note that this group does not '
254 . 'require anything on its own, but instead is augmented by various '
255 . 'RDBMS-specific groups. See the documentation of each rbms_* group '
260 # this is just for completeness as SQLite
261 # is a core dep of DBIC for testing
267 title => 'SQLite support',
268 desc => 'Modules required to connect to SQLite',
273 'DateTime::Format::SQLite' => '0',
279 # centralize the specification, as we have ICDT tests which can
280 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
285 'DateTime::Format::Pg' => '0.16004',
292 include => [qw( ic_dt _ic_dt_pg_base )],
296 include => '_ic_dt_pg_base',
301 title => 'PostgreSQL support',
302 desc => 'Modules required to connect to PostgreSQL',
307 'DBD::Pg' => '2.009002'
313 _rdbms_mssql_common => {
314 include => '_ic_dt_strptime_based',
317 rdbms_mssql_odbc => {
318 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
320 title => 'MSSQL support via DBD::ODBC',
321 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
325 rdbms_mssql_sybase => {
326 include => '_rdbms_mssql_common',
331 title => 'MSSQL support via DBD::Sybase',
332 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
337 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
339 title => 'MSSQL support via DBD::ADO (Windows only)',
340 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
344 _rdbms_msaccess_common => {
345 include => '_ic_dt_strptime_based',
348 rdbms_msaccess_odbc => {
349 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
351 title => 'MS Access support via DBD::ODBC',
352 desc => 'Modules required to connect to MS Access via DBD::ODBC',
356 rdbms_msaccess_ado => {
357 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
359 title => 'MS Access support via DBD::ADO (Windows only)',
360 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
364 # centralize the specification, as we have ICDT tests which can
365 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
366 _ic_dt_mysql_base => {
370 'DateTime::Format::MySQL' => '0',
377 include => [qw( ic_dt _ic_dt_mysql_base )],
381 include => '_ic_dt_mysql_base',
386 title => 'MySQL support',
387 desc => 'Modules required to connect to MySQL',
392 include => 'id_shortener',
397 title => 'Oracle support',
398 desc => 'Modules required to connect to Oracle',
403 'DateTime::Format::Oracle' => '0',
410 include => '_ic_dt_strptime_based',
415 title => 'Sybase ASE support',
416 desc => 'Modules required to connect to Sybase ASE',
420 _rdbms_db2_common => {
424 'DateTime::Format::DB2' => '0',
431 include => '_rdbms_db2_common',
436 title => 'DB2 support',
437 desc => 'Modules required to connect to DB2',
442 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
444 title => 'DB2 on AS/400 support',
445 desc => 'Modules required to connect to DB2 on AS/400',
450 include => '_ic_dt_strptime_based',
452 'DBD::Informix' => 0,
455 title => 'Informix support',
456 desc => 'Modules required to connect to Informix',
460 _rdbms_sqlanywhere_common => {
461 include => '_ic_dt_strptime_based',
464 rdbms_sqlanywhere => {
465 include => '_rdbms_sqlanywhere_common',
467 'DBD::SQLAnywhere' => 0,
470 title => 'SQLAnywhere support',
471 desc => 'Modules required to connect to SQLAnywhere',
475 rdbms_sqlanywhere_odbc => {
476 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
478 title => 'SQLAnywhere support via DBD::ODBC',
479 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
483 _rdbms_firebird_common => {
484 include => '_ic_dt_strptime_based',
488 include => '_rdbms_firebird_common',
490 'DBD::Firebird' => 0,
493 title => 'Firebird support',
494 desc => 'Modules required to connect to Firebird',
498 rdbms_firebird_interbase => {
499 include => '_rdbms_firebird_common',
501 'DBD::InterBase' => 0,
504 title => 'Firebird support via DBD::InterBase',
505 desc => 'Modules required to connect to Firebird via DBD::InterBase',
509 rdbms_firebird_odbc => {
510 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
512 title => 'Firebird support via DBD::ODBC',
513 desc => 'Modules required to connect to Firebird via DBD::ODBC',
517 test_rdbms_sqlite => {
518 include => 'rdbms_sqlite',
521 ### IMPORTANT - do not raise this dependency
522 ### even though many bugfixes are present in newer versions, the general DBIC
523 ### rule is to bend over backwards for available DBDs (given upgrading them is
524 ### often *not* easy or even possible)
526 'DBD::SQLite' => '1.29',
531 include => 'rdbms_pg',
533 DBICTEST_PG_DSN => 1,
534 DBICTEST_PG_USER => 0,
535 DBICTEST_PG_PASS => 0,
539 test_rdbms_mssql_odbc => {
540 include => 'rdbms_mssql_odbc',
542 DBICTEST_MSSQL_ODBC_DSN => 1,
543 DBICTEST_MSSQL_ODBC_USER => 0,
544 DBICTEST_MSSQL_ODBC_PASS => 0,
548 test_rdbms_mssql_ado => {
549 include => 'rdbms_mssql_ado',
551 DBICTEST_MSSQL_ADO_DSN => 1,
552 DBICTEST_MSSQL_ADO_USER => 0,
553 DBICTEST_MSSQL_ADO_PASS => 0,
557 test_rdbms_mssql_sybase => {
558 include => 'rdbms_mssql_sybase',
560 DBICTEST_MSSQL_DSN => 1,
561 DBICTEST_MSSQL_USER => 0,
562 DBICTEST_MSSQL_PASS => 0,
566 test_rdbms_msaccess_odbc => {
567 include => 'rdbms_msaccess_odbc',
569 DBICTEST_MSACCESS_ODBC_DSN => 1,
570 DBICTEST_MSACCESS_ODBC_USER => 0,
571 DBICTEST_MSACCESS_ODBC_PASS => 0,
578 test_rdbms_msaccess_ado => {
579 include => 'rdbms_msaccess_ado',
581 DBICTEST_MSACCESS_ADO_DSN => 1,
582 DBICTEST_MSACCESS_ADO_USER => 0,
583 DBICTEST_MSACCESS_ADO_PASS => 0,
590 test_rdbms_mysql => {
591 include => 'rdbms_mysql',
593 DBICTEST_MYSQL_DSN => 1,
594 DBICTEST_MYSQL_USER => 0,
595 DBICTEST_MYSQL_PASS => 0,
599 test_rdbms_oracle => {
600 include => 'rdbms_oracle',
602 DBICTEST_ORA_DSN => 1,
603 DBICTEST_ORA_USER => 0,
604 DBICTEST_ORA_PASS => 0,
607 'DBD::Oracle' => '1.24',
612 include => 'rdbms_ase',
614 DBICTEST_SYBASE_DSN => 1,
615 DBICTEST_SYBASE_USER => 0,
616 DBICTEST_SYBASE_PASS => 0,
621 include => 'rdbms_db2',
623 DBICTEST_DB2_DSN => 1,
624 DBICTEST_DB2_USER => 0,
625 DBICTEST_DB2_PASS => 0,
629 test_rdbms_db2_400 => {
630 include => 'rdbms_db2_400',
632 DBICTEST_DB2_400_DSN => 1,
633 DBICTEST_DB2_400_USER => 0,
634 DBICTEST_DB2_400_PASS => 0,
638 test_rdbms_informix => {
639 include => 'rdbms_informix',
641 DBICTEST_INFORMIX_DSN => 1,
642 DBICTEST_INFORMIX_USER => 0,
643 DBICTEST_INFORMIX_PASS => 0,
647 test_rdbms_sqlanywhere => {
648 include => 'rdbms_sqlanywhere',
650 DBICTEST_SQLANYWHERE_DSN => 1,
651 DBICTEST_SQLANYWHERE_USER => 0,
652 DBICTEST_SQLANYWHERE_PASS => 0,
656 test_rdbms_sqlanywhere_odbc => {
657 include => 'rdbms_sqlanywhere_odbc',
659 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
660 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
661 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
665 test_rdbms_firebird => {
666 include => 'rdbms_firebird',
668 DBICTEST_FIREBIRD_DSN => 1,
669 DBICTEST_FIREBIRD_USER => 0,
670 DBICTEST_FIREBIRD_PASS => 0,
674 test_rdbms_firebird_interbase => {
675 include => 'rdbms_firebird_interbase',
677 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
678 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
679 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
683 test_rdbms_firebird_odbc => {
684 include => 'rdbms_firebird_odbc',
686 DBICTEST_FIREBIRD_ODBC_DSN => 1,
687 DBICTEST_FIREBIRD_ODBC_USER => 0,
688 DBICTEST_FIREBIRD_ODBC_PASS => 0,
694 DBICTEST_MEMCACHED => 1,
697 'Cache::Memcached' => 0,
702 # we need to run the dbicadmin so we can self-generate its POD
703 # also we do not want surprises in case JSON::XS is in the path
704 # so make sure we get an always-working JSON::Any
707 _json_xs_compatible_json_any
716 'ExtUtils::MakeMaker' => '6.64',
717 'Module::Install' => '1.06',
718 'Pod::Inherit' => '0.91',
724 'CPAN::Uploader' => '0.103001',
740 if ($action eq '-die_without') {
744 eval { $class->die_unless_req_ok_for(\@_); 1 }
747 die "\n$err\n" if $err;
749 elsif ($action eq '-list_missing') {
750 print $class->modreq_missing_for(\@_);
754 elsif ($action eq '-skip_all_without') {
756 # sanity check - make sure ->current_test is 0 and no plan has been declared
760 Test::Builder->new->current_test
762 Test::Builder->new->has_plan
764 } and croak("Unable to invoke -skip_all_without after testing has started");
766 if ( my $missing = $class->req_missing_for(\@_) ) {
768 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
769 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
771 print "1..0 # SKIP requirements not satisfied: $missing\n";
775 elsif ($action =~ /^-/) {
776 croak "Unknown import-time action '$action'";
779 croak "$class is not an exporter, unable to import '$action'";
787 croak( __PACKAGE__ . " does not implement unimport" );
790 # OO for (mistakenly considered) ease of extensibility, not due to any need to
791 # carry state of any sort. This API is currently used outside, so leave as-is.
792 # FIXME - make sure to not propagate this further if module is extracted as a
793 # standalone library - keep the stupidity to a DBIC-secific shim!
796 shift->_groups_to_reqs(shift)->{effective_modreqs};
799 sub modreq_list_for {
800 shift->_groups_to_reqs(shift)->{modreqs};
805 { $_ => $_[0]->_groups_to_reqs($_) }
806 grep { $_ !~ /^_/ } keys %$dbic_reqs
810 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
811 sub modreq_errorlist_for {
812 my ($self, $groups) = @_;
813 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
817 shift->req_missing_for(shift) ? 0 : 1;
820 sub req_missing_for {
821 my ($self, $groups) = @_;
823 my $reqs = $self->_groups_to_reqs($groups);
825 my $mods_missing = $reqs->{missing_envvars}
826 ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
827 : $self->modreq_missing_for($groups)
833 ! $reqs->{missing_envvars}
836 my @res = $mods_missing || ();
838 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
839 { __envvar_group_desc($_) }
840 @{$reqs->{missing_envvars}}
841 if $reqs->{missing_envvars};
844 ( join ' as well as ', @res )
846 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
850 sub modreq_missing_for {
851 my ($self, $groups) = @_;
853 my $reqs = $self->_groups_to_reqs($groups);
854 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
858 { $reqs->{modreqs}{$_} ? "$_~$reqs->{modreqs}{$_}" : $_ }
859 sort { lc($a) cmp lc($b) } keys %$modreq_errors
865 my ($self, $groups) = @_;
867 $tb ||= do { local $@; eval { Test::Builder->new } }
868 or croak "Calling skip_without() before loading Test::Builder makes no sense";
870 if ( my $err = $self->req_missing_for($groups) ) {
871 my ($fn, $ln) = (caller(0))[1,2];
872 $tb->skip("block in $fn around line $ln requires $err");
874 BEGIN { ${^WARNING_BITS} = "" }
882 sub die_unless_req_ok_for {
883 if (my $err = shift->req_missing_for(shift) ) {
884 die "Unable to continue due to missing requirements: $err\n";
890 ### Private functions
892 # potentially shorten group desc
893 sub __envvar_group_desc {
896 my (@res, $last_prefix);
897 while (my $ev = shift @envs) {
898 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
900 if ( defined $sep and ($last_prefix||'') eq $pref ) {
901 push @res, "...${sep}${suff}"
907 $last_prefix = $pref if $sep;
913 my $groupname_re = qr/ [a-z_] [0-9_a-z]* /x;
914 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
915 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
917 # Expand includes from a random group in a specific order:
918 # nonvariable groups first, then their includes, then the variable groups,
919 # then their includes.
920 # This allows reliably marking the rest of the mod reqs as variable (this is
921 # also why variable includes are currently not allowed)
922 sub __expand_includes {
923 my ($groups, $seen) = @_;
925 # !! DIFFERENT !! behavior and return depending on invocation mode
926 # (easier to recurse this way)
927 my $is_toplevel = $seen
932 my ($res_per_type, $missing_envvars);
934 # breadth-first evaluation, with non-variable includes on top
935 for my $g (@$groups) {
937 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
938 if $g !~ qr/ \A $groupname_re \z/x;
940 my $r = $dbic_reqs->{$g}
941 or croak "Requirement group '$g' is not defined";
943 # always do this check *before* the $seen check
944 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
945 if ( $r->{env} and ! $is_toplevel );
947 next if $seen->{$g}++;
949 my $req_type = 'static';
951 if ( my @e = @{$r->{env}||[]} ) {
953 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
954 unless $g =~ /^test_/;
956 croak "Unexpected *odd* list in 'env' under group '$g'"
959 # deconstruct the whole thing
960 my (@group_envnames_list, $some_envs_required, $some_required_missing);
962 push @group_envnames_list, my $envname = shift @e;
964 # env required or not
965 next unless shift @e;
967 $some_envs_required ||= 1;
969 $some_required_missing ||= (
970 ! defined $ENV{$envname}
972 ! length $ENV{$envname}
976 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
977 unless $some_envs_required;
979 if ($some_required_missing) {
980 push @{$missing_envvars->{$g}}, \@group_envnames_list;
981 $req_type = 'variable';
985 push @{$res_per_type->{"base_${req_type}"}}, $g;
987 if (my $i = $dbic_reqs->{$g}{include}) {
988 $i = [ $i ] unless ref $i eq 'ARRAY';
990 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
993 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
998 @{ $res_per_type->{"base_${_}"} || [] },
999 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
1000 } qw(static variable);
1002 return ! $is_toplevel ? @ret : do {
1005 idx => 1 + keys %$rv,
1006 missing_envvars => $missing_envvars->{$_},
1008 $rv->{$_}{user_requested} = 1 for @$groups;
1014 our %req_unavailability_cache;
1016 # this method is just a lister and envvar/metadata checker - it does not try to load anything
1017 sub _groups_to_reqs {
1018 my ($self, $want) = @_;
1020 $want = [ $want || () ]
1021 unless ref $want eq 'ARRAY';
1023 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
1028 modreqs_fully_documented => 1,
1032 for my $piece (@$want) {
1033 if ($piece =~ qr/ \A $groupname_re \z /x) {
1034 push @$groups, $piece;
1036 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
1037 croak "Ad hoc module specification lists '$mod' twice"
1038 if exists $ret->{modreqs}{$mod};
1040 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
1041 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
1043 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
1046 $ret->{modreqs}{$mod} = $ver;
1047 $ret->{modreqs_fully_documented} = 0;
1050 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1054 my $all_groups = __expand_includes($groups);
1056 # pre-assemble list of augmentations, perform basic sanity checks
1057 # Note that below we *DO NOT* respect the source/target reationship, but
1058 # instead always default to augment the "later" group
1059 # This is done so that the "stable/variable" boundary keeps working as
1062 for my $requesting_group (keys %$all_groups) {
1063 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1064 for my $target_group (keys %$ag) {
1066 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1067 unless $dbic_reqs->{$target_group};
1069 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1070 if $dbic_reqs->{$requesting_group}{env};
1072 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1073 if $dbic_reqs->{$target_group}{env};
1075 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1076 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1079 $ret->{augments}{$target_group} = 1;
1081 # no augmentation for stuff that hasn't been selected
1082 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1083 push @{$augmentations->{
1084 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1093 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1095 my $group_reqs = $dbic_reqs->{$group}{req};
1098 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1099 for (keys %$req_bag) {
1101 $_ =~ / \A $modname_re \z /x
1102 or croak "Requirement '$_' in group '$group' is not a valid module name";
1104 # !!!DO NOT CHANGE!!!
1105 # remember - version.pm may not be available on the system
1106 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1107 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1111 if (my $e = $all_groups->{$group}{missing_envvars}) {
1112 push @{$ret->{missing_envvars}}, @$e;
1115 # assemble into the final ret
1118 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1120 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1121 for my $mod (keys %$req_bag) {
1123 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1125 ! exists $ret->{$type}{$mod}
1127 # we sanitized the version to be numeric above - we can just -gt it
1128 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1135 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1136 if $all_groups->{$group}{user_requested};
1138 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1145 # this method tries to find/load specified modreqs and returns a hashref of
1146 # module/loaderror pairs for anything that failed
1147 sub _errorlist_for_modreqs {
1148 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1149 # safe to eval at will
1150 my ($self, $reqs) = @_;
1154 for my $m ( keys %$reqs ) {
1155 my $v = $reqs->{$m};
1157 if (! exists $req_unavailability_cache{$m}{$v} ) {
1158 # masking this off is important, as it may very well be
1160 local $SIG{__DIE__} if $SIG{__DIE__};
1162 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1163 $req_unavailability_cache{$m}{$v} = $@;
1166 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1167 if $req_unavailability_cache{$m}{$v};
1173 # Unlike the above DO NOT try to load anything
1174 # This is executed when some needed envvars are not available
1175 # which in turn means a module load will never be reached anyway
1176 # This is important because some modules (especially DBDs) can be
1177 # *really* fickle when a require() is attempted, with pretty confusing
1178 # side-effects (especially on windows)
1179 sub _list_physically_missing_modules {
1180 my ($self, $modreqs) = @_;
1182 # in case there is a coderef in @INC there is nothing we can definitively prove
1183 # so short circuit directly
1184 return '' if grep { length ref $_ } @INC;
1186 my @definitely_missing;
1187 for my $mod (keys %$modreqs) {
1188 (my $fn = $mod . '.pm') =~ s|::|/|g;
1190 push @definitely_missing, $mod unless grep
1191 # this should work on any combination of slashes
1192 { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1198 { $modreqs->{$_} ? "$_~$modreqs->{$_}" : $_ }
1199 sort { lc($a) cmp lc($b) } @definitely_missing
1204 # This is to be called by the author only (automatically in Makefile.PL)
1206 my ($class, $distver, $pod_dir) = @_;
1208 die "No POD root dir supplied" unless $pod_dir;
1211 eval { require DBIx::Class; DBIx::Class->VERSION; }
1214 "\n\n---------------------------------------------------------------------\n" .
1215 'Unable to load core DBIx::Class module to determine current version, '.
1216 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1218 "\n\n---------------------------------------------------------------------\n"
1221 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1223 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1225 require DBIx::Class::_Util;
1226 DBIx::Class::_Util::mkdir_p( DBIx::Class::_Util::parent_dir( $podfn ) );
1228 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1229 or die "Hrmm? No sqlt dep?";
1237 push @chunks, <<"EOC";
1238 #########################################################################
1239 ##################### A U T O G E N E R A T E D ########################
1240 #########################################################################
1242 # The contents of this POD file are auto-generated. Any changes you make
1243 # will be lost. If you need to change the generated text edit _gen_pod()
1244 # at the end of $modfn
1249 $class - Optional module dependency specifications (for module authors)
1254 #@@ SYNOPSIS HEADING
1256 push @chunks, <<"EOC";
1259 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1263 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1264 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1265 'DBIx::Class' => '$distver',
1270 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1272 $class->req_list_for([qw( deploy rdbms_oracle ic_dt )]);
1275 \$EUMM_ARGS{PREREQ_PM} = {
1276 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1277 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1282 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1284 B<Note>: The C<eval> protection within the example is due to support for
1285 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1286 not being available on a sufficient portion of production installations of
1287 Perl. Robust support for such dependency requirements is available in the
1288 L<CPAN> installer only since version C<1.94_56> first made available for
1289 production with perl version C<5.12>. It is the belief of the current
1290 maintainer that support for requirements during the C<configure> build phase
1291 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1292 hence the extra care demonstrated above. It should also be noted that some
1293 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1294 with configure requirements independent from the versions of perl and CPAN
1300 #@@ DESCRIPTION HEADING
1302 push @chunks, <<'EOC';
1305 Some of the less-frequently used features of L<DBIx::Class> have external
1306 module dependencies on their own. In order not to burden the average user
1307 with modules they will never use, these optional dependencies are not included
1308 in the base Makefile.PL. Instead an exception with a descriptive message is
1309 thrown when a specific feature can't find one or several modules required for
1310 its operation. This module is the central holding place for the current list
1311 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1314 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1315 group can list one or more required modules, with an optional minimum version
1316 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1317 a set of environment variables, some (or all) of which are marked as required
1318 for the group to be considered by L</req_list_for>
1320 Each group name (or a combination thereof) can be used in the
1321 L<public methods|/METHODS> as described below.
1326 #@@ REQUIREMENT GROUPLIST HEADING
1328 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1330 my $standalone_info;
1332 for my $group (sort keys %$dbic_reqs) {
1334 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1337 $info->{modreqs_fully_documented}
1339 ( $info->{augments} or $info->{modreqs} )
1342 my $p = $dbic_reqs->{$group}{pod};
1345 "=head2 $p->{title}",
1351 if ( keys %{ $info->{modreqs}||{} } ) {
1353 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1354 ( sort keys %{ $info->{modreqs} } )
1358 push @chunks, '=item * No standalone requirements',
1361 push @chunks, '=back';
1363 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1364 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1366 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1367 for (keys %$newreqs) {
1368 delete $newreqs->{$_} if (
1369 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1371 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1375 if (keys %$newreqs) {
1377 "Combined with L</$ag> additionally requires:",
1380 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1381 ( sort keys %$newreqs )
1391 #@@ API DOCUMENTATION HEADING
1393 push @chunks, <<'EOC';
1395 =head1 IMPORT-LIKE ACTIONS
1397 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1398 supplied to its C<import> method.
1400 =head2 -skip_all_without
1404 =item Arguments: @group_names
1408 A convenience wrapper for use during testing:
1411 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1413 push @chunks, 'Roughly equivalent to the following code:';
1415 push @chunks, sprintf <<'EOS', ($class) x 2;
1419 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1420 print "1..0 # SKIP requirements not satisfied: $missing\n";
1426 push @chunks, <<'EOC';
1428 It also takes into account the C<RELEASE_TESTING> environment variable and
1429 behaves like L</-die_without> for any requirement groups marked as
1430 C<release_testing_mandatory>.
1436 =item Arguments: @group_names
1440 A convenience wrapper around L</die_unless_req_ok_for>:
1443 push @chunks, " use $class -die_without => qw(deploy admin);";
1445 push @chunks, <<'EOC';
1447 =head2 -list_missing
1451 =item Arguments: @group_names
1455 A convenience wrapper around L</modreq_missing_for>:
1457 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1461 =head2 req_group_list
1465 =item Arguments: none
1467 =item Return Value: \%list_of_requirement_groups
1471 This method should be used by DBIx::Class packagers, to get a hashref of all
1472 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1473 thereof (as an arrayref) can be supplied to the methods below.
1474 The B<values> of the returned hash are currently a set of options B<without a
1475 well defined structure>. If you have use for any of the contents - contact the
1476 maintainers, instead of treating this as public (left alone stable) API.
1482 =item Arguments: $group_name | \@group_names
1484 =item Return Value: \%set_of_module_version_pairs
1488 This method should be used by DBIx::Class extension authors, to determine the
1489 version of modules a specific set of features requires for this version of
1490 DBIx::Class (regardless of their availability on the system).
1491 See the L</SYNOPSIS> for a real-world example.
1493 When handling C<test_*> groups this method behaves B<differently> from
1494 L</modreq_list_for> below (and is the only such inconsistency among the
1495 C<req_*> methods). If a particular group declares as requirements some
1496 C<environment variables> and these requirements are not satisfied (the envvars
1497 are unset) - then the C<module requirements> of this group are not included in
1500 =head2 modreq_list_for
1504 =item Arguments: $group_name | \@group_names
1506 =item Return Value: \%set_of_module_version_pairs
1510 Same as L</req_list_for> but does not take into consideration any
1511 C<environment variable requirements> - returns just the list of required
1518 =item Arguments: $group_name | \@group_names
1520 =item Return Value: 1|0
1524 Returns true or false depending on whether all modules/envvars required by
1525 the group(s) are loadable/set on the system.
1527 =head2 req_missing_for
1531 =item Arguments: $group_name | \@group_names
1533 =item Return Value: $error_message_string
1537 Returns a single-line string suitable for inclusion in larger error messages.
1538 This method would normally be used by DBIx::Class core features, to indicate to
1539 the user that they need to install specific modules and/or set specific
1540 environment variables before being able to use a specific feature set.
1542 For example if some of the requirements for C<deploy> are not available,
1543 the returned string could look like:
1546 push @chunks, qq{ "SQL::Translator~$sqltver" (see $class documentation for details)};
1548 push @chunks, <<'EOC';
1549 The author is expected to prepend the necessary text to this message before
1550 returning the actual error seen by the user. See also L</modreq_missing_for>
1552 =head2 modreq_missing_for
1556 =item Arguments: $group_name | \@group_names
1558 =item Return Value: $error_message_string
1562 Same as L</req_missing_for> except that the error string is guaranteed to be
1563 either empty, or contain a set of module requirement specifications suitable
1564 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1565 attempt to validate the state of required environment variables (if any).
1567 For instance if some of the requirements for C<deploy> are not available,
1568 the returned string could look like:
1571 push @chunks, qq{ "SQL::Translator~$sqltver"};
1573 push @chunks, <<'EOC';
1575 See also L</-list_missing>.
1581 =item Arguments: $group_name | \@group_names
1585 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1586 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1587 (it is always C<1>, thus mandating unconditional use of
1588 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1589 requirement specifications:
1592 push @chunks, <<EOC;
1594 $class->skip_without([ deploy YAML>=0.90 ]);
1600 push @chunks, <<'EOC';
1602 =head2 die_unless_req_ok_for
1606 =item Arguments: $group_name | \@group_names
1610 Checks if L</req_ok_for> passes for the supplied group(s), and
1611 in case of failure throws an exception including the information
1612 from L</req_missing_for>. See also L</-die_without>.
1614 =head2 modreq_errorlist_for
1618 =item Arguments: $group_name | \@group_names
1620 =item Return Value: \%set_of_loaderrors_per_module
1624 Returns a hashref containing the actual errors that occurred while attempting
1625 to load each module in the requirement group(s).
1627 =head2 req_errorlist_for
1629 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1636 push @chunks, <<'EOC';
1637 =head1 FURTHER QUESTIONS?
1639 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1641 =head1 COPYRIGHT AND LICENSE
1643 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1644 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1645 redistribute it and/or modify it under the same terms as the
1646 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1650 open (my $fh, '>', $podfn) or die;
1651 print $fh join ("\n\n", @chunks) or die;
1652 print $fh "\n" or die;
1654 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );