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 'DateTime' => '0.55',
150 'DateTime::TimeZone::OlsonDB' => 0,
153 title => 'InflateColumn::DateTime support',
155 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
156 . 'Note that this group does not require much on its own, but '
157 . 'instead is augmented by various RDBMS-specific groups. See the '
158 . 'documentation of each C<rbms_*> group for details',
164 'Math::BigInt' => '1.80',
165 'Math::Base36' => '0.07',
171 'Class::Data::Inheritable' => '0',
172 'Class::Trigger' => '0',
173 'DBIx::ContextualFetch' => '0',
177 title => 'DBIx::Class::CDBICompat support',
178 desc => 'Modules required for L<DBIx::Class::CDBICompat>'
184 'Test::Pod' => '1.42',
186 release_testing_mandatory => 1,
189 test_podcoverage => {
191 'Test::Pod::Coverage' => '1.08',
192 'Pod::Coverage' => '0.20',
194 release_testing_mandatory => 1,
199 'Test::EOL' => '1.0',
200 'Test::NoTabs' => '0.9',
202 release_testing_mandatory => 1,
207 'Test::Strict' => '0.20',
209 release_testing_mandatory => 1,
212 test_prettydebug => {
213 include => '_json_any',
216 test_admin_script => {
217 include => [qw( admin_script _json_xs_compatible_json_any )],
221 'Cpanel::JSON::XS' => 0,
224 # for t/admin/10script.t
225 ? ('Win32::ShellQuote' => 0)
226 # DWIW does not compile (./configure even) on win32
227 : ('JSON::DWIW' => 0 )
232 test_leaks_heavy => {
234 'Class::MethodCache' => '0.02',
235 'PadWalker' => '1.06',
241 title => 'Binary datatype support (certain RDBMS)',
243 'Some RDBMS engines require specific versions of the respective DBD '
244 . 'driver for binary data support. Note that this group does not '
245 . 'require anything on its own, but instead is augmented by various '
246 . 'RDBMS-specific groups. See the documentation of each rbms_* group '
251 # this is just for completeness as SQLite
252 # is a core dep of DBIC for testing
258 title => 'SQLite support',
259 desc => 'Modules required to connect to SQLite',
264 'DateTime::Format::SQLite' => '0',
270 # centralize the specification, as we have ICDT tests which can
271 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
276 'DateTime::Format::Pg' => '0.16004',
283 include => [qw( ic_dt _ic_dt_pg_base )],
287 include => '_ic_dt_pg_base',
292 title => 'PostgreSQL support',
293 desc => 'Modules required to connect to PostgreSQL',
298 'DBD::Pg' => '2.009002'
304 _rdbms_mssql_common => {
305 include => '_ic_dt_strptime_based',
308 rdbms_mssql_odbc => {
309 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
311 title => 'MSSQL support via DBD::ODBC',
312 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
316 rdbms_mssql_sybase => {
317 include => '_rdbms_mssql_common',
322 title => 'MSSQL support via DBD::Sybase',
323 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
328 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
330 title => 'MSSQL support via DBD::ADO (Windows only)',
331 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
335 _rdbms_msaccess_common => {
336 include => '_ic_dt_strptime_based',
339 rdbms_msaccess_odbc => {
340 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
342 title => 'MS Access support via DBD::ODBC',
343 desc => 'Modules required to connect to MS Access via DBD::ODBC',
347 rdbms_msaccess_ado => {
348 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
350 title => 'MS Access support via DBD::ADO (Windows only)',
351 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
355 # centralize the specification, as we have ICDT tests which can
356 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
357 _ic_dt_mysql_base => {
361 'DateTime::Format::MySQL' => '0',
368 include => [qw( ic_dt _ic_dt_mysql_base )],
372 include => '_ic_dt_mysql_base',
377 title => 'MySQL support',
378 desc => 'Modules required to connect to MySQL',
383 include => 'id_shortener',
388 title => 'Oracle support',
389 desc => 'Modules required to connect to Oracle',
394 'DateTime::Format::Oracle' => '0',
401 include => '_ic_dt_strptime_based',
406 title => 'Sybase ASE support',
407 desc => 'Modules required to connect to Sybase ASE',
411 _rdbms_db2_common => {
415 'DateTime::Format::DB2' => '0',
422 include => '_rdbms_db2_common',
427 title => 'DB2 support',
428 desc => 'Modules required to connect to DB2',
433 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
435 title => 'DB2 on AS/400 support',
436 desc => 'Modules required to connect to DB2 on AS/400',
441 include => '_ic_dt_strptime_based',
443 'DBD::Informix' => 0,
446 title => 'Informix support',
447 desc => 'Modules required to connect to Informix',
451 _rdbms_sqlanywhere_common => {
452 include => '_ic_dt_strptime_based',
455 rdbms_sqlanywhere => {
456 include => '_rdbms_sqlanywhere_common',
458 'DBD::SQLAnywhere' => 0,
461 title => 'SQLAnywhere support',
462 desc => 'Modules required to connect to SQLAnywhere',
466 rdbms_sqlanywhere_odbc => {
467 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
469 title => 'SQLAnywhere support via DBD::ODBC',
470 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
474 _rdbms_firebird_common => {
475 include => '_ic_dt_strptime_based',
479 include => '_rdbms_firebird_common',
481 'DBD::Firebird' => 0,
484 title => 'Firebird support',
485 desc => 'Modules required to connect to Firebird',
489 rdbms_firebird_interbase => {
490 include => '_rdbms_firebird_common',
492 'DBD::InterBase' => 0,
495 title => 'Firebird support via DBD::InterBase',
496 desc => 'Modules required to connect to Firebird via DBD::InterBase',
500 rdbms_firebird_odbc => {
501 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
503 title => 'Firebird support via DBD::ODBC',
504 desc => 'Modules required to connect to Firebird via DBD::ODBC',
508 test_rdbms_sqlite => {
509 include => 'rdbms_sqlite',
512 ### IMPORTANT - do not raise this dependency
513 ### even though many bugfixes are present in newer versions, the general DBIC
514 ### rule is to bend over backwards for available DBDs (given upgrading them is
515 ### often *not* easy or even possible)
517 'DBD::SQLite' => '1.29',
522 include => 'rdbms_pg',
524 DBICTEST_PG_DSN => 1,
525 DBICTEST_PG_USER => 0,
526 DBICTEST_PG_PASS => 0,
530 test_rdbms_mssql_odbc => {
531 include => 'rdbms_mssql_odbc',
533 DBICTEST_MSSQL_ODBC_DSN => 1,
534 DBICTEST_MSSQL_ODBC_USER => 0,
535 DBICTEST_MSSQL_ODBC_PASS => 0,
539 test_rdbms_mssql_ado => {
540 include => 'rdbms_mssql_ado',
542 DBICTEST_MSSQL_ADO_DSN => 1,
543 DBICTEST_MSSQL_ADO_USER => 0,
544 DBICTEST_MSSQL_ADO_PASS => 0,
548 test_rdbms_mssql_sybase => {
549 include => 'rdbms_mssql_sybase',
551 DBICTEST_MSSQL_DSN => 1,
552 DBICTEST_MSSQL_USER => 0,
553 DBICTEST_MSSQL_PASS => 0,
557 test_rdbms_msaccess_odbc => {
558 include => 'rdbms_msaccess_odbc',
560 DBICTEST_MSACCESS_ODBC_DSN => 1,
561 DBICTEST_MSACCESS_ODBC_USER => 0,
562 DBICTEST_MSACCESS_ODBC_PASS => 0,
569 test_rdbms_msaccess_ado => {
570 include => 'rdbms_msaccess_ado',
572 DBICTEST_MSACCESS_ADO_DSN => 1,
573 DBICTEST_MSACCESS_ADO_USER => 0,
574 DBICTEST_MSACCESS_ADO_PASS => 0,
581 test_rdbms_mysql => {
582 include => 'rdbms_mysql',
584 DBICTEST_MYSQL_DSN => 1,
585 DBICTEST_MYSQL_USER => 0,
586 DBICTEST_MYSQL_PASS => 0,
590 test_rdbms_oracle => {
591 include => 'rdbms_oracle',
593 DBICTEST_ORA_DSN => 1,
594 DBICTEST_ORA_USER => 0,
595 DBICTEST_ORA_PASS => 0,
598 'DBD::Oracle' => '1.24',
603 include => 'rdbms_ase',
605 DBICTEST_SYBASE_DSN => 1,
606 DBICTEST_SYBASE_USER => 0,
607 DBICTEST_SYBASE_PASS => 0,
612 include => 'rdbms_db2',
614 DBICTEST_DB2_DSN => 1,
615 DBICTEST_DB2_USER => 0,
616 DBICTEST_DB2_PASS => 0,
620 test_rdbms_db2_400 => {
621 include => 'rdbms_db2_400',
623 DBICTEST_DB2_400_DSN => 1,
624 DBICTEST_DB2_400_USER => 0,
625 DBICTEST_DB2_400_PASS => 0,
629 test_rdbms_informix => {
630 include => 'rdbms_informix',
632 DBICTEST_INFORMIX_DSN => 1,
633 DBICTEST_INFORMIX_USER => 0,
634 DBICTEST_INFORMIX_PASS => 0,
638 test_rdbms_sqlanywhere => {
639 include => 'rdbms_sqlanywhere',
641 DBICTEST_SQLANYWHERE_DSN => 1,
642 DBICTEST_SQLANYWHERE_USER => 0,
643 DBICTEST_SQLANYWHERE_PASS => 0,
647 test_rdbms_sqlanywhere_odbc => {
648 include => 'rdbms_sqlanywhere_odbc',
650 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
651 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
652 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
656 test_rdbms_firebird => {
657 include => 'rdbms_firebird',
659 DBICTEST_FIREBIRD_DSN => 1,
660 DBICTEST_FIREBIRD_USER => 0,
661 DBICTEST_FIREBIRD_PASS => 0,
665 test_rdbms_firebird_interbase => {
666 include => 'rdbms_firebird_interbase',
668 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
669 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
670 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
674 test_rdbms_firebird_odbc => {
675 include => 'rdbms_firebird_odbc',
677 DBICTEST_FIREBIRD_ODBC_DSN => 1,
678 DBICTEST_FIREBIRD_ODBC_USER => 0,
679 DBICTEST_FIREBIRD_ODBC_PASS => 0,
685 DBICTEST_MEMCACHED => 1,
688 'Cache::Memcached' => 0,
693 # we need to run the dbicadmin so we can self-generate its POD
694 # also we do not want surprises in case JSON::XS is in the path
695 # so make sure we get an always-working JSON::Any
698 _json_xs_compatible_json_any
707 'ExtUtils::MakeMaker' => '6.64',
708 'Module::Install' => '1.06',
709 'Pod::Inherit' => '0.91',
715 'CPAN::Uploader' => '0.103001',
731 if ($action eq '-die_without') {
735 eval { $class->die_unless_req_ok_for(\@_); 1 }
738 die "\n$err\n" if $err;
740 elsif ($action eq '-list_missing') {
741 print $class->modreq_missing_for(\@_);
745 elsif ($action eq '-skip_all_without') {
747 # sanity check - make sure ->current_test is 0 and no plan has been declared
751 Test::Builder->new->current_test
753 Test::Builder->new->has_plan
755 } and croak("Unable to invoke -skip_all_without after testing has started");
757 if ( my $missing = $class->req_missing_for(\@_) ) {
759 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
760 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
762 print "1..0 # SKIP requirements not satisfied: $missing\n";
766 elsif ($action =~ /^-/) {
767 croak "Unknown import-time action '$action'";
770 croak "$class is not an exporter, unable to import '$action'";
778 croak( __PACKAGE__ . " does not implement unimport" );
781 # OO for (mistakenly considered) ease of extensibility, not due to any need to
782 # carry state of any sort. This API is currently used outside, so leave as-is.
783 # FIXME - make sure to not propagate this further if module is extracted as a
784 # standalone library - keep the stupidity to a DBIC-secific shim!
787 shift->_groups_to_reqs(shift)->{effective_modreqs};
790 sub modreq_list_for {
791 shift->_groups_to_reqs(shift)->{modreqs};
796 { $_ => $_[0]->_groups_to_reqs($_) }
797 grep { $_ !~ /^_/ } keys %$dbic_reqs
801 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
802 sub modreq_errorlist_for {
803 my ($self, $groups) = @_;
804 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
808 shift->req_missing_for(shift) ? 0 : 1;
811 sub req_missing_for {
812 my ($self, $groups) = @_;
814 my $reqs = $self->_groups_to_reqs($groups);
816 my $mods_missing = $reqs->{missing_envvars}
817 ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
818 : $self->modreq_missing_for($groups)
824 ! $reqs->{missing_envvars}
827 my @res = $mods_missing || ();
829 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
830 { __envvar_group_desc($_) }
831 @{$reqs->{missing_envvars}}
832 if $reqs->{missing_envvars};
835 ( join ' as well as ', @res )
837 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
841 sub modreq_missing_for {
842 my ($self, $groups) = @_;
844 my $reqs = $self->_groups_to_reqs($groups);
845 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
849 { $reqs->{modreqs}{$_} ? "$_~$reqs->{modreqs}{$_}" : $_ }
850 sort { lc($a) cmp lc($b) } keys %$modreq_errors
856 my ($self, $groups) = @_;
858 $tb ||= do { local $@; eval { Test::Builder->new } }
859 or croak "Calling skip_without() before loading Test::Builder makes no sense";
861 if ( my $err = $self->req_missing_for($groups) ) {
862 my ($fn, $ln) = (caller(0))[1,2];
863 $tb->skip("block in $fn around line $ln requires $err");
865 BEGIN { ${^WARNING_BITS} = "" }
873 sub die_unless_req_ok_for {
874 if (my $err = shift->req_missing_for(shift) ) {
875 die "Unable to continue due to missing requirements: $err\n";
881 ### Private functions
883 # potentially shorten group desc
884 sub __envvar_group_desc {
887 my (@res, $last_prefix);
888 while (my $ev = shift @envs) {
889 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
891 if ( defined $sep and ($last_prefix||'') eq $pref ) {
892 push @res, "...${sep}${suff}"
898 $last_prefix = $pref if $sep;
904 my $groupname_re = qr/ [a-z_] [0-9_a-z]* /x;
905 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
906 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
908 # Expand includes from a random group in a specific order:
909 # nonvariable groups first, then their includes, then the variable groups,
910 # then their includes.
911 # This allows reliably marking the rest of the mod reqs as variable (this is
912 # also why variable includes are currently not allowed)
913 sub __expand_includes {
914 my ($groups, $seen) = @_;
916 # !! DIFFERENT !! behavior and return depending on invocation mode
917 # (easier to recurse this way)
918 my $is_toplevel = $seen
923 my ($res_per_type, $missing_envvars);
925 # breadth-first evaluation, with non-variable includes on top
926 for my $g (@$groups) {
928 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
929 if $g !~ qr/ \A $groupname_re \z/x;
931 my $r = $dbic_reqs->{$g}
932 or croak "Requirement group '$g' is not defined";
934 # always do this check *before* the $seen check
935 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
936 if ( $r->{env} and ! $is_toplevel );
938 next if $seen->{$g}++;
940 my $req_type = 'static';
942 if ( my @e = @{$r->{env}||[]} ) {
944 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
945 unless $g =~ /^test_/;
947 croak "Unexpected *odd* list in 'env' under group '$g'"
950 # deconstruct the whole thing
951 my (@group_envnames_list, $some_envs_required, $some_required_missing);
953 push @group_envnames_list, my $envname = shift @e;
955 # env required or not
956 next unless shift @e;
958 $some_envs_required ||= 1;
960 $some_required_missing ||= (
961 ! defined $ENV{$envname}
963 ! length $ENV{$envname}
967 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
968 unless $some_envs_required;
970 if ($some_required_missing) {
971 push @{$missing_envvars->{$g}}, \@group_envnames_list;
972 $req_type = 'variable';
976 push @{$res_per_type->{"base_${req_type}"}}, $g;
978 if (my $i = $dbic_reqs->{$g}{include}) {
979 $i = [ $i ] unless ref $i eq 'ARRAY';
981 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
984 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
989 @{ $res_per_type->{"base_${_}"} || [] },
990 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
991 } qw(static variable);
993 return ! $is_toplevel ? @ret : do {
996 idx => 1 + keys %$rv,
997 missing_envvars => $missing_envvars->{$_},
999 $rv->{$_}{user_requested} = 1 for @$groups;
1005 our %req_unavailability_cache;
1007 # this method is just a lister and envvar/metadata checker - it does not try to load anything
1008 sub _groups_to_reqs {
1009 my ($self, $want) = @_;
1011 $want = [ $want || () ]
1012 unless ref $want eq 'ARRAY';
1014 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
1019 modreqs_fully_documented => 1,
1023 for my $piece (@$want) {
1024 if ($piece =~ qr/ \A $groupname_re \z /x) {
1025 push @$groups, $piece;
1027 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
1028 croak "Ad hoc module specification lists '$mod' twice"
1029 if exists $ret->{modreqs}{$mod};
1031 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
1032 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
1034 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
1037 $ret->{modreqs}{$mod} = $ver;
1038 $ret->{modreqs_fully_documented} = 0;
1041 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1045 my $all_groups = __expand_includes($groups);
1047 # pre-assemble list of augmentations, perform basic sanity checks
1048 # Note that below we *DO NOT* respect the source/target reationship, but
1049 # instead always default to augment the "later" group
1050 # This is done so that the "stable/variable" boundary keeps working as
1053 for my $requesting_group (keys %$all_groups) {
1054 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1055 for my $target_group (keys %$ag) {
1057 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1058 unless $dbic_reqs->{$target_group};
1060 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1061 if $dbic_reqs->{$requesting_group}{env};
1063 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1064 if $dbic_reqs->{$target_group}{env};
1066 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1067 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1070 $ret->{augments}{$target_group} = 1;
1072 # no augmentation for stuff that hasn't been selected
1073 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1074 push @{$augmentations->{
1075 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1084 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1086 my $group_reqs = $dbic_reqs->{$group}{req};
1089 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1090 for (keys %$req_bag) {
1092 $_ =~ / \A $modname_re \z /x
1093 or croak "Requirement '$_' in group '$group' is not a valid module name";
1095 # !!!DO NOT CHANGE!!!
1096 # remember - version.pm may not be available on the system
1097 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1098 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1102 if (my $e = $all_groups->{$group}{missing_envvars}) {
1103 push @{$ret->{missing_envvars}}, @$e;
1106 # assemble into the final ret
1109 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1111 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1112 for my $mod (keys %$req_bag) {
1114 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1116 ! exists $ret->{$type}{$mod}
1118 # we sanitized the version to be numeric above - we can just -gt it
1119 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1126 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1127 if $all_groups->{$group}{user_requested};
1129 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1136 # this method tries to find/load specified modreqs and returns a hashref of
1137 # module/loaderror pairs for anything that failed
1138 sub _errorlist_for_modreqs {
1139 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1140 # safe to eval at will
1141 my ($self, $reqs) = @_;
1145 for my $m ( keys %$reqs ) {
1146 my $v = $reqs->{$m};
1148 if (! exists $req_unavailability_cache{$m}{$v} ) {
1150 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1151 $req_unavailability_cache{$m}{$v} = $@;
1154 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1155 if $req_unavailability_cache{$m}{$v};
1161 # Unlike the above DO NOT try to load anything
1162 # This is executed when some needed envvars are not available
1163 # which in turn means a module load will never be reached anyway
1164 # This is important because some modules (especially DBDs) can be
1165 # *really* fickle when a require() is attempted, with pretty confusing
1166 # side-effects (especially on windows)
1167 sub _list_physically_missing_modules {
1168 my ($self, $modreqs) = @_;
1170 # in case there is a coderef in @INC there is nothing we can definitively prove
1171 # so short circuit directly
1172 return '' if grep { length ref $_ } @INC;
1174 my @definitely_missing;
1175 for my $mod (keys %$modreqs) {
1176 (my $fn = $mod . '.pm') =~ s|::|/|g;
1178 push @definitely_missing, $mod unless grep
1179 # this should work on any combination of slashes
1180 { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1186 { $modreqs->{$_} ? "$_~$modreqs->{$_}" : $_ }
1187 sort { lc($a) cmp lc($b) } @definitely_missing
1192 # This is to be called by the author only (automatically in Makefile.PL)
1194 my ($class, $distver, $pod_dir) = @_;
1196 die "No POD root dir supplied" unless $pod_dir;
1199 eval { require DBIx::Class; DBIx::Class->VERSION; }
1202 "\n\n---------------------------------------------------------------------\n" .
1203 'Unable to load core DBIx::Class module to determine current version, '.
1204 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1206 "\n\n---------------------------------------------------------------------\n"
1209 # do not ask for a recent version, use 1.x API calls
1210 # this *may* execute on a smoker with old perl or whatnot
1213 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1215 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1216 (my $dir = $podfn) =~ s|/[^/]+$||;
1218 File::Path::mkpath([$dir]);
1220 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1221 or die "Hrmm? No sqlt dep?";
1229 push @chunks, <<"EOC";
1230 #########################################################################
1231 ##################### A U T O G E N E R A T E D ########################
1232 #########################################################################
1234 # The contents of this POD file are auto-generated. Any changes you make
1235 # will be lost. If you need to change the generated text edit _gen_pod()
1236 # at the end of $modfn
1241 $class - Optional module dependency specifications (for module authors)
1246 #@@ SYNOPSIS HEADING
1248 push @chunks, <<"EOC";
1251 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1255 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1256 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1257 'DBIx::Class' => '$distver',
1262 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1264 $class->req_list_for([qw( deploy rdbms_oracle ic_dt )]);
1267 \$EUMM_ARGS{PREREQ_PM} = {
1268 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1269 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1274 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1276 B<Note>: The C<eval> protection within the example is due to support for
1277 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1278 not being available on a sufficient portion of production installations of
1279 Perl. Robust support for such dependency requirements is available in the
1280 L<CPAN> installer only since version C<1.94_56> first made available for
1281 production with perl version C<5.12>. It is the belief of the current
1282 maintainer that support for requirements during the C<configure> build phase
1283 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1284 hence the extra care demonstrated above. It should also be noted that some
1285 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1286 with configure requirements independent from the versions of perl and CPAN
1292 #@@ DESCRIPTION HEADING
1294 push @chunks, <<'EOC';
1297 Some of the less-frequently used features of L<DBIx::Class> have external
1298 module dependencies on their own. In order not to burden the average user
1299 with modules they will never use, these optional dependencies are not included
1300 in the base Makefile.PL. Instead an exception with a descriptive message is
1301 thrown when a specific feature can't find one or several modules required for
1302 its operation. This module is the central holding place for the current list
1303 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1306 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1307 group can list one or more required modules, with an optional minimum version
1308 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1309 a set of environment variables, some (or all) of which are marked as required
1310 for the group to be considered by L</req_list_for>
1312 Each group name (or a combination thereof) can be used in the
1313 L<public methods|/METHODS> as described below.
1318 #@@ REQUIREMENT GROUPLIST HEADING
1320 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1322 my $standalone_info;
1324 for my $group (sort keys %$dbic_reqs) {
1326 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1329 $info->{modreqs_fully_documented}
1331 ( $info->{augments} or $info->{modreqs} )
1334 my $p = $dbic_reqs->{$group}{pod};
1337 "=head2 $p->{title}",
1343 if ( keys %{ $info->{modreqs}||{} } ) {
1345 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1346 ( sort keys %{ $info->{modreqs} } )
1350 push @chunks, '=item * No standalone requirements',
1353 push @chunks, '=back';
1355 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1356 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1358 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1359 for (keys %$newreqs) {
1360 delete $newreqs->{$_} if (
1361 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1363 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1367 if (keys %$newreqs) {
1369 "Combined with L</$ag> additionally requires:",
1372 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1373 ( sort keys %$newreqs )
1383 #@@ API DOCUMENTATION HEADING
1385 push @chunks, <<'EOC';
1387 =head1 IMPORT-LIKE ACTIONS
1389 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1390 supplied to its C<import> method.
1392 =head2 -skip_all_without
1396 =item Arguments: @group_names
1400 A convenience wrapper for use during testing:
1403 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1405 push @chunks, 'Roughly equivalent to the following code:';
1407 push @chunks, sprintf <<'EOS', ($class) x 2;
1411 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1412 print "1..0 # SKIP requirements not satisfied: $missing\n";
1418 push @chunks, <<'EOC';
1420 It also takes into account the C<RELEASE_TESTING> environment variable and
1421 behaves like L</-die_without> for any requirement groups marked as
1422 C<release_testing_mandatory>.
1428 =item Arguments: @group_names
1432 A convenience wrapper around L</die_unless_req_ok_for>:
1435 push @chunks, " use $class -die_without => qw(deploy admin);";
1437 push @chunks, <<'EOC';
1439 =head2 -list_missing
1443 =item Arguments: @group_names
1447 A convenience wrapper around L</modreq_missing_for>:
1449 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1453 =head2 req_group_list
1457 =item Arguments: none
1459 =item Return Value: \%list_of_requirement_groups
1463 This method should be used by DBIx::Class packagers, to get a hashref of all
1464 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1465 thereof (as an arrayref) can be supplied to the methods below.
1466 The B<values> of the returned hash are currently a set of options B<without a
1467 well defined structure>. If you have use for any of the contents - contact the
1468 maintainers, instead of treating this as public (left alone stable) API.
1474 =item Arguments: $group_name | \@group_names
1476 =item Return Value: \%set_of_module_version_pairs
1480 This method should be used by DBIx::Class extension authors, to determine the
1481 version of modules a specific set of features requires for this version of
1482 DBIx::Class (regardless of their availability on the system).
1483 See the L</SYNOPSIS> for a real-world example.
1485 When handling C<test_*> groups this method behaves B<differently> from
1486 L</modreq_list_for> below (and is the only such inconsistency among the
1487 C<req_*> methods). If a particular group declares as requirements some
1488 C<environment variables> and these requirements are not satisfied (the envvars
1489 are unset) - then the C<module requirements> of this group are not included in
1492 =head2 modreq_list_for
1496 =item Arguments: $group_name | \@group_names
1498 =item Return Value: \%set_of_module_version_pairs
1502 Same as L</req_list_for> but does not take into consideration any
1503 C<environment variable requirements> - returns just the list of required
1510 =item Arguments: $group_name | \@group_names
1512 =item Return Value: 1|0
1516 Returns true or false depending on whether all modules/envvars required by
1517 the group(s) are loadable/set on the system.
1519 =head2 req_missing_for
1523 =item Arguments: $group_name | \@group_names
1525 =item Return Value: $error_message_string
1529 Returns a single-line string suitable for inclusion in larger error messages.
1530 This method would normally be used by DBIx::Class core features, to indicate to
1531 the user that they need to install specific modules and/or set specific
1532 environment variables before being able to use a specific feature set.
1534 For example if some of the requirements for C<deploy> are not available,
1535 the returned string could look like:
1538 push @chunks, qq{ "SQL::Translator~$sqltver" (see $class documentation for details)};
1540 push @chunks, <<'EOC';
1541 The author is expected to prepend the necessary text to this message before
1542 returning the actual error seen by the user. See also L</modreq_missing_for>
1544 =head2 modreq_missing_for
1548 =item Arguments: $group_name | \@group_names
1550 =item Return Value: $error_message_string
1554 Same as L</req_missing_for> except that the error string is guaranteed to be
1555 either empty, or contain a set of module requirement specifications suitable
1556 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1557 attempt to validate the state of required environment variables (if any).
1559 For instance if some of the requirements for C<deploy> are not available,
1560 the returned string could look like:
1563 push @chunks, qq{ "SQL::Translator~$sqltver"};
1565 push @chunks, <<'EOC';
1567 See also L</-list_missing>.
1573 =item Arguments: $group_name | \@group_names
1577 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1578 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1579 (it is always C<1>, thus mandating unconditional use of
1580 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1581 requirement specifications:
1584 push @chunks, <<EOC;
1586 $class->skip_without([ deploy YAML>=0.90 ]);
1592 push @chunks, <<'EOC';
1594 =head2 die_unless_req_ok_for
1598 =item Arguments: $group_name | \@group_names
1602 Checks if L</req_ok_for> passes for the supplied group(s), and
1603 in case of failure throws an exception including the information
1604 from L</req_missing_for>. See also L</-die_without>.
1606 =head2 modreq_errorlist_for
1610 =item Arguments: $group_name | \@group_names
1612 =item Return Value: \%set_of_loaderrors_per_module
1616 Returns a hashref containing the actual errors that occurred while attempting
1617 to load each module in the requirement group(s).
1619 =head2 req_errorlist_for
1621 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1628 push @chunks, <<'EOC';
1629 =head1 FURTHER QUESTIONS?
1631 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1633 =head1 COPYRIGHT AND LICENSE
1635 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1636 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1637 redistribute it and/or modify it under the same terms as the
1638 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1642 open (my $fh, '>', $podfn) or die;
1643 print $fh join ("\n\n", @chunks) or die;
1644 print $fh "\n" or die;
1646 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );