lib/DBIx/Class/Optional/Dependencies.pm

   1 package DBIx::Class::Optional::Dependencies;
   2
   3 ### This may look crazy, but it in fact tangibly ( by 50(!)% ) shortens
   4 #   the skip-test time when everything requested is unavailable
   5 BEGIN {
   6   if ( $ENV{RELEASE_TESTING} ) {
   7     require warnings and warnings->import;
   8     require strict and strict->import;
   9   }
  10 }
  11
  12 sub croak {
  13   require Carp;
  14   Carp::croak(@_);
  15 };
  16 ###
  17
  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
  20
  21 # POD is generated automatically by calling _gen_pod from the
  22 # Makefile.PL in $AUTHOR mode
  23
  24 # *DELIBERATELY* not making a group for these - they must disappear
  25 # forever as optdeps in the first place
  26 my $moose_basic = {
  27   'Moose'                         => '0.98',
  28   'MooseX::Types'                 => '0.21',
  29   'MooseX::Types::LoadableClass'  => '0.011',
  30 };
  31
  32 my $dbic_reqs = {
  33
  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
  37   _json_any => {
  38     req => {
  39       'JSON::Any' => '1.23',
  40     },
  41   },
  42
  43   _json_xs_compatible_json_any => {
  44     req => {
  45       'JSON::Any' => '1.31',
  46     },
  47   },
  48
  49   # a common placeholder for engines with IC::DT support based off DT::F::S
  50   _icdt_strptime_based => {
  51     augment => {
  52       icdt => {
  53         req => {
  54           'DateTime::Format::Strptime' => '1.2',
  55         },
  56       },
  57     }
  58   },
  59
  60   _rdbms_generic_odbc => {
  61     req => {
  62       'DBD::ODBC' => 0,
  63     }
  64   },
  65
  66   _rdbms_generic_ado => {
  67     req => {
  68       'DBD::ADO' => 0,
  69     }
  70   },
  71
  72   # must list any dep used by adhoc testing
  73   # this prevents the "skips due to forgotten deps" issue
  74   test_adhoc => {
  75     req => {
  76       'Class::DBI::Plugin::DeepAbstractSearch' => '0',
  77       'Class::DBI' => '3.000005',
  78       'Date::Simple' => '3.03',
  79       'YAML' => '0',
  80       'Class::Unload' => '0.07',
  81       'Time::Piece' => '0',
  82       'Time::Piece::MySQL' => '0',
  83     },
  84   },
  85
  86   replicated => {
  87     req => $moose_basic,
  88     pod => {
  89       title => 'Storage::Replicated',
  90       desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
  91     },
  92   },
  93
  94   test_replicated => {
  95     include => 'replicated',
  96     req => {
  97       'Test::Moose' => '0',
  98     },
  99   },
 100
 101   admin => {
 102     include => '_json_any',
 103     req => {
 104       %$moose_basic,
 105       'MooseX::Types::Path::Class' => '0.05',
 106       'MooseX::Types::JSON' => '0.02',
 107     },
 108     pod => {
 109       title => 'DBIx::Class::Admin',
 110       desc => 'Modules required for the DBIx::Class administrative library',
 111     },
 112   },
 113
 114   admin_script => {
 115     include => 'admin',
 116     req => {
 117       'Getopt::Long::Descriptive' => '0.081',
 118       'Text::CSV' => '1.16',
 119     },
 120     pod => {
 121       title => 'dbicadmin',
 122       desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
 123     },
 124   },
 125
 126   deploy => {
 127     req => {
 128       'SQL::Translator'           => '0.11018',
 129     },
 130     pod => {
 131       title => 'Storage::DBI::deploy()',
 132       desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
 133     },
 134   },
 135
 136   icdt => {
 137     req => {
 138       'DateTime' => '0.55',
 139     },
 140     pod => {
 141       title => 'InflateColumn::DateTime support',
 142       desc =>
 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',
 147     },
 148   },
 149
 150   id_shortener => {
 151     req => {
 152       'Math::BigInt' => '1.80',
 153       'Math::Base36' => '0.07',
 154     },
 155   },
 156
 157   cdbicompat => {
 158     req => {
 159       'Class::Data::Inheritable' => '0',
 160       'Class::Trigger' => '0',
 161       'DBIx::ContextualFetch' => '0',
 162       'Clone' => '0.32',
 163     },
 164     pod => {
 165       title => 'DBIx::Class::CDBICompat support',
 166       desc => 'Modules required for L<DBIx::Class::CDBICompat>'
 167     },
 168   },
 169
 170   test_pod => {
 171     req => {
 172       'Test::Pod'                 => '1.42',
 173     },
 174     release_testing_mandatory => 1,
 175   },
 176
 177   test_podcoverage => {
 178     req => {
 179       'Test::Pod::Coverage'       => '1.08',
 180       'Pod::Coverage'             => '0.20',
 181     },
 182     release_testing_mandatory => 1,
 183   },
 184
 185   test_whitespace => {
 186     req => {
 187       'Test::EOL'                 => '1.0',
 188       'Test::NoTabs'              => '0.9',
 189     },
 190     release_testing_mandatory => 1,
 191   },
 192
 193   test_strictures => {
 194     req => {
 195       'Test::Strict'              => '0.20',
 196     },
 197     release_testing_mandatory => 1,
 198   },
 199
 200   test_prettydebug => {
 201     include => '_json_any',
 202   },
 203
 204   test_admin_script => {
 205     include => [qw( admin_script _json_xs_compatible_json_any )],
 206     req => {
 207       'JSON' => 0,
 208       'JSON::PP' => 0,
 209       'Cpanel::JSON::XS' => 0,
 210       'JSON::XS' => 0,
 211       $^O eq 'MSWin32'
 212         # for t/admin/10script.t
 213         ? ('Win32::ShellQuote' => 0)
 214         # DWIW does not compile (./configure even) on win32
 215         : ('JSON::DWIW' => 0 )
 216       ,
 217     }
 218   },
 219
 220   test_leaks_heavy => {
 221     req => {
 222       'Class::MethodCache' => '0.02',
 223       'PadWalker' => '1.06',
 224     },
 225   },
 226
 227
 228   # this is just for completeness as SQLite
 229   # is a core dep of DBIC for testing
 230   rdbms_sqlite => {
 231     req => {
 232       'DBD::SQLite' => 0,
 233     },
 234     pod => {
 235       title => 'SQLite support',
 236       desc => 'Modules required to connect to SQLite',
 237     },
 238     augment => {
 239       icdt => {
 240         req => {
 241           'DateTime::Format::SQLite' => '0',
 242         },
 243       },
 244     },
 245   },
 246
 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
 249   # not _-prefixed so that it will show up under req_group_list
 250   icdt_pg => {
 251     augment => {
 252       icdt => {
 253         req => {
 254           'DateTime::Format::Pg' => '0.16004',
 255         },
 256       },
 257     },
 258   },
 259
 260   rdbms_pg => {
 261     include => 'icdt_pg',
 262     req => {
 263       # when changing this list make sure to adjust xt/optional_deps.t
 264       'DBD::Pg' => 0,
 265     },
 266     pod => {
 267       title => 'PostgreSQL support',
 268       desc => 'Modules required to connect to PostgreSQL',
 269     },
 270   },
 271
 272   _rdbms_mssql_common => {
 273     include => '_icdt_strptime_based',
 274   },
 275
 276   rdbms_mssql_odbc => {
 277     include => [qw( _rdbms_generic_odbc _rdbms_mssql_common )],
 278     pod => {
 279       title => 'MSSQL support via DBD::ODBC',
 280       desc => 'Modules required to connect to MSSQL via DBD::ODBC',
 281     },
 282   },
 283
 284   rdbms_mssql_sybase => {
 285     include => '_rdbms_mssql_common',
 286     req => {
 287       'DBD::Sybase' => 0,
 288     },
 289     pod => {
 290       title => 'MSSQL support via DBD::Sybase',
 291       desc => 'Modules required to connect to MSSQL via DBD::Sybase',
 292     },
 293   },
 294
 295   rdbms_mssql_ado => {
 296     include => [qw( _rdbms_generic_ado _rdbms_mssql_common )],
 297     pod => {
 298       title => 'MSSQL support via DBD::ADO (Windows only)',
 299       desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
 300     },
 301   },
 302
 303   _rdbms_msaccess_common => {
 304     include => '_icdt_strptime_based',
 305   },
 306
 307   rdbms_msaccess_odbc => {
 308     include => [qw( _rdbms_generic_odbc _rdbms_msaccess_common )],
 309     pod => {
 310       title => 'MS Access support via DBD::ODBC',
 311       desc => 'Modules required to connect to MS Access via DBD::ODBC',
 312     },
 313   },
 314
 315   rdbms_msaccess_ado => {
 316     include => [qw( _rdbms_generic_ado _rdbms_msaccess_common )],
 317     pod => {
 318       title => 'MS Access support via DBD::ADO (Windows only)',
 319       desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
 320     },
 321   },
 322
 323   # centralize the specification, as we have ICDT tests which can
 324   # test the full behavior of RDBMS-specific ICDT on top of bare SQLite
 325   # not _-prefixed so that it will show up under req_group_list
 326   icdt_mysql => {
 327     augment => {
 328       icdt => {
 329         req => {
 330           'DateTime::Format::MySQL' => '0',
 331         },
 332       },
 333     },
 334   },
 335
 336   rdbms_mysql => {
 337     include => 'icdt_mysql',
 338     req => {
 339       'DBD::mysql' => 0,
 340     },
 341     pod => {
 342       title => 'MySQL support',
 343       desc => 'Modules required to connect to MySQL',
 344     },
 345   },
 346
 347   rdbms_oracle => {
 348     include => 'id_shortener',
 349     req => {
 350       'DBD::Oracle' => 0,
 351     },
 352     pod => {
 353       title => 'Oracle support',
 354       desc => 'Modules required to connect to Oracle',
 355     },
 356     augment => {
 357       icdt => {
 358         req => {
 359           'DateTime::Format::Oracle' => '0',
 360         },
 361       },
 362     },
 363   },
 364
 365   rdbms_ase => {
 366     include => '_icdt_strptime_based',
 367     req => {
 368       'DBD::Sybase' => 0,
 369     },
 370     pod => {
 371       title => 'Sybase ASE support',
 372       desc => 'Modules required to connect to Sybase ASE',
 373     },
 374   },
 375
 376   _rdbms_db2_common => {
 377     augment => {
 378       icdt => {
 379         req => {
 380           'DateTime::Format::DB2' => '0',
 381         },
 382       },
 383     },
 384   },
 385
 386   rdbms_db2 => {
 387     include => '_rdbms_db2_common',
 388     req => {
 389       'DBD::DB2' => 0,
 390     },
 391     pod => {
 392       title => 'DB2 support',
 393       desc => 'Modules required to connect to DB2',
 394     },
 395   },
 396
 397   rdbms_db2_400 => {
 398     include => [qw( _rdbms_generic_odbc _rdbms_db2_common )],
 399     pod => {
 400       title => 'DB2 on AS/400 support',
 401       desc => 'Modules required to connect to DB2 on AS/400',
 402     },
 403   },
 404
 405   rdbms_informix => {
 406     include => '_icdt_strptime_based',
 407     req => {
 408       'DBD::Informix' => 0,
 409     },
 410     pod => {
 411       title => 'Informix support',
 412       desc => 'Modules required to connect to Informix',
 413     },
 414   },
 415
 416   _rdbms_sqlanywhere_common => {
 417     inclide => '_icdt_strptime_based',
 418   },
 419
 420   rdbms_sqlanywhere => {
 421     include => '_rdbms_sqlanywhere_common',
 422     req => {
 423       'DBD::SQLAnywhere' => 0,
 424     },
 425     pod => {
 426       title => 'SQLAnywhere support',
 427       desc => 'Modules required to connect to SQLAnywhere',
 428     },
 429   },
 430
 431   rdbms_sqlanywhere_odbc => {
 432     include => [qw( _rdbms_generic_odbc _rdbms_sqlanywhere_common )],
 433     pod => {
 434       title => 'SQLAnywhere support via DBD::ODBC',
 435       desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
 436     },
 437   },
 438
 439   _rdbms_firebird_common => {
 440     include => '_icdt_strptime_based',
 441   },
 442
 443   rdbms_firebird => {
 444     include => '_rdbms_firebird_common',
 445     req => {
 446       'DBD::Firebird' => 0,
 447     },
 448     pod => {
 449       title => 'Firebird support',
 450       desc => 'Modules required to connect to Firebird',
 451     },
 452   },
 453
 454   rdbms_firebird_interbase => {
 455     include => '_rdbms_firebird_common',
 456     req => {
 457       'DBD::InterBase' => 0,
 458     },
 459     pod => {
 460       title => 'Firebird support via DBD::InterBase',
 461       desc => 'Modules required to connect to Firebird via DBD::InterBase',
 462     },
 463   },
 464
 465   rdbms_firebird_odbc => {
 466     include => [qw( _rdbms_generic_odbc _rdbms_firebird_common )],
 467     pod => {
 468       title => 'Firebird support via DBD::ODBC',
 469       desc => 'Modules required to connect to Firebird via DBD::ODBC',
 470     },
 471   },
 472
 473   test_rdbms_sqlite => {
 474     include => 'rdbms_sqlite',
 475     req => {
 476       ###
 477       ### IMPORTANT - do not raise this dependency
 478       ### even though many bugfixes are present in newer versions, the general DBIC
 479       ### rule is to bend over backwards for available DBDs (given upgrading them is
 480       ### often *not* easy or even possible)
 481       ###
 482       'DBD::SQLite' => '1.29',
 483     },
 484   },
 485
 486   test_rdbms_pg => {
 487     include => 'rdbms_pg',
 488     env => [
 489       DBICTEST_PG_DSN => 1,
 490       DBICTEST_PG_USER => 0,
 491       DBICTEST_PG_PASS => 0,
 492     ],
 493     req => {
 494       # the order does matter because the rdbms support group might require
 495       # a different version that the test group
 496       #
 497       # when changing this list make sure to adjust xt/optional_deps.t
 498       'DBD::Pg' => '2.009002',  # specific version to test bytea
 499     },
 500   },
 501
 502   test_rdbms_mssql_odbc => {
 503     include => 'rdbms_mssql_odbc',
 504     env => [
 505       DBICTEST_MSSQL_ODBC_DSN => 1,
 506       DBICTEST_MSSQL_ODBC_USER => 0,
 507       DBICTEST_MSSQL_ODBC_PASS => 0,
 508     ],
 509   },
 510
 511   test_rdbms_mssql_ado => {
 512     include => 'rdbms_mssql_ado',
 513     env => [
 514       DBICTEST_MSSQL_ADO_DSN => 1,
 515       DBICTEST_MSSQL_ADO_USER => 0,
 516       DBICTEST_MSSQL_ADO_PASS => 0,
 517     ],
 518   },
 519
 520   test_rdbms_mssql_sybase => {
 521     include => 'rdbms_mssql_sybase',
 522     env => [
 523       DBICTEST_MSSQL_DSN => 1,
 524       DBICTEST_MSSQL_USER => 0,
 525       DBICTEST_MSSQL_PASS => 0,
 526     ],
 527   },
 528
 529   test_rdbms_msaccess_odbc => {
 530     include => 'rdbms_msaccess_odbc',
 531     env => [
 532       DBICTEST_MSACCESS_ODBC_DSN => 1,
 533       DBICTEST_MSACCESS_ODBC_USER => 0,
 534       DBICTEST_MSACCESS_ODBC_PASS => 0,
 535     ],
 536     req => {
 537       'Data::GUID' => '0',
 538     },
 539   },
 540
 541   test_rdbms_msaccess_ado => {
 542     include => 'rdbms_msaccess_ado',
 543     env => [
 544       DBICTEST_MSACCESS_ADO_DSN => 1,
 545       DBICTEST_MSACCESS_ADO_USER => 0,
 546       DBICTEST_MSACCESS_ADO_PASS => 0,
 547     ],
 548     req => {
 549       'Data::GUID' => 0,
 550     },
 551   },
 552
 553   test_rdbms_mysql => {
 554     include => 'rdbms_mysql',
 555     env => [
 556       DBICTEST_MYSQL_DSN => 1,
 557       DBICTEST_MYSQL_USER => 0,
 558       DBICTEST_MYSQL_PASS => 0,
 559     ],
 560   },
 561
 562   test_rdbms_oracle => {
 563     include => 'rdbms_oracle',
 564     env => [
 565       DBICTEST_ORA_DSN => 1,
 566       DBICTEST_ORA_USER => 0,
 567       DBICTEST_ORA_PASS => 0,
 568     ],
 569     req => {
 570       'DBD::Oracle'              => '1.24',
 571     },
 572   },
 573
 574   test_rdbms_ase => {
 575     include => 'rdbms_ase',
 576     env => [
 577       DBICTEST_SYBASE_DSN => 1,
 578       DBICTEST_SYBASE_USER => 0,
 579       DBICTEST_SYBASE_PASS => 0,
 580     ],
 581   },
 582
 583   test_rdbms_db2 => {
 584     include => 'rdbms_db2',
 585     env => [
 586       DBICTEST_DB2_DSN => 1,
 587       DBICTEST_DB2_USER => 0,
 588       DBICTEST_DB2_PASS => 0,
 589     ],
 590   },
 591
 592   test_rdbms_db2_400 => {
 593     include => 'rdbms_db2_400',
 594     env => [
 595       DBICTEST_DB2_400_DSN => 1,
 596       DBICTEST_DB2_400_USER => 0,
 597       DBICTEST_DB2_400_PASS => 0,
 598     ],
 599   },
 600
 601   test_rdbms_informix => {
 602     include => 'rdbms_informix',
 603     env => [
 604       DBICTEST_INFORMIX_DSN => 1,
 605       DBICTEST_INFORMIX_USER => 0,
 606       DBICTEST_INFORMIX_PASS => 0,
 607     ],
 608   },
 609
 610   test_rdbms_sqlanywhere => {
 611     include => 'rdbms_sqlanywhere',
 612     env => [
 613       DBICTEST_SQLANYWHERE_DSN => 1,
 614       DBICTEST_SQLANYWHERE_USER => 0,
 615       DBICTEST_SQLANYWHERE_PASS => 0,
 616     ],
 617   },
 618
 619   test_rdbms_sqlanywhere_odbc => {
 620     include => 'rdbms_sqlanywhere_odbc',
 621     env => [
 622       DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
 623       DBICTEST_SQLANYWHERE_ODBC_USER => 0,
 624       DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
 625     ],
 626   },
 627
 628   test_rdbms_firebird => {
 629     include => 'rdbms_firebird',
 630     env => [
 631       DBICTEST_FIREBIRD_DSN => 1,
 632       DBICTEST_FIREBIRD_USER => 0,
 633       DBICTEST_FIREBIRD_PASS => 0,
 634     ],
 635   },
 636
 637   test_rdbms_firebird_interbase => {
 638     include => 'rdbms_firebird_interbase',
 639     env => [
 640       DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
 641       DBICTEST_FIREBIRD_INTERBASE_USER => 0,
 642       DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
 643     ],
 644   },
 645
 646   test_rdbms_firebird_odbc => {
 647     include => 'rdbms_firebird_odbc',
 648     env => [
 649       DBICTEST_FIREBIRD_ODBC_DSN => 1,
 650       DBICTEST_FIREBIRD_ODBC_USER => 0,
 651       DBICTEST_FIREBIRD_ODBC_PASS => 0,
 652     ],
 653   },
 654
 655   test_memcached => {
 656     env => [
 657       DBICTEST_MEMCACHED => 1,
 658     ],
 659     req => {
 660       'Cache::Memcached' => 0,
 661     },
 662   },
 663
 664   dist_dir => {
 665     # we need to run the dbicadmin so we can self-generate its POD
 666     # also we do not want surprises in case JSON::XS is in the path
 667     # so make sure we get an always-working JSON::Any
 668     include => [qw(
 669       admin_script
 670       _json_xs_compatible_json_any
 671       id_shortener
 672       deploy
 673       test_pod
 674       test_podcoverage
 675       test_whitespace
 676       test_strictures
 677     )],
 678     req => {
 679       'ExtUtils::MakeMaker' => '6.64',
 680       'Module::Install'     => '1.06',
 681       'Pod::Inherit'        => '0.91',
 682     },
 683   },
 684
 685   dist_upload => {
 686     req => {
 687       'CPAN::Uploader' => '0.103001',
 688     },
 689   },
 690 };
 691
 692
 693
 694 ### Public API
 695
 696 sub import {
 697   my $class = shift;
 698
 699   if (@_) {
 700
 701     my $action = shift;
 702
 703     if ($action eq '-die_without') {
 704       my $err;
 705       {
 706         local $@;
 707         eval { $class->die_unless_req_ok_for(\@_); 1 }
 708           or $err = $@;
 709       }
 710       die "\n$err\n" if $err;
 711     }
 712     elsif ($action eq '-list_missing') {
 713       print $class->modreq_missing_for(\@_);
 714       print "\n";
 715       exit 0;
 716     }
 717     elsif ($action eq '-skip_all_without') {
 718
 719       # sanity check - make sure ->current_test is 0 and no plan has been declared
 720       do {
 721         local $@;
 722         defined eval {
 723           Test::Builder->new->current_test
 724             or
 725           Test::Builder->new->has_plan
 726         };
 727       } and croak("Unable to invoke -skip_all_without after testing has started");
 728
 729       if ( my $missing = $class->req_missing_for(\@_) ) {
 730
 731         die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
 732           if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
 733
 734         print "1..0 # SKIP requirements not satisfied: $missing\n";
 735         exit 0;
 736       }
 737     }
 738     elsif ($action =~ /^-/) {
 739       croak "Unknown import-time action '$action'";
 740     }
 741     else {
 742       croak "$class is not an exporter, unable to import '$action'";
 743     }
 744   }
 745
 746   1;
 747 }
 748
 749 sub unimport {
 750   croak( __PACKAGE__ . " does not implement unimport" );
 751 }
 752
 753 # OO for (mistakenly considered) ease of extensibility, not due to any need to
 754 # carry state of any sort. This API is currently used outside, so leave as-is.
 755 # FIXME - make sure to not propagate this further if module is extracted as a
 756 # standalone library - keep the stupidity to a DBIC-secific shim!
 757 #
 758 sub req_list_for {
 759   shift->_groups_to_reqs(shift)->{effective_modreqs};
 760 }
 761
 762 sub modreq_list_for {
 763   shift->_groups_to_reqs(shift)->{modreqs};
 764 }
 765
 766 sub req_group_list {
 767   +{ map
 768     { $_ => $_[0]->_groups_to_reqs($_) }
 769     grep { $_ !~ /^_/ } keys %$dbic_reqs
 770   }
 771 }
 772
 773 sub req_errorlist_for { shift->modreq_errorlist_for(shift) }  # deprecated
 774 sub modreq_errorlist_for {
 775   my ($self, $groups) = @_;
 776   $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
 777 }
 778
 779 sub req_ok_for {
 780   shift->req_missing_for(shift) ? 0 : 1;
 781 }
 782
 783 sub req_missing_for {
 784   my ($self, $groups) = @_;
 785
 786   my $reqs = $self->_groups_to_reqs($groups);
 787
 788   my $mods_missing = $reqs->{missing_envvars}
 789     ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
 790     : $self->modreq_missing_for($groups)
 791   ;
 792
 793   return '' if
 794     ! $mods_missing
 795       and
 796     ! $reqs->{missing_envvars}
 797   ;
 798
 799   my @res = $mods_missing || ();
 800
 801   push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
 802     { __envvar_group_desc($_) }
 803     @{$reqs->{missing_envvars}}
 804   if $reqs->{missing_envvars};
 805
 806   return (
 807     ( join ' as well as ', @res )
 808       .
 809     ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
 810   );
 811 }
 812
 813 sub modreq_missing_for {
 814   my ($self, $groups) = @_;
 815
 816   my $reqs = $self->_groups_to_reqs($groups);
 817   my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
 818     or return '';
 819
 820   join ' ', map
 821     { $reqs->{modreqs}{$_} ? "$_~$reqs->{modreqs}{$_}" : $_ }
 822     sort { lc($a) cmp lc($b) } keys %$modreq_errors
 823   ;
 824 }
 825
 826 my $tb;
 827 sub skip_without {
 828   my ($self, $groups) = @_;
 829
 830   $tb ||= do { local $@; eval { Test::Builder->new } }
 831     or croak "Calling skip_without() before loading Test::Builder makes no sense";
 832
 833   if ( my $err = $self->req_missing_for($groups) ) {
 834     my ($fn, $ln) = (caller(0))[1,2];
 835     $tb->skip("block in $fn around line $ln requires $err");
 836     local $^W = 0;
 837     last SKIP;
 838   }
 839
 840   1;
 841 }
 842
 843 sub die_unless_req_ok_for {
 844   if (my $err = shift->req_missing_for(shift) ) {
 845     die "Unable to continue due to missing requirements: $err\n";
 846   }
 847 }
 848
 849
 850
 851 ### Private functions
 852
 853 # potentially shorten group desc
 854 sub __envvar_group_desc {
 855   my @envs = @{$_[0]};
 856
 857   my (@res, $last_prefix);
 858   while (my $ev = shift @envs) {
 859     my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
 860
 861     if ( defined $sep and ($last_prefix||'') eq $pref ) {
 862         push @res, "...${sep}${suff}"
 863     }
 864     else {
 865       push @res, $ev;
 866     }
 867
 868     $last_prefix = $pref if $sep;
 869   }
 870
 871   join '/', @res;
 872 }
 873
 874 my $groupname_re = qr/ [A-Z_a-z][0-9A-Z_a-z]* /x;
 875 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
 876 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
 877
 878 # Expand includes from a random group in a specific order:
 879 # nonvariable groups first, then their includes, then the variable groups,
 880 # then their includes.
 881 # This allows reliably marking the rest of the mod reqs as variable (this is
 882 # also why variable includes are currently not allowed)
 883 sub __expand_includes {
 884   my ($groups, $seen) = @_;
 885
 886   # !! DIFFERENT !! behavior and return depending on invocation mode
 887   # (easier to recurse this way)
 888   my $is_toplevel = $seen
 889     ? 0
 890     : !! ($seen = {})
 891   ;
 892
 893   my ($res_per_type, $missing_envvars);
 894
 895   # breadth-first evaluation, with non-variable includes on top
 896   for my $g (@$groups) {
 897
 898     croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
 899       if $g !~ qr/ \A $groupname_re \z/x;
 900
 901     my $r = $dbic_reqs->{$g}
 902       or croak "Requirement group '$g' is not defined";
 903
 904     # always do this check *before* the $seen check
 905     croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
 906       if ( $r->{env} and ! $is_toplevel );
 907
 908     next if $seen->{$g}++;
 909
 910     my $req_type = 'static';
 911
 912     if ( my @e = @{$r->{env}||[]} ) {
 913
 914       croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
 915         unless $g =~ /^test_/;
 916
 917       croak "Unexpected *odd* list in 'env' under group '$g'"
 918         if @e % 2;
 919
 920       # deconstruct the whole thing
 921       my (@group_envnames_list, $some_envs_required, $some_required_missing);
 922       while (@e) {
 923         push @group_envnames_list, my $envname = shift @e;
 924
 925         # env required or not
 926         next unless shift @e;
 927
 928         $some_envs_required ||= 1;
 929
 930         $some_required_missing ||= (
 931           ! defined $ENV{$envname}
 932             or
 933           ! length $ENV{$envname}
 934         );
 935       }
 936
 937       croak "None of the envvars in group '$g' declared as required, making the requirement moot"
 938         unless $some_envs_required;
 939
 940       if ($some_required_missing) {
 941         push @{$missing_envvars->{$g}}, \@group_envnames_list;
 942         $req_type = 'variable';
 943       }
 944     }
 945
 946     push @{$res_per_type->{"base_${req_type}"}}, $g;
 947
 948     if (my $i = $dbic_reqs->{$g}{include}) {
 949       $i = [ $i ] unless ref $i eq 'ARRAY';
 950
 951       croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
 952         unless @$i;
 953
 954       push @{$res_per_type->{"incs_${req_type}"}}, @$i;
 955     }
 956   }
 957
 958   my @ret = map {
 959     @{ $res_per_type->{"base_${_}"} || [] },
 960     ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
 961   } qw(static variable);
 962
 963   return ! $is_toplevel ? @ret : do {
 964     my $rv = {};
 965     $rv->{$_} = {
 966       idx => 1 + keys %$rv,
 967       missing_envvars => $missing_envvars->{$_},
 968     } for @ret;
 969     $rv->{$_}{user_requested} = 1 for @$groups;
 970     $rv;
 971   };
 972 }
 973
 974 ### Private OO API
 975 our %req_unavailability_cache;
 976
 977 # this method is just a lister and envvar/metadata checker - it does not try to load anything
 978 sub _groups_to_reqs {
 979   my ($self, $want) = @_;
 980
 981   $want = [ $want || () ]
 982     unless ref $want eq 'ARRAY';
 983
 984   croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
 985     unless @$want;
 986
 987   my $ret = {
 988     modreqs => {},
 989     modreqs_fully_documented => 1,
 990   };
 991
 992   my $groups;
 993   for my $piece (@$want) {
 994     if ($piece =~ qr/ \A $groupname_re \z /x) {
 995       push @$groups, $piece;
 996     }
 997     elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
 998       croak "Ad hoc module specification lists '$mod' twice"
 999         if exists $ret->{modreqs}{$mod};
1000
1001       croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
1002         ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
1003           or
1004         $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
1005       );
1006
1007       $ret->{modreqs}{$mod} = $ver;
1008       $ret->{modreqs_fully_documented} = 0;
1009     }
1010     else {
1011       croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1012     }
1013   }
1014
1015   my $all_groups = __expand_includes($groups);
1016
1017   # pre-assemble list of augmentations, perform basic sanity checks
1018   # Note that below we *DO NOT* respect the source/target reationship, but
1019   # instead always default to augment the "later" group
1020   # This is done so that the "stable/variable" boundary keeps working as
1021   # expected
1022   my $augmentations;
1023   for my $requesting_group (keys %$all_groups) {
1024     if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1025       for my $target_group (keys %$ag) {
1026
1027         croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1028           unless $dbic_reqs->{$target_group};
1029
1030         croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1031           if $dbic_reqs->{$requesting_group}{env};
1032
1033         croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1034           if $dbic_reqs->{$target_group}{env};
1035
1036         if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1037           croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1038         }
1039
1040         $ret->{augments}{$target_group} = 1;
1041
1042         # no augmentation for stuff that hasn't been selected
1043         if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1044           push @{$augmentations->{
1045             ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1046               ? $target_group
1047               : $requesting_group
1048           }}, $ar;
1049         }
1050       }
1051     }
1052   }
1053
1054   for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1055
1056     my $group_reqs = $dbic_reqs->{$group}{req};
1057
1058     # sanity-check
1059     for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1060       for (keys %$req_bag) {
1061
1062         $_ =~ / \A $modname_re \z /x
1063           or croak "Requirement '$_' in group '$group' is not a valid module name";
1064
1065         # !!!DO NOT CHANGE!!!
1066         # remember - version.pm may not be available on the system
1067         croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1068           if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1069       }
1070     }
1071
1072     if (my $e = $all_groups->{$group}{missing_envvars}) {
1073       push @{$ret->{missing_envvars}}, @$e;
1074     }
1075
1076     # assemble into the final ret
1077     for my $type (
1078       'modreqs',
1079       ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1080     ) {
1081       for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1082         for my $mod (keys %$req_bag) {
1083
1084           $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1085
1086             ! exists $ret->{$type}{$mod}
1087               or
1088             # we sanitized the version to be numeric above - we can just -gt it
1089             ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1090
1091           );
1092         }
1093       }
1094     }
1095
1096     $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1097       if $all_groups->{$group}{user_requested};
1098
1099     $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1100   }
1101
1102   return $ret;
1103 }
1104
1105
1106 # this method tries to find/load specified modreqs and returns a hashref of
1107 # module/loaderror pairs for anything that failed
1108 sub _errorlist_for_modreqs {
1109   # args supposedly already went through _groups_to_reqs and are therefore sanitized
1110   # safe to eval at will
1111   my ($self, $reqs) = @_;
1112
1113   my $ret;
1114
1115   for my $m ( keys %$reqs ) {
1116     my $v = $reqs->{$m};
1117
1118     if (! exists $req_unavailability_cache{$m}{$v} ) {
1119       local $@;
1120       eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1121       $req_unavailability_cache{$m}{$v} = $@;
1122     }
1123
1124     $ret->{$m} = $req_unavailability_cache{$m}{$v}
1125       if $req_unavailability_cache{$m}{$v};
1126   }
1127
1128   $ret;
1129 }
1130
1131 # Unlike the above DO NOT try to load anything
1132 # This is executed when some needed envvars are not available
1133 # which in turn means a module load will never be reached anyway
1134 # This is important because some modules (especially DBDs) can be
1135 # *really* fickle when a require() is attempted, with pretty confusing
1136 # side-effects (especially on windows)
1137 sub _list_physically_missing_modules {
1138   my ($self, $modreqs) = @_;
1139
1140   # in case there is a coderef in @INC there is nothing we can definitively prove
1141   # so short circuit directly
1142   return '' if grep { length ref $_ } @INC;
1143
1144   my @definitely_missing;
1145   for my $mod (keys %$modreqs) {
1146     (my $fn = $mod . '.pm') =~ s|::|/|g;
1147
1148     push @definitely_missing, $mod unless grep
1149       # this should work on any combination of slashes
1150       { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1151       @INC
1152     ;
1153   }
1154
1155   join ' ', map
1156     { $modreqs->{$_} ? "$_~$modreqs->{$_}" : $_ }
1157     sort { lc($a) cmp lc($b) } @definitely_missing
1158   ;
1159 }
1160
1161
1162 # This is to be called by the author only (automatically in Makefile.PL)
1163 sub _gen_pod {
1164   my ($class, $distver, $pod_dir) = @_;
1165
1166   die "No POD root dir supplied" unless $pod_dir;
1167
1168   $distver ||=
1169     eval { require DBIx::Class; DBIx::Class->VERSION; }
1170       ||
1171     die
1172 "\n\n---------------------------------------------------------------------\n" .
1173 'Unable to load core DBIx::Class module to determine current version, '.
1174 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1175 "halted\n\n" . $@ .
1176 "\n\n---------------------------------------------------------------------\n"
1177   ;
1178
1179   # do not ask for a recent version, use 1.x API calls
1180   # this *may* execute on a smoker with old perl or whatnot
1181   require File::Path;
1182
1183   (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1184
1185   (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1186   (my $dir = $podfn) =~ s|/[^/]+$||;
1187
1188   File::Path::mkpath([$dir]);
1189
1190   my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1191     or die "Hrmm? No sqlt dep?";
1192
1193
1194   my @chunks;
1195
1196 #@@
1197 #@@ HEADER
1198 #@@
1199   push @chunks, <<"EOC";
1200 #########################################################################
1201 #####################  A U T O G E N E R A T E D ########################
1202 #########################################################################
1203 #
1204 # The contents of this POD file are auto-generated.  Any changes you make
1205 # will be lost. If you need to change the generated text edit _gen_pod()
1206 # at the end of $modfn
1207 #
1208
1209 =head1 NAME
1210
1211 $class - Optional module dependency specifications (for module authors)
1212 EOC
1213
1214
1215 #@@
1216 #@@ SYNOPSIS HEADING
1217 #@@
1218   push @chunks, <<"EOC";
1219 =head1 SYNOPSIS
1220
1221 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1222
1223   ...
1224
1225   \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1226     \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1227     'DBIx::Class' => '$distver',
1228   };
1229
1230   ...
1231
1232   my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1233     require $class;
1234     $class->req_list_for([qw( deploy rdbms_oracle icdt )]);
1235   } || {} };
1236
1237   \$EUMM_ARGS{PREREQ_PM} = {
1238     \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1239     \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1240   };
1241
1242   ...
1243
1244   ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1245
1246 B<Note>: The C<eval> protection within the example is due to support for
1247 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1248 not being available on a sufficient portion of production installations of
1249 Perl. Robust support for such dependency requirements is available in the
1250 L<CPAN> installer only since version C<1.94_56> first made available for
1251 production with perl version C<5.12>. It is the belief of the current
1252 maintainer that support for requirements during the C<configure> build phase
1253 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1254 hence the extra care demonstrated above. It should also be noted that some
1255 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1256 with configure requirements independent from the versions of perl and CPAN
1257 available.
1258 EOC
1259
1260
1261 #@@
1262 #@@ DESCRIPTION HEADING
1263 #@@
1264   push @chunks, <<'EOC';
1265 =head1 DESCRIPTION
1266
1267 Some of the less-frequently used features of L<DBIx::Class> have external
1268 module dependencies on their own. In order not to burden the average user
1269 with modules they will never use, these optional dependencies are not included
1270 in the base Makefile.PL. Instead an exception with a descriptive message is
1271 thrown when a specific feature can't find one or several modules required for
1272 its operation. This module is the central holding place for the current list
1273 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1274 authors alike.
1275
1276 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1277 group can list one or more required modules, with an optional minimum version
1278 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1279 a set of environment variables, some (or all) of which are marked as required
1280 for the group to be considered by L</req_list_for>
1281
1282 Each group name (or a combination thereof) can be used in the
1283 L<public methods|/METHODS> as described below.
1284 EOC
1285
1286
1287 #@@
1288 #@@ REQUIREMENT GROUPLIST HEADING
1289 #@@
1290   push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1291
1292   my $standalone_info;
1293
1294   for my $group (sort keys %$dbic_reqs) {
1295
1296     my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1297
1298     next unless (
1299       $info->{modreqs_fully_documented}
1300         and
1301       ( $info->{augments} or $info->{modreqs} )
1302     );
1303
1304     my $p = $dbic_reqs->{$group}{pod};
1305
1306     push @chunks, (
1307       "=head2 $p->{title}",
1308       "=head3 $group",
1309       $p->{desc},
1310       '=over',
1311     );
1312
1313     if ( keys %{ $info->{modreqs}||{} } ) {
1314       push @chunks, map
1315         { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1316         ( sort keys %{ $info->{modreqs} } )
1317       ;
1318     }
1319     else {
1320       push @chunks, '=item * No standalone requirements',
1321     }
1322
1323     push @chunks, '=back';
1324
1325     for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1326       my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1327
1328       my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1329       for (keys %$newreqs) {
1330         delete $newreqs->{$_} if (
1331           ( defined $info->{modreqs}{$_}    and $info->{modreqs}{$_}    == $newreqs->{$_} )
1332             or
1333           ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1334         );
1335       }
1336
1337       if (keys %$newreqs) {
1338         push @chunks, (
1339           "Combined with L</$ag> additionally requires:",
1340           '=over',
1341           ( map
1342             { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1343             ( sort keys %$newreqs )
1344           ),
1345           '=back',
1346         );
1347       }
1348     }
1349   }
1350
1351
1352 #@@
1353 #@@ API DOCUMENTATION HEADING
1354 #@@
1355   push @chunks, <<'EOC';
1356
1357 =head1 IMPORT-LIKE ACTIONS
1358
1359 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1360 supplied to its C<import> method.
1361
1362 =head2 -skip_all_without
1363
1364 =over
1365
1366 =item Arguments: @group_names
1367
1368 =back
1369
1370 A convenience wrapper for use during testing:
1371 EOC
1372
1373   push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1374
1375   push @chunks, 'Roughly equivalent to the following code:';
1376
1377   push @chunks, sprintf <<'EOS', ($class) x 2;
1378
1379  BEGIN {
1380    require %s;
1381    if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1382      print "1..0 # SKIP requirements not satisfied: $missing\n";
1383      exit 0;
1384    }
1385  }
1386 EOS
1387
1388   push @chunks, <<'EOC';
1389
1390 It also takes into account the C<RELEASE_TESTING> environment variable and
1391 behaves like L</-die_without> for any requirement groups marked as
1392 C<release_testing_mandatory>.
1393
1394 =head2 -die_without
1395
1396 =over
1397
1398 =item Arguments: @group_names
1399
1400 =back
1401
1402 A convenience wrapper around L</die_unless_req_ok_for>:
1403 EOC
1404
1405   push @chunks, " use $class -die_without => qw(deploy admin);";
1406
1407   push @chunks, <<'EOC';
1408
1409 =head2 -list_missing
1410
1411 =over
1412
1413 =item Arguments: @group_names
1414
1415 =back
1416
1417 A convenience wrapper around L</modreq_missing_for>:
1418
1419  perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1420
1421 =head1 METHODS
1422
1423 =head2 req_group_list
1424
1425 =over
1426
1427 =item Arguments: none
1428
1429 =item Return Value: \%list_of_requirement_groups
1430
1431 =back
1432
1433 This method should be used by DBIx::Class packagers, to get a hashref of all
1434 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1435 thereof (as an arrayref) can be supplied to the methods below.
1436 The B<values> of the returned hash are currently a set of options B<without a
1437 well defined structure>. If you have use for any of the contents - contact the
1438 maintainers, instead of treating this as public (left alone stable) API.
1439
1440 =head2 req_list_for
1441
1442 =over
1443
1444 =item Arguments: $group_name | \@group_names
1445
1446 =item Return Value: \%set_of_module_version_pairs
1447
1448 =back
1449
1450 This method should be used by DBIx::Class extension authors, to determine the
1451 version of modules a specific set of features requires for this version of
1452 DBIx::Class (regardless of their availability on the system).
1453 See the L</SYNOPSIS> for a real-world example.
1454
1455 When handling C<test_*> groups this method behaves B<differently> from
1456 L</modreq_list_for> below (and is the only such inconsistency among the
1457 C<req_*> methods). If a particular group declares as requirements some
1458 C<environment variables> and these requirements are not satisfied (the envvars
1459 are unset) - then the C<module requirements> of this group are not included in
1460 the returned list.
1461
1462 =head2 modreq_list_for
1463
1464 =over
1465
1466 =item Arguments: $group_name | \@group_names
1467
1468 =item Return Value: \%set_of_module_version_pairs
1469
1470 =back
1471
1472 Same as L</req_list_for> but does not take into consideration any
1473 C<environment variable requirements> - returns just the list of required
1474 modules.
1475
1476 =head2 req_ok_for
1477
1478 =over
1479
1480 =item Arguments: $group_name | \@group_names
1481
1482 =item Return Value: 1|0
1483
1484 =back
1485
1486 Returns true or false depending on whether all modules/envvars required by
1487 the group(s) are loadable/set on the system.
1488
1489 =head2 req_missing_for
1490
1491 =over
1492
1493 =item Arguments: $group_name | \@group_names
1494
1495 =item Return Value: $error_message_string
1496
1497 =back
1498
1499 Returns a single-line string suitable for inclusion in larger error messages.
1500 This method would normally be used by DBIx::Class core features, to indicate to
1501 the user that they need to install specific modules and/or set specific
1502 environment variables before being able to use a specific feature set.
1503
1504 For example if some of the requirements for C<deploy> are not available,
1505 the returned string could look like:
1506 EOC
1507
1508   push @chunks, qq{ "SQL::Translator~$sqltver" (see $class documentation for details)};
1509
1510   push @chunks, <<'EOC';
1511 The author is expected to prepend the necessary text to this message before
1512 returning the actual error seen by the user. See also L</modreq_missing_for>
1513
1514 =head2 modreq_missing_for
1515
1516 =over
1517
1518 =item Arguments: $group_name | \@group_names
1519
1520 =item Return Value: $error_message_string
1521
1522 =back
1523
1524 Same as L</req_missing_for> except that the error string is guaranteed to be
1525 either empty, or contain a set of module requirement specifications suitable
1526 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1527 attempt to validate the state of required environment variables (if any).
1528
1529 For instance if some of the requirements for C<deploy> are not available,
1530 the returned string could look like:
1531 EOC
1532
1533   push @chunks, qq{ "SQL::Translator~$sqltver"};
1534
1535   push @chunks, <<'EOC';
1536
1537 See also L</-list_missing>.
1538
1539 =head2 skip_without
1540
1541 =over
1542
1543 =item Arguments: $group_name | \@group_names
1544
1545 =back
1546
1547 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1548 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1549 (it is always C<1>, thus mandating unconditional use of
1550 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1551 requirement specifications:
1552 EOC
1553
1554   push @chunks, <<EOC;
1555   SKIP: {
1556     $class->skip_without([ deploy YAML>=0.90 ]);
1557
1558     ...
1559   }
1560 EOC
1561
1562   push @chunks, <<'EOC';
1563
1564 =head2 die_unless_req_ok_for
1565
1566 =over
1567
1568 =item Arguments: $group_name | \@group_names
1569
1570 =back
1571
1572 Checks if L</req_ok_for> passes for the supplied group(s), and
1573 in case of failure throws an exception including the information
1574 from L</req_missing_for>. See also L</-die_without>.
1575
1576 =head2 modreq_errorlist_for
1577
1578 =over
1579
1580 =item Arguments: $group_name | \@group_names
1581
1582 =item Return Value: \%set_of_loaderrors_per_module
1583
1584 =back
1585
1586 Returns a hashref containing the actual errors that occurred while attempting
1587 to load each module in the requirement group(s).
1588
1589 =head2 req_errorlist_for
1590
1591 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1592
1593 EOC
1594
1595 #@@
1596 #@@ FOOTER
1597 #@@
1598   push @chunks, <<'EOC';
1599 =head1 FURTHER QUESTIONS?
1600
1601 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1602
1603 =head1 COPYRIGHT AND LICENSE
1604
1605 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1606 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1607 redistribute it and/or modify it under the same terms as the
1608 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1609 EOC
1610
1611   eval {
1612     open (my $fh, '>', $podfn) or die;
1613     print $fh join ("\n\n", @chunks) or die;
1614     print $fh "\n" or die;
1615     close ($fh) or die;
1616   } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );
1617 }
1618
1619 1;