/usr/share/perl5/Module/Implementation.pm is in libmodule-implementation-perl 0.09-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 | package Module::Implementation;
# git description: v0.08-2-gd599347
$Module::Implementation::VERSION = '0.09';
use strict;
use warnings;
use Module::Runtime 0.012 qw( require_module );
use Try::Tiny;
# This is needed for the benefit of Test::CleanNamespaces, which in turn loads
# Package::Stash, which in turn loads this module and expects a minimum
# version.
unless ( exists $Module::Implementation::{VERSION}
&& ${ $Module::Implementation::{VERSION} } ) {
$Module::Implementation::{VERSION} = \42;
}
my %Implementation;
sub build_loader_sub {
my $caller = caller();
return _build_loader( $caller, @_ );
}
sub _build_loader {
my $package = shift;
my %args = @_;
my @implementations = @{ $args{implementations} };
my @symbols = @{ $args{symbols} || [] };
my $implementation;
my $env_var = uc $package;
$env_var =~ s/::/_/g;
$env_var .= '_IMPLEMENTATION';
return sub {
my ( $implementation, $loaded ) = _load_implementation(
$package,
$ENV{$env_var},
\@implementations,
);
$Implementation{$package} = $implementation;
_copy_symbols( $loaded, $package, \@symbols );
return $loaded;
};
}
sub implementation_for {
my $package = shift;
return $Implementation{$package};
}
sub _load_implementation {
my $package = shift;
my $env_value = shift;
my $implementations = shift;
if ($env_value) {
die "$env_value is not a valid implementation for $package"
unless grep { $_ eq $env_value } @{$implementations};
my $requested = "${package}::$env_value";
# Values from the %ENV hash are tainted. We know it's safe to untaint
# this value because the value was one of our known implementations.
($requested) = $requested =~ /^(.+)$/;
try {
require_module($requested);
}
catch {
require Carp;
Carp::croak("Could not load $requested: $_");
};
return ( $env_value, $requested );
}
else {
my $err;
for my $possible ( @{$implementations} ) {
my $try = "${package}::$possible";
my $ok;
try {
require_module($try);
$ok = 1;
}
catch {
$err .= $_ if defined $_;
};
return ( $possible, $try ) if $ok;
}
require Carp;
if ( defined $err && length $err ) {
Carp::croak(
"Could not find a suitable $package implementation: $err");
}
else {
Carp::croak(
'Module::Runtime failed to load a module but did not throw a real error. This should never happen. Something is very broken'
);
}
}
}
sub _copy_symbols {
my $from_package = shift;
my $to_package = shift;
my $symbols = shift;
for my $sym ( @{$symbols} ) {
my $type = $sym =~ s/^([\$\@\%\&\*])// ? $1 : '&';
my $from = "${from_package}::$sym";
my $to = "${to_package}::$sym";
{
no strict 'refs';
no warnings 'once';
# Copied from Exporter
*{$to}
= $type eq '&' ? \&{$from}
: $type eq '$' ? \${$from}
: $type eq '@' ? \@{$from}
: $type eq '%' ? \%{$from}
: $type eq '*' ? *{$from}
: die
"Can't copy symbol from $from_package to $to_package: $type$sym";
}
}
}
1;
# ABSTRACT: Loads one of several alternate underlying implementations for a module
__END__
=pod
=encoding UTF-8
=head1 NAME
Module::Implementation - Loads one of several alternate underlying implementations for a module
=head1 VERSION
version 0.09
=head1 SYNOPSIS
package Foo::Bar;
use Module::Implementation;
BEGIN {
my $loader = Module::Implementation::build_loader_sub(
implementations => [ 'XS', 'PurePerl' ],
symbols => [ 'run', 'check' ],
);
$loader->();
}
package Consumer;
# loads the first viable implementation
use Foo::Bar;
=head1 DESCRIPTION
This module abstracts out the process of choosing one of several underlying
implementations for a module. This can be used to provide XS and pure Perl
implementations of a module, or it could be used to load an implementation for
a given OS or any other case of needing to provide multiple implementations.
This module is only useful when you know all the implementations ahead of
time. If you want to load arbitrary implementations then you probably want
something like a plugin system, not this module.
=head1 API
This module provides two subroutines, neither of which are exported.
=head2 Module::Implementation::build_loader_sub(...)
This subroutine takes the following arguments.
=over 4
=item * implementations
This should be an array reference of implementation names. Each name should
correspond to a module in the caller's namespace.
In other words, using the example in the L</SYNOPSIS>, this module will look
for the C<Foo::Bar::XS> and C<Foo::Bar::PurePerl> modules.
This argument is required.
=item * symbols
A list of symbols to copy from the implementation package to the calling
package.
These can be prefixed with a variable type: C<$>, C<@>, C<%>, C<&>, or
C<*)>. If no prefix is given, the symbol is assumed to be a subroutine.
This argument is optional.
=back
This subroutine I<returns> the implementation loader as a sub reference.
It is up to you to call this loader sub in your code.
I recommend that you I<do not> call this loader in an C<import()> sub. If a
caller explicitly requests no imports, your C<import()> sub will not be run at
all, which can cause weird breakage.
=head2 Module::Implementation::implementation_for($package)
Given a package name, this subroutine returns the implementation that was
loaded for the package. This is not a full package name, just the suffix that
identifies the implementation. For the L</SYNOPSIS> example, this subroutine
would be called as C<Module::Implementation::implementation_for('Foo::Bar')>,
and it would return "XS" or "PurePerl".
=head1 HOW THE IMPLEMENTATION LOADER WORKS
The implementation loader works like this ...
First, it checks for an C<%ENV> var specifying the implementation to load. The
env var is based on the package name which loads the implementations. The
C<::> package separator is replaced with C<_>, and made entirely
upper-case. Finally, we append "_IMPLEMENTATION" to this name.
So in our L</SYNOPSIS> example, the corresponding C<%ENV> key would be
C<FOO_BAR_IMPLEMENTATION>.
If this is set, then the loader will B<only> try to load this one
implementation.
If the env var requests an implementation which doesn't match one of the
implementations specified when the loader was created, an error is thrown.
If this one implementation fails to load then loader throws an error. This is
useful for testing. You can request a specific implementation in a test file
by writing something like this:
BEGIN { $ENV{FOO_BAR_IMPLEMENTATION} = 'XS' }
use Foo::Bar;
If the environment variable is I<not> set, then the loader simply tries the
implementations originally passed to C<Module::Implementation>. The
implementations are tried in the order in which they were originally passed.
The loader will use the first implementation that loads without an error. It
will copy any requested symbols from this implementation.
If none of the implementations can be loaded, then the loader throws an
exception.
The loader returns the name of the package it loaded.
=head1 AUTHOR
Dave Rolsky <autarch@urth.org>
=head1 COPYRIGHT AND LICENSE
This software is Copyright (c) 2014 by Dave Rolsky.
This is free software, licensed under:
The Artistic License 2.0 (GPL Compatible)
=cut
|