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