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( admin_script _json_xs_compatible_json_any )],
 669     req => {
 670       'ExtUtils::MakeMaker' => '6.64',
 671       'Pod::Inherit'        => '0.91',
 672     },
 673   },
 674
 675   dist_upload => {
 676     req => {
 677       'CPAN::Uploader' => '0.103001',
 678     },
 679   },
 680 };
 681
 682
 683
 684 ### Public API
 685
 686 sub import {
 687   my $class = shift;
 688
 689   if (@_) {
 690
 691     my $action = shift;
 692
 693     if ($action eq '-die_without') {
 694       my $err;
 695       {
 696         local $@;
 697         eval { $class->die_unless_req_ok_for(\@_); 1 }
 698           or $err = $@;
 699       }
 700       die "\n$err\n" if $err;
 701     }
 702     elsif ($action eq '-list_missing') {
 703       print $class->modreq_missing_for(\@_);
 704       print "\n";
 705       exit 0;
 706     }
 707     elsif ($action eq '-skip_all_without') {
 708
 709       # sanity check - make sure ->current_test is 0 and no plan has been declared
 710       do {
 711         local $@;
 712         defined eval {
 713           Test::Builder->new->current_test
 714             or
 715           Test::Builder->new->has_plan
 716         };
 717       } and croak("Unable to invoke -skip_all_without after testing has started");
 718
 719       if ( my $missing = $class->req_missing_for(\@_) ) {
 720
 721         die ("\nMandatory requirements not satisfied during release-testing: $missing\n\n")
 722           if $ENV{RELEASE_TESTING} and $class->_groups_to_reqs(\@_)->{release_testing_mandatory};
 723
 724         print "1..0 # SKIP requirements not satisfied: $missing\n";
 725         exit 0;
 726       }
 727     }
 728     elsif ($action =~ /^-/) {
 729       croak "Unknown import-time action '$action'";
 730     }
 731     else {
 732       croak "$class is not an exporter, unable to import '$action'";
 733     }
 734   }
 735
 736   1;
 737 }
 738
 739 sub unimport {
 740   croak( __PACKAGE__ . " does not implement unimport" );
 741 }
 742
 743 # OO for (mistakenly considered) ease of extensibility, not due to any need to
 744 # carry state of any sort. This API is currently used outside, so leave as-is.
 745 # FIXME - make sure to not propagate this further if module is extracted as a
 746 # standalone library - keep the stupidity to a DBIC-secific shim!
 747 #
 748 sub req_list_for {
 749   shift->_groups_to_reqs(shift)->{effective_modreqs};
 750 }
 751
 752 sub modreq_list_for {
 753   shift->_groups_to_reqs(shift)->{modreqs};
 754 }
 755
 756 sub req_group_list {
 757   +{ map
 758     { $_ => $_[0]->_groups_to_reqs($_) }
 759     grep { $_ !~ /^_/ } keys %$dbic_reqs
 760   }
 761 }
 762
 763 sub req_errorlist_for { shift->modreq_errorlist_for(shift) }  # deprecated
 764 sub modreq_errorlist_for {
 765   my ($self, $groups) = @_;
 766   $self->_errorlist_for_modreqs( $self->_groups_to_reqs($groups)->{modreqs} );
 767 }
 768
 769 sub req_ok_for {
 770   shift->req_missing_for(shift) ? 0 : 1;
 771 }
 772
 773 sub req_missing_for {
 774   my ($self, $groups) = @_;
 775
 776   my $reqs = $self->_groups_to_reqs($groups);
 777
 778   my $mods_missing = $reqs->{missing_envvars}
 779     ? $self->_list_physically_missing_modules( $reqs->{modreqs} )
 780     : $self->modreq_missing_for($groups)
 781   ;
 782
 783   return '' if
 784     ! $mods_missing
 785       and
 786     ! $reqs->{missing_envvars}
 787   ;
 788
 789   my @res = $mods_missing || ();
 790
 791   push @res, 'the following group(s) of environment variables: ' . join ' and ', sort map
 792     { __envvar_group_desc($_) }
 793     @{$reqs->{missing_envvars}}
 794   if $reqs->{missing_envvars};
 795
 796   return (
 797     ( join ' as well as ', @res )
 798       .
 799     ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
 800   );
 801 }
 802
 803 sub modreq_missing_for {
 804   my ($self, $groups) = @_;
 805
 806   my $reqs = $self->_groups_to_reqs($groups);
 807   my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
 808     or return '';
 809
 810   join ' ', map
 811     { $reqs->{modreqs}{$_} ? qq("$_~>=$reqs->{modreqs}{$_}") : $_ }
 812     sort { lc($a) cmp lc($b) } keys %$modreq_errors
 813   ;
 814 }
 815
 816 my $tb;
 817 sub skip_without {
 818   my ($self, $groups) = @_;
 819
 820   $tb ||= do { local $@; eval { Test::Builder->new } }
 821     or croak "Calling skip_without() before loading Test::Builder makes no sense";
 822
 823   if ( my $err = $self->req_missing_for($groups) ) {
 824     my ($fn, $ln) = (caller(0))[1,2];
 825     $tb->skip("block in $fn around line $ln requires $err");
 826     local $^W = 0;
 827     last SKIP;
 828   }
 829
 830   1;
 831 }
 832
 833 sub die_unless_req_ok_for {
 834   if (my $err = shift->req_missing_for(shift) ) {
 835     die "Unable to continue due to missing requirements: $err\n";
 836   }
 837 }
 838
 839
 840
 841 ### Private functions
 842
 843 # potentially shorten group desc
 844 sub __envvar_group_desc {
 845   my @envs = @{$_[0]};
 846
 847   my (@res, $last_prefix);
 848   while (my $ev = shift @envs) {
 849     my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
 850
 851     if ( defined $sep and ($last_prefix||'') eq $pref ) {
 852         push @res, "...${sep}${suff}"
 853     }
 854     else {
 855       push @res, $ev;
 856     }
 857
 858     $last_prefix = $pref if $sep;
 859   }
 860
 861   join '/', @res;
 862 }
 863
 864 my $groupname_re = qr/ [A-Z_a-z][0-9A-Z_a-z]* /x;
 865 my $modname_re = qr/ [A-Z_a-z] [0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* /x;
 866 my $modver_re = qr/ [0-9]+ (?: \. [0-9]+ )? /x;
 867
 868 # Expand includes from a random group in a specific order:
 869 # nonvariable groups first, then their includes, then the variable groups,
 870 # then their includes.
 871 # This allows reliably marking the rest of the mod reqs as variable (this is
 872 # also why variable includes are currently not allowed)
 873 sub __expand_includes {
 874   my ($groups, $seen) = @_;
 875
 876   # !! DIFFERENT !! behavior and return depending on invocation mode
 877   # (easier to recurse this way)
 878   my $is_toplevel = $seen
 879     ? 0
 880     : !! ($seen = {})
 881   ;
 882
 883   my ($res_per_type, $missing_envvars);
 884
 885   # breadth-first evaluation, with non-variable includes on top
 886   for my $g (@$groups) {
 887
 888     croak "Invalid requirement group name '$g': only ascii alphanumerics and _ are allowed"
 889       if $g !~ qr/ \A $groupname_re \z/x;
 890
 891     my $r = $dbic_reqs->{$g}
 892       or croak "Requirement group '$g' is not defined";
 893
 894     # always do this check *before* the $seen check
 895     croak "Group '$g' with variable effective_modreqs can not be specified as an 'include'"
 896       if ( $r->{env} and ! $is_toplevel );
 897
 898     next if $seen->{$g}++;
 899
 900     my $req_type = 'static';
 901
 902     if ( my @e = @{$r->{env}||[]} ) {
 903
 904       croak "Unexpected 'env' attribute under group '$g' (only allowed in test_* groups)"
 905         unless $g =~ /^test_/;
 906
 907       croak "Unexpected *odd* list in 'env' under group '$g'"
 908         if @e % 2;
 909
 910       # deconstruct the whole thing
 911       my (@group_envnames_list, $some_envs_required, $some_required_missing);
 912       while (@e) {
 913         push @group_envnames_list, my $envname = shift @e;
 914
 915         # env required or not
 916         next unless shift @e;
 917
 918         $some_envs_required ||= 1;
 919
 920         $some_required_missing ||= (
 921           ! defined $ENV{$envname}
 922             or
 923           ! length $ENV{$envname}
 924         );
 925       }
 926
 927       croak "None of the envvars in group '$g' declared as required, making the requirement moot"
 928         unless $some_envs_required;
 929
 930       if ($some_required_missing) {
 931         push @{$missing_envvars->{$g}}, \@group_envnames_list;
 932         $req_type = 'variable';
 933       }
 934     }
 935
 936     push @{$res_per_type->{"base_${req_type}"}}, $g;
 937
 938     if (my $i = $dbic_reqs->{$g}{include}) {
 939       $i = [ $i ] unless ref $i eq 'ARRAY';
 940
 941       croak "Malformed 'include' for group '$g': must be another existing group name or arrayref of existing group names"
 942         unless @$i;
 943
 944       push @{$res_per_type->{"incs_${req_type}"}}, @$i;
 945     }
 946   }
 947
 948   my @ret = map {
 949     @{ $res_per_type->{"base_${_}"} || [] },
 950     ( $res_per_type->{"incs_${_}"} ? __expand_includes( $res_per_type->{"incs_${_}"}, $seen ) : () ),
 951   } qw(static variable);
 952
 953   return ! $is_toplevel ? @ret : do {
 954     my $rv = {};
 955     $rv->{$_} = {
 956       idx => 1 + keys %$rv,
 957       missing_envvars => $missing_envvars->{$_},
 958     } for @ret;
 959     $rv->{$_}{user_requested} = 1 for @$groups;
 960     $rv;
 961   };
 962 }
 963
 964 ### Private OO API
 965 our %req_unavailability_cache;
 966
 967 # this method is just a lister and envvar/metadata checker - it does not try to load anything
 968 sub _groups_to_reqs {
 969   my ($self, $want) = @_;
 970
 971   $want = [ $want || () ]
 972     unless ref $want eq 'ARRAY';
 973
 974   croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
 975     unless @$want;
 976
 977   my $ret = {
 978     modreqs => {},
 979     modreqs_fully_documented => 1,
 980   };
 981
 982   my $groups;
 983   for my $piece (@$want) {
 984     if ($piece =~ qr/ \A $groupname_re \z /x) {
 985       push @$groups, $piece;
 986     }
 987     elsif ( my ($mod, $ver) = $piece =~ qr/ \A ($modname_re) \>\= ($modver_re) \z /x ) {
 988       croak "Ad hoc module specification lists '$mod' twice"
 989         if exists $ret->{modreqs}{$mod};
 990
 991       croak "Ad hoc module specification '${mod} >= $ver' (or greater) not listed in the test_adhoc optdep group" if (
 992         ! defined $dbic_reqs->{test_adhoc}{req}{$mod}
 993           or
 994         $dbic_reqs->{test_adhoc}{req}{$mod} < $ver
 995       );
 996
 997       $ret->{modreqs}{$mod} = $ver;
 998       $ret->{modreqs_fully_documented} = 0;
 999     }
1000     else {
1001       croak "Unsupported argument '$piece' supplied to @{[ (caller(1))[3] ]}()"
1002     }
1003   }
1004
1005   my $all_groups = __expand_includes($groups);
1006
1007   # pre-assemble list of augmentations, perform basic sanity checks
1008   # Note that below we *DO NOT* respect the source/target reationship, but
1009   # instead always default to augment the "later" group
1010   # This is done so that the "stable/variable" boundary keeps working as
1011   # expected
1012   my $augmentations;
1013   for my $requesting_group (keys %$all_groups) {
1014     if (my $ag = $dbic_reqs->{$requesting_group}{augment}) {
1015       for my $target_group (keys %$ag) {
1016
1017         croak "Group '$requesting_group' claims to augment a non-existent group '$target_group'"
1018           unless $dbic_reqs->{$target_group};
1019
1020         croak "Augmentation combined with variable effective_modreqs currently unsupported for group '$requesting_group'"
1021           if $dbic_reqs->{$requesting_group}{env};
1022
1023         croak "Augmentation of group '$target_group' with variable effective_modreqs unsupported (requested by '$requesting_group')"
1024           if $dbic_reqs->{$target_group}{env};
1025
1026         if (my @foreign = grep { $_ ne 'req' } keys %{$ag->{$target_group}} ) {
1027           croak "Only 'req' augmentations are currently supported (group '$requesting_group' attempts to alter '$foreign[0]' of group '$target_group'";
1028         }
1029
1030         $ret->{augments}{$target_group} = 1;
1031
1032         # no augmentation for stuff that hasn't been selected
1033         if ( $all_groups->{$target_group} and my $ar = $ag->{$target_group}{req} ) {
1034           push @{$augmentations->{
1035             ( $all_groups->{$requesting_group}{idx} < $all_groups->{$target_group}{idx} )
1036               ? $target_group
1037               : $requesting_group
1038           }}, $ar;
1039         }
1040       }
1041     }
1042   }
1043
1044   for my $group (sort { $all_groups->{$a}{idx} <=> $all_groups->{$b}{idx} } keys %$all_groups ) {
1045
1046     my $group_reqs = $dbic_reqs->{$group}{req};
1047
1048     # sanity-check
1049     for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1050       for (keys %$req_bag) {
1051
1052         $_ =~ / \A $modname_re \z /x
1053           or croak "Requirement '$_' in group '$group' is not a valid module name";
1054
1055         # !!!DO NOT CHANGE!!!
1056         # remember - version.pm may not be available on the system
1057         croak "Requirement '$_' in group '$group' specifies an invalid version '$req_bag->{$_}' (only plain non-underscored floating point decimals are supported)"
1058           if ( ($req_bag->{$_}||0) !~ qr/ \A $modver_re \z /x );
1059       }
1060     }
1061
1062     if (my $e = $all_groups->{$group}{missing_envvars}) {
1063       push @{$ret->{missing_envvars}}, @$e;
1064     }
1065
1066     # assemble into the final ret
1067     for my $type (
1068       'modreqs',
1069       ( $ret->{missing_envvars} ? () : 'effective_modreqs' ),
1070     ) {
1071       for my $req_bag ($group_reqs, @{ $augmentations->{$group} || [] } ) {
1072         for my $mod (keys %$req_bag) {
1073
1074           $ret->{$type}{$mod} = $req_bag->{$mod}||0 if (
1075
1076             ! exists $ret->{$type}{$mod}
1077               or
1078             # we sanitized the version to be numeric above - we can just -gt it
1079             ($req_bag->{$mod}||0) > $ret->{$type}{$mod}
1080
1081           );
1082         }
1083       }
1084     }
1085
1086     $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod}
1087       if $all_groups->{$group}{user_requested};
1088
1089     $ret->{release_testing_mandatory} ||= !!$dbic_reqs->{$group}{release_testing_mandatory};
1090   }
1091
1092   return $ret;
1093 }
1094
1095
1096 # this method tries to find/load specified modreqs and returns a hashref of
1097 # module/loaderror pairs for anything that failed
1098 sub _errorlist_for_modreqs {
1099   # args supposedly already went through _groups_to_reqs and are therefore sanitized
1100   # safe to eval at will
1101   my ($self, $reqs) = @_;
1102
1103   my $ret;
1104
1105   for my $m ( keys %$reqs ) {
1106     my $v = $reqs->{$m};
1107
1108     if (! exists $req_unavailability_cache{$m}{$v} ) {
1109       local $@;
1110       eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
1111       $req_unavailability_cache{$m}{$v} = $@;
1112     }
1113
1114     $ret->{$m} = $req_unavailability_cache{$m}{$v}
1115       if $req_unavailability_cache{$m}{$v};
1116   }
1117
1118   $ret;
1119 }
1120
1121 # Unlike the above DO NOT try to load anything
1122 # This is executed when some needed envvars are not available
1123 # which in turn means a module load will never be reached anyway
1124 # This is important because some modules (especially DBDs) can be
1125 # *really* fickle when a require() is attempted, with pretty confusing
1126 # side-effects (especially on windows)
1127 sub _list_physically_missing_modules {
1128   my ($self, $modreqs) = @_;
1129
1130   # in case there is a coderef in @INC there is nothing we can definitively prove
1131   # so short circuit directly
1132   return '' if grep { length ref $_ } @INC;
1133
1134   my @definitely_missing;
1135   for my $mod (keys %$modreqs) {
1136     (my $fn = $mod . '.pm') =~ s|::|/|g;
1137
1138     push @definitely_missing, $mod unless grep
1139       # this should work on any combination of slashes
1140       { $_ and -d $_ and -f "$_/$fn" and -r "$_/$fn" }
1141       @INC
1142     ;
1143   }
1144
1145   join ' ', map
1146     { $modreqs->{$_} ? qq("$_~>=$modreqs->{$_}") : $_ }
1147     sort { lc($a) cmp lc($b) } @definitely_missing
1148   ;
1149 }
1150
1151
1152 # This is to be called by the author only (automatically in Makefile.PL)
1153 sub _gen_pod {
1154   my ($class, $distver, $pod_dir) = @_;
1155
1156   die "No POD root dir supplied" unless $pod_dir;
1157
1158   $distver ||=
1159     eval { require DBIx::Class; DBIx::Class->VERSION; }
1160       ||
1161     die
1162 "\n\n---------------------------------------------------------------------\n" .
1163 'Unable to load core DBIx::Class module to determine current version, '.
1164 'possibly due to missing dependencies. Author-mode autodocumentation ' .
1165 "halted\n\n" . $@ .
1166 "\n\n---------------------------------------------------------------------\n"
1167   ;
1168
1169   # do not ask for a recent version, use 1.x API calls
1170   # this *may* execute on a smoker with old perl or whatnot
1171   require File::Path;
1172
1173   (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
1174
1175   (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
1176   (my $dir = $podfn) =~ s|/[^/]+$||;
1177
1178   File::Path::mkpath([$dir]);
1179
1180   my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
1181     or die "Hrmm? No sqlt dep?";
1182
1183
1184   my @chunks;
1185
1186 #@@
1187 #@@ HEADER
1188 #@@
1189   push @chunks, <<"EOC";
1190 #########################################################################
1191 #####################  A U T O G E N E R A T E D ########################
1192 #########################################################################
1193 #
1194 # The contents of this POD file are auto-generated.  Any changes you make
1195 # will be lost. If you need to change the generated text edit _gen_pod()
1196 # at the end of $modfn
1197 #
1198
1199 =head1 NAME
1200
1201 $class - Optional module dependency specifications (for module authors)
1202 EOC
1203
1204
1205 #@@
1206 #@@ SYNOPSIS HEADING
1207 #@@
1208   push @chunks, <<"EOC";
1209 =head1 SYNOPSIS
1210
1211 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
1212
1213   ...
1214
1215   \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
1216     \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
1217     'DBIx::Class' => '$distver',
1218   };
1219
1220   ...
1221
1222   my %DBIC_DEPLOY_AND_ORACLE_DEPS = %{ eval {
1223     require $class;
1224     $class->req_list_for([qw( deploy rdbms_oracle icdt )]);
1225   } || {} };
1226
1227   \$EUMM_ARGS{PREREQ_PM} = {
1228     \%DBIC_DEPLOY_AND_ORACLE_DEPS,
1229     \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
1230   };
1231
1232   ...
1233
1234   ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
1235
1236 B<Note>: The C<eval> protection within the example is due to support for
1237 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
1238 not being available on a sufficient portion of production installations of
1239 Perl. Robust support for such dependency requirements is available in the
1240 L<CPAN> installer only since version C<1.94_56> first made available for
1241 production with perl version C<5.12>. It is the belief of the current
1242 maintainer that support for requirements during the C<configure> build phase
1243 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
1244 hence the extra care demonstrated above. It should also be noted that some
1245 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
1246 with configure requirements independent from the versions of perl and CPAN
1247 available.
1248 EOC
1249
1250
1251 #@@
1252 #@@ DESCRIPTION HEADING
1253 #@@
1254   push @chunks, <<'EOC';
1255 =head1 DESCRIPTION
1256
1257 Some of the less-frequently used features of L<DBIx::Class> have external
1258 module dependencies on their own. In order not to burden the average user
1259 with modules they will never use, these optional dependencies are not included
1260 in the base Makefile.PL. Instead an exception with a descriptive message is
1261 thrown when a specific feature can't find one or several modules required for
1262 its operation. This module is the central holding place for the current list
1263 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1264 authors alike.
1265
1266 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1267 group can list one or more required modules, with an optional minimum version
1268 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1269 a set of environment variables, some (or all) of which are marked as required
1270 for the group to be considered by L</req_list_for>
1271
1272 Each group name (or a combination thereof) can be used in the
1273 L<public methods|/METHODS> as described below.
1274 EOC
1275
1276
1277 #@@
1278 #@@ REQUIREMENT GROUPLIST HEADING
1279 #@@
1280   push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1281
1282   my $standalone_info;
1283
1284   for my $group (sort keys %$dbic_reqs) {
1285
1286     my $info = $standalone_info->{$group} ||= $class->_groups_to_reqs($group);
1287
1288     next unless (
1289       $info->{modreqs_fully_documented}
1290         and
1291       ( $info->{augments} or $info->{modreqs} )
1292     );
1293
1294     my $p = $dbic_reqs->{$group}{pod};
1295
1296     push @chunks, (
1297       "=head2 $p->{title}",
1298       "=head3 $group",
1299       $p->{desc},
1300       '=over',
1301     );
1302
1303     if ( keys %{ $info->{modreqs}||{} } ) {
1304       push @chunks, map
1305         { "=item * $_" . ($info->{modreqs}{$_} ? " >= $info->{modreqs}{$_}" : '') }
1306         ( sort keys %{ $info->{modreqs} } )
1307       ;
1308     }
1309     else {
1310       push @chunks, '=item * No standalone requirements',
1311     }
1312
1313     push @chunks, '=back';
1314
1315     for my $ag ( sort keys %{ $info->{augments} || {} } ) {
1316       my $ag_info = $standalone_info->{$ag} ||= $class->_groups_to_reqs($ag);
1317
1318       my $newreqs = $class->modreq_list_for([ $group, $ag ]);
1319       for (keys %$newreqs) {
1320         delete $newreqs->{$_} if (
1321           ( defined $info->{modreqs}{$_}    and $info->{modreqs}{$_}    == $newreqs->{$_} )
1322             or
1323           ( defined $ag_info->{modreqs}{$_} and $ag_info->{modreqs}{$_} == $newreqs->{$_} )
1324         );
1325       }
1326
1327       if (keys %$newreqs) {
1328         push @chunks, (
1329           "Combined with L</$ag> additionally requires:",
1330           '=over',
1331           ( map
1332             { "=item * $_" . ($newreqs->{$_} ? " >= $newreqs->{$_}" : '') }
1333             ( sort keys %$newreqs )
1334           ),
1335           '=back',
1336         );
1337       }
1338     }
1339   }
1340
1341
1342 #@@
1343 #@@ API DOCUMENTATION HEADING
1344 #@@
1345   push @chunks, <<'EOC';
1346
1347 =head1 IMPORT-LIKE ACTIONS
1348
1349 Even though this module is not an L<Exporter>, it recognizes several C<actions>
1350 supplied to its C<import> method.
1351
1352 =head2 -skip_all_without
1353
1354 =over
1355
1356 =item Arguments: @group_names
1357
1358 =back
1359
1360 A convenience wrapper for use during testing:
1361 EOC
1362
1363   push @chunks, " use $class -skip_all_without => qw(admin test_rdbms_mysql);";
1364
1365   push @chunks, 'Roughly equivalent to the following code:';
1366
1367   push @chunks, sprintf <<'EOS', ($class) x 2;
1368
1369  BEGIN {
1370    require %s;
1371    if ( my $missing = %s->req_missing_for(\@group_names_) ) {
1372      print "1..0 # SKIP requirements not satisfied: $missing\n";
1373      exit 0;
1374    }
1375  }
1376 EOS
1377
1378   push @chunks, <<'EOC';
1379
1380 It also takes into account the C<RELEASE_TESTING> environment variable and
1381 behaves like L</-die_without> for any requirement groups marked as
1382 C<release_testing_mandatory>.
1383
1384 =head2 -die_without
1385
1386 =over
1387
1388 =item Arguments: @group_names
1389
1390 =back
1391
1392 A convenience wrapper around L</die_unless_req_ok_for>:
1393 EOC
1394
1395   push @chunks, " use $class -die_without => qw(deploy admin);";
1396
1397   push @chunks, <<'EOC';
1398
1399 =head2 -list_missing
1400
1401 =over
1402
1403 =item Arguments: @group_names
1404
1405 =back
1406
1407 A convenience wrapper around L</modreq_missing_for>:
1408
1409  perl -Ilib -MDBIx::Class::Optional::Dependencies=-list_missing,deploy,admin | cpanm
1410
1411 =head1 METHODS
1412
1413 =head2 req_group_list
1414
1415 =over
1416
1417 =item Arguments: none
1418
1419 =item Return Value: \%list_of_requirement_groups
1420
1421 =back
1422
1423 This method should be used by DBIx::Class packagers, to get a hashref of all
1424 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1425 thereof (as an arrayref) can be supplied to the methods below.
1426 The B<values> of the returned hash are currently a set of options B<without a
1427 well defined structure>. If you have use for any of the contents - contact the
1428 maintainers, instead of treating this as public (left alone stable) API.
1429
1430 =head2 req_list_for
1431
1432 =over
1433
1434 =item Arguments: $group_name | \@group_names
1435
1436 =item Return Value: \%set_of_module_version_pairs
1437
1438 =back
1439
1440 This method should be used by DBIx::Class extension authors, to determine the
1441 version of modules a specific set of features requires for this version of
1442 DBIx::Class (regardless of their availability on the system).
1443 See the L</SYNOPSIS> for a real-world example.
1444
1445 When handling C<test_*> groups this method behaves B<differently> from
1446 L</modreq_list_for> below (and is the only such inconsistency among the
1447 C<req_*> methods). If a particular group declares as requirements some
1448 C<environment variables> and these requirements are not satisfied (the envvars
1449 are unset) - then the C<module requirements> of this group are not included in
1450 the returned list.
1451
1452 =head2 modreq_list_for
1453
1454 =over
1455
1456 =item Arguments: $group_name | \@group_names
1457
1458 =item Return Value: \%set_of_module_version_pairs
1459
1460 =back
1461
1462 Same as L</req_list_for> but does not take into consideration any
1463 C<environment variable requirements> - returns just the list of required
1464 modules.
1465
1466 =head2 req_ok_for
1467
1468 =over
1469
1470 =item Arguments: $group_name | \@group_names
1471
1472 =item Return Value: 1|0
1473
1474 =back
1475
1476 Returns true or false depending on whether all modules/envvars required by
1477 the group(s) are loadable/set on the system.
1478
1479 =head2 req_missing_for
1480
1481 =over
1482
1483 =item Arguments: $group_name | \@group_names
1484
1485 =item Return Value: $error_message_string
1486
1487 =back
1488
1489 Returns a single-line string suitable for inclusion in larger error messages.
1490 This method would normally be used by DBIx::Class core features, to indicate to
1491 the user that they need to install specific modules and/or set specific
1492 environment variables before being able to use a specific feature set.
1493
1494 For example if some of the requirements for C<deploy> are not available,
1495 the returned string could look like:
1496 EOC
1497
1498   push @chunks, qq{ "SQL::Translator~>=$sqltver" (see $class documentation for details)};
1499
1500   push @chunks, <<'EOC';
1501 The author is expected to prepend the necessary text to this message before
1502 returning the actual error seen by the user. See also L</modreq_missing_for>
1503
1504 =head2 modreq_missing_for
1505
1506 =over
1507
1508 =item Arguments: $group_name | \@group_names
1509
1510 =item Return Value: $error_message_string
1511
1512 =back
1513
1514 Same as L</req_missing_for> except that the error string is guaranteed to be
1515 either empty, or contain a set of module requirement specifications suitable
1516 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1517 attempt to validate the state of required environment variables (if any).
1518
1519 For instance if some of the requirements for C<deploy> are not available,
1520 the returned string could look like:
1521 EOC
1522
1523   push @chunks, qq{ "SQL::Translator~>=$sqltver"};
1524
1525   push @chunks, <<'EOC';
1526
1527 See also L</-list_missing>.
1528
1529 =head2 skip_without
1530
1531 =over
1532
1533 =item Arguments: $group_name | \@group_names
1534
1535 =back
1536
1537 A convenience wrapper around L<skip|Test::More/SKIP>. It does not take neither
1538 a reason (it is generated by L</req_missing_for>) nor an amount of skipped tests
1539 (it is always C<1>, thus mandating unconditional use of
1540 L<done_testing|Test::More/done_testing>). Most useful in combination with ad hoc
1541 requirement specifications:
1542 EOC
1543
1544   push @chunks, <<EOC;
1545   SKIP: {
1546     $class->skip_without([ deploy YAML>=0.90 ]);
1547
1548     ...
1549   }
1550 EOC
1551
1552   push @chunks, <<'EOC';
1553
1554 =head2 die_unless_req_ok_for
1555
1556 =over
1557
1558 =item Arguments: $group_name | \@group_names
1559
1560 =back
1561
1562 Checks if L</req_ok_for> passes for the supplied group(s), and
1563 in case of failure throws an exception including the information
1564 from L</req_missing_for>. See also L</-die_without>.
1565
1566 =head2 modreq_errorlist_for
1567
1568 =over
1569
1570 =item Arguments: $group_name | \@group_names
1571
1572 =item Return Value: \%set_of_loaderrors_per_module
1573
1574 =back
1575
1576 Returns a hashref containing the actual errors that occurred while attempting
1577 to load each module in the requirement group(s).
1578
1579 =head2 req_errorlist_for
1580
1581 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1582
1583 EOC
1584
1585 #@@
1586 #@@ FOOTER
1587 #@@
1588   push @chunks, <<'EOC';
1589 =head1 FURTHER QUESTIONS?
1590
1591 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1592
1593 =head1 COPYRIGHT AND LICENSE
1594
1595 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1596 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1597 redistribute it and/or modify it under the same terms as the
1598 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1599 EOC
1600
1601   eval {
1602     open (my $fh, '>', $podfn) or die;
1603     print $fh join ("\n\n", @chunks) or die;
1604     print $fh "\n" or die;
1605     close ($fh) or die;
1606   } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );
1607 }
1608
1609 1;