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