[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Optional / Dependencies.pm

package DBIx::Class::Optional::Dependencies;

use warnings;
use strict;

use Carp ();

# NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
# This module is to be loaded by Makefile.PM on a pristine system

# POD is generated automatically by calling _gen_pod from the
# Makefile.PL in $AUTHOR mode

my $json_any = {
  'JSON::Any'                     => '1.22',
};

my $moose_basic = {
  'Moose'                         => '0.98',
  'MooseX::Types'                 => '0.21',
};

my $replicated = {
  %$moose_basic,
};

my $admin_basic = {
  %$moose_basic,
  %$json_any,
  'MooseX::Types::Path::Class'    => '0.05',
  'MooseX::Types::JSON'           => '0.02',
  'namespace::autoclean'          => '0.09',
};

my $datetime_basic = {
  'DateTime'                      => '0.55',
  'DateTime::Format::Strptime'    => '1.2',
};

my $id_shortener = {
  'Math::BigInt'                  => '1.89',
  'Math::Base36'                  => '0.07',
};

my $rdbms_sqlite = {
  'DBD::SQLite'                   => '0',
};
my $rdbms_pg = {
  'DBD::Pg'                       => '0',
};
my $rdbms_mssql_odbc = {
  'DBD::ODBC'                     => '0',
};
my $rdbms_mssql_sybase = {
  'DBD::Sybase'                   => '0',
};
my $rdbms_mssql_ado = {
  'DBD::ADO'                      => '0',
};
my $rdbms_msaccess_odbc = {
  'DBD::ODBC'                     => '0',
};
my $rdbms_msaccess_ado = {
  'DBD::ADO'                      => '0',
};
my $rdbms_mysql = {
  'DBD::mysql'                    => '0',
};
my $rdbms_oracle = {
  'DBD::Oracle'                   => '0',
  %$id_shortener,
};
my $rdbms_ase = {
  'DBD::Sybase'                   => '0',
};
my $rdbms_db2 = {
  'DBD::DB2'                      => '0',
};
my $rdbms_firebird_odbc = {
  'DBD::ODBC'                     => '0',
};

my $reqs = {
  dist => {
    #'Module::Install::Pod::Inherit' => '0.01',
  },

  replicated => {
    req => $replicated,
    pod => {
      title => 'Storage::Replicated',
      desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
    },
  },

  test_replicated => {
    req => {
      %$replicated,
      'Test::Moose'               => '0',
    },
  },


  admin => {
    req => {
      %$admin_basic,
    },
    pod => {
      title => 'DBIx::Class::Admin',
      desc => 'Modules required for the DBIx::Class administrative library',
    },
  },

  admin_script => {
    req => {
      %$moose_basic,
      %$admin_basic,
      'Getopt::Long::Descriptive' => '0.081',
      'Text::CSV'                 => '1.16',
    },
    pod => {
      title => 'dbicadmin',
      desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
    },
  },

  deploy => {
    req => {
      'SQL::Translator'           => '0.11006',
    },
    pod => {
      title => 'Storage::DBI::deploy()',
      desc => 'Modules required for L<DBIx::Class::Storage::DBI/deploy> and L<DBIx::Class::Storage::DBI/deployment_statements>',
    },
  },

  id_shortener => {
    req => $id_shortener,
  },

  test_component_accessor => {
    req => {
      'Class::Unload'             => '0.07',
    },
  },

  test_pod => {
    req => {
      'Test::Pod'                 => '1.41',
    },
  },

  test_podcoverage => {
    req => {
      'Test::Pod::Coverage'       => '1.08',
      'Pod::Coverage'             => '0.20',
    },
  },

  test_notabs => {
    req => {
      'Test::NoTabs'              => '0.9',
    },
  },

  test_eol => {
    req => {
      'Test::EOL'                 => '0.6',
    },
  },

  test_prettydebug => {
    req => $json_any,
  },

  test_leaks => {
    req => {
      'Test::Memory::Cycle'       => '0',
      'Devel::Cycle'              => '1.10',
    },
  },

  test_dt => {
    req => $datetime_basic,
  },

  test_dt_sqlite => {
    req => {
      %$datetime_basic,
      # t/36datetime.t
      # t/60core.t
      'DateTime::Format::SQLite'  => '0',
    },
  },

  test_dt_mysql => {
    req => {
      %$datetime_basic,
      # t/inflate/datetime_mysql.t
      # (doesn't need Mysql itself)
      'DateTime::Format::MySQL'   => '0',
    },
  },

  test_dt_pg => {
    req => {
      %$datetime_basic,
      # t/inflate/datetime_pg.t
      # (doesn't need PG itself)
      'DateTime::Format::Pg'      => '0.16004',
    },
  },

  test_cdbicompat => {
    req => {
      'DBIx::ContextualFetch'     => '0',
      'Class::DBI::Plugin::DeepAbstractSearch' => '0',
      'Class::Trigger'            => '0',
      'Time::Piece::MySQL'        => '0',
      'Clone'                     => '0',
      'Date::Simple'              => '3.03',
    },
  },

  # this is just for completeness as SQLite
  # is a core dep of DBIC for testing
  rdbms_sqlite => {
    req => {
      %$rdbms_sqlite,
    },
    pod => {
      title => 'SQLite support',
      desc => 'Modules required to connect to SQLite',
    },
  },

  rdbms_pg => {
    req => {
      %$rdbms_pg,
    },
    pod => {
      title => 'PostgreSQL support',
      desc => 'Modules required to connect to PostgreSQL',
    },
  },

  rdbms_mssql_odbc => {
    req => {
      %$rdbms_mssql_odbc,
    },
    pod => {
      title => 'MSSQL support via DBD::ODBC',
      desc => 'Modules required to connect to MSSQL via DBD::ODBC',
    },
  },

  rdbms_mssql_sybase => {
    req => {
      %$rdbms_mssql_sybase,
    },
    pod => {
      title => 'MSSQL support via DBD::Sybase',
      desc => 'Modules required to connect to MSSQL via DBD::Sybase',
    },
  },

  rdbms_mssql_ado => {
    req => {
      %$rdbms_mssql_ado,
    },
    pod => {
      title => 'MSSQL support via DBD::ADO (Windows only)',
      desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
    },
  },

  rdbms_msaccess_odbc => {
    req => {
      %$rdbms_msaccess_odbc,
    },
    pod => {
      title => 'MS Access support via DBD::ODBC',
      desc => 'Modules required to connect to MS Access via DBD::ODBC',
    },
  },

  rdbms_msaccess_ado => {
    req => {
      %$rdbms_msaccess_ado,
    },
    pod => {
      title => 'MS Access support via DBD::ADO (Windows only)',
      desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
    },
  },

  rdbms_mysql => {
    req => {
      %$rdbms_mysql,
    },
    pod => {
      title => 'MySQL support',
      desc => 'Modules required to connect to MySQL',
    },
  },

  rdbms_oracle => {
    req => {
      %$rdbms_oracle,
    },
    pod => {
      title => 'Oracle support',
      desc => 'Modules required to connect to Oracle',
    },
  },

  rdbms_ase => {
    req => {
      %$rdbms_ase,
    },
    pod => {
      title => 'Sybase ASE support',
      desc => 'Modules required to connect to Sybase ASE',
    },
  },

  rdbms_db2 => {
    req => {
      %$rdbms_db2,
    },
    pod => {
      title => 'DB2 support',
      desc => 'Modules required to connect to DB2',
    },
  },

# the order does matter because the rdbms support group might require
# a different version that the test group
  test_rdbms_pg => {
    req => {
      $ENV{DBICTEST_PG_DSN}
        ? (
          %$rdbms_pg,
          'Sys::SigAction'        => '0',
          'DBD::Pg'               => '2.009002',
        ) : ()
    },
  },

  test_rdbms_mssql_odbc => {
    req => {
      $ENV{DBICTEST_MSSQL_ODBC_DSN}
        ? (
          %$rdbms_mssql_odbc,
        ) : ()
    },
  },

  test_rdbms_mssql_ado => {
    req => {
      $ENV{DBICTEST_MSSQL_ADO_DSN}
        ? (
          %$rdbms_mssql_ado,
        ) : ()
    },
  },

  test_rdbms_mssql_sybase => {
    req => {
      $ENV{DBICTEST_MSSQL_DSN}
        ? (
          %$rdbms_mssql_sybase,
        ) : ()
    },
  },

  test_rdbms_msaccess_odbc => {
    req => {
      $ENV{DBICTEST_MSACCESS_ODBC_DSN}
        ? (
          %$rdbms_msaccess_odbc,
          %$datetime_basic,
          'Data::GUID' => '0',
        ) : ()
    },
  },

  test_rdbms_msaccess_ado => {
    req => {
      $ENV{DBICTEST_MSACCESS_ADO_DSN}
        ? (
          %$rdbms_msaccess_ado,
          %$datetime_basic,
          'Data::GUID' => 0,
        ) : ()
    },
  },

  test_rdbms_mysql => {
    req => {
      $ENV{DBICTEST_MYSQL_DSN}
        ? (
          %$rdbms_mysql,
        ) : ()
    },
  },

  test_rdbms_oracle => {
    req => {
      $ENV{DBICTEST_ORA_DSN}
        ? (
          %$rdbms_oracle,
          'DateTime::Format::Oracle' => '0',
          'DBD::Oracle'              => '1.24',
        ) : ()
    },
  },

  test_rdbms_ase => {
    req => {
      $ENV{DBICTEST_SYBASE_DSN}
        ? (
          %$rdbms_ase,
          'DateTime::Format::Sybase' => '0',
        ) : ()
    },
  },

  test_rdbms_db2 => {
    req => {
      $ENV{DBICTEST_DB2_DSN}
        ? (
          %$rdbms_db2,
        ) : ()
    },
  },

  test_rdbms_firebird_odbc => {
    req => {
      $ENV{DBICTEST_FIREBIRD_ODBC_DSN}
        ? (
          %$rdbms_firebird_odbc,
        ) : ()
    },
  },

  test_memcached => {
    req => {
      $ENV{DBICTEST_MEMCACHED}
        ? (
          'Cache::Memcached' => 0,
        ) : ()
    },
  },

};


sub req_list_for {
  my ($class, $group) = @_;

  Carp::croak "req_list_for() expects a requirement group name"
    unless $group;

  my $deps = $reqs->{$group}{req}
    or Carp::croak "Requirement group '$group' does not exist";

  return { %$deps };
}


our %req_availability_cache;
sub req_ok_for {
  my ($class, $group) = @_;

  Carp::croak "req_ok_for() expects a requirement group name"
    unless $group;

  return $class->_check_deps($group)->{status};
}

sub req_missing_for {
  my ($class, $group) = @_;

  Carp::croak "req_missing_for() expects a requirement group name"
    unless $group;

  return $class->_check_deps($group)->{missing};
}

sub req_errorlist_for {
  my ($class, $group) = @_;

  Carp::croak "req_errorlist_for() expects a requirement group name"
    unless $group;

  return $class->_check_deps($group)->{errorlist};
}

sub _check_deps {
  my ($class, $group) = @_;

  return $req_availability_cache{$group} ||= do {

    my $deps = $class->req_list_for ($group);

    my %errors;
    for my $mod (keys %$deps) {
      my $req_line = "require $mod;";
      if (my $ver = $deps->{$mod}) {
        $req_line .= "$mod->VERSION($ver);";
      }

      eval $req_line;

      $errors{$mod} = $@ if $@;
    }

    my $res;

    if (keys %errors) {
      my $missing = join (', ', map { $deps->{$_} ? "$_ >= $deps->{$_}" : $_ } (sort keys %errors) );
      $missing .= " (see $class for details)" if $reqs->{$group}{pod};
      $missing .= "\n";
      $res = {
        status => 0,
        errorlist => \%errors,
        missing => $missing,
      };
    }
    else {
      $res = {
        status => 1,
        errorlist => {},
        missing => '',
      };
    }

    $res;
  };
}

sub req_group_list {
  return { map { $_ => { %{ $reqs->{$_}{req} || {} } } } (keys %$reqs) };
}

# This is to be called by the author only (automatically in Makefile.PL)
sub _gen_pod {
  my ($class, $distver) = @_;

  my $modfn = __PACKAGE__ . '.pm';
  $modfn =~ s/\:\:/\//g;

  my $podfn = __FILE__;
  $podfn =~ s/\.pm$/\.pod/;

  $distver ||=
    eval { require DBIx::Class; DBIx::Class->VERSION; }
      ||
    die
"\n\n---------------------------------------------------------------------\n" .
'Unable to load core DBIx::Class module to determine current version, '.
'possibly due to missing dependencies. Author-mode autodocumentation ' .
"halted\n\n" . $@ .
"\n\n---------------------------------------------------------------------\n"
  ;

  my $sqltver = $class->req_list_for ('deploy')->{'SQL::Translator'}
    or die "Hrmm? No sqlt dep?";

  my @chunks = (
    <<'EOC',
#########################################################################
#####################  A U T O G E N E R A T E D ########################
#########################################################################
#
# The contents of this POD file are auto-generated.  Any changes you make
# will be lost. If you need to change the generated text edit _gen_pod()
# at the end of $modfn
#
EOC
    '=head1 NAME',
    "$class - Optional module dependency specifications (for module authors)",
    '=head1 SYNOPSIS',
    <<"EOS",
Somewhere in your build-file (e.g. L<Module::Install>'s Makefile.PL):

  ...

  configure_requires 'DBIx::Class' => '$distver';

  require $class;

  my \$deploy_deps = $class->req_list_for('deploy');

  for (keys %\$deploy_deps) {
    requires \$_ => \$deploy_deps->{\$_};
  }

  ...

Note that there are some caveats regarding C<configure_requires()>, more info
can be found at L<Module::Install/configure_requires>
EOS
    '=head1 DESCRIPTION',
    <<'EOD',
Some of the less-frequently used features of L<DBIx::Class> have external
module dependencies on their own. In order not to burden the average user
with modules he will never use, these optional dependencies are not included
in the base Makefile.PL. Instead an exception with a descriptive message is
thrown when a specific feature is missing one or several modules required for
its operation. This module is the central holding place for  the current list
of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
authors alike.
EOD
    '=head1 CURRENT REQUIREMENT GROUPS',
    <<'EOD',
Dependencies are organized in C<groups> and each group can list one or more
required modules, with an optional minimum version (or 0 for any version).
The group name can be used in the
EOD
  );

  for my $group (sort keys %$reqs) {
    my $p = $reqs->{$group}{pod}
      or next;

    my $modlist = $reqs->{$group}{req}
      or next;

    next unless keys %$modlist;

    push @chunks, (
      "=head2 $p->{title}",
      "$p->{desc}",
      '=over',
      ( map { "=item * $_" . ($modlist->{$_} ? " >= $modlist->{$_}" : '') } (sort keys %$modlist) ),
      '=back',
      "Requirement group: B<$group>",
    );
  }

  push @chunks, (
    '=head1 METHODS',
    '=head2 req_group_list',
    '=over',
    '=item Arguments: none',
    '=item Returns: \%list_of_requirement_groups',
    '=back',
    <<'EOD',
This method should be used by DBIx::Class packagers, to get a hashref of all
dependencies keyed by dependency group. Each key (group name) can be supplied
to one of the group-specific methods below.
EOD

    '=head2 req_list_for',
    '=over',
    '=item Arguments: $group_name',
    '=item Returns: \%list_of_module_version_pairs',
    '=back',
    <<'EOD',
This method should be used by DBIx::Class extension authors, to determine the
version of modules a specific feature requires in the B<current> version of
DBIx::Class. See the L</SYNOPSIS> for a real-world
example.
EOD

    '=head2 req_ok_for',
    '=over',
    '=item Arguments: $group_name',
    '=item Returns: 1|0',
    '=back',
    <<'EOD',
Returns true or false depending on whether all modules required by
C<$group_name> are present on the system and loadable.
EOD

    '=head2 req_missing_for',
    '=over',
    '=item Arguments: $group_name',
    '=item Returns: $error_message_string',
    '=back',
    <<"EOD",
Returns a single line string suitable for inclusion in larger error messages.
This method would normally be used by DBIx::Class core-module author, to
indicate to the user that he needs to install specific modules before he will
be able to use a specific feature.

For example if some of the requirements for C<deploy> are not available,
the returned string could look like:

 SQL::Translator >= $sqltver (see $class for details)

The author is expected to prepend the necessary text to this message before
returning the actual error seen by the user.
EOD

    '=head2 req_errorlist_for',
    '=over',
    '=item Arguments: $group_name',
    '=item Returns: \%list_of_loaderrors_per_module',
    '=back',
    <<'EOD',
Returns a hashref containing the actual errors that occured while attempting
to load each module in the requirement group.
EOD
    '=head1 AUTHOR',
    'See L<DBIx::Class/CONTRIBUTORS>.',
    '=head1 LICENSE',
    'You may distribute this code under the same terms as Perl itself',
  );

  open (my $fh, '>', $podfn) or Carp::croak "Unable to write to $podfn: $!";
  print $fh join ("\n\n", @chunks);
  close ($fh);
}

1;
Commit	Line	Data
8057ed01	1	package DBIx::Class::Optional::Dependencies;
	2
	3	use warnings;
	4	use strict;
	5
9c1700e3	6	use Carp ();
fb39747c	7
fb39747c	8	# NO EXTERNAL NON-5.8.1 CORE DEPENDENCIES EVER (e.g. C::A::G)
8057ed01	9	# This module is to be loaded by Makefile.PM on a pristine system
8057ed01	10
f6b26571	11	# POD is generated automatically by calling _gen_pod from the
	12	# Makefile.PL in $AUTHOR mode
	13
2a2a7b23	14	my $json_any = {
	15	'JSON::Any' => '1.22',
	16	};
	17
2b48ebff	18	my $moose_basic = {
68de9438	19	'Moose' => '0.98',
	20	'MooseX::Types' => '0.21',
	21	};
	22
	23	my $replicated = {
	24	%$moose_basic,
2b48ebff	25	};
2b48ebff	26
ebcd0e4f	27	my $admin_basic = {
ebcd0e4f	28	%$moose_basic,
2a2a7b23	29	%$json_any,
68de9438	30	'MooseX::Types::Path::Class' => '0.05',
68de9438	31	'MooseX::Types::JSON' => '0.02',
68de9438	32	'namespace::autoclean' => '0.09',
	33	};
	34
	35	my $datetime_basic = {
	36	'DateTime' => '0.55',
	37	'DateTime::Format::Strptime' => '1.2',
ebcd0e4f	38	};
ebcd0e4f	39
c7d50a7d	40	my $id_shortener = {
	41	'Math::BigInt' => '1.89',
	42	'Math::Base36' => '0.07',
	43	};
	44
be68095d	45	my $rdbms_sqlite = {
	46	'DBD::SQLite' => '0',
	47	};
	48	my $rdbms_pg = {
	49	'DBD::Pg' => '0',
	50	};
	51	my $rdbms_mssql_odbc = {
	52	'DBD::ODBC' => '0',
	53	};
	54	my $rdbms_mssql_sybase = {
	55	'DBD::Sybase' => '0',
	56	};
56dca25f	57	my $rdbms_mssql_ado = {
	58	'DBD::ADO' => '0',
	59	};
726c8f65	60	my $rdbms_msaccess_odbc = {
	61	'DBD::ODBC' => '0',
	62	};
	63	my $rdbms_msaccess_ado = {
	64	'DBD::ADO' => '0',
	65	};
be68095d	66	my $rdbms_mysql = {
	67	'DBD::mysql' => '0',
	68	};
	69	my $rdbms_oracle = {
	70	'DBD::Oracle' => '0',
	71	%$id_shortener,
	72	};
	73	my $rdbms_ase = {
	74	'DBD::Sybase' => '0',
	75	};
	76	my $rdbms_db2 = {
	77	'DBD::DB2' => '0',
	78	};
e02b39b4	79	my $rdbms_firebird_odbc = {
	80	'DBD::ODBC' => '0',
	81	};
be68095d	82
8057ed01	83	my $reqs = {
	84	dist => {
	85	#'Module::Install::Pod::Inherit' => '0.01',
	86	},
	87
	88	replicated => {
68de9438	89	req => $replicated,
f6b26571	90	pod => {
	91	title => 'Storage::Replicated',
	92	desc => 'Modules required for L<DBIx::Class::Storage::DBI::Replicated>',
	93	},
8057ed01	94	},
8057ed01	95
68de9438	96	test_replicated => {
	97	req => {
	98	%$replicated,
	99	'Test::Moose' => '0',
	100	},
	101	},
	102
	103
8057ed01	104	admin => {
2b48ebff	105	req => {
ebcd0e4f	106	%$admin_basic,
	107	},
	108	pod => {
	109	title => 'DBIx::Class::Admin',
	110	desc => 'Modules required for the DBIx::Class administrative library',
	111	},
	112	},
	113
a4a02f15	114	admin_script => {
ebcd0e4f	115	req => {
2b48ebff	116	%$moose_basic,
ebcd0e4f	117	%$admin_basic,
2b48ebff	118	'Getopt::Long::Descriptive' => '0.081',
2b48ebff	119	'Text::CSV' => '1.16',
2b48ebff	120	},
e144415f	121	pod => {
	122	title => 'dbicadmin',
	123	desc => 'Modules required for the CLI DBIx::Class interface dbicadmin',
	124	},
8057ed01	125	},
	126
	127	deploy => {
f6b26571	128	req => {
9e34d554	129	'SQL::Translator' => '0.11006',
f6b26571	130	},
	131	pod => {
	132	title => 'Storage::DBI::deploy()',
c7d50a7d	133	desc => 'Modules required for L<DBIx::Class::Storage::DBI/deploy> and L<DBIx::Class::Storage::DBI/deployment_statements>',
f6b26571	134	},
8057ed01	135	},
8057ed01	136
c7d50a7d	137	id_shortener => {
	138	req => $id_shortener,
	139	},
	140
0d374214	141	test_component_accessor => {
	142	req => {
	143	'Class::Unload' => '0.07',
	144	},
	145	},
	146
a109c954	147	test_pod => {
f6b26571	148	req => {
14d17d71	149	'Test::Pod' => '1.41',
a109c954	150	},
	151	},
	152
	153	test_podcoverage => {
	154	req => {
f6b26571	155	'Test::Pod::Coverage' => '1.08',
f6b26571	156	'Pod::Coverage' => '0.20',
a109c954	157	},
	158	},
	159
	160	test_notabs => {
	161	req => {
d146b340	162	'Test::NoTabs' => '0.9',
a109c954	163	},
	164	},
	165
	166	test_eol => {
	167	req => {
d146b340	168	'Test::EOL' => '0.6',
f6b26571	169	},
8057ed01	170	},
8057ed01	171
2a2a7b23	172	test_prettydebug => {
	173	req => $json_any,
	174	},
	175
226d1c35	176	test_leaks => {
f6b26571	177	req => {
f6b26571	178	'Test::Memory::Cycle' => '0',
f6b26571	179	'Devel::Cycle' => '1.10',
a109c954	180	},
a109c954	181	},
f6b26571	182
68de9438	183	test_dt => {
	184	req => $datetime_basic,
	185	},
	186
	187	test_dt_sqlite => {
a109c954	188	req => {
68de9438	189	%$datetime_basic,
f6b26571	190	# t/36datetime.t
	191	# t/60core.t
	192	'DateTime::Format::SQLite' => '0',
68de9438	193	},
68de9438	194	},
f6b26571	195
68de9438	196	test_dt_mysql => {
	197	req => {
	198	%$datetime_basic,
9c92bb1c	199	# t/inflate/datetime_mysql.t
9c92bb1c	200	# (doesn't need Mysql itself)
68de9438	201	'DateTime::Format::MySQL' => '0',
	202	},
	203	},
9c92bb1c	204
68de9438	205	test_dt_pg => {
	206	req => {
	207	%$datetime_basic,
9c92bb1c	208	# t/inflate/datetime_pg.t
9c92bb1c	209	# (doesn't need PG itself)
ab35aeab	210	'DateTime::Format::Pg' => '0.16004',
f6b26571	211	},
8057ed01	212	},
8057ed01	213
68de9438	214	test_cdbicompat => {
f6b26571	215	req => {
	216	'DBIx::ContextualFetch' => '0',
	217	'Class::DBI::Plugin::DeepAbstractSearch' => '0',
	218	'Class::Trigger' => '0',
	219	'Time::Piece::MySQL' => '0',
	220	'Clone' => '0',
	221	'Date::Simple' => '3.03',
	222	},
8057ed01	223	},
8057ed01	224
be68095d	225	# this is just for completeness as SQLite
	226	# is a core dep of DBIC for testing
	227	rdbms_sqlite => {
	228	req => {
	229	%$rdbms_sqlite,
	230	},
	231	pod => {
	232	title => 'SQLite support',
	233	desc => 'Modules required to connect to SQLite',
	234	},
	235	},
	236
	237	rdbms_pg => {
	238	req => {
	239	%$rdbms_pg,
	240	},
	241	pod => {
	242	title => 'PostgreSQL support',
	243	desc => 'Modules required to connect to PostgreSQL',
	244	},
	245	},
	246
	247	rdbms_mssql_odbc => {
	248	req => {
	249	%$rdbms_mssql_odbc,
	250	},
	251	pod => {
	252	title => 'MSSQL support via DBD::ODBC',
	253	desc => 'Modules required to connect to MSSQL via DBD::ODBC',
	254	},
	255	},
	256
	257	rdbms_mssql_sybase => {
	258	req => {
	259	%$rdbms_mssql_sybase,
	260	},
	261	pod => {
	262	title => 'MSSQL support via DBD::Sybase',
56dca25f	263	desc => 'Modules required to connect to MSSQL via DBD::Sybase',
	264	},
	265	},
	266
	267	rdbms_mssql_ado => {
	268	req => {
	269	%$rdbms_mssql_ado,
	270	},
	271	pod => {
	272	title => 'MSSQL support via DBD::ADO (Windows only)',
	273	desc => 'Modules required to connect to MSSQL via DBD::ADO. This particular DBD is available on Windows only',
be68095d	274	},
	275	},
	276
726c8f65	277	rdbms_msaccess_odbc => {
	278	req => {
	279	%$rdbms_msaccess_odbc,
	280	},
	281	pod => {
	282	title => 'MS Access support via DBD::ODBC',
	283	desc => 'Modules required to connect to MS Access via DBD::ODBC',
	284	},
	285	},
	286
	287	rdbms_msaccess_ado => {
	288	req => {
	289	%$rdbms_msaccess_ado,
	290	},
	291	pod => {
	292	title => 'MS Access support via DBD::ADO (Windows only)',
	293	desc => 'Modules required to connect to MS Access via DBD::ADO. This particular DBD is available on Windows only',
	294	},
	295	},
	296
be68095d	297	rdbms_mysql => {
	298	req => {
	299	%$rdbms_mysql,
	300	},
	301	pod => {
	302	title => 'MySQL support',
	303	desc => 'Modules required to connect to MySQL',
	304	},
	305	},
	306
	307	rdbms_oracle => {
	308	req => {
	309	%$rdbms_oracle,
	310	},
	311	pod => {
	312	title => 'Oracle support',
	313	desc => 'Modules required to connect to Oracle',
	314	},
	315	},
	316
	317	rdbms_ase => {
	318	req => {
	319	%$rdbms_ase,
	320	},
	321	pod => {
	322	title => 'Sybase ASE support',
	323	desc => 'Modules required to connect to Sybase ASE',
	324	},
	325	},
	326
	327	rdbms_db2 => {
	328	req => {
	329	%$rdbms_db2,
	330	},
	331	pod => {
	332	title => 'DB2 support',
	333	desc => 'Modules required to connect to DB2',
	334	},
	335	},
	336
	337	# the order does matter because the rdbms support group might require
	338	# a different version that the test group
68de9438	339	test_rdbms_pg => {
f6b26571	340	req => {
	341	$ENV{DBICTEST_PG_DSN}
	342	? (
be68095d	343	%$rdbms_pg,
f6b26571	344	'Sys::SigAction' => '0',
f6b26571	345	'DBD::Pg' => '2.009002',
f6b26571	346	) : ()
f6b26571	347	},
8057ed01	348	},
8057ed01	349
afae8507	350	test_rdbms_mssql_odbc => {
	351	req => {
	352	$ENV{DBICTEST_MSSQL_ODBC_DSN}
	353	? (
be68095d	354	%$rdbms_mssql_odbc,
afae8507	355	) : ()
	356	},
	357	},
	358
56dca25f	359	test_rdbms_mssql_ado => {
	360	req => {
	361	$ENV{DBICTEST_MSSQL_ADO_DSN}
	362	? (
	363	%$rdbms_mssql_ado,
	364	) : ()
	365	},
	366	},
	367
afae8507	368	test_rdbms_mssql_sybase => {
	369	req => {
	370	$ENV{DBICTEST_MSSQL_DSN}
	371	? (
be68095d	372	%$rdbms_mssql_sybase,
afae8507	373	) : ()
	374	},
	375	},
	376
726c8f65	377	test_rdbms_msaccess_odbc => {
	378	req => {
	379	$ENV{DBICTEST_MSACCESS_ODBC_DSN}
	380	? (
	381	%$rdbms_msaccess_odbc,
	382	%$datetime_basic,
	383	'Data::GUID' => '0',
	384	) : ()
	385	},
	386	},
	387
	388	test_rdbms_msaccess_ado => {
	389	req => {
	390	$ENV{DBICTEST_MSACCESS_ADO_DSN}
	391	? (
	392	%$rdbms_msaccess_ado,
	393	%$datetime_basic,
	394	'Data::GUID' => 0,
	395	) : ()
	396	},
	397	},
	398
68de9438	399	test_rdbms_mysql => {
f6b26571	400	req => {
	401	$ENV{DBICTEST_MYSQL_DSN}
	402	? (
be68095d	403	%$rdbms_mysql,
f6b26571	404	) : ()
f6b26571	405	},
8057ed01	406	},
8057ed01	407
68de9438	408	test_rdbms_oracle => {
f6b26571	409	req => {
	410	$ENV{DBICTEST_ORA_DSN}
	411	? (
be68095d	412	%$rdbms_oracle,
f6b26571	413	'DateTime::Format::Oracle' => '0',
e1b7e9b4	414	'DBD::Oracle' => '1.24',
f6b26571	415	) : ()
f6b26571	416	},
8057ed01	417	},
8057ed01	418
68de9438	419	test_rdbms_ase => {
f6b26571	420	req => {
	421	$ENV{DBICTEST_SYBASE_DSN}
	422	? (
be68095d	423	%$rdbms_ase,
be68095d	424	'DateTime::Format::Sybase' => '0',
f6b26571	425	) : ()
f6b26571	426	},
8057ed01	427	},
8057ed01	428
68de9438	429	test_rdbms_db2 => {
f58a165c	430	req => {
	431	$ENV{DBICTEST_DB2_DSN}
	432	? (
be68095d	433	%$rdbms_db2,
f58a165c	434	) : ()
	435	},
	436	},
	437
e02b39b4	438	test_rdbms_firebird_odbc => {
	439	req => {
	440	$ENV{DBICTEST_FIREBIRD_ODBC_DSN}
	441	? (
	442	%$rdbms_firebird_odbc,
	443	) : ()
	444	},
	445	},
	446
42168332	447	test_memcached => {
	448	req => {
	449	$ENV{DBICTEST_MEMCACHED}
	450	? (
	451	'Cache::Memcached' => 0,
	452	) : ()
	453	},
	454	},
	455
8057ed01	456	};
8057ed01	457
f6b26571	458
fb39747c	459	sub req_list_for {
	460	my ($class, $group) = @_;
	461
9c1700e3	462	Carp::croak "req_list_for() expects a requirement group name"
fb39747c	463	unless $group;
fb39747c	464
f6b26571	465	my $deps = $reqs->{$group}{req}
9c1700e3	466	or Carp::croak "Requirement group '$group' does not exist";
fb39747c	467
	468	return { %$deps };
	469	}
	470
	471
	472	our %req_availability_cache;
	473	sub req_ok_for {
	474	my ($class, $group) = @_;
	475
9c1700e3	476	Carp::croak "req_ok_for() expects a requirement group name"
fb39747c	477	unless $group;
fb39747c	478
d8799bab	479	return $class->_check_deps($group)->{status};
fb39747c	480	}
	481
	482	sub req_missing_for {
	483	my ($class, $group) = @_;
	484
9c1700e3	485	Carp::croak "req_missing_for() expects a requirement group name"
fb39747c	486	unless $group;
fb39747c	487
d8799bab	488	return $class->_check_deps($group)->{missing};
fb39747c	489	}
	490
	491	sub req_errorlist_for {
	492	my ($class, $group) = @_;
	493
9c1700e3	494	Carp::croak "req_errorlist_for() expects a requirement group name"
fb39747c	495	unless $group;
fb39747c	496
d8799bab	497	return $class->_check_deps($group)->{errorlist};
fb39747c	498	}
	499
	500	sub _check_deps {
	501	my ($class, $group) = @_;
	502
d8799bab	503	return $req_availability_cache{$group} \|\|= do {
	504
	505	my $deps = $class->req_list_for ($group);
	506
	507	my %errors;
	508	for my $mod (keys %$deps) {
	509	my $req_line = "require $mod;";
	510	if (my $ver = $deps->{$mod}) {
	511	$req_line .= "$mod->VERSION($ver);";
	512	}
	513
	514	eval $req_line;
	515
	516	$errors{$mod} = $@ if $@;
	517	}
	518
	519	my $res;
fb39747c	520
d8799bab	521	if (keys %errors) {
	522	my $missing = join (', ', map { $deps->{$_} ? "$_ >= $deps->{$_}" : $_ } (sort keys %errors) );
	523	$missing .= " (see $class for details)" if $reqs->{$group}{pod};
70c28808	524	$missing .= "\n";
d8799bab	525	$res = {
	526	status => 0,
	527	errorlist => \%errors,
	528	missing => $missing,
	529	};
fb39747c	530	}
fb39747c	531	else {
d8799bab	532	$res = {
	533	status => 1,
	534	errorlist => {},
	535	missing => '',
	536	};
fb39747c	537	}
fb39747c	538
d8799bab	539	$res;
d8799bab	540	};
fb39747c	541	}
fb39747c	542
e3fc11e1	543	sub req_group_list {
	544	return { map { $_ => { %{ $reqs->{$_}{req} \|\| {} } } } (keys %$reqs) };
	545	}
	546
	547	# This is to be called by the author only (automatically in Makefile.PL)
f6b26571	548	sub _gen_pod {
ccebe1f1	549	my ($class, $distver) = @_;
31fa1764	550
af4ac504	551	my $modfn = __PACKAGE__ . '.pm';
af4ac504	552	$modfn =~ s/\:\:/\//g;
f6b26571	553
31fa1764	554	my $podfn = __FILE__;
	555	$podfn =~ s/\.pm$/\.pod/;
	556
ccebe1f1	557	$distver \|\|=
31fa1764	558	eval { require DBIx::Class; DBIx::Class->VERSION; }
31fa1764	559	\|\|
ccebe1f1	560	die
31fa1764	561	"\n\n---------------------------------------------------------------------\n" .
	562	'Unable to load core DBIx::Class module to determine current version, '.
	563	'possibly due to missing dependencies. Author-mode autodocumentation ' .
	564	"halted\n\n" . $@ .
	565	"\n\n---------------------------------------------------------------------\n"
31fa1764	566	;
31fa1764	567
e3fc11e1	568	my $sqltver = $class->req_list_for ('deploy')->{'SQL::Translator'}
e3fc11e1	569	or die "Hrmm? No sqlt dep?";
7e3dc46f	570
f6b26571	571	my @chunks = (
d8799bab	572	<<'EOC',
af4ac504	573	#########################################################################
	574	##################### A U T O G E N E R A T E D ########################
	575	#########################################################################
	576	#
	577	# The contents of this POD file are auto-generated. Any changes you make
	578	# will be lost. If you need to change the generated text edit _gen_pod()
	579	# at the end of $modfn
	580	#
	581	EOC
f6b26571	582	'=head1 NAME',
7e3dc46f	583	"$class - Optional module dependency specifications (for module authors)",
e3fc11e1	584	'=head1 SYNOPSIS',
d8799bab	585	<<"EOS",
7e3dc46f	586	Somewhere in your build-file (e.g. L<Module::Install>'s Makefile.PL):
	587
	588	...
	589
	590	configure_requires 'DBIx::Class' => '$distver';
	591
	592	require $class;
	593
be68095d	594	my \$deploy_deps = $class->req_list_for('deploy');
7e3dc46f	595
	596	for (keys %\$deploy_deps) {
	597	requires \$_ => \$deploy_deps->{\$_};
	598	}
	599
	600	...
	601
	602	Note that there are some caveats regarding C<configure_requires()>, more info
	603	can be found at L<Module::Install/configure_requires>
	604	EOS
f6b26571	605	'=head1 DESCRIPTION',
	606	<<'EOD',
	607	Some of the less-frequently used features of L<DBIx::Class> have external
	608	module dependencies on their own. In order not to burden the average user
	609	with modules he will never use, these optional dependencies are not included
	610	in the base Makefile.PL. Instead an exception with a descriptive message is
	611	thrown when a specific feature is missing one or several modules required for
	612	its operation. This module is the central holding place for the current list
7e3dc46f	613	of such dependencies, for DBIx::Class core authors, and DBIx::Class extension
7e3dc46f	614	authors alike.
f6b26571	615	EOD
	616	'=head1 CURRENT REQUIREMENT GROUPS',
	617	<<'EOD',
	618	Dependencies are organized in C<groups> and each group can list one or more
	619	required modules, with an optional minimum version (or 0 for any version).
ecb68746	620	The group name can be used in the
f6b26571	621	EOD
	622	);
	623
	624	for my $group (sort keys %$reqs) {
	625	my $p = $reqs->{$group}{pod}
	626	or next;
	627
	628	my $modlist = $reqs->{$group}{req}
	629	or next;
	630
	631	next unless keys %$modlist;
	632
	633	push @chunks, (
	634	"=head2 $p->{title}",
	635	"$p->{desc}",
	636	'=over',
	637	( map { "=item * $_" . ($modlist->{$_} ? " >= $modlist->{$_}" : '') } (sort keys %$modlist) ),
	638	'=back',
	639	"Requirement group: B<$group>",
	640	);
	641	}
	642
	643	push @chunks, (
	644	'=head1 METHODS',
e3fc11e1	645	'=head2 req_group_list',
e3fc11e1	646	'=over',
d8799bab	647	'=item Arguments: none',
e3fc11e1	648	'=item Returns: \%list_of_requirement_groups',
e3fc11e1	649	'=back',
d8799bab	650	<<'EOD',
e3fc11e1	651	This method should be used by DBIx::Class packagers, to get a hashref of all
	652	dependencies keyed by dependency group. Each key (group name) can be supplied
	653	to one of the group-specific methods below.
	654	EOD
	655
f6b26571	656	'=head2 req_list_for',
	657	'=over',
	658	'=item Arguments: $group_name',
	659	'=item Returns: \%list_of_module_version_pairs',
	660	'=back',
d8799bab	661	<<'EOD',
f6b26571	662	This method should be used by DBIx::Class extension authors, to determine the
7e3dc46f	663	version of modules a specific feature requires in the B<current> version of
e3fc11e1	664	DBIx::Class. See the L</SYNOPSIS> for a real-world
7e3dc46f	665	example.
f6b26571	666	EOD
	667
	668	'=head2 req_ok_for',
	669	'=over',
	670	'=item Arguments: $group_name',
	671	'=item Returns: 1\|0',
	672	'=back',
d8799bab	673	<<'EOD',
	674	Returns true or false depending on whether all modules required by
	675	C<$group_name> are present on the system and loadable.
	676	EOD
f6b26571	677
	678	'=head2 req_missing_for',
	679	'=over',
	680	'=item Arguments: $group_name',
	681	'=item Returns: $error_message_string',
	682	'=back',
d8799bab	683	<<"EOD",
f6b26571	684	Returns a single line string suitable for inclusion in larger error messages.
	685	This method would normally be used by DBIx::Class core-module author, to
	686	indicate to the user that he needs to install specific modules before he will
	687	be able to use a specific feature.
	688
e3fc11e1	689	For example if some of the requirements for C<deploy> are not available,
e3fc11e1	690	the returned string could look like:
f6b26571	691
e3fc11e1	692	SQL::Translator >= $sqltver (see $class for details)
f6b26571	693
	694	The author is expected to prepend the necessary text to this message before
	695	returning the actual error seen by the user.
	696	EOD
	697
	698	'=head2 req_errorlist_for',
	699	'=over',
	700	'=item Arguments: $group_name',
	701	'=item Returns: \%list_of_loaderrors_per_module',
	702	'=back',
	703	<<'EOD',
	704	Returns a hashref containing the actual errors that occured while attempting
	705	to load each module in the requirement group.
	706	EOD
fb8ae353	707	'=head1 AUTHOR',
	708	'See L<DBIx::Class/CONTRIBUTORS>.',
	709	'=head1 LICENSE',
	710	'You may distribute this code under the same terms as Perl itself',
f6b26571	711	);
f6b26571	712
9c1700e3	713	open (my $fh, '>', $podfn) or Carp::croak "Unable to write to $podfn: $!";
f6b26571	714	print $fh join ("\n\n", @chunks);
	715	close ($fh);
	716	}
	717
8057ed01	718	1;