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