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