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
5 use if $ENV{RELEASE_TESTING} => 'warnings';
6 use if $ENV{RELEASE_TESTING} => 'strict';
14 # NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
15 # This module is to be loaded by Makefile.PM on a pristine system
17 # POD is generated automatically by calling _gen_pod from the
18 # Makefile.PL in $AUTHOR mode
20 # *DELIBERATELY* not making a group for these - they must disappear
21 # forever as optdeps in the first place
24 'MooseX::Types' => '0.21',
25 'MooseX::Types::LoadableClass' => '0.011',
30 # NOTE: the rationale for 2 JSON::Any versions is that
31 # we need the newer only to work around JSON::XS, which
32 # itself is an optional dep
35 'JSON::Any' => '1.23',
39 _json_xs_compatible_json_any => {
41 'JSON::Any' => '1.31',
45 # a common placeholder for engines with IC::DT support based off DT::F::S
46 _icdt_strptime_based => {
50 'DateTime::Format::Strptime' => '1.2',
56 _rdbms_generic_odbc => {
62 _rdbms_generic_ado => {
68 # must list any dep used by adhoc testing
69 # this prevents the "skips due to forgotten deps" issue
72 'Date::Simple' => '3.03',
74 'Class::Unload' => '0.07',
81 title => 'Storage::Replicated',
82 desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
87 include => 'replicated',
94 include => '_json_any',
97 'MooseX::Types::Path::Class' => '0.05',
98 'MooseX::Types::JSON' => '0.02',
101 title => 'DBIx::Class::Admin',
102 desc => 'Modules required for the DBIx::Class administrative library',
109 'Getopt::Long::Descriptive' => '0.081',
110 'Text::CSV' => '1.16',
113 title => 'dbicadmin',
114 desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
120 'SQL::Translator' => '0.11018',
123 title => 'Storage::DBI::deploy()',
124 desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
130 'DateTime' => '0.55',
133 title => 'InflateColumn::DateTime support',
135 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
136 . 'Note that this group does not require much on its own, but '
137 . 'instead is augmented by various RDBMS-specific groups. See the '
138 . 'documentation of each C<rbms_*> group for details',
144 'Math::BigInt' => '1.80',
145 'Math::Base36' => '0.07',
151 'Test::Pod' => '1.42',
153 release_testing_mandatory => 1,
156 test_podcoverage => {
158 'Test::Pod::Coverage' => '1.08',
159 'Pod::Coverage' => '0.20',
161 release_testing_mandatory => 1,
166 'Test::EOL' => '1.0',
167 'Test::NoTabs' => '0.9',
169 release_testing_mandatory => 1,
174 'Test::Strict' => '0.20',
176 release_testing_mandatory => 1,
179 test_prettydebug => {
180 include => '_json_any',
183 test_admin_script => {
184 include => [qw( admin_script _json_xs_compatible_json_any )],
188 'Cpanel::JSON::XS' => 0,
191 # for t/admin/10script.t
192 ? ('Win32::ShellQuote' => 0)
193 # DWIW does not compile (./configure even) on win32
194 : ('JSON::DWIW' => 0 )
199 test_leaks_heavy => {
201 'Class::MethodCache' => '0.02',
202 'PadWalker' => '1.06',
209 'Class::DBI::Plugin::DeepAbstractSearch' => '0',
210 'Time::Piece::MySQL' => '0',
214 # this is just for completeness as SQLite
215 # is a core dep of DBIC for testing
221 title => 'SQLite support',
222 desc => 'Modules required to connect to SQLite',
227 'DateTime::Format::SQLite' => '0',
233 # centralize the specification, as we have ICDT tests which can
234 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
235 # not _-prefixed so that it will show up under req_group_list
240 'DateTime::Format::Pg' => '0.16004',
247 include => 'icdt_pg',
249 # when changing this list make sure to adjust xt/optional_deps.t
253 title => 'PostgreSQL support',
254 desc => 'Modules required to connect to PostgreSQL',
258 _rdbms_mssql_common => {
259 include => '_icdt_strptime_based',
262 rdbms_mssql_odbc => {
263 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
265 title => 'MSSQL support via DBD::ODBC',
266 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
270 rdbms_mssql_sybase => {
271 include => '_rdbms_mssql_common',
276 title => 'MSSQL support via DBD::Sybase',
277 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
282 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
284 title => 'MSSQL support via DBD::ADO (Windows only)',
285 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
289 _rdbms_msaccess_common => {
290 include => '_icdt_strptime_based',
293 rdbms_msaccess_odbc => {
294 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
296 title => 'MS Access support via DBD::ODBC',
297 desc => 'Modules required to connect to MS Access via DBD::ODBC',
301 rdbms_msaccess_ado => {
302 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
304 title => 'MS Access support via DBD::ADO (Windows only)',
305 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
309 # centralize the specification, as we have ICDT tests which can
310 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
311 # not _-prefixed so that it will show up under req_group_list
316 'DateTime::Format::MySQL' => '0',
323 include => 'icdt_mysql',
328 title => 'MySQL support',
329 desc => 'Modules required to connect to MySQL',
334 include => 'id_shortener',
339 title => 'Oracle support',
340 desc => 'Modules required to connect to Oracle',
345 'DateTime::Format::Oracle' => '0',
352 include => '_icdt_strptime_based',
357 title => 'Sybase ASE support',
358 desc => 'Modules required to connect to Sybase ASE',
362 _rdbms_db2_common => {
366 'DateTime::Format::DB2' => '0',
373 include => '_rdbms_db2_common',
378 title => 'DB2 support',
379 desc => 'Modules required to connect to DB2',
384 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
386 title => 'DB2 on AS/400 support',
387 desc => 'Modules required to connect to DB2 on AS/400',
392 include => '_icdt_strptime_based',
394 'DBD::Informix' => 0,
397 title => 'Informix support',
398 desc => 'Modules required to connect to Informix',
402 _rdbms_sqlanywhere_common => {
403 inclide => '_icdt_strptime_based',
406 rdbms_sqlanywhere => {
407 include => '_rdbms_sqlanywhere_common',
409 'DBD::SQLAnywhere' => 0,
412 title => 'SQLAnywhere support',
413 desc => 'Modules required to connect to SQLAnywhere',
417 rdbms_sqlanywhere_odbc => {
418 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
420 title => 'SQLAnywhere support via DBD::ODBC',
421 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
425 _rdbms_firebird_common => {
426 include => '_icdt_strptime_based',
430 include => '_rdbms_firebird_common',
432 'DBD::Firebird' => 0,
435 title => 'Firebird support',
436 desc => 'Modules required to connect to Firebird',
440 rdbms_firebird_interbase => {
441 include => '_rdbms_firebird_common',
443 'DBD::InterBase' => 0,
446 title => 'Firebird support via DBD::InterBase',
447 desc => 'Modules required to connect to Firebird via DBD::InterBase',
451 rdbms_firebird_odbc => {
452 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
454 title => 'Firebird support via DBD::ODBC',
455 desc => 'Modules required to connect to Firebird via DBD::ODBC',
459 test_rdbms_sqlite => {
460 include => 'rdbms_sqlite',
463 ### IMPORTANT - do not raise this dependency
464 ### even though many bugfixes are present in newer versions, the general DBIC
465 ### rule is to bend over backwards for available DBDs (given upgrading them is
466 ### often *not* easy or even possible)
468 'DBD::SQLite' => '1.29',
473 include => 'rdbms_pg',
475 DBICTEST_PG_DSN => 1,
476 DBICTEST_PG_USER => 0,
477 DBICTEST_PG_PASS => 0,
480 # the order does matter because the rdbms support group might require
481 # a different version that the test group
483 # when changing this list make sure to adjust xt/optional_deps.t
484 'DBD::Pg' => '2.009002', # specific version to test bytea
488 test_rdbms_mssql_odbc => {
489 include => 'rdbms_mssql_odbc',
491 DBICTEST_MSSQL_ODBC_DSN => 1,
492 DBICTEST_MSSQL_ODBC_USER => 0,
493 DBICTEST_MSSQL_ODBC_PASS => 0,
497 test_rdbms_mssql_ado => {
498 include => 'rdbms_mssql_ado',
500 DBICTEST_MSSQL_ADO_DSN => 1,
501 DBICTEST_MSSQL_ADO_USER => 0,
502 DBICTEST_MSSQL_ADO_PASS => 0,
506 test_rdbms_mssql_sybase => {
507 include => 'rdbms_mssql_sybase',
509 DBICTEST_MSSQL_DSN => 1,
510 DBICTEST_MSSQL_USER => 0,
511 DBICTEST_MSSQL_PASS => 0,
515 test_rdbms_msaccess_odbc => {
516 include => 'rdbms_msaccess_odbc',
518 DBICTEST_MSACCESS_ODBC_DSN => 1,
519 DBICTEST_MSACCESS_ODBC_USER => 0,
520 DBICTEST_MSACCESS_ODBC_PASS => 0,
527 test_rdbms_msaccess_ado => {
528 include => 'rdbms_msaccess_ado',
530 DBICTEST_MSACCESS_ADO_DSN => 1,
531 DBICTEST_MSACCESS_ADO_USER => 0,
532 DBICTEST_MSACCESS_ADO_PASS => 0,
539 test_rdbms_mysql => {
540 include => 'rdbms_mysql',
542 DBICTEST_MYSQL_DSN => 1,
543 DBICTEST_MYSQL_USER => 0,
544 DBICTEST_MYSQL_PASS => 0,
548 test_rdbms_oracle => {
549 include => 'rdbms_oracle',
551 DBICTEST_ORA_DSN => 1,
552 DBICTEST_ORA_USER => 0,
553 DBICTEST_ORA_PASS => 0,
556 'DBD::Oracle' => '1.24',
561 include => 'rdbms_ase',
563 DBICTEST_SYBASE_DSN => 1,
564 DBICTEST_SYBASE_USER => 0,
565 DBICTEST_SYBASE_PASS => 0,
570 include => 'rdbms_db2',
572 DBICTEST_DB2_DSN => 1,
573 DBICTEST_DB2_USER => 0,
574 DBICTEST_DB2_PASS => 0,
578 test_rdbms_db2_400 => {
579 include => 'rdbms_db2_400',
581 DBICTEST_DB2_400_DSN => 1,
582 DBICTEST_DB2_400_USER => 0,
583 DBICTEST_DB2_400_PASS => 0,
587 test_rdbms_informix => {
588 include => 'rdbms_informix',
590 DBICTEST_INFORMIX_DSN => 1,
591 DBICTEST_INFORMIX_USER => 0,
592 DBICTEST_INFORMIX_PASS => 0,
596 test_rdbms_sqlanywhere => {
597 include => 'rdbms_sqlanywhere',
599 DBICTEST_SQLANYWHERE_DSN => 1,
600 DBICTEST_SQLANYWHERE_USER => 0,
601 DBICTEST_SQLANYWHERE_PASS => 0,
605 test_rdbms_sqlanywhere_odbc => {
606 include => 'rdbms_sqlanywhere_odbc',
608 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
609 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
610 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
614 test_rdbms_firebird => {
615 include => 'rdbms_firebird',
617 DBICTEST_FIREBIRD_DSN => 1,
618 DBICTEST_FIREBIRD_USER => 0,
619 DBICTEST_FIREBIRD_PASS => 0,
623 test_rdbms_firebird_interbase => {
624 include => 'rdbms_firebird_interbase',
626 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
627 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
628 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
632 test_rdbms_firebird_odbc => {
633 include => 'rdbms_firebird_odbc',
635 DBICTEST_FIREBIRD_ODBC_DSN => 1,
636 DBICTEST_FIREBIRD_ODBC_USER => 0,
637 DBICTEST_FIREBIRD_ODBC_PASS => 0,
643 DBICTEST_MEMCACHED => 1,
646 'Cache::Memcached' => 0,
651 # we need to run the dbicadmin so we can self-generate its POD
652 # also we do not want surprises in case JSON::XS is in the path
653 # so make sure we get an always-working JSON::Any
654 include => [qw( admin_script _json_xs_compatible_json_any )],
656 'ExtUtils::MakeMaker' => '6.64',
657 'Pod::Inherit' => '0.91',
663 'CPAN::Uploader' => '0.103001',
679 if ($action eq '-die_without') {
683 eval { $class->die_unless_req_ok_for(\@_); 1 }
686 die "\n$err\n" if $err;
688 elsif ($action eq '-list_missing') {
689 print $class->modreq_missing_for(\@_);
693 elsif ($action eq '-skip_all_without') {
695 # sanity check - make sure ->current_test is 0 and no plan has been declared
699 Test::Builder->new->current_test
701 Test::Builder->new->has_plan
703 } and croak("Unable to invoke -skip_all_without after testing has started");
705 if ( my $missing = $class->req_missing_for(\@_) ) {
707 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
708 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
710 print "1..0 # SKIP requirements not satisfied: $missing\n";
714 elsif ($action =~ /^-/) {
715 croak "Unknown import-time action '$action'";
718 croak "$class is not an exporter, unable to import '$action'";
726 croak( __PACKAGE__ . " does not implement unimport" );
729 # OO for (mistakenly considered) ease of extensibility, not due to any need to
730 # carry state of any sort. This API is currently used outside, so leave as-is.
731 # FIXME - make sure to not propagate this further if module is extracted as a
732 # standalone library - keep the stupidity to a DBIC-secific shim!
735 shift->_groups_to_reqs(shift)->{effective_modreqs};
738 sub modreq_list_for {
739 shift->_groups_to_reqs(shift)->{modreqs};
744 { $_ => $_[0]->_groups_to_reqs($_) }
745 grep { $_ !~ /^_/ } keys %$dbic_reqs
749 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
750 sub modreq_errorlist_for {
751 my ($self, $groups) = @_;
752 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
756 shift->req_missing_for(shift) ? 0 : 1;
759 sub req_missing_for {
760 my ($self, $groups) = @_;
762 my $reqs = $self->_groups_to_reqs($groups);
763 my $mods_missing = $self->modreq_missing_for($groups);
768 ! $reqs->{missing_envvars}
771 my @res = $mods_missing || ();
773 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
774 { __envvar_group_desc($_) }
775 @{$reqs->{missing_envvars}}
776 if $reqs->{missing_envvars};
779 ( join ' as well as ', @res )
781 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
785 sub modreq_missing_for {
786 my ($self, $groups) = @_;
788 my $reqs = $self->_groups_to_reqs($groups);
789 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
793 { $reqs->{modreqs}{$_} ? qq("$_~>=$reqs->{modreqs}{$_}") : $_ }
794 sort { lc($a) cmp lc($b) } keys %$modreq_errors
800 my ($self, $groups) = @_;
802 $tb ||= do { local $@; eval { Test::Builder->new } }
803 or croak "Calling skip_without() before loading Test::Builder makes no sense";
805 if ( my $err = $self->req_missing_for($groups) ) {
806 my ($fn, $ln) = (caller(0))[1,2];
807 $tb->skip("block in $fn around line $ln requires $err");
815 sub die_unless_req_ok_for {
816 if (my $err = shift->req_missing_for(shift) ) {
817 die "Unable to continue due to missing requirements: $err\n";
823 ### Private functions
825 # potentially shorten group desc
826 sub __envvar_group_desc {
829 my (@res, $last_prefix);
830 while (my $ev = shift @envs) {
831 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
833 if ( defined $sep and ($last_prefix||'') eq $pref ) {
834 push @res, "...${sep}${suff}"
840 $last_prefix = $pref if $sep;
846 my $groupname_re = qr/ [A-Z_a-z][0-9A-Z_a-z]* /x;
847 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
848 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
850 # Expand includes from a random group in a specific order:
851 # nonvariable groups first, then their includes, then the variable groups,
852 # then their includes.
853 # This allows reliably marking the rest of the mod reqs as variable (this is
854 # also why variable includes are currently not allowed)
855 sub __expand_includes {
856 my ($groups, $seen) = @_;
858 # !! DIFFERENT !! behavior and return depending on invocation mode
859 # (easier to recurse this way)
860 my $is_toplevel = $seen
865 my ($res_per_type, $missing_envvars);
867 # breadth-first evaluation, with non-variable includes on top
868 for my $g (@$groups) {
870 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
871 if $g !~ qr/ \A $groupname_re \z/x;
873 my $r = $dbic_reqs->{$g}
874 or croak "Requirement group '$g' is not defined";
876 # always do this check *before* the $seen check
877 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
878 if ( $r->{env} and ! $is_toplevel );
880 next if $seen->{$g}++;
882 my $req_type = 'static';
884 if ( my @e = @{$r->{env}||[]} ) {
886 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
887 unless $g =~ /^test_/;
889 croak "Unexpected *odd* list in 'env' under group '$g'"
892 # deconstruct the whole thing
893 my (@group_envnames_list, $some_envs_required, $some_required_missing);
895 push @group_envnames_list, my $envname = shift @e;
897 # env required or not
898 next unless shift @e;
900 $some_envs_required ||= 1;
902 $some_required_missing ||= (
903 ! defined $ENV{$envname}
905 ! length $ENV{$envname}
909 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
910 unless $some_envs_required;
912 if ($some_required_missing) {
913 push @{$missing_envvars->{$g}}, \@group_envnames_list;
914 $req_type = 'variable';
918 push @{$res_per_type->{"base_${req_type}"}}, $g;
920 if (my $i = $dbic_reqs->{$g}{include}) {
921 $i = [ $i ] unless ref $i eq 'ARRAY';
923 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
926 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
931 @{ $res_per_type->{"base_${_}"} || [] },
932 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
933 } qw(static variable);
935 return ! $is_toplevel ? @ret : do {
938 idx => 1 + keys %$rv,
939 missing_envvars => $missing_envvars->{$_},
941 $rv->{$_}{user_requested} = 1 for @$groups;
947 our %req_unavailability_cache;
949 # this method is just a lister and envvar/metadata checker - it does not try to load anything
950 sub _groups_to_reqs {
951 my ($self, $want) = @_;
953 $want = [ $want || () ]
954 unless ref $want eq 'ARRAY';
956 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
961 modreqs_fully_documented => 1,
965 for my $piece (@$want) {
966 if ($piece =~ qr/ \A $groupname_re \z /x) {
967 push @$groups, $piece;
969 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
970 croak "Ad hoc module specification lists '$mod' twice"
971 if exists $ret->{modreqs}{$mod};
973 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
974 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
976 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
979 $ret->{modreqs}{$mod} = $ver;
980 $ret->{modreqs_fully_documented} = 0;
983 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
987 my $all_groups = __expand_includes($groups);
989 # pre-assemble list of augmentations, perform basic sanity checks
990 # Note that below we *DO NOT* respect the source/target reationship, but
991 # instead always default to augment the "later" group
992 # This is done so that the "stable/variable" boundary keeps working as
995 for my $requesting_group (keys %$all_groups) {
996 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
997 for my $target_group (keys %$ag) {
999 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1000 unless $dbic_reqs->{$target_group};
1002 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1003 if $dbic_reqs->{$requesting_group}{env};
1005 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1006 if $dbic_reqs->{$target_group}{env};
1008 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1009 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1012 $ret->{augments}{$target_group} = 1;
1014 # no augmentation for stuff that hasn't been selected
1015 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1016 push @{$augmentations->{
1017 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1026 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1028 my $group_reqs = $dbic_reqs->{$group}{req};
1031 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1032 for (keys %$req_bag) {
1034 $_ =~ / \A $modname_re \z /x
1035 or croak "Requirement '$_' in group '$group' is not a valid module name";
1037 # !!!DO NOT CHANGE!!!
1038 # remember - version.pm may not be available on the system
1039 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1040 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1044 if (my $e = $all_groups->{$group}{missing_envvars}) {
1045 push @{$ret->{missing_envvars}}, @$e;
1048 # assemble into the final ret
1051 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1053 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1054 for my $mod (keys %$req_bag) {
1056 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1058 ! exists $ret->{$type}{$mod}
1060 # we sanitized the version to be numeric above - we can just -gt it
1061 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1068 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1069 if $all_groups->{$group}{user_requested};
1071 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1078 # this method tries to load specified modreqs and returns a hashref of
1079 # module/loaderror pairs for anything that failed
1080 sub _errorlist_for_modreqs {
1081 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1082 # safe to eval at will
1083 my ($self, $reqs) = @_;
1087 for my $m ( keys %$reqs ) {
1088 my $v = $reqs->{$m};
1090 if (! exists $req_unavailability_cache{$m}{$v} ) {
1092 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1093 $req_unavailability_cache{$m}{$v} = $@;
1096 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1097 if $req_unavailability_cache{$m}{$v};
1104 # This is to be called by the author only (automatically in Makefile.PL)
1106 my ($class, $distver, $pod_dir) = @_;
1108 die "No POD root dir supplied" unless $pod_dir;
1111 eval { require DBIx::Class; DBIx::Class->VERSION; }
1114 "\n\n---------------------------------------------------------------------\n" .
1115 'Unable to load core DBIx::Class module to determine current version, '.
1116 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1118 "\n\n---------------------------------------------------------------------\n"
1121 # do not ask for a recent version, use 1.x API calls
1122 # this *may* execute on a smoker with old perl or whatnot
1125 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1127 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1128 (my $dir = $podfn) =~ s|/[^/]+$||;
1130 File::Path::mkpath([$dir]);
1132 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1133 or die "Hrmm? No sqlt dep?";
1141 push @chunks, <<"EOC";
1142 #########################################################################
1143 ##################### A U T O G E N E R A T E D ########################
1144 #########################################################################
1146 # The contents of this POD file are auto-generated. Any changes you make
1147 # will be lost. If you need to change the generated text edit _gen_pod()
1148 # at the end of $modfn
1153 $class - Optional module dependency specifications (for module authors)
1158 #@@ SYNOPSIS HEADING
1160 push @chunks, <<"EOC";
1163 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1167 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1168 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1169 'DBIx::Class' => '$distver',
1174 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1176 $class->req_list_for([qw( deploy rdbms_oracle icdt )]);
1179 \$EUMM_ARGS{PREREQ_PM} = {
1180 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1181 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1186 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1188 B<Note>: The C<eval> protection within the example is due to support for
1189 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1190 not being available on a sufficient portion of production installations of
1191 Perl. Robust support for such dependency requirements is available in the
1192 L<CPAN> installer only since version C<1.94_56> first made available for
1193 production with perl version C<5.12>. It is the belief of the current
1194 maintainer that support for requirements during the C<configure> build phase
1195 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1196 hence the extra care demonstrated above. It should also be noted that some
1197 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1198 with configure requirements independent from the versions of perl and CPAN
1204 #@@ DESCRIPTION HEADING
1206 push @chunks, <<'EOC';
1209 Some of the less-frequently used features of L<DBIx::Class> have external
1210 module dependencies on their own. In order not to burden the average user
1211 with modules they will never use, these optional dependencies are not included
1212 in the base Makefile.PL. Instead an exception with a descriptive message is
1213 thrown when a specific feature can't find one or several modules required for
1214 its operation. This module is the central holding place for the current list
1215 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1218 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1219 group can list one or more required modules, with an optional minimum version
1220 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1221 a set of environment variables, some (or all) of which are marked as required
1222 for the group to be considered by L</req_list_for>
1224 Each group name (or a combination thereof) can be used in the
1225 L<public methods|/METHODS> as described below.
1230 #@@ REQUIREMENT GROUPLIST HEADING
1232 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1234 my $standalone_info;
1236 for my $group (sort keys %$dbic_reqs) {
1238 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1241 $info->{modreqs_fully_documented}
1243 ( $info->{augments} or $info->{modreqs} )
1246 my $p = $dbic_reqs->{$group}{pod};
1249 "=head2 $p->{title}",
1255 if ( keys %{ $info->{modreqs}||{} } ) {
1257 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1258 ( sort keys %{ $info->{modreqs} } )
1262 push @chunks, '=item * No standalone requirements',
1265 push @chunks, '=back';
1267 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1268 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1270 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1271 for (keys %$newreqs) {
1272 delete $newreqs->{$_} if (
1273 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1275 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1279 if (keys %$newreqs) {
1281 "Combined with L</$ag> additionally requires:",
1284 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1285 ( sort keys %$newreqs )
1295 #@@ API DOCUMENTATION HEADING
1297 push @chunks, <<'EOC';
1299 =head1 IMPORT-LIKE ACTIONS
1301 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1302 supplied to its C<import> method.
1304 =head2 -skip_all_without
1308 =item Arguments: @group_names
1312 A convenience wrapper for use during testing:
1315 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1317 push @chunks, 'Roughly equivalent to the following code:';
1319 push @chunks, sprintf <<'EOS', ($class) x 2;
1323 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1324 print "1..0 # SKIP requirements not satisfied: $missing\n";
1330 push @chunks, <<'EOC';
1332 It also takes into account the C<RELEASE_TESTING> environment variable and
1333 behaves like L</-die_without> for any requirement groups marked as
1334 C<release_testing_mandatory>.
1340 =item Arguments: @group_names
1344 A convenience wrapper around L</die_unless_req_ok_for>:
1347 push @chunks, " use $class -die_without => qw(deploy admin);";
1349 push @chunks, <<'EOC';
1351 =head2 -list_missing
1355 =item Arguments: @group_names
1359 A convenience wrapper around L</modreq_missing_for>:
1361 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1365 =head2 req_group_list
1369 =item Arguments: none
1371 =item Return Value: \%list_of_requirement_groups
1375 This method should be used by DBIx::Class packagers, to get a hashref of all
1376 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1377 thereof (as an arrayref) can be supplied to the methods below.
1378 The B<values> of the returned hash are currently a set of options B<without a
1379 well defined structure>. If you have use for any of the contents - contact the
1380 maintainers, instead of treating this as public (left alone stable) API.
1386 =item Arguments: $group_name | \@group_names
1388 =item Return Value: \%set_of_module_version_pairs
1392 This method should be used by DBIx::Class extension authors, to determine the
1393 version of modules a specific set of features requires for this version of
1394 DBIx::Class (regardless of their availability on the system).
1395 See the L</SYNOPSIS> for a real-world example.
1397 When handling C<test_*> groups this method behaves B<differently> from
1398 L</modreq_list_for> below (and is the only such inconsistency among the
1399 C<req_*> methods). If a particular group declares as requirements some
1400 C<environment variables> and these requirements are not satisfied (the envvars
1401 are unset) - then the C<module requirements> of this group are not included in
1404 =head2 modreq_list_for
1408 =item Arguments: $group_name | \@group_names
1410 =item Return Value: \%set_of_module_version_pairs
1414 Same as L</req_list_for> but does not take into consideration any
1415 C<environment variable requirements> - returns just the list of required
1422 =item Arguments: $group_name | \@group_names
1424 =item Return Value: 1|0
1428 Returns true or false depending on whether all modules/envvars required by
1429 the group(s) are loadable/set on the system.
1431 =head2 req_missing_for
1435 =item Arguments: $group_name | \@group_names
1437 =item Return Value: $error_message_string
1441 Returns a single-line string suitable for inclusion in larger error messages.
1442 This method would normally be used by DBIx::Class core features, to indicate to
1443 the user that they need to install specific modules and/or set specific
1444 environment variables before being able to use a specific feature set.
1446 For example if some of the requirements for C<deploy> are not available,
1447 the returned string could look like:
1450 push @chunks, qq{ "SQL::Translator~>=$sqltver" (see $class documentation for details)};
1452 push @chunks, <<'EOC';
1453 The author is expected to prepend the necessary text to this message before
1454 returning the actual error seen by the user. See also L</modreq_missing_for>
1456 =head2 modreq_missing_for
1460 =item Arguments: $group_name | \@group_names
1462 =item Return Value: $error_message_string
1466 Same as L</req_missing_for> except that the error string is guaranteed to be
1467 either empty, or contain a set of module requirement specifications suitable
1468 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1469 attempt to validate the state of required environment variables (if any).
1471 For instance if some of the requirements for C<deploy> are not available,
1472 the returned string could look like:
1475 push @chunks, qq{ "SQL::Translator~>=$sqltver"};
1477 push @chunks, <<'EOC';
1479 See also L</-list_missing>.
1485 =item Arguments: $group_name | \@group_names
1489 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1490 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1491 (it is always C<1>, thus mandating unconditional use of
1492 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1493 requirement specifications:
1496 push @chunks, <<EOC;
1498 $class->skip_without([ deploy YAML>=0.90 ]);
1504 push @chunks, <<'EOC';
1506 =head2 die_unless_req_ok_for
1510 =item Arguments: $group_name | \@group_names
1514 Checks if L</req_ok_for> passes for the supplied group(s), and
1515 in case of failure throws an exception including the information
1516 from L</req_missing_for>. See also L</-die_without>.
1518 =head2 modreq_errorlist_for
1522 =item Arguments: $group_name | \@group_names
1524 =item Return Value: \%set_of_loaderrors_per_module
1528 Returns a hashref containing the actual errors that occurred while attempting
1529 to load each module in the requirement group(s).
1531 =head2 req_errorlist_for
1533 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1540 push @chunks, <<'EOC';
1541 =head1 FURTHER QUESTIONS?
1543 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1545 =head1 COPYRIGHT AND LICENSE
1547 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1548 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1549 redistribute it and/or modify it under the same terms as the
1550 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1554 open (my $fh, '>', $podfn) or die;
1555 print $fh join ("\n\n", @chunks) or die;
1556 print $fh "\n" or die;
1558 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );