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 _icdt_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',
105 'MooseX::Types::Path::Class' => '0.05',
106 'MooseX::Types::JSON' => '0.02',
109 title => 'DBIx::Class::Admin',
110 desc => 'Modules required for the DBIx::Class administrative library',
117 'Getopt::Long::Descriptive' => '0.081',
118 'Text::CSV' => '1.16',
121 title => 'dbicadmin',
122 desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
128 'SQL::Translator' => '0.11018',
131 title => 'Storage::DBI::deploy()',
132 desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
138 'DateTime' => '0.55',
141 title => 'InflateColumn::DateTime support',
143 'Modules required for L<DBIx::Class::InflateColumn::DateTime>. '
144 . 'Note that this group does not require much on its own, but '
145 . 'instead is augmented by various RDBMS-specific groups. See the '
146 . 'documentation of each C<rbms_*> group for details',
152 'Math::BigInt' => '1.80',
153 'Math::Base36' => '0.07',
159 'Class::Data::Inheritable' => '0',
160 'Class::Trigger' => '0',
161 'DBIx::ContextualFetch' => '0',
165 title => 'DBIx::Class::CDBICompat support',
166 desc => 'Modules required for L<DBIx::Class::CDBICompat>'
172 'Test::Pod' => '1.42',
174 release_testing_mandatory => 1,
177 test_podcoverage => {
179 'Test::Pod::Coverage' => '1.08',
180 'Pod::Coverage' => '0.20',
182 release_testing_mandatory => 1,
187 'Test::EOL' => '1.0',
188 'Test::NoTabs' => '0.9',
190 release_testing_mandatory => 1,
195 'Test::Strict' => '0.20',
197 release_testing_mandatory => 1,
200 test_prettydebug => {
201 include => '_json_any',
204 test_admin_script => {
205 include => [qw( admin_script _json_xs_compatible_json_any )],
209 'Cpanel::JSON::XS' => 0,
212 # for t/admin/10script.t
213 ? ('Win32::ShellQuote' => 0)
214 # DWIW does not compile (./configure even) on win32
215 : ('JSON::DWIW' => 0 )
220 test_leaks_heavy => {
222 'Class::MethodCache' => '0.02',
223 'PadWalker' => '1.06',
228 # this is just for completeness as SQLite
229 # is a core dep of DBIC for testing
235 title => 'SQLite support',
236 desc => 'Modules required to connect to SQLite',
241 'DateTime::Format::SQLite' => '0',
247 # centralize the specification, as we have ICDT tests which can
248 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
253 'DateTime::Format::Pg' => '0.16004',
260 include => [qw( icdt _icdt_pg_base )],
264 include => '_icdt_pg_base',
266 # when changing this list make sure to adjust xt/optional_deps.t
270 title => 'PostgreSQL support',
271 desc => 'Modules required to connect to PostgreSQL',
275 _rdbms_mssql_common => {
276 include => '_icdt_strptime_based',
279 rdbms_mssql_odbc => {
280 include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
282 title => 'MSSQL support via DBD::ODBC',
283 desc => 'Modules required to connect to MSSQL via DBD::ODBC',
287 rdbms_mssql_sybase => {
288 include => '_rdbms_mssql_common',
293 title => 'MSSQL support via DBD::Sybase',
294 desc => 'Modules required to connect to MSSQL via DBD::Sybase',
299 include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
301 title => 'MSSQL support via DBD::ADO (Windows only)',
302 desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
306 _rdbms_msaccess_common => {
307 include => '_icdt_strptime_based',
310 rdbms_msaccess_odbc => {
311 include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
313 title => 'MS Access support via DBD::ODBC',
314 desc => 'Modules required to connect to MS Access via DBD::ODBC',
318 rdbms_msaccess_ado => {
319 include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
321 title => 'MS Access support via DBD::ADO (Windows only)',
322 desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
326 # centralize the specification, as we have ICDT tests which can
327 # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
328 _icdt_mysql_base => {
332 'DateTime::Format::MySQL' => '0',
339 include => [qw( icdt _icdt_mysql_base )],
343 include => '_icdt_mysql_base',
348 title => 'MySQL support',
349 desc => 'Modules required to connect to MySQL',
354 include => 'id_shortener',
359 title => 'Oracle support',
360 desc => 'Modules required to connect to Oracle',
365 'DateTime::Format::Oracle' => '0',
372 include => '_icdt_strptime_based',
377 title => 'Sybase ASE support',
378 desc => 'Modules required to connect to Sybase ASE',
382 _rdbms_db2_common => {
386 'DateTime::Format::DB2' => '0',
393 include => '_rdbms_db2_common',
398 title => 'DB2 support',
399 desc => 'Modules required to connect to DB2',
404 include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
406 title => 'DB2 on AS/400 support',
407 desc => 'Modules required to connect to DB2 on AS/400',
412 include => '_icdt_strptime_based',
414 'DBD::Informix' => 0,
417 title => 'Informix support',
418 desc => 'Modules required to connect to Informix',
422 _rdbms_sqlanywhere_common => {
423 inclide => '_icdt_strptime_based',
426 rdbms_sqlanywhere => {
427 include => '_rdbms_sqlanywhere_common',
429 'DBD::SQLAnywhere' => 0,
432 title => 'SQLAnywhere support',
433 desc => 'Modules required to connect to SQLAnywhere',
437 rdbms_sqlanywhere_odbc => {
438 include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
440 title => 'SQLAnywhere support via DBD::ODBC',
441 desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
445 _rdbms_firebird_common => {
446 include => '_icdt_strptime_based',
450 include => '_rdbms_firebird_common',
452 'DBD::Firebird' => 0,
455 title => 'Firebird support',
456 desc => 'Modules required to connect to Firebird',
460 rdbms_firebird_interbase => {
461 include => '_rdbms_firebird_common',
463 'DBD::InterBase' => 0,
466 title => 'Firebird support via DBD::InterBase',
467 desc => 'Modules required to connect to Firebird via DBD::InterBase',
471 rdbms_firebird_odbc => {
472 include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
474 title => 'Firebird support via DBD::ODBC',
475 desc => 'Modules required to connect to Firebird via DBD::ODBC',
479 test_rdbms_sqlite => {
480 include => 'rdbms_sqlite',
483 ### IMPORTANT - do not raise this dependency
484 ### even though many bugfixes are present in newer versions, the general DBIC
485 ### rule is to bend over backwards for available DBDs (given upgrading them is
486 ### often *not* easy or even possible)
488 'DBD::SQLite' => '1.29',
493 include => 'rdbms_pg',
495 DBICTEST_PG_DSN => 1,
496 DBICTEST_PG_USER => 0,
497 DBICTEST_PG_PASS => 0,
500 # the order does matter because the rdbms support group might require
501 # a different version that the test group
503 # when changing this list make sure to adjust xt/optional_deps.t
504 'DBD::Pg' => '2.009002', # specific version to test bytea
508 test_rdbms_mssql_odbc => {
509 include => 'rdbms_mssql_odbc',
511 DBICTEST_MSSQL_ODBC_DSN => 1,
512 DBICTEST_MSSQL_ODBC_USER => 0,
513 DBICTEST_MSSQL_ODBC_PASS => 0,
517 test_rdbms_mssql_ado => {
518 include => 'rdbms_mssql_ado',
520 DBICTEST_MSSQL_ADO_DSN => 1,
521 DBICTEST_MSSQL_ADO_USER => 0,
522 DBICTEST_MSSQL_ADO_PASS => 0,
526 test_rdbms_mssql_sybase => {
527 include => 'rdbms_mssql_sybase',
529 DBICTEST_MSSQL_DSN => 1,
530 DBICTEST_MSSQL_USER => 0,
531 DBICTEST_MSSQL_PASS => 0,
535 test_rdbms_msaccess_odbc => {
536 include => 'rdbms_msaccess_odbc',
538 DBICTEST_MSACCESS_ODBC_DSN => 1,
539 DBICTEST_MSACCESS_ODBC_USER => 0,
540 DBICTEST_MSACCESS_ODBC_PASS => 0,
547 test_rdbms_msaccess_ado => {
548 include => 'rdbms_msaccess_ado',
550 DBICTEST_MSACCESS_ADO_DSN => 1,
551 DBICTEST_MSACCESS_ADO_USER => 0,
552 DBICTEST_MSACCESS_ADO_PASS => 0,
559 test_rdbms_mysql => {
560 include => 'rdbms_mysql',
562 DBICTEST_MYSQL_DSN => 1,
563 DBICTEST_MYSQL_USER => 0,
564 DBICTEST_MYSQL_PASS => 0,
568 test_rdbms_oracle => {
569 include => 'rdbms_oracle',
571 DBICTEST_ORA_DSN => 1,
572 DBICTEST_ORA_USER => 0,
573 DBICTEST_ORA_PASS => 0,
576 'DBD::Oracle' => '1.24',
581 include => 'rdbms_ase',
583 DBICTEST_SYBASE_DSN => 1,
584 DBICTEST_SYBASE_USER => 0,
585 DBICTEST_SYBASE_PASS => 0,
590 include => 'rdbms_db2',
592 DBICTEST_DB2_DSN => 1,
593 DBICTEST_DB2_USER => 0,
594 DBICTEST_DB2_PASS => 0,
598 test_rdbms_db2_400 => {
599 include => 'rdbms_db2_400',
601 DBICTEST_DB2_400_DSN => 1,
602 DBICTEST_DB2_400_USER => 0,
603 DBICTEST_DB2_400_PASS => 0,
607 test_rdbms_informix => {
608 include => 'rdbms_informix',
610 DBICTEST_INFORMIX_DSN => 1,
611 DBICTEST_INFORMIX_USER => 0,
612 DBICTEST_INFORMIX_PASS => 0,
616 test_rdbms_sqlanywhere => {
617 include => 'rdbms_sqlanywhere',
619 DBICTEST_SQLANYWHERE_DSN => 1,
620 DBICTEST_SQLANYWHERE_USER => 0,
621 DBICTEST_SQLANYWHERE_PASS => 0,
625 test_rdbms_sqlanywhere_odbc => {
626 include => 'rdbms_sqlanywhere_odbc',
628 DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
629 DBICTEST_SQLANYWHERE_ODBC_USER => 0,
630 DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
634 test_rdbms_firebird => {
635 include => 'rdbms_firebird',
637 DBICTEST_FIREBIRD_DSN => 1,
638 DBICTEST_FIREBIRD_USER => 0,
639 DBICTEST_FIREBIRD_PASS => 0,
643 test_rdbms_firebird_interbase => {
644 include => 'rdbms_firebird_interbase',
646 DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
647 DBICTEST_FIREBIRD_INTERBASE_USER => 0,
648 DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
652 test_rdbms_firebird_odbc => {
653 include => 'rdbms_firebird_odbc',
655 DBICTEST_FIREBIRD_ODBC_DSN => 1,
656 DBICTEST_FIREBIRD_ODBC_USER => 0,
657 DBICTEST_FIREBIRD_ODBC_PASS => 0,
663 DBICTEST_MEMCACHED => 1,
666 'Cache::Memcached' => 0,
671 # we need to run the dbicadmin so we can self-generate its POD
672 # also we do not want surprises in case JSON::XS is in the path
673 # so make sure we get an always-working JSON::Any
674 include => [qw( admin_script _json_xs_compatible_json_any )],
676 'ExtUtils::MakeMaker' => '6.64',
677 'Pod::Inherit' => '0.91',
683 'CPAN::Uploader' => '0.103001',
699 if ($action eq '-die_without') {
703 eval { $class->die_unless_req_ok_for(\@_); 1 }
706 die "\n$err\n" if $err;
708 elsif ($action eq '-list_missing') {
709 print $class->modreq_missing_for(\@_);
713 elsif ($action eq '-skip_all_without') {
715 # sanity check - make sure ->current_test is 0 and no plan has been declared
719 Test::Builder->new->current_test
721 Test::Builder->new->has_plan
723 } and croak("Unable to invoke -skip_all_without after testing has started");
725 if ( my $missing = $class->req_missing_for(\@_) ) {
727 die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
728 if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
730 print "1..0 # SKIP requirements not satisfied: $missing\n";
734 elsif ($action =~ /^-/) {
735 croak "Unknown import-time action '$action'";
738 croak "$class is not an exporter, unable to import '$action'";
746 croak( __PACKAGE__ . " does not implement unimport" );
749 # OO for (mistakenly considered) ease of extensibility, not due to any need to
750 # carry state of any sort. This API is currently used outside, so leave as-is.
751 # FIXME - make sure to not propagate this further if module is extracted as a
752 # standalone library - keep the stupidity to a DBIC-secific shim!
755 shift->_groups_to_reqs(shift)->{effective_modreqs};
758 sub modreq_list_for {
759 shift->_groups_to_reqs(shift)->{modreqs};
764 { $_ => $_[0]->_groups_to_reqs($_) }
765 grep { $_ !~ /^_/ } keys %$dbic_reqs
769 sub req_errorlist_for { shift->modreq_errorlist_for(shift) } # deprecated
770 sub modreq_errorlist_for {
771 my ($self, $groups) = @_;
772 $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
776 shift->req_missing_for(shift) ? 0 : 1;
779 sub req_missing_for {
780 my ($self, $groups) = @_;
782 my $reqs = $self->_groups_to_reqs($groups);
784 my $mods_missing = $reqs->{missing_envvars}
785 ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
786 : $self->modreq_missing_for($groups)
792 ! $reqs->{missing_envvars}
795 my @res = $mods_missing || ();
797 push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
798 { __envvar_group_desc($_) }
799 @{$reqs->{missing_envvars}}
800 if $reqs->{missing_envvars};
803 ( join ' as well as ', @res )
805 ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
809 sub modreq_missing_for {
810 my ($self, $groups) = @_;
812 my $reqs = $self->_groups_to_reqs($groups);
813 my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
817 { $reqs->{modreqs}{$_} ? "$_~$reqs->{modreqs}{$_}" : $_ }
818 sort { lc($a) cmp lc($b) } keys %$modreq_errors
824 my ($self, $groups) = @_;
826 $tb ||= do { local $@; eval { Test::Builder->new } }
827 or croak "Calling skip_without() before loading Test::Builder makes no sense";
829 if ( my $err = $self->req_missing_for($groups) ) {
830 my ($fn, $ln) = (caller(0))[1,2];
831 $tb->skip("block in $fn around line $ln requires $err");
839 sub die_unless_req_ok_for {
840 if (my $err = shift->req_missing_for(shift) ) {
841 die "Unable to continue due to missing requirements: $err\n";
847 ### Private functions
849 # potentially shorten group desc
850 sub __envvar_group_desc {
853 my (@res, $last_prefix);
854 while (my $ev = shift @envs) {
855 my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
857 if ( defined $sep and ($last_prefix||'') eq $pref ) {
858 push @res, "...${sep}${suff}"
864 $last_prefix = $pref if $sep;
870 my $groupname_re = qr/ [A-Z_a-z][0-9A-Z_a-z]* /x;
871 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
872 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
874 # Expand includes from a random group in a specific order:
875 # nonvariable groups first, then their includes, then the variable groups,
876 # then their includes.
877 # This allows reliably marking the rest of the mod reqs as variable (this is
878 # also why variable includes are currently not allowed)
879 sub __expand_includes {
880 my ($groups, $seen) = @_;
882 # !! DIFFERENT !! behavior and return depending on invocation mode
883 # (easier to recurse this way)
884 my $is_toplevel = $seen
889 my ($res_per_type, $missing_envvars);
891 # breadth-first evaluation, with non-variable includes on top
892 for my $g (@$groups) {
894 croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
895 if $g !~ qr/ \A $groupname_re \z/x;
897 my $r = $dbic_reqs->{$g}
898 or croak "Requirement group '$g' is not defined";
900 # always do this check *before* the $seen check
901 croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
902 if ( $r->{env} and ! $is_toplevel );
904 next if $seen->{$g}++;
906 my $req_type = 'static';
908 if ( my @e = @{$r->{env}||[]} ) {
910 croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
911 unless $g =~ /^test_/;
913 croak "Unexpected *odd* list in 'env' under group '$g'"
916 # deconstruct the whole thing
917 my (@group_envnames_list, $some_envs_required, $some_required_missing);
919 push @group_envnames_list, my $envname = shift @e;
921 # env required or not
922 next unless shift @e;
924 $some_envs_required ||= 1;
926 $some_required_missing ||= (
927 ! defined $ENV{$envname}
929 ! length $ENV{$envname}
933 croak "None of the envvars in group '$g' declared as required, making the requirement moot"
934 unless $some_envs_required;
936 if ($some_required_missing) {
937 push @{$missing_envvars->{$g}}, \@group_envnames_list;
938 $req_type = 'variable';
942 push @{$res_per_type->{"base_${req_type}"}}, $g;
944 if (my $i = $dbic_reqs->{$g}{include}) {
945 $i = [ $i ] unless ref $i eq 'ARRAY';
947 croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
950 push @{$res_per_type->{"incs_${req_type}"}}, @$i;
955 @{ $res_per_type->{"base_${_}"} || [] },
956 ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
957 } qw(static variable);
959 return ! $is_toplevel ? @ret : do {
962 idx => 1 + keys %$rv,
963 missing_envvars => $missing_envvars->{$_},
965 $rv->{$_}{user_requested} = 1 for @$groups;
971 our %req_unavailability_cache;
973 # this method is just a lister and envvar/metadata checker - it does not try to load anything
974 sub _groups_to_reqs {
975 my ($self, $want) = @_;
977 $want = [ $want || () ]
978 unless ref $want eq 'ARRAY';
980 croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
985 modreqs_fully_documented => 1,
989 for my $piece (@$want) {
990 if ($piece =~ qr/ \A $groupname_re \z /x) {
991 push @$groups, $piece;
993 elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
994 croak "Ad hoc module specification lists '$mod' twice"
995 if exists $ret->{modreqs}{$mod};
997 croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
998 ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
1000 $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
1003 $ret->{modreqs}{$mod} = $ver;
1004 $ret->{modreqs_fully_documented} = 0;
1007 croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1011 my $all_groups = __expand_includes($groups);
1013 # pre-assemble list of augmentations, perform basic sanity checks
1014 # Note that below we *DO NOT* respect the source/target reationship, but
1015 # instead always default to augment the "later" group
1016 # This is done so that the "stable/variable" boundary keeps working as
1019 for my $requesting_group (keys %$all_groups) {
1020 if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1021 for my $target_group (keys %$ag) {
1023 croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1024 unless $dbic_reqs->{$target_group};
1026 croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1027 if $dbic_reqs->{$requesting_group}{env};
1029 croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1030 if $dbic_reqs->{$target_group}{env};
1032 if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1033 croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1036 $ret->{augments}{$target_group} = 1;
1038 # no augmentation for stuff that hasn't been selected
1039 if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1040 push @{$augmentations->{
1041 ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1050 for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1052 my $group_reqs = $dbic_reqs->{$group}{req};
1055 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1056 for (keys %$req_bag) {
1058 $_ =~ / \A $modname_re \z /x
1059 or croak "Requirement '$_' in group '$group' is not a valid module name";
1061 # !!!DO NOT CHANGE!!!
1062 # remember - version.pm may not be available on the system
1063 croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1064 if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1068 if (my $e = $all_groups->{$group}{missing_envvars}) {
1069 push @{$ret->{missing_envvars}}, @$e;
1072 # assemble into the final ret
1075 ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1077 for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1078 for my $mod (keys %$req_bag) {
1080 $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1082 ! exists $ret->{$type}{$mod}
1084 # we sanitized the version to be numeric above - we can just -gt it
1085 ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1092 $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1093 if $all_groups->{$group}{user_requested};
1095 $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1102 # this method tries to find/load specified modreqs and returns a hashref of
1103 # module/loaderror pairs for anything that failed
1104 sub _errorlist_for_modreqs {
1105 # args supposedly already went through _groups_to_reqs and are therefore sanitized
1106 # safe to eval at will
1107 my ($self, $reqs) = @_;
1111 for my $m ( keys %$reqs ) {
1112 my $v = $reqs->{$m};
1114 if (! exists $req_unavailability_cache{$m}{$v} ) {
1116 eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1117 $req_unavailability_cache{$m}{$v} = $@;
1120 $ret->{$m} = $req_unavailability_cache{$m}{$v}
1121 if $req_unavailability_cache{$m}{$v};
1127 # Unlike the above DO NOT try to load anything
1128 # This is executed when some needed envvars are not available
1129 # which in turn means a module load will never be reached anyway
1130 # This is important because some modules (especially DBDs) can be
1131 # *really* fickle when a require() is attempted, with pretty confusing
1132 # side-effects (especially on windows)
1133 sub _list_physically_missing_modules {
1134 my ($self, $modreqs) = @_;
1136 # in case there is a coderef in @INC there is nothing we can definitively prove
1137 # so short circuit directly
1138 return '' if grep { length ref $_ } @INC;
1140 my @definitely_missing;
1141 for my $mod (keys %$modreqs) {
1142 (my $fn = $mod . '.pm') =~ s|::|/|g;
1144 push @definitely_missing, $mod unless grep
1145 # this should work on any combination of slashes
1146 { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1152 { $modreqs->{$_} ? "$_~$modreqs->{$_}" : $_ }
1153 sort { lc($a) cmp lc($b) } @definitely_missing
1158 # This is to be called by the author only (automatically in Makefile.PL)
1160 my ($class, $distver, $pod_dir) = @_;
1162 die "No POD root dir supplied" unless $pod_dir;
1165 eval { require DBIx::Class; DBIx::Class->VERSION; }
1168 "\n\n---------------------------------------------------------------------\n" .
1169 'Unable to load core DBIx::Class module to determine current version, '.
1170 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1172 "\n\n---------------------------------------------------------------------\n"
1175 # do not ask for a recent version, use 1.x API calls
1176 # this *may* execute on a smoker with old perl or whatnot
1179 (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1181 (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1182 (my $dir = $podfn) =~ s|/[^/]+$||;
1184 File::Path::mkpath([$dir]);
1186 my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1187 or die "Hrmm? No sqlt dep?";
1195 push @chunks, <<"EOC";
1196 #########################################################################
1197 ##################### A U T O G E N E R A T E D ########################
1198 #########################################################################
1200 # The contents of this POD file are auto-generated. Any changes you make
1201 # will be lost. If you need to change the generated text edit _gen_pod()
1202 # at the end of $modfn
1207 $class - Optional module dependency specifications (for module authors)
1212 #@@ SYNOPSIS HEADING
1214 push @chunks, <<"EOC";
1217 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1221 \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1222 \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1223 'DBIx::Class' => '$distver',
1228 my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1230 $class->req_list_for([qw( deploy rdbms_oracle icdt )]);
1233 \$EUMM_ARGS{PREREQ_PM} = {
1234 \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1235 \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1240 ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1242 B<Note>: The C<eval> protection within the example is due to support for
1243 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1244 not being available on a sufficient portion of production installations of
1245 Perl. Robust support for such dependency requirements is available in the
1246 L<CPAN> installer only since version C<1.94_56> first made available for
1247 production with perl version C<5.12>. It is the belief of the current
1248 maintainer that support for requirements during the C<configure> build phase
1249 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1250 hence the extra care demonstrated above. It should also be noted that some
1251 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1252 with configure requirements independent from the versions of perl and CPAN
1258 #@@ DESCRIPTION HEADING
1260 push @chunks, <<'EOC';
1263 Some of the less-frequently used features of L<DBIx::Class> have external
1264 module dependencies on their own. In order not to burden the average user
1265 with modules they will never use, these optional dependencies are not included
1266 in the base Makefile.PL. Instead an exception with a descriptive message is
1267 thrown when a specific feature can't find one or several modules required for
1268 its operation. This module is the central holding place for the current list
1269 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1272 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1273 group can list one or more required modules, with an optional minimum version
1274 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1275 a set of environment variables, some (or all) of which are marked as required
1276 for the group to be considered by L</req_list_for>
1278 Each group name (or a combination thereof) can be used in the
1279 L<public methods|/METHODS> as described below.
1284 #@@ REQUIREMENT GROUPLIST HEADING
1286 push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1288 my $standalone_info;
1290 for my $group (sort keys %$dbic_reqs) {
1292 my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1295 $info->{modreqs_fully_documented}
1297 ( $info->{augments} or $info->{modreqs} )
1300 my $p = $dbic_reqs->{$group}{pod};
1303 "=head2 $p->{title}",
1309 if ( keys %{ $info->{modreqs}||{} } ) {
1311 { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1312 ( sort keys %{ $info->{modreqs} } )
1316 push @chunks, '=item * No standalone requirements',
1319 push @chunks, '=back';
1321 for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1322 my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1324 my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1325 for (keys %$newreqs) {
1326 delete $newreqs->{$_} if (
1327 ( defined $info->{modreqs}{$_} and $info->{modreqs}{$_} == $newreqs->{$_} )
1329 ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1333 if (keys %$newreqs) {
1335 "Combined with L</$ag> additionally requires:",
1338 { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1339 ( sort keys %$newreqs )
1349 #@@ API DOCUMENTATION HEADING
1351 push @chunks, <<'EOC';
1353 =head1 IMPORT-LIKE ACTIONS
1355 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1356 supplied to its C<import> method.
1358 =head2 -skip_all_without
1362 =item Arguments: @group_names
1366 A convenience wrapper for use during testing:
1369 push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1371 push @chunks, 'Roughly equivalent to the following code:';
1373 push @chunks, sprintf <<'EOS', ($class) x 2;
1377 if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1378 print "1..0 # SKIP requirements not satisfied: $missing\n";
1384 push @chunks, <<'EOC';
1386 It also takes into account the C<RELEASE_TESTING> environment variable and
1387 behaves like L</-die_without> for any requirement groups marked as
1388 C<release_testing_mandatory>.
1394 =item Arguments: @group_names
1398 A convenience wrapper around L</die_unless_req_ok_for>:
1401 push @chunks, " use $class -die_without => qw(deploy admin);";
1403 push @chunks, <<'EOC';
1405 =head2 -list_missing
1409 =item Arguments: @group_names
1413 A convenience wrapper around L</modreq_missing_for>:
1415 perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1419 =head2 req_group_list
1423 =item Arguments: none
1425 =item Return Value: \%list_of_requirement_groups
1429 This method should be used by DBIx::Class packagers, to get a hashref of all
1430 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1431 thereof (as an arrayref) can be supplied to the methods below.
1432 The B<values> of the returned hash are currently a set of options B<without a
1433 well defined structure>. If you have use for any of the contents - contact the
1434 maintainers, instead of treating this as public (left alone stable) API.
1440 =item Arguments: $group_name | \@group_names
1442 =item Return Value: \%set_of_module_version_pairs
1446 This method should be used by DBIx::Class extension authors, to determine the
1447 version of modules a specific set of features requires for this version of
1448 DBIx::Class (regardless of their availability on the system).
1449 See the L</SYNOPSIS> for a real-world example.
1451 When handling C<test_*> groups this method behaves B<differently> from
1452 L</modreq_list_for> below (and is the only such inconsistency among the
1453 C<req_*> methods). If a particular group declares as requirements some
1454 C<environment variables> and these requirements are not satisfied (the envvars
1455 are unset) - then the C<module requirements> of this group are not included in
1458 =head2 modreq_list_for
1462 =item Arguments: $group_name | \@group_names
1464 =item Return Value: \%set_of_module_version_pairs
1468 Same as L</req_list_for> but does not take into consideration any
1469 C<environment variable requirements> - returns just the list of required
1476 =item Arguments: $group_name | \@group_names
1478 =item Return Value: 1|0
1482 Returns true or false depending on whether all modules/envvars required by
1483 the group(s) are loadable/set on the system.
1485 =head2 req_missing_for
1489 =item Arguments: $group_name | \@group_names
1491 =item Return Value: $error_message_string
1495 Returns a single-line string suitable for inclusion in larger error messages.
1496 This method would normally be used by DBIx::Class core features, to indicate to
1497 the user that they need to install specific modules and/or set specific
1498 environment variables before being able to use a specific feature set.
1500 For example if some of the requirements for C<deploy> are not available,
1501 the returned string could look like:
1504 push @chunks, qq{ "SQL::Translator~$sqltver" (see $class documentation for details)};
1506 push @chunks, <<'EOC';
1507 The author is expected to prepend the necessary text to this message before
1508 returning the actual error seen by the user. See also L</modreq_missing_for>
1510 =head2 modreq_missing_for
1514 =item Arguments: $group_name | \@group_names
1516 =item Return Value: $error_message_string
1520 Same as L</req_missing_for> except that the error string is guaranteed to be
1521 either empty, or contain a set of module requirement specifications suitable
1522 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1523 attempt to validate the state of required environment variables (if any).
1525 For instance if some of the requirements for C<deploy> are not available,
1526 the returned string could look like:
1529 push @chunks, qq{ "SQL::Translator~$sqltver"};
1531 push @chunks, <<'EOC';
1533 See also L</-list_missing>.
1539 =item Arguments: $group_name | \@group_names
1543 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1544 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1545 (it is always C<1>, thus mandating unconditional use of
1546 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1547 requirement specifications:
1550 push @chunks, <<EOC;
1552 $class->skip_without([ deploy YAML>=0.90 ]);
1558 push @chunks, <<'EOC';
1560 =head2 die_unless_req_ok_for
1564 =item Arguments: $group_name | \@group_names
1568 Checks if L</req_ok_for> passes for the supplied group(s), and
1569 in case of failure throws an exception including the information
1570 from L</req_missing_for>. See also L</-die_without>.
1572 =head2 modreq_errorlist_for
1576 =item Arguments: $group_name | \@group_names
1578 =item Return Value: \%set_of_loaderrors_per_module
1582 Returns a hashref containing the actual errors that occurred while attempting
1583 to load each module in the requirement group(s).
1585 =head2 req_errorlist_for
1587 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1594 push @chunks, <<'EOC';
1595 =head1 FURTHER QUESTIONS?
1597 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1599 =head1 COPYRIGHT AND LICENSE
1601 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1602 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1603 redistribute it and/or modify it under the same terms as the
1604 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1608 open (my $fh, '>', $podfn) or die;
1609 print $fh join ("\n\n", @chunks) or die;
1610 print $fh "\n" or die;
1612 } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );