lib/DBIx/Class/Optional/Dependencies.pm

   1 package DBIx::Class::Optional::Dependencies;
   2
   3 use warnings;
   4 use strict;
   5
   6 use Carp;
   7
   8 # NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
   9 # This module is to be loaded by Makefile.PM on a pristine system
  10
  11 # POD is generated automatically by calling _gen_pod from the
  12 # Makefile.PL in $AUTHOR mode
  13
  14 # NOTE: the rationale for 2 JSON::Any versions is that
  15 # we need the newer only to work around JSON::XS, which
  16 # itself is an optional dep
  17 my $min_json_any = {
  18   'JSON::Any'                     => '1.23',
  19 };
  20 my $test_and_dist_json_any = {
  21   'JSON::Any'                     => '1.31',
  22 };
  23
  24 my $moose_basic = {
  25   'Moose'                         => '0.98',
  26   'MooseX::Types'                 => '0.21',
  27   'MooseX::Types::LoadableClass'  => '0.011',
  28 };
  29
  30 my $replicated = {
  31   %$moose_basic,
  32 };
  33
  34 my $admin_basic = {
  35   %$moose_basic,
  36   %$min_json_any,
  37   'MooseX::Types::Path::Class'    => '0.05',
  38   'MooseX::Types::JSON'           => '0.02',
  39 };
  40
  41 my $admin_script = {
  42   %$moose_basic,
  43   %$admin_basic,
  44   'Getopt::Long::Descriptive' => '0.081',
  45   'Text::CSV'                 => '1.16',
  46 };
  47
  48 my $datetime_basic = {
  49   'DateTime'                      => '0.55',
  50   'DateTime::Format::Strptime'    => '1.2',
  51 };
  52
  53 my $id_shortener = {
  54   'Math::BigInt'                  => '1.80',
  55   'Math::Base36'                  => '0.07',
  56 };
  57
  58 my $rdbms_sqlite = {
  59   'DBD::SQLite'                   => '0',
  60 };
  61 my $rdbms_pg = {
  62   'DBD::Pg'                       => '0',
  63 };
  64 my $rdbms_mssql_odbc = {
  65   'DBD::ODBC'                     => '0',
  66 };
  67 my $rdbms_mssql_sybase = {
  68   'DBD::Sybase'                   => '0',
  69 };
  70 my $rdbms_mssql_ado = {
  71   'DBD::ADO'                      => '0',
  72 };
  73 my $rdbms_msaccess_odbc = {
  74   'DBD::ODBC'                     => '0',
  75 };
  76 my $rdbms_msaccess_ado = {
  77   'DBD::ADO'                      => '0',
  78 };
  79 my $rdbms_mysql = {
  80   'DBD::mysql'                    => '0',
  81 };
  82 my $rdbms_oracle = {
  83   'DBD::Oracle'                   => '0',
  84   %$id_shortener,
  85 };
  86 my $rdbms_ase = {
  87   'DBD::Sybase'                   => '0',
  88 };
  89 my $rdbms_db2 = {
  90   'DBD::DB2'                      => '0',
  91 };
  92 my $rdbms_db2_400 = {
  93   'DBD::ODBC'                     => '0',
  94 };
  95 my $rdbms_informix = {
  96   'DBD::Informix'                 => '0',
  97 };
  98 my $rdbms_sqlanywhere = {
  99   'DBD::SQLAnywhere'              => '0',
 100 };
 101 my $rdbms_sqlanywhere_odbc = {
 102   'DBD::ODBC'                     => '0',
 103 };
 104 my $rdbms_firebird = {
 105   'DBD::Firebird'                 => '0',
 106 };
 107 my $rdbms_firebird_interbase = {
 108   'DBD::InterBase'                => '0',
 109 };
 110 my $rdbms_firebird_odbc = {
 111   'DBD::ODBC'                     => '0',
 112 };
 113
 114 my $dbic_reqs = {
 115   replicated => {
 116     req => $replicated,
 117     pod => {
 118       title => 'Storage::Replicated',
 119       desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
 120     },
 121   },
 122
 123   test_replicated => {
 124     req => {
 125       %$replicated,
 126       'Test::Moose'               => '0',
 127     },
 128   },
 129
 130
 131   admin => {
 132     req => {
 133       %$admin_basic,
 134     },
 135     pod => {
 136       title => 'DBIx::Class::Admin',
 137       desc => 'Modules required for the DBIx::Class administrative library',
 138     },
 139   },
 140
 141   admin_script => {
 142     req => {
 143       %$admin_script,
 144     },
 145     pod => {
 146       title => 'dbicadmin',
 147       desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
 148     },
 149   },
 150
 151   deploy => {
 152     req => {
 153       'SQL::Translator'           => '0.11018',
 154     },
 155     pod => {
 156       title => 'Storage::DBI::deploy()',
 157       desc => 'Modules required for L<DBIx::Class::Storage::DBI/deployment_statements> and L<DBIx::Class::Schema/deploy>',
 158     },
 159   },
 160
 161   id_shortener => {
 162     req => $id_shortener,
 163   },
 164
 165   test_component_accessor => {
 166     req => {
 167       'Class::Unload'             => '0.07',
 168     },
 169   },
 170
 171   test_pod => {
 172     req => {
 173       'Test::Pod'                 => '1.42',
 174     },
 175   },
 176
 177   test_podcoverage => {
 178     req => {
 179       'Test::Pod::Coverage'       => '1.08',
 180       'Pod::Coverage'             => '0.20',
 181     },
 182   },
 183
 184   test_whitespace => {
 185     req => {
 186       'Test::EOL'                 => '1.0',
 187       'Test::NoTabs'              => '0.9',
 188     },
 189   },
 190
 191   test_strictures => {
 192     req => {
 193       'Test::Strict'              => '0.20',
 194     },
 195   },
 196
 197   test_prettydebug => {
 198     req => $min_json_any,
 199   },
 200
 201   test_admin_script => {
 202     req => {
 203       %$admin_script,
 204       %$test_and_dist_json_any,
 205       'JSON' => 0,
 206       'JSON::PP' => 0,
 207       'Cpanel::JSON::XS' => 0,
 208       'JSON::XS' => 0,
 209       $^O eq 'MSWin32'
 210         # for t/admin/10script.t
 211         ? ('Win32::ShellQuote' => 0)
 212         # DWIW does not compile (./configure even) on win32
 213         : ('JSON::DWIW' => 0 )
 214       ,
 215     }
 216   },
 217
 218   test_leaks_heavy => {
 219     req => {
 220       'Class::MethodCache' => '0.02',
 221       'PadWalker' => '1.06',
 222     },
 223   },
 224
 225   test_dt => {
 226     req => $datetime_basic,
 227   },
 228
 229   test_dt_sqlite => {
 230     req => {
 231       %$datetime_basic,
 232       # t/36datetime.t
 233       # t/60core.t
 234       'DateTime::Format::SQLite'  => '0',
 235     },
 236   },
 237
 238   test_dt_mysql => {
 239     req => {
 240       %$datetime_basic,
 241       # t/inflate/datetime_mysql.t
 242       # (doesn't need Mysql itself)
 243       'DateTime::Format::MySQL'   => '0',
 244     },
 245   },
 246
 247   test_dt_pg => {
 248     req => {
 249       %$datetime_basic,
 250       # t/inflate/datetime_pg.t
 251       # (doesn't need PG itself)
 252       'DateTime::Format::Pg'      => '0.16004',
 253     },
 254   },
 255
 256   test_cdbicompat => {
 257     req => {
 258       'Class::DBI::Plugin::DeepAbstractSearch' => '0',
 259       %$datetime_basic,
 260       'Time::Piece::MySQL'        => '0',
 261       'Date::Simple'              => '3.03',
 262     },
 263   },
 264
 265   # this is just for completeness as SQLite
 266   # is a core dep of DBIC for testing
 267   rdbms_sqlite => {
 268     req => {
 269       %$rdbms_sqlite,
 270     },
 271     pod => {
 272       title => 'SQLite support',
 273       desc => 'Modules required to connect to SQLite',
 274     },
 275   },
 276
 277   rdbms_pg => {
 278     req => {
 279       # when changing this list make sure to adjust xt/optional_deps.t
 280       %$rdbms_pg,
 281     },
 282     pod => {
 283       title => 'PostgreSQL support',
 284       desc => 'Modules required to connect to PostgreSQL',
 285     },
 286   },
 287
 288   rdbms_mssql_odbc => {
 289     req => {
 290       %$rdbms_mssql_odbc,
 291     },
 292     pod => {
 293       title => 'MSSQL support via DBD::ODBC',
 294       desc => 'Modules required to connect to MSSQL via DBD::ODBC',
 295     },
 296   },
 297
 298   rdbms_mssql_sybase => {
 299     req => {
 300       %$rdbms_mssql_sybase,
 301     },
 302     pod => {
 303       title => 'MSSQL support via DBD::Sybase',
 304       desc => 'Modules required to connect to MSSQL via DBD::Sybase',
 305     },
 306   },
 307
 308   rdbms_mssql_ado => {
 309     req => {
 310       %$rdbms_mssql_ado,
 311     },
 312     pod => {
 313       title => 'MSSQL support via DBD::ADO (Windows only)',
 314       desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
 315     },
 316   },
 317
 318   rdbms_msaccess_odbc => {
 319     req => {
 320       %$rdbms_msaccess_odbc,
 321     },
 322     pod => {
 323       title => 'MS Access support via DBD::ODBC',
 324       desc => 'Modules required to connect to MS Access via DBD::ODBC',
 325     },
 326   },
 327
 328   rdbms_msaccess_ado => {
 329     req => {
 330       %$rdbms_msaccess_ado,
 331     },
 332     pod => {
 333       title => 'MS Access support via DBD::ADO (Windows only)',
 334       desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
 335     },
 336   },
 337
 338   rdbms_mysql => {
 339     req => {
 340       %$rdbms_mysql,
 341     },
 342     pod => {
 343       title => 'MySQL support',
 344       desc => 'Modules required to connect to MySQL',
 345     },
 346   },
 347
 348   rdbms_oracle => {
 349     req => {
 350       %$rdbms_oracle,
 351     },
 352     pod => {
 353       title => 'Oracle support',
 354       desc => 'Modules required to connect to Oracle',
 355     },
 356   },
 357
 358   rdbms_ase => {
 359     req => {
 360       %$rdbms_ase,
 361     },
 362     pod => {
 363       title => 'Sybase ASE support',
 364       desc => 'Modules required to connect to Sybase ASE',
 365     },
 366   },
 367
 368   rdbms_db2 => {
 369     req => {
 370       %$rdbms_db2,
 371     },
 372     pod => {
 373       title => 'DB2 support',
 374       desc => 'Modules required to connect to DB2',
 375     },
 376   },
 377
 378   rdbms_db2_400 => {
 379     req => {
 380       %$rdbms_db2_400,
 381     },
 382     pod => {
 383       title => 'DB2 on AS/400 support',
 384       desc => 'Modules required to connect to DB2 on AS/400',
 385     },
 386   },
 387
 388   rdbms_informix => {
 389     req => {
 390       %$rdbms_informix,
 391     },
 392     pod => {
 393       title => 'Informix support',
 394       desc => 'Modules required to connect to Informix',
 395     },
 396   },
 397
 398   rdbms_sqlanywhere => {
 399     req => {
 400       %$rdbms_sqlanywhere,
 401     },
 402     pod => {
 403       title => 'SQLAnywhere support',
 404       desc => 'Modules required to connect to SQLAnywhere',
 405     },
 406   },
 407
 408   rdbms_sqlanywhere_odbc => {
 409     req => {
 410       %$rdbms_sqlanywhere_odbc,
 411     },
 412     pod => {
 413       title => 'SQLAnywhere support via DBD::ODBC',
 414       desc => 'Modules required to connect to SQLAnywhere via DBD::ODBC',
 415     },
 416   },
 417
 418   rdbms_firebird => {
 419     req => {
 420       %$rdbms_firebird,
 421     },
 422     pod => {
 423       title => 'Firebird support',
 424       desc => 'Modules required to connect to Firebird',
 425     },
 426   },
 427
 428   rdbms_firebird_interbase => {
 429     req => {
 430       %$rdbms_firebird_interbase,
 431     },
 432     pod => {
 433       title => 'Firebird support via DBD::InterBase',
 434       desc => 'Modules required to connect to Firebird via DBD::InterBase',
 435     },
 436   },
 437
 438   rdbms_firebird_odbc => {
 439     req => {
 440       %$rdbms_firebird_odbc,
 441     },
 442     pod => {
 443       title => 'Firebird support via DBD::ODBC',
 444       desc => 'Modules required to connect to Firebird via DBD::ODBC',
 445     },
 446   },
 447
 448   test_rdbms_pg => {
 449     env => [
 450       DBICTEST_PG_DSN => 1,
 451       DBICTEST_PG_USER => 0,
 452       DBICTEST_PG_PASS => 0,
 453     ],
 454     req => {
 455       # the order does matter because the rdbms support group might require
 456       # a different version that the test group
 457       #
 458       # when changing this list make sure to adjust xt/optional_deps.t
 459       %$rdbms_pg,
 460       'DBD::Pg' => '2.009002',  # specific version to test bytea
 461     },
 462   },
 463
 464   test_rdbms_mssql_odbc => {
 465     env => [
 466       DBICTEST_MSSQL_ODBC_DSN => 1,
 467       DBICTEST_MSSQL_ODBC_USER => 0,
 468       DBICTEST_MSSQL_ODBC_PASS => 0,
 469     ],
 470     req => {
 471       %$rdbms_mssql_odbc,
 472     },
 473   },
 474
 475   test_rdbms_mssql_ado => {
 476     env => [
 477       DBICTEST_MSSQL_ADO_DSN => 1,
 478       DBICTEST_MSSQL_ADO_USER => 0,
 479       DBICTEST_MSSQL_ADO_PASS => 0,
 480     ],
 481     req => {
 482       %$rdbms_mssql_ado,
 483     },
 484   },
 485
 486   test_rdbms_mssql_sybase => {
 487     env => [
 488       DBICTEST_MSSQL_DSN => 1,
 489       DBICTEST_MSSQL_USER => 0,
 490       DBICTEST_MSSQL_PASS => 0,
 491     ],
 492     req => {
 493       %$rdbms_mssql_sybase,
 494     },
 495   },
 496
 497   test_rdbms_msaccess_odbc => {
 498     env => [
 499       DBICTEST_MSACCESS_ODBC_DSN => 1,
 500       DBICTEST_MSACCESS_ODBC_USER => 0,
 501       DBICTEST_MSACCESS_ODBC_PASS => 0,
 502     ],
 503     req => {
 504       %$rdbms_msaccess_odbc,
 505       %$datetime_basic,
 506       'Data::GUID' => '0',
 507     },
 508   },
 509
 510   test_rdbms_msaccess_ado => {
 511     env => [
 512       DBICTEST_MSACCESS_ADO_DSN => 1,
 513       DBICTEST_MSACCESS_ADO_USER => 0,
 514       DBICTEST_MSACCESS_ADO_PASS => 0,
 515     ],
 516     req => {
 517       %$rdbms_msaccess_ado,
 518       %$datetime_basic,
 519       'Data::GUID' => 0,
 520     },
 521   },
 522
 523   test_rdbms_mysql => {
 524     env => [
 525       DBICTEST_MYSQL_DSN => 1,
 526       DBICTEST_MYSQL_USER => 0,
 527       DBICTEST_MYSQL_PASS => 0,
 528     ],
 529     req => {
 530       %$rdbms_mysql,
 531     },
 532   },
 533
 534   test_rdbms_oracle => {
 535     env => [
 536       DBICTEST_ORA_DSN => 1,
 537       DBICTEST_ORA_USER => 0,
 538       DBICTEST_ORA_PASS => 0,
 539     ],
 540     req => {
 541       %$rdbms_oracle,
 542       'DateTime::Format::Oracle' => '0',
 543       'DBD::Oracle'              => '1.24',
 544     },
 545   },
 546
 547   test_rdbms_ase => {
 548     env => [
 549       DBICTEST_SYBASE_DSN => 1,
 550       DBICTEST_SYBASE_USER => 0,
 551       DBICTEST_SYBASE_PASS => 0,
 552     ],
 553     req => {
 554       %$rdbms_ase,
 555     },
 556   },
 557
 558   test_rdbms_db2 => {
 559     env => [
 560       DBICTEST_DB2_DSN => 1,
 561       DBICTEST_DB2_USER => 0,
 562       DBICTEST_DB2_PASS => 0,
 563     ],
 564     req => {
 565       %$rdbms_db2,
 566     },
 567   },
 568
 569   test_rdbms_db2_400 => {
 570     env => [
 571       DBICTEST_DB2_400_DSN => 1,
 572       DBICTEST_DB2_400_USER => 0,
 573       DBICTEST_DB2_400_PASS => 0,
 574     ],
 575     req => {
 576       %$rdbms_db2_400,
 577     },
 578   },
 579
 580   test_rdbms_informix => {
 581     env => [
 582       DBICTEST_INFORMIX_DSN => 1,
 583       DBICTEST_INFORMIX_USER => 0,
 584       DBICTEST_INFORMIX_PASS => 0,
 585     ],
 586     req => {
 587       %$rdbms_informix,
 588     },
 589   },
 590
 591   test_rdbms_sqlanywhere => {
 592     env => [
 593       DBICTEST_SQLANYWHERE_DSN => 1,
 594       DBICTEST_SQLANYWHERE_USER => 0,
 595       DBICTEST_SQLANYWHERE_PASS => 0,
 596     ],
 597     req => {
 598       %$rdbms_sqlanywhere,
 599     },
 600   },
 601
 602   test_rdbms_sqlanywhere_odbc => {
 603     env => [
 604       DBICTEST_SQLANYWHERE_ODBC_DSN => 1,
 605       DBICTEST_SQLANYWHERE_ODBC_USER => 0,
 606       DBICTEST_SQLANYWHERE_ODBC_PASS => 0,
 607     ],
 608     req => {
 609       %$rdbms_sqlanywhere_odbc,
 610     },
 611   },
 612
 613   test_rdbms_firebird => {
 614     env => [
 615       DBICTEST_FIREBIRD_DSN => 1,
 616       DBICTEST_FIREBIRD_USER => 0,
 617       DBICTEST_FIREBIRD_PASS => 0,
 618     ],
 619     req => {
 620       %$rdbms_firebird,
 621     },
 622   },
 623
 624   test_rdbms_firebird_interbase => {
 625     env => [
 626       DBICTEST_FIREBIRD_INTERBASE_DSN => 1,
 627       DBICTEST_FIREBIRD_INTERBASE_USER => 0,
 628       DBICTEST_FIREBIRD_INTERBASE_PASS => 0,
 629     ],
 630     req => {
 631       %$rdbms_firebird_interbase,
 632     },
 633   },
 634
 635   test_rdbms_firebird_odbc => {
 636     env => [
 637       DBICTEST_FIREBIRD_ODBC_DSN => 1,
 638       DBICTEST_FIREBIRD_ODBC_USER => 0,
 639       DBICTEST_FIREBIRD_ODBC_PASS => 0,
 640     ],
 641     req => {
 642       %$rdbms_firebird_odbc,
 643     },
 644   },
 645
 646   test_memcached => {
 647     env => [
 648       DBICTEST_MEMCACHED => 1,
 649     ],
 650     req => {
 651       'Cache::Memcached' => 0,
 652     },
 653   },
 654
 655   dist_dir => {
 656     req => {
 657       %$test_and_dist_json_any,
 658       'ExtUtils::MakeMaker' => '6.64',
 659       'Pod::Inherit'        => '0.91',
 660     },
 661   },
 662
 663   dist_upload => {
 664     req => {
 665       'CPAN::Uploader' => '0.103001',
 666     },
 667   },
 668
 669 };
 670
 671
 672
 673 ### Public API
 674
 675 # OO for (mistakenly considered) ease of extensibility, not due to any need to
 676 # carry state of any sort. This API is currently used outside, so leave as-is.
 677 # FIXME - make sure to not propagate this further if module is extracted as a
 678 # standalone library - keep the stupidity to a DBIC-secific shim!
 679 #
 680 sub req_list_for {
 681   shift->_groups_to_reqs(@_)->{effective_modreqs};
 682 }
 683
 684 sub modreq_list_for {
 685   shift->_groups_to_reqs(@_)->{modreqs};
 686 }
 687
 688 sub req_group_list {
 689   +{ map
 690     { $_ => $_[0]->_groups_to_reqs($_) }
 691     keys %$dbic_reqs
 692   }
 693 }
 694
 695 sub req_errorlist_for { shift->modreq_errorlist_for(@_) }  # deprecated
 696 sub modreq_errorlist_for {
 697   my $self = shift;
 698   $self->_errorlist_for_modreqs( $self->_groups_to_reqs(@_)->{modreqs} );
 699 }
 700
 701 sub req_ok_for {
 702   shift->req_missing_for(@_) ? 0 : 1;
 703 }
 704
 705 sub req_missing_for {
 706   my $self = shift;
 707
 708   my $reqs = $self->_groups_to_reqs(@_);
 709   my $mods_missing = $self->modreq_missing_for(@_);
 710
 711   return '' if
 712     ! $mods_missing
 713       and
 714     ! $reqs->{missing_envvars}
 715   ;
 716
 717   my @res = $mods_missing || ();
 718
 719   push @res, 'the following group(s) of environment variables: ' . join ' and ', map
 720     { __envvar_group_desc($_) }
 721     @{$reqs->{missing_envvars}}
 722   if $reqs->{missing_envvars};
 723
 724   return (
 725     ( join ' as well as ', @res )
 726       .
 727     ( $reqs->{modreqs_fully_documented} ? " (see @{[ ref $self || $self ]} documentation for details)" : '' ),
 728   );
 729 }
 730
 731 sub modreq_missing_for {
 732   my $self = shift;
 733
 734   my $reqs = $self->_groups_to_reqs(@_);
 735   my $modreq_errors = $self->_errorlist_for_modreqs($reqs->{modreqs})
 736     or return '';
 737
 738   join ' ', map
 739     { $reqs->{modreqs}{$_} ? qq("$_~>=$reqs->{modreqs}{$_}") : $_ }
 740     sort { lc($a) cmp lc($b) } keys %$modreq_errors
 741   ;
 742 }
 743
 744 sub die_unless_req_ok_for {
 745   if (my $err = shift->req_missing_for(@_) ) {
 746     die "Unable to continue due to missing requirements: $err\n";
 747   }
 748 }
 749
 750
 751
 752 ### Private functions
 753
 754 # potentially shorten group desc
 755 sub __envvar_group_desc {
 756   my @envs = @{$_[0]};
 757
 758   my (@res, $last_prefix);
 759   while (my $ev = shift @envs) {
 760     my ($pref, $sep, $suff) = split / ([\_\-]) (?= [^\_\-]+ \z )/x, $ev;
 761
 762     if ( defined $sep and ($last_prefix||'') eq $pref ) {
 763         push @res, "...${sep}${suff}"
 764     }
 765     else {
 766       push @res, $ev;
 767     }
 768
 769     $last_prefix = $pref if $sep;
 770   }
 771
 772   join '/', @res;
 773 }
 774
 775
 776
 777 ### Private OO API
 778 our %req_unavailability_cache;
 779
 780 # this method is just a lister and envvar/metadata checker - it does not try to load anything
 781 sub _groups_to_reqs {
 782   my ($self, $groups) = @_;
 783
 784   $groups = [ $groups || () ]
 785     unless ref $groups eq 'ARRAY';
 786
 787   croak "@{[ (caller(1))[3] ]}() expects a requirement group name or arrayref of group names"
 788     unless @$groups;
 789
 790   my $ret = {
 791     modreqs => {},
 792     modreqs_fully_documented => 1,
 793   };
 794
 795   for my $group ( @$groups ) {
 796
 797     $group =~ /\A [A-Za-z][0-9A-Z_a-z]* \z/x
 798       or croak "Invalid requirement group name '$group': only ascii alphanumerics and _ are allowed";
 799
 800     my $group_reqs = ($dbic_reqs->{$group}||{})->{req}
 801       or croak "Requirement group '$group' is not defined";
 802
 803     # sanity-check
 804     for (keys %$group_reqs) {
 805
 806       $_ =~ /\A [A-Z_a-z][0-9A-Z_a-z]* (?:::[0-9A-Z_a-z]+)* \z /x
 807         or croak "Requirement '$_' in group '$group' is not a valid module name";
 808
 809       # !!!DO NOT CHANGE!!!
 810       # remember - version.pm may not be available on the system
 811       croak "Requirement '$_' in group '$group' specifies an invalid version '$group_reqs->{$_}' (only plain non-underscored floating point decimals are supported)"
 812         if ( ($group_reqs->{$_}||0) !~ / \A [0-9]+ (?: \. [0-9]+ )? \z /x );
 813     }
 814
 815     # check if we have all required envvars if such names are defined
 816     my ($some_envs_required, $some_envs_missing);
 817     if (my @e = @{$dbic_reqs->{$group}{env} || [] }) {
 818
 819       croak "Unexpected 'env' attribute under group '$group' (only allowed in test_* groups)"
 820         unless $group =~ /^test_/;
 821
 822       croak "Unexpected *odd* list in 'env' under group '$group'"
 823         if @e % 2;
 824
 825       my @group_envnames_list;
 826
 827       # deconstruct the whole thing
 828       while (@e) {
 829         push @group_envnames_list, my $envname = shift @e;
 830
 831         # env required or not
 832         next unless shift @e;
 833
 834         $some_envs_required ||= 1;
 835
 836         $some_envs_missing ||= (
 837           ! defined $ENV{$envname}
 838             or
 839           ! length $ENV{$envname}
 840         );
 841       }
 842
 843       croak "None of the envvars in group '$group' declared as required, making the requirement moot"
 844         unless $some_envs_required;
 845
 846       push @{$ret->{missing_envvars}}, \@group_envnames_list if $some_envs_missing;
 847     }
 848
 849     # assemble into the final ret
 850     for my $type (
 851       'modreqs',
 852       $some_envs_missing ? () : 'effective_modreqs'
 853     ) {
 854       for my $mod (keys %$group_reqs) {
 855
 856         $ret->{$type}{$mod} = $group_reqs->{$mod}||0 if (
 857
 858           ! exists $ret->{$type}{$mod}
 859             or
 860           # we sanitized the version to be numeric above - we can just -gt it
 861           ($group_reqs->{$mod}||0) > $ret->{$type}{$mod}
 862
 863         );
 864       }
 865     }
 866
 867     $ret->{modreqs_fully_documented} &&= !!$dbic_reqs->{$group}{pod};
 868   }
 869
 870   return $ret;
 871 }
 872
 873
 874 # this method tries to load specified modreqs and returns a hashref of
 875 # module/loaderror pairs for anything that failed
 876 sub _errorlist_for_modreqs {
 877   # args supposedly already went through _groups_to_reqs and are therefore sanitized
 878   # safe to eval at will
 879   my ($self, $reqs) = @_;
 880
 881   my $ret;
 882
 883   for my $m ( keys %$reqs ) {
 884     my $v = $reqs->{$m};
 885
 886     if (! exists $req_unavailability_cache{$m}{$v} ) {
 887       local $@;
 888       eval( "require $m;" . ( $v ? "$m->VERSION(q($v))" : '' ) );
 889       $req_unavailability_cache{$m}{$v} = $@;
 890     }
 891
 892     $ret->{$m} = $req_unavailability_cache{$m}{$v}
 893       if $req_unavailability_cache{$m}{$v};
 894   }
 895
 896   $ret;
 897 }
 898
 899
 900 # This is to be called by the author only (automatically in Makefile.PL)
 901 sub _gen_pod {
 902   my ($class, $distver, $pod_dir) = @_;
 903
 904   die "No POD root dir supplied" unless $pod_dir;
 905
 906   $distver ||=
 907     eval { require DBIx::Class; DBIx::Class->VERSION; }
 908       ||
 909     die
 910 "\n\n---------------------------------------------------------------------\n" .
 911 'Unable to load core DBIx::Class module to determine current version, '.
 912 'possibly due to missing dependencies. Author-mode autodocumentation ' .
 913 "halted\n\n" . $@ .
 914 "\n\n---------------------------------------------------------------------\n"
 915   ;
 916
 917   # do not ask for a recent version, use 1.x API calls
 918   # this *may* execute on a smoker with old perl or whatnot
 919   require File::Path;
 920
 921   (my $modfn = __PACKAGE__ . '.pm') =~ s|::|/|g;
 922
 923   (my $podfn = "$pod_dir/$modfn") =~ s/\.pm$/\.pod/;
 924   (my $dir = $podfn) =~ s|/[^/]+$||;
 925
 926   File::Path::mkpath([$dir]);
 927
 928   my $sqltver = $class->req_list_for('deploy')->{'SQL::Translator'}
 929     or die "Hrmm? No sqlt dep?";
 930
 931
 932   my @chunks;
 933
 934 #@@
 935 #@@ HEADER
 936 #@@
 937   push @chunks, <<"EOC";
 938 #########################################################################
 939 #####################  A U T O G E N E R A T E D ########################
 940 #########################################################################
 941 #
 942 # The contents of this POD file are auto-generated.  Any changes you make
 943 # will be lost. If you need to change the generated text edit _gen_pod()
 944 # at the end of $modfn
 945 #
 946
 947 =head1 NAME
 948
 949 $class - Optional module dependency specifications (for module authors)
 950 EOC
 951
 952
 953 #@@
 954 #@@ SYNOPSIS HEADING
 955 #@@
 956   push @chunks, <<"EOC";
 957 =head1 SYNOPSIS
 958
 959 Somewhere in your build-file (e.g. L<ExtUtils::MakeMaker>'s F<Makefile.PL>):
 960
 961   ...
 962
 963   \$EUMM_ARGS{CONFIGURE_REQUIRES} = {
 964     \%{ \$EUMM_ARGS{CONFIGURE_REQUIRES} || {} },
 965     'DBIx::Class' => '$distver',
 966   };
 967
 968   ...
 969
 970   my %DBIC_DEPLOY_DEPS = %{ eval {
 971     require $class;
 972     $class->req_list_for('deploy');
 973   } || {} };
 974
 975   \$EUMM_ARGS{PREREQ_PM} = {
 976     \%DBIC_DEPLOY_DEPS,
 977     \%{ \$EUMM_ARGS{PREREQ_PM} || {} },
 978   };
 979
 980   ...
 981
 982   ExtUtils::MakeMaker::WriteMakefile(\%EUMM_ARGS);
 983
 984 B<Note>: The C<eval> protection within the example is due to support for
 985 requirements during L<the C<configure> build phase|CPAN::Meta::Spec/Phases>
 986 not being available on a sufficient portion of production installations of
 987 Perl. Robust support for such dependency requirements is available in the
 988 L<CPAN> installer only since version C<1.94_56> first made available for
 989 production with perl version C<5.12>. It is the belief of the current
 990 maintainer that support for requirements during the C<configure> build phase
 991 will not be sufficiently ubiquitous until the B<year 2020> at the earliest,
 992 hence the extra care demonstrated above. It should also be noted that some
 993 3rd party installers (e.g. L<cpanminus|App::cpanminus>) do the right thing
 994 with configure requirements independent from the versions of perl and CPAN
 995 available.
 996 EOC
 997
 998
 999 #@@
1000 #@@ DESCRIPTION HEADING
1001 #@@
1002   push @chunks, <<'EOC';
1003 =head1 DESCRIPTION
1004
1005 Some of the less-frequently used features of L<DBIx::Class> have external
1006 module dependencies on their own. In order not to burden the average user
1007 with modules they will never use, these optional dependencies are not included
1008 in the base Makefile.PL. Instead an exception with a descriptive message is
1009 thrown when a specific feature can't find one or several modules required for
1010 its operation. This module is the central holding place for the current list
1011 of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
1012 authors alike.
1013
1014 Dependencies are organized in L<groups|/CURRENT REQUIREMENT GROUPS> where each
1015 group can list one or more required modules, with an optional minimum version
1016 (or 0 for any version). In addition groups prefixed with C<test_> can specify
1017 a set of environment variables, some (or all) of which are marked as required
1018 for the group to be considered by L</req_list_for>
1019
1020 Each group name (or a combination thereof) can be used in the
1021 L<public methods|/METHODS> as described below.
1022 EOC
1023
1024
1025 #@@
1026 #@@ REQUIREMENT GROUPLIST HEADING
1027 #@@
1028   push @chunks, '=head1 CURRENT REQUIREMENT GROUPS';
1029
1030   for my $group (sort keys %$dbic_reqs) {
1031     my $p = $dbic_reqs->{$group}{pod}
1032       or next;
1033
1034     my $modlist = $dbic_reqs->{$group}{req}
1035       or next;
1036
1037     next unless keys %$modlist;
1038
1039     push @chunks, (
1040       "=head2 $p->{title}",
1041       "$p->{desc}",
1042       '=over',
1043       ( map { "=item * $_" . ($modlist->{$_} ? " >= $modlist->{$_}" : '') } (sort keys %$modlist) ),
1044       '=back',
1045       "Requirement group: B<$group>",
1046     );
1047   }
1048
1049
1050 #@@
1051 #@@ API DOCUMENTATION HEADING
1052 #@@
1053   push @chunks, <<'EOC';
1054
1055 =head1 METHODS
1056
1057 =head2 req_group_list
1058
1059 =over
1060
1061 =item Arguments: none
1062
1063 =item Return Value: \%list_of_requirement_groups
1064
1065 =back
1066
1067 This method should be used by DBIx::Class packagers, to get a hashref of all
1068 dependencies B<keyed> by dependency group. Each key (group name), or a combination
1069 thereof (as an arrayref) can be supplied to the methods below.
1070 The B<values> of the returned hash are currently a set of options B<without a
1071 well defined structure>. If you have use for any of the contents - contact the
1072 maintainers, instead of treating this as public (left alone stable) API.
1073
1074 =head2 req_list_for
1075
1076 =over
1077
1078 =item Arguments: $group_name | \@group_names
1079
1080 =item Return Value: \%set_of_module_version_pairs
1081
1082 =back
1083
1084 This method should be used by DBIx::Class extension authors, to determine the
1085 version of modules a specific set of features requires for this version of
1086 DBIx::Class (regardless of their availability on the system).
1087 See the L</SYNOPSIS> for a real-world example.
1088
1089 When handling C<test_*> groups this method behaves B<differently> from
1090 L</modreq_list_for> below (and is the only such inconsistency among the
1091 C<req_*> methods). If a particular group declares as requirements some
1092 C<environment variables> and these requirements are not satisfied (the envvars
1093 are unset) - then the C<module requirements> of this group are not included in
1094 the returned list.
1095
1096 =head2 modreq_list_for
1097
1098 =over
1099
1100 =item Arguments: $group_name | \@group_names
1101
1102 =item Return Value: \%set_of_module_version_pairs
1103
1104 =back
1105
1106 Same as L</req_list_for> but does not take into consideration any
1107 C<environment variable requirements> - returns just the list of required
1108 modules.
1109
1110 =head2 req_ok_for
1111
1112 =over
1113
1114 =item Arguments: $group_name | \@group_names
1115
1116 =item Return Value: 1|0
1117
1118 =back
1119
1120 Returns true or false depending on whether all modules/envvars required by
1121 the group(s) are loadable/set on the system.
1122
1123 =head2 req_missing_for
1124
1125 =over
1126
1127 =item Arguments: $group_name | \@group_names
1128
1129 =item Return Value: $error_message_string
1130
1131 =back
1132
1133 Returns a single-line string suitable for inclusion in larger error messages.
1134 This method would normally be used by DBIx::Class core features, to indicate to
1135 the user that they need to install specific modules and/or set specific
1136 environment variables before being able to use a specific feature set.
1137
1138 For example if some of the requirements for C<deploy> are not available,
1139 the returned string could look like:
1140 EOC
1141
1142   push @chunks, qq{ "SQL::Translator~>=$sqltver" (see $class documentation for details)};
1143
1144   push @chunks, <<'EOC';
1145 The author is expected to prepend the necessary text to this message before
1146 returning the actual error seen by the user. See also L</modreq_missing_for>
1147
1148 =head2 modreq_missing_for
1149
1150 =over
1151
1152 =item Arguments: $group_name | \@group_names
1153
1154 =item Return Value: $error_message_string
1155
1156 =back
1157
1158 Same as L</req_missing_for> except that the error string is guaranteed to be
1159 either empty, or contain a set of module requirement specifications suitable
1160 for piping to e.g. L<cpanminus|App::cpanminus>. The method explicitly does not
1161 attempt to validate the state of required environment variables (if any).
1162
1163 For instance if some of the requirements for C<deploy> are not available,
1164 the returned string could look like:
1165 EOC
1166
1167   push @chunks, qq{ "SQL::Translator~>=$sqltver"};
1168
1169   push @chunks, <<'EOC';
1170 =head2 die_unless_req_ok_for
1171
1172 =over
1173
1174 =item Arguments: $group_name | \@group_names
1175
1176 =back
1177
1178 Checks if L</req_ok_for> passes for the supplied group(s), and
1179 in case of failure throws an exception including the information
1180 from L</req_missing_for>.
1181
1182 =head2 modreq_errorlist_for
1183
1184 =over
1185
1186 =item Arguments: $group_name | \@group_names
1187
1188 =item Return Value: \%set_of_loaderrors_per_module
1189
1190 =back
1191
1192 Returns a hashref containing the actual errors that occurred while attempting
1193 to load each module in the requirement group(s).
1194
1195 =head2 req_errorlist_for
1196
1197 Deprecated method name, equivalent (via proxy) to L</modreq_errorlist_for>.
1198
1199 EOC
1200
1201 #@@
1202 #@@ FOOTER
1203 #@@
1204   push @chunks, <<'EOC';
1205 =head1 FURTHER QUESTIONS?
1206
1207 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1208
1209 =head1 COPYRIGHT AND LICENSE
1210
1211 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1212 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1213 redistribute it and/or modify it under the same terms as the
1214 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1215 EOC
1216
1217   eval {
1218     open (my $fh, '>', $podfn) or die;
1219     print $fh join ("\n\n", @chunks) or die;
1220     print $fh "\n" or die;
1221     close ($fh) or die;
1222   } or croak( "Unable to write $podfn: " . ( $! || $@ || 'unknown error') );
1223 }
1224
1225 1;