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