These are already pre-required by the OptDeps check
[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Optional / Dependencies.pm
1 package DBIx::Class::Optional::Dependencies;
2
3 use warnings;
4 use strict;
5
6 use Carp;
7
8 # NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
9 # This module is to be loaded by Makefile.PM on a pristine system
10
11 # POD is generated automatically by calling _gen_pod from the
12 # Makefile.PL in $AUTHOR mode
13
14 # NOTE: the rationale for 2 JSON::Any versions is that
15 # we need the newer only to work around JSON::XS, which
16 # itself is an optional dep
17 my $min_json_any = {
18   'JSON::Any'                     => '1.23',
19 };
20 my $test_and_dist_json_any = {
21   'JSON::Any'                     => '1.31',
22 };
23
24 my $moose_basic = {
25   'Moose'                         => '0.98',
26   'MooseX::Types'                 => '0.21',
27   'MooseX::Types::LoadableClass'  => '0.011',
28 };
29
30 my $replicated = {
31   %$moose_basic,
32 };
33
34 my $admin_basic = {
35   %$moose_basic,
36   %$min_json_any,
37   'MooseX::Types::Path::Class'    => '0.05',
38   'MooseX::Types::JSON'           => '0.02',
39 };
40
41 my $admin_script = {
42   %$moose_basic,
43   %$admin_basic,
44   'Getopt::Long::Descriptive' => '0.081',
45   'Text::CSV'                 => '1.16',
46 };
47
48 my $datetime_basic = {
49   'DateTime'                      => '0.55',
50   'DateTime::Format::Strptime'    => '1.2',
51 };
52
53 my $id_shortener = {
54   'Digest::MD5'                   => '0',
55   'Math::BigInt'                  => '1.80',
56   'Math::Base36'                  => '0.07',
57 };
58
59 my $rdbms_sqlite = {
60   'DBD::SQLite'                   => '0',
61 };
62 my $rdbms_pg = {
63   'DBD::Pg'                       => '0',
64 };
65 my $rdbms_mssql_odbc = {
66   'DBD::ODBC'                     => '0',
67 };
68 my $rdbms_mssql_sybase = {
69   'DBD::Sybase'                   => '0',
70 };
71 my $rdbms_mssql_ado = {
72   'DBD::ADO'                      => '0',
73 };
74 my $rdbms_msaccess_odbc = {
75   'DBD::ODBC'                     => '0',
76 };
77 my $rdbms_msaccess_ado = {
78   'DBD::ADO'                      => '0',
79 };
80 my $rdbms_mysql = {
81   'DBD::mysql'                    => '0',
82 };
83 my $rdbms_oracle = {
84   'DBD::Oracle'                   => '0',
85   %$id_shortener,
86 };
87 my $rdbms_ase = {
88   'DBD::Sybase'                   => '0',
89 };
90 my $rdbms_db2 = {
91   'DBD::DB2'                      => '0',
92 };
93 my $rdbms_db2_400 = {
94   'DBD::ODBC'                     => '0',
95 };
96 my $rdbms_informix = {
97   'DBD::Informix'                 => '0',
98 };
99 my $rdbms_sqlanywhere = {
100   'DBD::SQLAnywhere'              => '0',
101 };
102 my $rdbms_sqlanywhere_odbc = {
103   'DBD::ODBC'                     => '0',
104 };
105 my $rdbms_firebird = {
106   'DBD::Firebird'                 => '0',
107 };
108 my $rdbms_firebird_interbase = {
109   'DBD::InterBase'                => '0',
110 };
111 my $rdbms_firebird_odbc = {
112   'DBD::ODBC'                     => '0',
113 };
114
115 my $reqs = {
116   replicated => {
117     req => $replicated,
118     pod => {
119       title => 'Storage::Replicated',
120       desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
121     },
122   },
123
124   test_replicated => {
125     req => {
126       %$replicated,
127       'Test::Moose'               => '0',
128     },
129   },
130
131
132   admin => {
133     req => {
134       %$admin_basic,
135     },
136     pod => {
137       title => 'DBIx::Class::Admin',
138       desc => 'Modules required for the DBIx::Class administrative library',
139     },
140   },
141
142   admin_script => {
143     req => {
144       %$admin_script,
145     },
146     pod => {
147       title => 'dbicadmin',
148       desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
149     },
150   },
151
152   deploy => {
153     req => {
154       'SQL::Translator'           => '0.11018',
155     },
156     pod => {
157       title => 'Storage::DBI::deploy()',
158       desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
159     },
160   },
161
162   id_shortener => {
163     req => $id_shortener,
164   },
165
166   test_component_accessor => {
167     req => {
168       'Class::Unload'             => '0.07',
169     },
170   },
171
172   test_pod => {
173     req => {
174       'Test::Pod'                 => '1.42',
175     },
176   },
177
178   test_podcoverage => {
179     req => {
180       'Test::Pod::Coverage'       => '1.08',
181       'Pod::Coverage'             => '0.20',
182     },
183   },
184
185   test_whitespace => {
186     req => {
187       'Test::EOL'                 => '1.0',
188       'Test::NoTabs'              => '0.9',
189     },
190   },
191
192   test_strictures => {
193     req => {
194       'Test::Strict'              => '0.20',
195     },
196   },
197
198   test_prettydebug => {
199     req => $min_json_any,
200   },
201
202   test_admin_script => {
203     req => {
204       %$admin_script,
205       %$test_and_dist_json_any,
206       'JSON' => 0,
207       'JSON::PP' => 0,
208       'Cpanel::JSON::XS' => 0,
209       'JSON::XS' => 0,
210       $^O eq 'MSWin32'
211         # for t/admin/10script.t
212         ? ('Win32::ShellQuote' => 0)
213         # DWIW does not compile (./configure even) on win32
214         : ('JSON::DWIW' => 0 )
215       ,
216     }
217   },
218
219   test_leaks_heavy => {
220     req => {
221       'Class::MethodCache' => '0.02',
222       'PadWalker' => '1.06',
223     },
224   },
225
226   test_dt => {
227     req => $datetime_basic,
228   },
229
230   test_dt_sqlite => {
231     req => {
232       %$datetime_basic,
233       # t/36datetime.t
234       # t/60core.t
235       'DateTime::Format::SQLite'  => '0',
236     },
237   },
238
239   test_dt_mysql => {
240     req => {
241       %$datetime_basic,
242       # t/inflate/datetime_mysql.t
243       # (doesn't need Mysql itself)
244       'DateTime::Format::MySQL'   => '0',
245     },
246   },
247
248   test_dt_pg => {
249     req => {
250       %$datetime_basic,
251       # t/inflate/datetime_pg.t
252       # (doesn't need PG itself)
253       'DateTime::Format::Pg'      => '0.16004',
254     },
255   },
256
257   test_cdbicompat => {
258     req => {
259       'Class::DBI::Plugin::DeepAbstractSearch' => '0',
260       %$datetime_basic,
261       'Time::Piece::MySQL'        => '0',
262       'Date::Simple'              => '3.03',
263     },
264   },
265
266   # this is just for completeness as SQLite
267   # is a core dep of DBIC for testing
268   rdbms_sqlite => {
269     req => {
270       %$rdbms_sqlite,
271     },
272     pod => {
273       title => 'SQLite support',
274       desc => 'Modules required to connect to SQLite',
275     },
276   },
277
278   rdbms_pg => {
279     req => {
280       # when changing this list make sure to adjust xt/optional_deps.t
281       %$rdbms_pg,
282     },
283     pod => {
284       title => 'PostgreSQL support',
285       desc => 'Modules required to connect to PostgreSQL',
286     },
287   },
288
289   rdbms_mssql_odbc => {
290     req => {
291       %$rdbms_mssql_odbc,
292     },
293     pod => {
294       title => 'MSSQL support via DBD::ODBC',
295       desc => 'Modules required to connect to MSSQL via DBD::ODBC',
296     },
297   },
298
299   rdbms_mssql_sybase => {
300     req => {
301       %$rdbms_mssql_sybase,
302     },
303     pod => {
304       title => 'MSSQL support via DBD::Sybase',
305       desc => 'Modules required to connect to MSSQL via DBD::Sybase',
306     },
307   },
308
309   rdbms_mssql_ado => {
310     req => {
311       %$rdbms_mssql_ado,
312     },
313     pod => {
314       title => 'MSSQL support via DBD::ADO (Windows only)',
315       desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
316     },
317   },
318
319   rdbms_msaccess_odbc => {
320     req => {
321       %$rdbms_msaccess_odbc,
322     },
323     pod => {
324       title => 'MS Access support via DBD::ODBC',
325       desc => 'Modules required to connect to MS Access via DBD::ODBC',
326     },
327   },
328
329   rdbms_msaccess_ado => {
330     req => {
331       %$rdbms_msaccess_ado,
332     },
333     pod => {
334       title => 'MS Access support via DBD::ADO (Windows only)',
335       desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
336     },
337   },
338
339   rdbms_mysql => {
340     req => {
341       %$rdbms_mysql,
342     },
343     pod => {
344       title => 'MySQL support',
345       desc => 'Modules required to connect to MySQL',
346     },
347   },
348
349   rdbms_oracle => {
350     req => {
351       %$rdbms_oracle,
352     },
353     pod => {
354       title => 'Oracle support',
355       desc => 'Modules required to connect to Oracle',
356     },
357   },
358
359   rdbms_ase => {
360     req => {
361       %$rdbms_ase,
362     },
363     pod => {
364       title => 'Sybase ASE support',
365       desc => 'Modules required to connect to Sybase ASE',
366     },
367   },
368
369   rdbms_db2 => {
370     req => {
371       %$rdbms_db2,
372     },
373     pod => {
374       title => 'DB2 support',
375       desc => 'Modules required to connect to DB2',
376     },
377   },
378
379   rdbms_db2_400 => {
380     req => {
381       %$rdbms_db2_400,
382     },
383     pod => {
384       title => 'DB2 on AS/400 support',
385       desc => 'Modules required to connect to DB2 on AS/400',
386     },
387   },
388
389   rdbms_informix => {
390     req => {
391       %$rdbms_informix,
392     },
393     pod => {
394       title => 'Informix support',
395       desc => 'Modules required to connect to Informix',
396     },
397   },
398
399   rdbms_sqlanywhere => {
400     req => {
401       %$rdbms_sqlanywhere,
402     },
403     pod => {
404       title => 'SQLAnywhere support',
405       desc => 'Modules required to connect to SQLAnywhere',
406     },
407   },
408
409   rdbms_sqlanywhere_odbc => {
410     req => {
411       %$rdbms_sqlanywhere_odbc,
412     },
413     pod => {
414       title => 'SQLAnywhere support via DBD::ODBC',
415       desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
416     },
417   },
418
419   rdbms_firebird => {
420     req => {
421       %$rdbms_firebird,
422     },
423     pod => {
424       title => 'Firebird support',
425       desc => 'Modules required to connect to Firebird',
426     },
427   },
428
429   rdbms_firebird_interbase => {
430     req => {
431       %$rdbms_firebird_interbase,
432     },
433     pod => {
434       title => 'Firebird support via DBD::InterBase',
435       desc => 'Modules required to connect to Firebird via DBD::InterBase',
436     },
437   },
438
439   rdbms_firebird_odbc => {
440     req => {
441       %$rdbms_firebird_odbc,
442     },
443     pod => {
444       title => 'Firebird support via DBD::ODBC',
445       desc => 'Modules required to connect to Firebird via DBD::ODBC',
446     },
447   },
448
449 # the order does matter because the rdbms support group might require
450 # a different version that the test group
451   test_rdbms_pg => {
452     req => {
453       $ENV{DBICTEST_PG_DSN}
454         ? (
455           # when changing this list make sure to adjust xt/optional_deps.t
456           %$rdbms_pg,
457           'DBD::Pg'               => '2.009002',
458         ) : ()
459     },
460   },
461
462   test_rdbms_mssql_odbc => {
463     req => {
464       $ENV{DBICTEST_MSSQL_ODBC_DSN}
465         ? (
466           %$rdbms_mssql_odbc,
467         ) : ()
468     },
469   },
470
471   test_rdbms_mssql_ado => {
472     req => {
473       $ENV{DBICTEST_MSSQL_ADO_DSN}
474         ? (
475           %$rdbms_mssql_ado,
476         ) : ()
477     },
478   },
479
480   test_rdbms_mssql_sybase => {
481     req => {
482       $ENV{DBICTEST_MSSQL_DSN}
483         ? (
484           %$rdbms_mssql_sybase,
485         ) : ()
486     },
487   },
488
489   test_rdbms_msaccess_odbc => {
490     req => {
491       $ENV{DBICTEST_MSACCESS_ODBC_DSN}
492         ? (
493           %$rdbms_msaccess_odbc,
494           %$datetime_basic,
495           'Data::GUID' => '0',
496         ) : ()
497     },
498   },
499
500   test_rdbms_msaccess_ado => {
501     req => {
502       $ENV{DBICTEST_MSACCESS_ADO_DSN}
503         ? (
504           %$rdbms_msaccess_ado,
505           %$datetime_basic,
506           'Data::GUID' => 0,
507         ) : ()
508     },
509   },
510
511   test_rdbms_mysql => {
512     req => {
513       $ENV{DBICTEST_MYSQL_DSN}
514         ? (
515           %$rdbms_mysql,
516         ) : ()
517     },
518   },
519
520   test_rdbms_oracle => {
521     req => {
522       $ENV{DBICTEST_ORA_DSN}
523         ? (
524           %$rdbms_oracle,
525           'DateTime::Format::Oracle' => '0',
526           'DBD::Oracle'              => '1.24',
527         ) : ()
528     },
529   },
530
531   test_rdbms_ase => {
532     req => {
533       $ENV{DBICTEST_SYBASE_DSN}
534         ? (
535           %$rdbms_ase,
536         ) : ()
537     },
538   },
539
540   test_rdbms_db2 => {
541     req => {
542       $ENV{DBICTEST_DB2_DSN}
543         ? (
544           %$rdbms_db2,
545         ) : ()
546     },
547   },
548
549   test_rdbms_db2_400 => {
550     req => {
551       $ENV{DBICTEST_DB2_400_DSN}
552         ? (
553           %$rdbms_db2_400,
554         ) : ()
555     },
556   },
557
558   test_rdbms_informix => {
559     req => {
560       $ENV{DBICTEST_INFORMIX_DSN}
561         ? (
562           %$rdbms_informix,
563         ) : ()
564     },
565   },
566
567   test_rdbms_sqlanywhere => {
568     req => {
569       $ENV{DBICTEST_SQLANYWHERE_DSN}
570         ? (
571           %$rdbms_sqlanywhere,
572         ) : ()
573     },
574   },
575
576   test_rdbms_sqlanywhere_odbc => {
577     req => {
578       $ENV{DBICTEST_SQLANYWHERE_ODBC_DSN}
579         ? (
580           %$rdbms_sqlanywhere_odbc,
581         ) : ()
582     },
583   },
584
585   test_rdbms_firebird => {
586     req => {
587       $ENV{DBICTEST_FIREBIRD_DSN}
588         ? (
589           %$rdbms_firebird,
590         ) : ()
591     },
592   },
593
594   test_rdbms_firebird_interbase => {
595     req => {
596       $ENV{DBICTEST_FIREBIRD_INTERBASE_DSN}
597         ? (
598           %$rdbms_firebird_interbase,
599         ) : ()
600     },
601   },
602
603   test_rdbms_firebird_odbc => {
604     req => {
605       $ENV{DBICTEST_FIREBIRD_ODBC_DSN}
606         ? (
607           %$rdbms_firebird_odbc,
608         ) : ()
609     },
610   },
611
612   test_memcached => {
613     req => {
614       $ENV{DBICTEST_MEMCACHED}
615         ? (
616           'Cache::Memcached' => 0,
617         ) : ()
618     },
619   },
620
621   dist_dir => {
622     req => {
623       %$test_and_dist_json_any,
624       'ExtUtils::MakeMaker' => '6.64',
625       'Pod::Inherit'        => '0.91',
626     },
627   },
628
629   dist_upload => {
630     req => {
631       'CPAN::Uploader' => '0.103001',
632     },
633   },
634
635 };
636
637 our %req_availability_cache;
638
639 sub req_list_for {
640   my ($class, $group) = @_;
641
642   croak "req_list_for() expects a requirement group name"
643     unless $group;
644
645   my $deps = $reqs->{$group}{req}
646     or croak "Requirement group '$group' does not exist";
647
648   return { %$deps };
649 }
650
651
652 sub die_unless_req_ok_for {
653   my ($class, $group) = @_;
654
655   croak "die_unless_req_ok_for() expects a requirement group name"
656     unless $group;
657
658   $class->_check_deps($group)->{status}
659     or die sprintf( "Required modules missing, unable to continue: %s\n", $class->_check_deps($group)->{missing} );
660 }
661
662 sub req_ok_for {
663   my ($class, $group) = @_;
664
665   croak "req_ok_for() expects a requirement group name"
666     unless $group;
667
668   return $class->_check_deps($group)->{status};
669 }
670
671 sub req_missing_for {
672   my ($class, $group) = @_;
673
674   croak "req_missing_for() expects a requirement group name"
675     unless $group;
676
677   return $class->_check_deps($group)->{missing};
678 }
679
680 sub req_errorlist_for {
681   my ($class, $group) = @_;
682
683   croak "req_errorlist_for() expects a requirement group name"
684     unless $group;
685
686   return $class->_check_deps($group)->{errorlist};
687 }
688
689 sub _check_deps {
690   my ($class, $group) = @_;
691
692   return $req_availability_cache{$group} ||= do {
693
694     my $deps = $class->req_list_for ($group);
695
696     my %errors;
697     for my $mod (keys %$deps) {
698       my $req_line = "require $mod;";
699       if (my $ver = $deps->{$mod}) {
700         $req_line .= "$mod->VERSION($ver);";
701       }
702
703       eval $req_line;
704
705       $errors{$mod} = $@ if $@;
706     }
707
708     my $res;
709
710     if (keys %errors) {
711       my $missing = join (', ', map { $deps->{$_} ? "$_ >= $deps->{$_}" : $_ } (sort keys %errors) );
712       $missing .= " (see $class for details)" if $reqs->{$group}{pod};
713       $res = {
714         status => 0,
715         errorlist => \%errors,
716         missing => $missing,
717       };
718     }
719     else {
720       $res = {
721         status => 1,
722         errorlist => {},
723         missing => '',
724       };
725     }
726
727     $res;
728   };
729 }
730
731 sub req_group_list {
732   return { map { $_ => { %{ $reqs->{$_}{req} || {} } } } (keys %$reqs) };
733 }
734
735 # This is to be called by the author only (automatically in Makefile.PL)
736 sub _gen_pod {
737   my ($class, $distver, $pod_dir) = @_;
738
739   die "No POD root dir supplied" unless $pod_dir;
740
741   $distver ||=
742     eval { require DBIx::Class; DBIx::Class->VERSION; }
743       ||
744     die
745 "\n\n---------------------------------------------------------------------\n" .
746 'Unable to load core DBIx::Class module to determine current version, '.
747 'possibly due to missing dependencies. Author-mode autodocumentation ' .
748 "halted\n\n" . $@ .
749 "\n\n---------------------------------------------------------------------\n"
750   ;
751
752   # do not ask for a recent version, use 1.x API calls
753   # this *may* execute on a smoker with old perl or whatnot
754   require File::Path;
755
756   (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
757
758   (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
759   (my $dir = $podfn) =~ s|/[^/]+$||;
760
761   File::Path::mkpath([$dir]);
762
763   my $sqltver = $class->req_list_for ('deploy')->{'SQL::Translator'}
764     or die "Hrmm? No sqlt dep?";
765
766   my @chunks = (
767     <<"EOC",
768 #########################################################################
769 #####################  A U T O G E N E R A T E D ########################
770 #########################################################################
771 #
772 # The contents of this POD file are auto-generated.  Any changes you make
773 # will be lost. If you need to change the generated text edit _gen_pod()
774 # at the end of $modfn
775 #
776 EOC
777     '=head1 NAME',
778     "$class - Optional module dependency specifications (for module authors)",
779     '=head1 SYNOPSIS',
780     <<"EOS",
781 Somewhere in your build-file (e.g. L<Module::Install>'s Makefile.PL):
782
783   ...
784
785   configure_requires 'DBIx::Class' => '$distver';
786
787   require $class;
788
789   my \$deploy_deps = $class->req_list_for('deploy');
790
791   for (keys %\$deploy_deps) {
792     requires \$_ => \$deploy_deps->{\$_};
793   }
794
795   ...
796
797 Note that there are some caveats regarding C<configure_requires()>, more info
798 can be found at L<Module::Install/configure_requires>
799 EOS
800     '=head1 DESCRIPTION',
801     <<'EOD',
802 Some of the less-frequently used features of L<DBIx::Class> have external
803 module dependencies on their own. In order not to burden the average user
804 with modules he will never use, these optional dependencies are not included
805 in the base Makefile.PL. Instead an exception with a descriptive message is
806 thrown when a specific feature is missing one or several modules required for
807 its operation. This module is the central holding place for  the current list
808 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
809 authors alike.
810 EOD
811     '=head1 CURRENT REQUIREMENT GROUPS',
812     <<'EOD',
813 Dependencies are organized in C<groups> and each group can list one or more
814 required modules, with an optional minimum version (or 0 for any version).
815 The group name can be used in the
816 EOD
817   );
818
819   for my $group (sort keys %$reqs) {
820     my $p = $reqs->{$group}{pod}
821       or next;
822
823     my $modlist = $reqs->{$group}{req}
824       or next;
825
826     next unless keys %$modlist;
827
828     push @chunks, (
829       "=head2 $p->{title}",
830       "$p->{desc}",
831       '=over',
832       ( map { "=item * $_" . ($modlist->{$_} ? " >= $modlist->{$_}" : '') } (sort keys %$modlist) ),
833       '=back',
834       "Requirement group: B<$group>",
835     );
836   }
837
838   push @chunks, (
839     '=head1 METHODS',
840     '=head2 req_group_list',
841     '=over',
842     '=item Arguments: none',
843     '=item Return Value: \%list_of_requirement_groups',
844     '=back',
845     <<'EOD',
846 This method should be used by DBIx::Class packagers, to get a hashref of all
847 dependencies keyed by dependency group. Each key (group name) can be supplied
848 to one of the group-specific methods below.
849 EOD
850
851     '=head2 req_list_for',
852     '=over',
853     '=item Arguments: $group_name',
854     '=item Return Value: \%list_of_module_version_pairs',
855     '=back',
856     <<'EOD',
857 This method should be used by DBIx::Class extension authors, to determine the
858 version of modules a specific feature requires in the B<current> version of
859 DBIx::Class. See the L</SYNOPSIS> for a real-world
860 example.
861 EOD
862
863     '=head2 req_ok_for',
864     '=over',
865     '=item Arguments: $group_name',
866     '=item Return Value: 1|0',
867     '=back',
868     <<'EOD',
869 Returns true or false depending on whether all modules required by
870 C<$group_name> are present on the system and loadable.
871 EOD
872
873     '=head2 req_missing_for',
874     '=over',
875     '=item Arguments: $group_name',
876     '=item Return Value: $error_message_string',
877     '=back',
878     <<"EOD",
879 Returns a single line string suitable for inclusion in larger error messages.
880 This method would normally be used by DBIx::Class core-module author, to
881 indicate to the user that he needs to install specific modules before he will
882 be able to use a specific feature.
883
884 For example if some of the requirements for C<deploy> are not available,
885 the returned string could look like:
886
887  SQL::Translator >= $sqltver (see $class for details)
888
889 The author is expected to prepend the necessary text to this message before
890 returning the actual error seen by the user.
891 EOD
892
893     '=head2 die_unless_req_ok_for',
894     '=over',
895     '=item Arguments: $group_name',
896     '=back',
897     <<'EOD',
898 Checks if L</req_ok_for> passes for the supplied C<$group_name>, and
899 in case of failure throws an exception including the information
900 from L</req_missing_for>.
901 EOD
902
903     '=head2 req_errorlist_for',
904     '=over',
905     '=item Arguments: $group_name',
906     '=item Return Value: \%list_of_loaderrors_per_module',
907     '=back',
908     <<'EOD',
909 Returns a hashref containing the actual errors that occurred while attempting
910 to load each module in the requirement group.
911 EOD
912     '=head1 FURTHER QUESTIONS?',
913     'Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.',
914     '=head1 COPYRIGHT AND LICENSE',
915     <<'EOL',
916 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
917 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
918 redistribute it and/or modify it under the same terms as the
919 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
920 EOL
921
922   );
923
924   eval {
925     open (my $fh, '>', $podfn) or die;
926     print $fh join ("\n\n", @chunks) or die;
927     print $fh "\n" or die;
928     close ($fh) or die;
929   } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );
930 }
931
932 1;