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',
89 title => 'Storage::Replicated',
90 desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
95 include => 'replicated',
102 include => '_json_any',
104 title => 'DBIx::Class::Admin',
105 desc => 'Modules required for the DBIx::Class administrative library',
112 'Getopt::Long::Descriptive' => '0.081',
113 'Text::CSV' => '1.16',
116 title => 'dbicadmin',
117 desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
123 'SQL::Translator' => '0.11018',
126 title => 'Storage::DBI::deploy()',
127 desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
133 'DateTime' => '0.55',
134 'DateTime::TimeZone::OlsonDB' => 0,
137 title => 'InflateColumn::DateTime support',
139 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
140 . 'Note that this group does not require much on its own, but '
141 . 'instead is augmented by various RDBMS-specific groups. See the '
142 . 'documentation of each C<rbms_*> group for details',
148 'Math::BigInt' => '1.80',
149 'Math::Base36' => '0.07',
155 'Class::Data::Inheritable' => '0',
156 'Class::Trigger' => '0',
157 'DBIx::ContextualFetch' => '0',
161 title => 'DBIx::Class::CDBICompat support',
162 desc => 'Modules required for L<DBIx::Class::CDBICompat>'
168 'Test::Pod' => '1.42',
170 release_testing_mandatory => 1,
173 test_podcoverage => {
175 'Test::Pod::Coverage' => '1.08',
176 'Pod::Coverage' => '0.20',
178 release_testing_mandatory => 1,
183 'Test::EOL' => '1.0',
184 'Test::NoTabs' => '0.9',
186 release_testing_mandatory => 1,
191 'Test::Strict' => '0.24',
193 release_testing_mandatory => 1,
196 test_prettydebug => {
197 include => '_json_any',
200 test_admin_script => {
201 include => [qw( admin_script _json_xs_compatible_json_any )],
205 'Cpanel::JSON::XS' => 0,
208 # for t/admin/10script.t
209 ? ('Win32::ShellQuote' => 0)
210 # DWIW does not compile (./configure even) on win32
211 : ('JSON::DWIW' => 0 )
216 test_leaks_heavy => {
218 'Class::MethodCache' => '0.02',
219 'PadWalker' => '1.06',
224 # this is just for completeness as SQLite
225 # is a core dep of DBIC for testing
231 title => 'SQLite support',
232 desc => 'Modules required to connect to SQLite',
237 'DateTime::Format::SQLite' => '0',
243 # centralize the specification, as we have ICDT tests which can
244 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
249 'DateTime::Format::Pg' => '0.16004',
256 include => [qw( ic_dt _ic_dt_pg_base )],
260 include => '_ic_dt_pg_base',
262 # when changing this list make sure to adjust xt/optional_deps.t
266 title => 'PostgreSQL support',
267 desc => 'Modules required to connect to PostgreSQL',
271 _rdbms_mssql_common => {
272 include => '_ic_dt_strptime_based',
275 rdbms_mssql_odbc => {
276 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
278 title => 'MSSQL support via DBD::ODBC',
279 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
283 rdbms_mssql_sybase => {
284 include => '_rdbms_mssql_common',
289 title => 'MSSQL support via DBD::Sybase',
290 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
295 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
297 title => 'MSSQL support via DBD::ADO (Windows only)',
298 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
302 _rdbms_msaccess_common => {
303 include => '_ic_dt_strptime_based',
306 rdbms_msaccess_odbc => {
307 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
309 title => 'MS Access support via DBD::ODBC',
310 desc => 'Modules required to connect to MS Access via DBD::ODBC',
314 rdbms_msaccess_ado => {
315 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
317 title => 'MS Access support via DBD::ADO (Windows only)',
318 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
322 # centralize the specification, as we have ICDT tests which can
323 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
324 _ic_dt_mysql_base => {
328 'DateTime::Format::MySQL' => '0',
335 include => [qw( ic_dt _ic_dt_mysql_base )],
339 include => '_ic_dt_mysql_base',
344 title => 'MySQL support',
345 desc => 'Modules required to connect to MySQL',
350 include => 'id_shortener',
355 title => 'Oracle support',
356 desc => 'Modules required to connect to Oracle',
361 'DateTime::Format::Oracle' => '0',
368 include => '_ic_dt_strptime_based',
373 title => 'Sybase ASE support',
374 desc => 'Modules required to connect to Sybase ASE',
378 _rdbms_db2_common => {
382 'DateTime::Format::DB2' => '0',
389 include => '_rdbms_db2_common',
394 title => 'DB2 support',
395 desc => 'Modules required to connect to DB2',
400 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
402 title => 'DB2 on AS/400 support',
403 desc => 'Modules required to connect to DB2 on AS/400',
408 include => '_ic_dt_strptime_based',
410 'DBD::Informix' => 0,
413 title => 'Informix support',
414 desc => 'Modules required to connect to Informix',
418 _rdbms_sqlanywhere_common => {
419 include => '_ic_dt_strptime_based',
422 rdbms_sqlanywhere => {
423 include => '_rdbms_sqlanywhere_common',
425 'DBD::SQLAnywhere' => 0,
428 title => 'SQLAnywhere support',
429 desc => 'Modules required to connect to SQLAnywhere',
433 rdbms_sqlanywhere_odbc => {
434 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
436 title => 'SQLAnywhere support via DBD::ODBC',
437 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
441 _rdbms_firebird_common => {
442 include => '_ic_dt_strptime_based',
446 include => '_rdbms_firebird_common',
448 'DBD::Firebird' => 0,
451 title => 'Firebird support',
452 desc => 'Modules required to connect to Firebird',
456 rdbms_firebird_interbase => {
457 include => '_rdbms_firebird_common',
459 'DBD::InterBase' => 0,
462 title => 'Firebird support via DBD::InterBase',
463 desc => 'Modules required to connect to Firebird via DBD::InterBase',
467 rdbms_firebird_odbc => {
468 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
470 title => 'Firebird support via DBD::ODBC',
471 desc => 'Modules required to connect to Firebird via DBD::ODBC',
475 test_rdbms_sqlite => {
476 include => 'rdbms_sqlite',
479 ### IMPORTANT - do not raise this dependency
480 ### even though many bugfixes are present in newer versions, the general DBIC
481 ### rule is to bend over backwards for available DBDs (given upgrading them is
482 ### often *not* easy or even possible)
484 'DBD::SQLite' => '1.29',
489 include => 'rdbms_pg',
491 DBICTEST_PG_DSN => 1,
492 DBICTEST_PG_USER => 0,
493 DBICTEST_PG_PASS => 0,
496 # the order does matter because the rdbms support group might require
497 # a different version that the test group
499 # when changing this list make sure to adjust xt/optional_deps.t
500 'DBD::Pg' => '2.009002', # specific version to test bytea
504 test_rdbms_mssql_odbc => {
505 include => 'rdbms_mssql_odbc',
507 DBICTEST_MSSQL_ODBC_DSN => 1,
508 DBICTEST_MSSQL_ODBC_USER => 0,
509 DBICTEST_MSSQL_ODBC_PASS => 0,
513 test_rdbms_mssql_ado => {
514 include => 'rdbms_mssql_ado',
516 DBICTEST_MSSQL_ADO_DSN => 1,
517 DBICTEST_MSSQL_ADO_USER => 0,
518 DBICTEST_MSSQL_ADO_PASS => 0,
522 test_rdbms_mssql_sybase => {
523 include => 'rdbms_mssql_sybase',
525 DBICTEST_MSSQL_DSN => 1,
526 DBICTEST_MSSQL_USER => 0,
527 DBICTEST_MSSQL_PASS => 0,
531 test_rdbms_msaccess_odbc => {
532 include => 'rdbms_msaccess_odbc',
534 DBICTEST_MSACCESS_ODBC_DSN => 1,
535 DBICTEST_MSACCESS_ODBC_USER => 0,
536 DBICTEST_MSACCESS_ODBC_PASS => 0,
543 test_rdbms_msaccess_ado => {
544 include => 'rdbms_msaccess_ado',
546 DBICTEST_MSACCESS_ADO_DSN => 1,
547 DBICTEST_MSACCESS_ADO_USER => 0,
548 DBICTEST_MSACCESS_ADO_PASS => 0,
555 test_rdbms_mysql => {
556 include => 'rdbms_mysql',
558 DBICTEST_MYSQL_DSN => 1,
559 DBICTEST_MYSQL_USER => 0,
560 DBICTEST_MYSQL_PASS => 0,
564 test_rdbms_oracle => {
565 include => 'rdbms_oracle',
567 DBICTEST_ORA_DSN => 1,
568 DBICTEST_ORA_USER => 0,
569 DBICTEST_ORA_PASS => 0,
572 'DBD::Oracle' => '1.24',
577 include => 'rdbms_ase',
579 DBICTEST_SYBASE_DSN => 1,
580 DBICTEST_SYBASE_USER => 0,
581 DBICTEST_SYBASE_PASS => 0,
586 include => 'rdbms_db2',
588 DBICTEST_DB2_DSN => 1,
589 DBICTEST_DB2_USER => 0,
590 DBICTEST_DB2_PASS => 0,
594 test_rdbms_db2_400 => {
595 include => 'rdbms_db2_400',
597 DBICTEST_DB2_400_DSN => 1,
598 DBICTEST_DB2_400_USER => 0,
599 DBICTEST_DB2_400_PASS => 0,
603 test_rdbms_informix => {
604 include => 'rdbms_informix',
606 DBICTEST_INFORMIX_DSN => 1,
607 DBICTEST_INFORMIX_USER => 0,
608 DBICTEST_INFORMIX_PASS => 0,
612 test_rdbms_sqlanywhere => {
613 include => 'rdbms_sqlanywhere',
615 DBICTEST_SQLANYWHERE_DSN => 1,
616 DBICTEST_SQLANYWHERE_USER => 0,
617 DBICTEST_SQLANYWHERE_PASS => 0,
621 test_rdbms_sqlanywhere_odbc => {
622 include => 'rdbms_sqlanywhere_odbc',
624 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
625 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
626 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
630 test_rdbms_firebird => {
631 include => 'rdbms_firebird',
633 DBICTEST_FIREBIRD_DSN => 1,
634 DBICTEST_FIREBIRD_USER => 0,
635 DBICTEST_FIREBIRD_PASS => 0,
639 test_rdbms_firebird_interbase => {
640 include => 'rdbms_firebird_interbase',
642 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
643 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
644 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
648 test_rdbms_firebird_odbc => {
649 include => 'rdbms_firebird_odbc',
651 DBICTEST_FIREBIRD_ODBC_DSN => 1,
652 DBICTEST_FIREBIRD_ODBC_USER => 0,
653 DBICTEST_FIREBIRD_ODBC_PASS => 0,
659 DBICTEST_MEMCACHED => 1,
662 'Cache::Memcached' => 0,
667 # we need to run the dbicadmin so we can self-generate its POD
668 # also we do not want surprises in case JSON::XS is in the path
669 # so make sure we get an always-working JSON::Any
672 _json_xs_compatible_json_any
681 'ExtUtils::MakeMaker' => '6.64',
682 'Module::Install' => '1.06',
683 'Pod::Inherit' => '0.91',
689 'CPAN::Uploader' => '0.103001',
705 if ($action eq '-die_without') {
709 eval { $class->die_unless_req_ok_for(\@_); 1 }
712 die "\n$err\n" if $err;
714 elsif ($action eq '-list_missing') {
715 print $class->modreq_missing_for(\@_);
719 elsif ($action eq '-skip_all_without') {
721 # sanity check - make sure ->current_test is 0 and no plan has been declared
725 Test::Builder->new->current_test
727 Test::Builder->new->has_plan
729 } and croak("Unable to invoke -skip_all_without after testing has started");
731 if ( my $missing = $class->req_missing_for(\@_) ) {
733 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
734 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
736 print "1..0 # SKIP requirements not satisfied: $missing\n";
740 elsif ($action =~ /^-/) {
741 croak "Unknown import-time action '$action'";
744 croak "$class is not an exporter, unable to import '$action'";
752 croak( __PACKAGE__ . " does not implement unimport" );
755 # OO for (mistakenly considered) ease of extensibility, not due to any need to
756 # carry state of any sort. This API is currently used outside, so leave as-is.
757 # FIXME - make sure to not propagate this further if module is extracted as a
758 # standalone library - keep the stupidity to a DBIC-secific shim!
761 shift->_groups_to_reqs(shift)->{effective_modreqs};
764 sub modreq_list_for {
765 shift->_groups_to_reqs(shift)->{modreqs};
770 { $_ => $_[0]->_groups_to_reqs($_) }
771 grep { $_ !~ /^_/ } keys %$dbic_reqs
775 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
776 sub modreq_errorlist_for {
777 my ($self, $groups) = @_;
778 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
782 shift->req_missing_for(shift) ? 0 : 1;
785 sub req_missing_for {
786 my ($self, $groups) = @_;
788 my $reqs = $self->_groups_to_reqs($groups);
790 my $mods_missing = $reqs->{missing_envvars}
791 ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
792 : $self->modreq_missing_for($groups)
798 ! $reqs->{missing_envvars}
801 my @res = $mods_missing || ();
803 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
804 { __envvar_group_desc($_) }
805 @{$reqs->{missing_envvars}}
806 if $reqs->{missing_envvars};
809 ( join ' as well as ', @res )
811 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
815 sub modreq_missing_for {
816 my ($self, $groups) = @_;
818 my $reqs = $self->_groups_to_reqs($groups);
819 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
823 { $reqs->{modreqs}{$_} ? "$_~$reqs->{modreqs}{$_}" : $_ }
824 sort { lc($a) cmp lc($b) } keys %$modreq_errors
830 my ($self, $groups) = @_;
832 $tb ||= do { local $@; eval { Test::Builder->new } }
833 or croak "Calling skip_without() before loading Test::Builder makes no sense";
835 if ( my $err = $self->req_missing_for($groups) ) {
836 my ($fn, $ln) = (caller(0))[1,2];
837 $tb->skip("block in $fn around line $ln requires $err");
845 sub die_unless_req_ok_for {
846 if (my $err = shift->req_missing_for(shift) ) {
847 die "Unable to continue due to missing requirements: $err\n";
853 ### Private functions
855 # potentially shorten group desc
856 sub __envvar_group_desc {
859 my (@res, $last_prefix);
860 while (my $ev = shift @envs) {
861 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
863 if ( defined $sep and ($last_prefix||'') eq $pref ) {
864 push @res, "...${sep}${suff}"
870 $last_prefix = $pref if $sep;
876 my $groupname_re = qr/ [a-z_] [0-9_a-z]* /x;
877 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
878 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
880 # Expand includes from a random group in a specific order:
881 # nonvariable groups first, then their includes, then the variable groups,
882 # then their includes.
883 # This allows reliably marking the rest of the mod reqs as variable (this is
884 # also why variable includes are currently not allowed)
885 sub __expand_includes {
886 my ($groups, $seen) = @_;
888 # !! DIFFERENT !! behavior and return depending on invocation mode
889 # (easier to recurse this way)
890 my $is_toplevel = $seen
895 my ($res_per_type, $missing_envvars);
897 # breadth-first evaluation, with non-variable includes on top
898 for my $g (@$groups) {
900 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
901 if $g !~ qr/ \A $groupname_re \z/x;
903 my $r = $dbic_reqs->{$g}
904 or croak "Requirement group '$g' is not defined";
906 # always do this check *before* the $seen check
907 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
908 if ( $r->{env} and ! $is_toplevel );
910 next if $seen->{$g}++;
912 my $req_type = 'static';
914 if ( my @e = @{$r->{env}||[]} ) {
916 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
917 unless $g =~ /^test_/;
919 croak "Unexpected *odd* list in 'env' under group '$g'"
922 # deconstruct the whole thing
923 my (@group_envnames_list, $some_envs_required, $some_required_missing);
925 push @group_envnames_list, my $envname = shift @e;
927 # env required or not
928 next unless shift @e;
930 $some_envs_required ||= 1;
932 $some_required_missing ||= (
933 ! defined $ENV{$envname}
935 ! length $ENV{$envname}
939 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
940 unless $some_envs_required;
942 if ($some_required_missing) {
943 push @{$missing_envvars->{$g}}, \@group_envnames_list;
944 $req_type = 'variable';
948 push @{$res_per_type->{"base_${req_type}"}}, $g;
950 if (my $i = $dbic_reqs->{$g}{include}) {
951 $i = [ $i ] unless ref $i eq 'ARRAY';
953 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
956 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
961 @{ $res_per_type->{"base_${_}"} || [] },
962 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
963 } qw(static variable);
965 return ! $is_toplevel ? @ret : do {
968 idx => 1 + keys %$rv,
969 missing_envvars => $missing_envvars->{$_},
971 $rv->{$_}{user_requested} = 1 for @$groups;
977 our %req_unavailability_cache;
979 # this method is just a lister and envvar/metadata checker - it does not try to load anything
980 sub _groups_to_reqs {
981 my ($self, $want) = @_;
983 $want = [ $want || () ]
984 unless ref $want eq 'ARRAY';
986 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
991 modreqs_fully_documented => 1,
995 for my $piece (@$want) {
996 if ($piece =~ qr/ \A $groupname_re \z /x) {
997 push @$groups, $piece;
999 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
1000 croak "Ad hoc module specification lists '$mod' twice"
1001 if exists $ret->{modreqs}{$mod};
1003 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
1004 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
1006 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
1009 $ret->{modreqs}{$mod} = $ver;
1010 $ret->{modreqs_fully_documented} = 0;
1013 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1017 my $all_groups = __expand_includes($groups);
1019 # pre-assemble list of augmentations, perform basic sanity checks
1020 # Note that below we *DO NOT* respect the source/target reationship, but
1021 # instead always default to augment the "later" group
1022 # This is done so that the "stable/variable" boundary keeps working as
1025 for my $requesting_group (keys %$all_groups) {
1026 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1027 for my $target_group (keys %$ag) {
1029 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1030 unless $dbic_reqs->{$target_group};
1032 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1033 if $dbic_reqs->{$requesting_group}{env};
1035 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1036 if $dbic_reqs->{$target_group}{env};
1038 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1039 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1042 $ret->{augments}{$target_group} = 1;
1044 # no augmentation for stuff that hasn't been selected
1045 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1046 push @{$augmentations->{
1047 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1056 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1058 my $group_reqs = $dbic_reqs->{$group}{req};
1061 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1062 for (keys %$req_bag) {
1064 $_ =~ / \A $modname_re \z /x
1065 or croak "Requirement '$_' in group '$group' is not a valid module name";
1067 # !!!DO NOT CHANGE!!!
1068 # remember - version.pm may not be available on the system
1069 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1070 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1074 if (my $e = $all_groups->{$group}{missing_envvars}) {
1075 push @{$ret->{missing_envvars}}, @$e;
1078 # assemble into the final ret
1081 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1083 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1084 for my $mod (keys %$req_bag) {
1086 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1088 ! exists $ret->{$type}{$mod}
1090 # we sanitized the version to be numeric above - we can just -gt it
1091 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1098 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1099 if $all_groups->{$group}{user_requested};
1101 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1108 # this method tries to find/load specified modreqs and returns a hashref of
1109 # module/loaderror pairs for anything that failed
1110 sub _errorlist_for_modreqs {
1111 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1112 # safe to eval at will
1113 my ($self, $reqs) = @_;
1117 for my $m ( keys %$reqs ) {
1118 my $v = $reqs->{$m};
1120 if (! exists $req_unavailability_cache{$m}{$v} ) {
1122 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1123 $req_unavailability_cache{$m}{$v} = $@;
1126 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1127 if $req_unavailability_cache{$m}{$v};
1133 # Unlike the above DO NOT try to load anything
1134 # This is executed when some needed envvars are not available
1135 # which in turn means a module load will never be reached anyway
1136 # This is important because some modules (especially DBDs) can be
1137 # *really* fickle when a require() is attempted, with pretty confusing
1138 # side-effects (especially on windows)
1139 sub _list_physically_missing_modules {
1140 my ($self, $modreqs) = @_;
1142 # in case there is a coderef in @INC there is nothing we can definitively prove
1143 # so short circuit directly
1144 return '' if grep { length ref $_ } @INC;
1146 my @definitely_missing;
1147 for my $mod (keys %$modreqs) {
1148 (my $fn = $mod . '.pm') =~ s|::|/|g;
1150 push @definitely_missing, $mod unless grep
1151 # this should work on any combination of slashes
1152 { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1158 { $modreqs->{$_} ? "$_~$modreqs->{$_}" : $_ }
1159 sort { lc($a) cmp lc($b) } @definitely_missing
1164 # This is to be called by the author only (automatically in Makefile.PL)
1166 my ($class, $distver, $pod_dir) = @_;
1168 die "No POD root dir supplied" unless $pod_dir;
1171 eval { require DBIx::Class; DBIx::Class->VERSION; }
1174 "\n\n---------------------------------------------------------------------\n" .
1175 'Unable to load core DBIx::Class module to determine current version, '.
1176 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1178 "\n\n---------------------------------------------------------------------\n"
1181 # do not ask for a recent version, use 1.x API calls
1182 # this *may* execute on a smoker with old perl or whatnot
1185 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1187 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1188 (my $dir = $podfn) =~ s|/[^/]+$||;
1190 File::Path::mkpath([$dir]);
1192 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1193 or die "Hrmm? No sqlt dep?";
1201 push @chunks, <<"EOC";
1202 #########################################################################
1203 ##################### A U T O G E N E R A T E D ########################
1204 #########################################################################
1206 # The contents of this POD file are auto-generated. Any changes you make
1207 # will be lost. If you need to change the generated text edit _gen_pod()
1208 # at the end of $modfn
1213 $class - Optional module dependency specifications (for module authors)
1218 #@@ SYNOPSIS HEADING
1220 push @chunks, <<"EOC";
1223 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1227 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1228 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1229 'DBIx::Class' => '$distver',
1234 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1236 $class->req_list_for([qw( deploy rdbms_oracle ic_dt )]);
1239 \$EUMM_ARGS{PREREQ_PM} = {
1240 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1241 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1246 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1248 B<Note>: The C<eval> protection within the example is due to support for
1249 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1250 not being available on a sufficient portion of production installations of
1251 Perl. Robust support for such dependency requirements is available in the
1252 L<CPAN> installer only since version C<1.94_56> first made available for
1253 production with perl version C<5.12>. It is the belief of the current
1254 maintainer that support for requirements during the C<configure> build phase
1255 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1256 hence the extra care demonstrated above. It should also be noted that some
1257 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1258 with configure requirements independent from the versions of perl and CPAN
1264 #@@ DESCRIPTION HEADING
1266 push @chunks, <<'EOC';
1269 Some of the less-frequently used features of L<DBIx::Class> have external
1270 module dependencies on their own. In order not to burden the average user
1271 with modules they will never use, these optional dependencies are not included
1272 in the base Makefile.PL. Instead an exception with a descriptive message is
1273 thrown when a specific feature can't find one or several modules required for
1274 its operation. This module is the central holding place for the current list
1275 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1278 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1279 group can list one or more required modules, with an optional minimum version
1280 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1281 a set of environment variables, some (or all) of which are marked as required
1282 for the group to be considered by L</req_list_for>
1284 Each group name (or a combination thereof) can be used in the
1285 L<public methods|/METHODS> as described below.
1290 #@@ REQUIREMENT GROUPLIST HEADING
1292 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1294 my $standalone_info;
1296 for my $group (sort keys %$dbic_reqs) {
1298 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1301 $info->{modreqs_fully_documented}
1303 ( $info->{augments} or $info->{modreqs} )
1306 my $p = $dbic_reqs->{$group}{pod};
1309 "=head2 $p->{title}",
1315 if ( keys %{ $info->{modreqs}||{} } ) {
1317 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1318 ( sort keys %{ $info->{modreqs} } )
1322 push @chunks, '=item * No standalone requirements',
1325 push @chunks, '=back';
1327 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1328 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1330 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1331 for (keys %$newreqs) {
1332 delete $newreqs->{$_} if (
1333 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1335 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1339 if (keys %$newreqs) {
1341 "Combined with L</$ag> additionally requires:",
1344 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1345 ( sort keys %$newreqs )
1355 #@@ API DOCUMENTATION HEADING
1357 push @chunks, <<'EOC';
1359 =head1 IMPORT-LIKE ACTIONS
1361 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1362 supplied to its C<import> method.
1364 =head2 -skip_all_without
1368 =item Arguments: @group_names
1372 A convenience wrapper for use during testing:
1375 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1377 push @chunks, 'Roughly equivalent to the following code:';
1379 push @chunks, sprintf <<'EOS', ($class) x 2;
1383 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1384 print "1..0 # SKIP requirements not satisfied: $missing\n";
1390 push @chunks, <<'EOC';
1392 It also takes into account the C<RELEASE_TESTING> environment variable and
1393 behaves like L</-die_without> for any requirement groups marked as
1394 C<release_testing_mandatory>.
1400 =item Arguments: @group_names
1404 A convenience wrapper around L</die_unless_req_ok_for>:
1407 push @chunks, " use $class -die_without => qw(deploy admin);";
1409 push @chunks, <<'EOC';
1411 =head2 -list_missing
1415 =item Arguments: @group_names
1419 A convenience wrapper around L</modreq_missing_for>:
1421 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1425 =head2 req_group_list
1429 =item Arguments: none
1431 =item Return Value: \%list_of_requirement_groups
1435 This method should be used by DBIx::Class packagers, to get a hashref of all
1436 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1437 thereof (as an arrayref) can be supplied to the methods below.
1438 The B<values> of the returned hash are currently a set of options B<without a
1439 well defined structure>. If you have use for any of the contents - contact the
1440 maintainers, instead of treating this as public (left alone stable) API.
1446 =item Arguments: $group_name | \@group_names
1448 =item Return Value: \%set_of_module_version_pairs
1452 This method should be used by DBIx::Class extension authors, to determine the
1453 version of modules a specific set of features requires for this version of
1454 DBIx::Class (regardless of their availability on the system).
1455 See the L</SYNOPSIS> for a real-world example.
1457 When handling C<test_*> groups this method behaves B<differently> from
1458 L</modreq_list_for> below (and is the only such inconsistency among the
1459 C<req_*> methods). If a particular group declares as requirements some
1460 C<environment variables> and these requirements are not satisfied (the envvars
1461 are unset) - then the C<module requirements> of this group are not included in
1464 =head2 modreq_list_for
1468 =item Arguments: $group_name | \@group_names
1470 =item Return Value: \%set_of_module_version_pairs
1474 Same as L</req_list_for> but does not take into consideration any
1475 C<environment variable requirements> - returns just the list of required
1482 =item Arguments: $group_name | \@group_names
1484 =item Return Value: 1|0
1488 Returns true or false depending on whether all modules/envvars required by
1489 the group(s) are loadable/set on the system.
1491 =head2 req_missing_for
1495 =item Arguments: $group_name | \@group_names
1497 =item Return Value: $error_message_string
1501 Returns a single-line string suitable for inclusion in larger error messages.
1502 This method would normally be used by DBIx::Class core features, to indicate to
1503 the user that they need to install specific modules and/or set specific
1504 environment variables before being able to use a specific feature set.
1506 For example if some of the requirements for C<deploy> are not available,
1507 the returned string could look like:
1510 push @chunks, qq{ "SQL::Translator~$sqltver" (see $class documentation for details)};
1512 push @chunks, <<'EOC';
1513 The author is expected to prepend the necessary text to this message before
1514 returning the actual error seen by the user. See also L</modreq_missing_for>
1516 =head2 modreq_missing_for
1520 =item Arguments: $group_name | \@group_names
1522 =item Return Value: $error_message_string
1526 Same as L</req_missing_for> except that the error string is guaranteed to be
1527 either empty, or contain a set of module requirement specifications suitable
1528 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1529 attempt to validate the state of required environment variables (if any).
1531 For instance if some of the requirements for C<deploy> are not available,
1532 the returned string could look like:
1535 push @chunks, qq{ "SQL::Translator~$sqltver"};
1537 push @chunks, <<'EOC';
1539 See also L</-list_missing>.
1545 =item Arguments: $group_name | \@group_names
1549 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1550 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1551 (it is always C<1>, thus mandating unconditional use of
1552 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1553 requirement specifications:
1556 push @chunks, <<EOC;
1558 $class->skip_without([ deploy YAML>=0.90 ]);
1564 push @chunks, <<'EOC';
1566 =head2 die_unless_req_ok_for
1570 =item Arguments: $group_name | \@group_names
1574 Checks if L</req_ok_for> passes for the supplied group(s), and
1575 in case of failure throws an exception including the information
1576 from L</req_missing_for>. See also L</-die_without>.
1578 =head2 modreq_errorlist_for
1582 =item Arguments: $group_name | \@group_names
1584 =item Return Value: \%set_of_loaderrors_per_module
1588 Returns a hashref containing the actual errors that occurred while attempting
1589 to load each module in the requirement group(s).
1591 =head2 req_errorlist_for
1593 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1600 push @chunks, <<'EOC';
1601 =head1 FURTHER QUESTIONS?
1603 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1605 =head1 COPYRIGHT AND LICENSE
1607 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1608 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1609 redistribute it and/or modify it under the same terms as the
1610 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1614 open (my $fh, '>', $podfn) or die;
1615 print $fh join ("\n\n", @chunks) or die;
1616 print $fh "\n" or die;
1618 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );