← Back to branch summary

~ubuntu-branches/ubuntu/wily/libb-hooks-op-check-entersubforcv-perl/wily

« back to all changes in this revision

Viewing changes to inc/Module/Install/Makefile.pm

  • Committer: Package Import Robot
  • Author(s): Stig Sandbeck Mathisen
  • Date: 2012-04-22 00:19:53 UTC
  • Revision ID: package-import@ubuntu.com-20120422001953-603chi8f9v2gwbtu
Tags: upstream-0.09
Import upstream version 0.09

Show diffs side-by-side

added added

removed removed

Lines of Context:
inc/Module/Install/Makefile.pm
 
1
#line 1
 
2
package Module::Install::Makefile;
 
3
 
 
4
use strict 'vars';
 
5
use ExtUtils::MakeMaker   ();
 
6
use Module::Install::Base ();
 
7
use Fcntl qw/:flock :seek/;
 
8
 
 
9
use vars qw{$VERSION @ISA $ISCORE};
 
10
BEGIN {
 
11
        $VERSION = '1.01';
 
12
        @ISA     = 'Module::Install::Base';
 
13
        $ISCORE  = 1;
 
14
}
 
15
 
 
16
sub Makefile { $_[0] }
 
17
 
 
18
my %seen = ();
 
19
 
 
20
sub prompt {
 
21
        shift;
 
22
 
 
23
        # Infinite loop protection
 
24
        my @c = caller();
 
25
        if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
 
26
                die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
 
27
        }
 
28
 
 
29
        # In automated testing or non-interactive session, always use defaults
 
30
        if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
 
31
                local $ENV{PERL_MM_USE_DEFAULT} = 1;
 
32
                goto &ExtUtils::MakeMaker::prompt;
 
33
        } else {
 
34
                goto &ExtUtils::MakeMaker::prompt;
 
35
        }
 
36
}
 
37
 
 
38
# Store a cleaned up version of the MakeMaker version,
 
39
# since we need to behave differently in a variety of
 
40
# ways based on the MM version.
 
41
my $makemaker = eval $ExtUtils::MakeMaker::VERSION;
 
42
 
 
43
# If we are passed a param, do a "newer than" comparison.
 
44
# Otherwise, just return the MakeMaker version.
 
45
sub makemaker {
 
46
        ( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0
 
47
}
 
48
 
 
49
# Ripped from ExtUtils::MakeMaker 6.56, and slightly modified
 
50
# as we only need to know here whether the attribute is an array
 
51
# or a hash or something else (which may or may not be appendable).
 
52
my %makemaker_argtype = (
 
53
 C                  => 'ARRAY',
 
54
 CONFIG             => 'ARRAY',
 
55
# CONFIGURE          => 'CODE', # ignore
 
56
 DIR                => 'ARRAY',
 
57
 DL_FUNCS           => 'HASH',
 
58
 DL_VARS            => 'ARRAY',
 
59
 EXCLUDE_EXT        => 'ARRAY',
 
60
 EXE_FILES          => 'ARRAY',
 
61
 FUNCLIST           => 'ARRAY',
 
62
 H                  => 'ARRAY',
 
63
 IMPORTS            => 'HASH',
 
64
 INCLUDE_EXT        => 'ARRAY',
 
65
 LIBS               => 'ARRAY', # ignore ''
 
66
 MAN1PODS           => 'HASH',
 
67
 MAN3PODS           => 'HASH',
 
68
 META_ADD           => 'HASH',
 
69
 META_MERGE         => 'HASH',
 
70
 PL_FILES           => 'HASH',
 
71
 PM                 => 'HASH',
 
72
 PMLIBDIRS          => 'ARRAY',
 
73
 PMLIBPARENTDIRS    => 'ARRAY',
 
74
 PREREQ_PM          => 'HASH',
 
75
 CONFIGURE_REQUIRES => 'HASH',
 
76
 SKIP               => 'ARRAY',
 
77
 TYPEMAPS           => 'ARRAY',
 
78
 XS                 => 'HASH',
 
79
# VERSION            => ['version',''],  # ignore
 
80
# _KEEP_AFTER_FLUSH  => '',
 
81
 
 
82
 clean      => 'HASH',
 
83
 depend     => 'HASH',
 
84
 dist       => 'HASH',
 
85
 dynamic_lib=> 'HASH',
 
86
 linkext    => 'HASH',
 
87
 macro      => 'HASH',
 
88
 postamble  => 'HASH',
 
89
 realclean  => 'HASH',
 
90
 test       => 'HASH',
 
91
 tool_autosplit => 'HASH',
 
92
 
 
93
 # special cases where you can use makemaker_append
 
94
 CCFLAGS   => 'APPENDABLE',
 
95
 DEFINE    => 'APPENDABLE',
 
96
 INC       => 'APPENDABLE',
 
97
 LDDLFLAGS => 'APPENDABLE',
 
98
 LDFROM    => 'APPENDABLE',
 
99
);
 
100
 
 
101
sub makemaker_args {
 
102
        my ($self, %new_args) = @_;
 
103
        my $args = ( $self->{makemaker_args} ||= {} );
 
104
        foreach my $key (keys %new_args) {
 
105
                if ($makemaker_argtype{$key}) {
 
106
                        if ($makemaker_argtype{$key} eq 'ARRAY') {
 
107
                                $args->{$key} = [] unless defined $args->{$key};
 
108
                                unless (ref $args->{$key} eq 'ARRAY') {
 
109
                                        $args->{$key} = [$args->{$key}]
 
110
                                }
 
111
                                push @{$args->{$key}},
 
112
                                        ref $new_args{$key} eq 'ARRAY'
 
113
                                                ? @{$new_args{$key}}
 
114
                                                : $new_args{$key};
 
115
                        }
 
116
                        elsif ($makemaker_argtype{$key} eq 'HASH') {
 
117
                                $args->{$key} = {} unless defined $args->{$key};
 
118
                                foreach my $skey (keys %{ $new_args{$key} }) {
 
119
                                        $args->{$key}{$skey} = $new_args{$key}{$skey};
 
120
                                }
 
121
                        }
 
122
                        elsif ($makemaker_argtype{$key} eq 'APPENDABLE') {
 
123
                                $self->makemaker_append($key => $new_args{$key});
 
124
                        }
 
125
                }
 
126
                else {
 
127
                        if (defined $args->{$key}) {
 
128
                                warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n};
 
129
                        }
 
130
                        $args->{$key} = $new_args{$key};
 
131
                }
 
132
        }
 
133
        return $args;
 
134
}
 
135
 
 
136
# For mm args that take multiple space-seperated args,
 
137
# append an argument to the current list.
 
138
sub makemaker_append {
 
139
        my $self = shift;
 
140
        my $name = shift;
 
141
        my $args = $self->makemaker_args;
 
142
        $args->{$name} = defined $args->{$name}
 
143
                ? join( ' ', $args->{$name}, @_ )
 
144
                : join( ' ', @_ );
 
145
}
 
146
 
 
147
sub build_subdirs {
 
148
        my $self    = shift;
 
149
        my $subdirs = $self->makemaker_args->{DIR} ||= [];
 
150
        for my $subdir (@_) {
 
151
                push @$subdirs, $subdir;
 
152
        }
 
153
}
 
154
 
 
155
sub clean_files {
 
156
        my $self  = shift;
 
157
        my $clean = $self->makemaker_args->{clean} ||= {};
 
158
          %$clean = (
 
159
                %$clean,
 
160
                FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_),
 
161
        );
 
162
}
 
163
 
 
164
sub realclean_files {
 
165
        my $self      = shift;
 
166
        my $realclean = $self->makemaker_args->{realclean} ||= {};
 
167
          %$realclean = (
 
168
                %$realclean,
 
169
                FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_),
 
170
        );
 
171
}
 
172
 
 
173
sub libs {
 
174
        my $self = shift;
 
175
        my $libs = ref $_[0] ? shift : [ shift ];
 
176
        $self->makemaker_args( LIBS => $libs );
 
177
}
 
178
 
 
179
sub inc {
 
180
        my $self = shift;
 
181
        $self->makemaker_args( INC => shift );
 
182
}
 
183
 
 
184
sub _wanted_t {
 
185
}
 
186
 
 
187
sub tests_recursive {
 
188
        my $self = shift;
 
189
        my $dir = shift || 't';
 
190
        unless ( -d $dir ) {
 
191
                die "tests_recursive dir '$dir' does not exist";
 
192
        }
 
193
        my %tests = map { $_ => 1 } split / /, ($self->tests || '');
 
194
        require File::Find;
 
195
        File::Find::find(
 
196
        sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 },
 
197
        $dir
 
198
    );
 
199
        $self->tests( join ' ', sort keys %tests );
 
200
}
 
201
 
 
202
sub write {
 
203
        my $self = shift;
 
204
        die "&Makefile->write() takes no arguments\n" if @_;
 
205
 
 
206
        # Check the current Perl version
 
207
        my $perl_version = $self->perl_version;
 
208
        if ( $perl_version ) {
 
209
                eval "use $perl_version; 1"
 
210
                        or die "ERROR: perl: Version $] is installed, "
 
211
                        . "but we need version >= $perl_version";
 
212
        }
 
213
 
 
214
        # Make sure we have a new enough MakeMaker
 
215
        require ExtUtils::MakeMaker;
 
216
 
 
217
        if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) {
 
218
                # MakeMaker can complain about module versions that include
 
219
                # an underscore, even though its own version may contain one!
 
220
                # Hence the funny regexp to get rid of it.  See RT #35800
 
221
                # for details.
 
222
                my $v = $ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/;
 
223
                $self->build_requires(     'ExtUtils::MakeMaker' => $v );
 
224
                $self->configure_requires( 'ExtUtils::MakeMaker' => $v );
 
225
        } else {
 
226
                # Allow legacy-compatibility with 5.005 by depending on the
 
227
                # most recent EU:MM that supported 5.005.
 
228
                $self->build_requires(     'ExtUtils::MakeMaker' => 6.42 );
 
229
                $self->configure_requires( 'ExtUtils::MakeMaker' => 6.42 );
 
230
        }
 
231
 
 
232
        # Generate the MakeMaker params
 
233
        my $args = $self->makemaker_args;
 
234
        $args->{DISTNAME} = $self->name;
 
235
        $args->{NAME}     = $self->module_name || $self->name;
 
236
        $args->{NAME}     =~ s/-/::/g;
 
237
        $args->{VERSION}  = $self->version or die <<'EOT';
 
238
ERROR: Can't determine distribution version. Please specify it
 
239
explicitly via 'version' in Makefile.PL, or set a valid $VERSION
 
240
in a module, and provide its file path via 'version_from' (or
 
241
'all_from' if you prefer) in Makefile.PL.
 
242
EOT
 
243
 
 
244
        $DB::single = 1;
 
245
        if ( $self->tests ) {
 
246
                my @tests = split ' ', $self->tests;
 
247
                my %seen;
 
248
                $args->{test} = {
 
249
                        TESTS => (join ' ', grep {!$seen{$_}++} @tests),
 
250
                };
 
251
    } elsif ( $Module::Install::ExtraTests::use_extratests ) {
 
252
        # Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness.
 
253
        # So, just ignore our xt tests here.
 
254
        } elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) {
 
255
                $args->{test} = {
 
256
                        TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ),
 
257
                };
 
258
        }
 
259
        if ( $] >= 5.005 ) {
 
260
                $args->{ABSTRACT} = $self->abstract;
 
261
                $args->{AUTHOR}   = join ', ', @{$self->author || []};
 
262
        }
 
263
        if ( $self->makemaker(6.10) ) {
 
264
                $args->{NO_META}   = 1;
 
265
                #$args->{NO_MYMETA} = 1;
 
266
        }
 
267
        if ( $self->makemaker(6.17) and $self->sign ) {
 
268
                $args->{SIGN} = 1;
 
269
        }
 
270
        unless ( $self->is_admin ) {
 
271
                delete $args->{SIGN};
 
272
        }
 
273
        if ( $self->makemaker(6.31) and $self->license ) {
 
274
                $args->{LICENSE} = $self->license;
 
275
        }
 
276
 
 
277
        my $prereq = ($args->{PREREQ_PM} ||= {});
 
278
        %$prereq = ( %$prereq,
 
279
                map { @$_ } # flatten [module => version]
 
280
                map { @$_ }
 
281
                grep $_,
 
282
                ($self->requires)
 
283
        );
 
284
 
 
285
        # Remove any reference to perl, PREREQ_PM doesn't support it
 
286
        delete $args->{PREREQ_PM}->{perl};
 
287
 
 
288
        # Merge both kinds of requires into BUILD_REQUIRES
 
289
        my $build_prereq = ($args->{BUILD_REQUIRES} ||= {});
 
290
        %$build_prereq = ( %$build_prereq,
 
291
                map { @$_ } # flatten [module => version]
 
292
                map { @$_ }
 
293
                grep $_,
 
294
                ($self->configure_requires, $self->build_requires)
 
295
        );
 
296
 
 
297
        # Remove any reference to perl, BUILD_REQUIRES doesn't support it
 
298
        delete $args->{BUILD_REQUIRES}->{perl};
 
299
 
 
300
        # Delete bundled dists from prereq_pm, add it to Makefile DIR
 
301
        my $subdirs = ($args->{DIR} || []);
 
302
        if ($self->bundles) {
 
303
                my %processed;
 
304
                foreach my $bundle (@{ $self->bundles }) {
 
305
                        my ($mod_name, $dist_dir) = @$bundle;
 
306
                        delete $prereq->{$mod_name};
 
307
                        $dist_dir = File::Basename::basename($dist_dir); # dir for building this module
 
308
                        if (not exists $processed{$dist_dir}) {
 
309
                                if (-d $dist_dir) {
 
310
                                        # List as sub-directory to be processed by make
 
311
                                        push @$subdirs, $dist_dir;
 
312
                                }
 
313
                                # Else do nothing: the module is already present on the system
 
314
                                $processed{$dist_dir} = undef;
 
315
                        }
 
316
                }
 
317
        }
 
318
 
 
319
        unless ( $self->makemaker('6.55_03') ) {
 
320
                %$prereq = (%$prereq,%$build_prereq);
 
321
                delete $args->{BUILD_REQUIRES};
 
322
        }
 
323
 
 
324
        if ( my $perl_version = $self->perl_version ) {
 
325
                eval "use $perl_version; 1"
 
326
                        or die "ERROR: perl: Version $] is installed, "
 
327
                        . "but we need version >= $perl_version";
 
328
 
 
329
                if ( $self->makemaker(6.48) ) {
 
330
                        $args->{MIN_PERL_VERSION} = $perl_version;
 
331
                }
 
332
        }
 
333
 
 
334
        if ($self->installdirs) {
 
335
                warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS};
 
336
                $args->{INSTALLDIRS} = $self->installdirs;
 
337
        }
 
338
 
 
339
        my %args = map {
 
340
                ( $_ => $args->{$_} ) } grep {defined($args->{$_} )
 
341
        } keys %$args;
 
342
 
 
343
        my $user_preop = delete $args{dist}->{PREOP};
 
344
        if ( my $preop = $self->admin->preop($user_preop) ) {
 
345
                foreach my $key ( keys %$preop ) {
 
346
                        $args{dist}->{$key} = $preop->{$key};
 
347
                }
 
348
        }
 
349
 
 
350
        my $mm = ExtUtils::MakeMaker::WriteMakefile(%args);
 
351
        $self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile');
 
352
}
 
353
 
 
354
sub fix_up_makefile {
 
355
        my $self          = shift;
 
356
        my $makefile_name = shift;
 
357
        my $top_class     = ref($self->_top) || '';
 
358
        my $top_version   = $self->_top->VERSION || '';
 
359
 
 
360
        my $preamble = $self->preamble
 
361
                ? "# Preamble by $top_class $top_version\n"
 
362
                        . $self->preamble
 
363
                : '';
 
364
        my $postamble = "# Postamble by $top_class $top_version\n"
 
365
                . ($self->postamble || '');
 
366
 
 
367
        local *MAKEFILE;
 
368
        open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!";
 
369
        eval { flock MAKEFILE, LOCK_EX };
 
370
        my $makefile = do { local $/; <MAKEFILE> };
 
371
 
 
372
        $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /;
 
373
        $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g;
 
374
        $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g;
 
375
        $makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m;
 
376
        $makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m;
 
377
 
 
378
        # Module::Install will never be used to build the Core Perl
 
379
        # Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks
 
380
        # PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist
 
381
        $makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m;
 
382
        #$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m;
 
383
 
 
384
        # Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well.
 
385
        $makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g;
 
386
 
 
387
        # XXX - This is currently unused; not sure if it breaks other MM-users
 
388
        # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg;
 
389
 
 
390
        seek MAKEFILE, 0, SEEK_SET;
 
391
        truncate MAKEFILE, 0;
 
392
        print MAKEFILE  "$preamble$makefile$postamble" or die $!;
 
393
        close MAKEFILE  or die $!;
 
394
 
 
395
        1;
 
396
}
 
397
 
 
398
sub preamble {
 
399
        my ($self, $text) = @_;
 
400
        $self->{preamble} = $text . $self->{preamble} if defined $text;
 
401
        $self->{preamble};
 
402
}
 
403
 
 
404
sub postamble {
 
405
        my ($self, $text) = @_;
 
406
        $self->{postamble} ||= $self->admin->postamble;
 
407
        $self->{postamble} .= $text if defined $text;
 
408
        $self->{postamble}
 
409
}
 
410
 
 
411
1;
 
412
 
 
413
__END__
 
414
 
 
415
#line 541