blib/lib/Perl/PrereqScanner/NotQuiteLite/App.pm untested

filter: Statementstmt 0.0% 0 / 362 Branchbran 0.0% 0 / 186 Conditioncond 0.0% 0 / 110 MC/DCmcdc n/a Subroutinesub 0.0% 0 / 35 Podpod 0.0% 0 / 17 totaltotal 0.0% 0 / 710 SCAR 91.0
CC
94
Cov
0%
new
380.0
run
306.0
_scan_file
240.0
CRAP 8930.0
1 package Perl::PrereqScanner::NotQuiteLite::App;
2  
3 use strict;
4 use warnings;
5 use File::Find;
6 use File::Glob 'bsd_glob';
7 use File::Basename;
8 use File::Spec;
9 use CPAN::Meta::Prereqs;
10 use CPAN::Meta::Requirements;
11 use Perl::PrereqScanner::NotQuiteLite;
12 use Perl::PrereqScanner::NotQuiteLite::Util::Prereqs;
13 use Parse::Distname;
14  
15 use constant WIN32 => $^O eq 'MSWin32';
16  
17 my %IsTestClassFamily = map {$_ => 1} qw(
18 Test::Class
19 Test::Class::Moose
20 Test::Class::Most
21 Test::Class::Sugar
22 Test::Classy
23 );
24  
25 sub new {
26 my ($class, %opts) = @_;
27  
28 for my $key (keys %opts) {
29 next unless $key =~ /\-/;
30 (my $replaced_key = $key) =~ s/\-/_/g;
31 $opts{$replaced_key} = $opts{$key};
32 }
33  
34 $opts{prereqs} = CPAN::Meta::Prereqs->new;
35 $opts{parsers} = [':bundled'] unless defined $opts{parsers};
36 $opts{recommends} = 0 unless defined $opts{recommends};
37 $opts{suggests} = 0 unless defined $opts{suggests};
38 $opts{base_dir} ||= File::Spec->curdir;
39  
40 $opts{cpanfile} = 1 if $opts{save_cpanfile};
41  
42 if ($opts{features} and ref $opts{features} ne 'HASH') {
43 my @features;
44 if (!ref $opts{features}) {
45 @features = split ';', $opts{features};
46 } elsif (ref $opts{features} eq 'ARRAY') {
47 @features = @{$opts{features}};
48 }
49 my %map;
50 for my $spec (@features) {
51 my ($identifier, $description, $paths) = split ':', $spec;
52 my @paths = map { bsd_glob(File::Spec->catdir($opts{base_dir}, $_)) } split ',', $paths;
53 if (WIN32) {
54 s|\\|/|g for @paths;
55 }
56 $map{$identifier} = {
57 description => $description,
58 paths => \@paths,
59 };
60 }
61 $opts{features} = \%map;
62 }
63  
64 if ($opts{ignore} and ref $opts{ignore} eq 'ARRAY') {
65 require Regexp::Trie;
66 my $re = Regexp::Trie->new;
67 for (@{$opts{ignore}}) {
68 s|\\|/|g if WIN32;
69 $re->add($_);
70 }
71 $opts{ignore_re} ||= $re->_regexp;
72 }
73  
74 if ($opts{private} and ref $opts{private} eq 'ARRAY') {
75 require Regexp::Trie;
76 my $re = Regexp::Trie->new;
77 for (@{$opts{private}}) {
78 $re->add($_);
79 }
80 $opts{private_re} ||= $re->_regexp;
81 }
82  
83 if ($opts{optional} and ref $opts{optional} eq 'ARRAY') {
84 require Regexp::Trie;
85 my $re = Regexp::Trie->new;
86 for (@{$opts{optional}}) {
87 s|\\|/|g if WIN32;
88 $re->add($_);
89 }
90 $opts{optional_re} ||= $re->_regexp;
91 }
92 if ($opts{optional_re}) {
93 $opts{suggests} = 1;
94 }
95  
96 if (my $index_name = delete $opts{use_index}) {
97 my $index_package = "CPAN::Common::Index::$index_name";
98 if (eval "require $index_package; 1") {
99 $opts{index} = $index_package->new;
100 }
101 }
102  
103 if ($opts{scan_also}) {
104 $opts{libs} ||= delete $opts{scan_also};
105 }
106  
107 bless \%opts, $class;
108 }
109  
110 sub run {
111 my ($self, @args) = @_;
112  
113 unless (@args) {
114 # for configure requires
115 push @args, "Makefile.PL", "Build.PL";
116  
117 # for test requires
118 push @args, "t";
119  
120 # for runtime requires;
121 if ($self->{blib} and -d File::Spec->catdir($self->{base_dir}, 'blib')) {
122 push @args, "blib/lib", "blib/bin", "blib/script";
123 } else {
124 push @args, "lib";
125 push @args, glob(File::Spec->catfile($self->{base_dir}, '*.pm'));
126 push @args, "bin", "script", "scripts";
127 }
128  
129 # extra libs
130 push @args, map { bsd_glob(File::Spec->catdir($self->{base_dir}, $_)) } @{$self->{libs} || []};
131  
132 # for develop requires
133 push @args, "xt", "author" if $self->{develop};
134 }
135  
136 if ($self->{verbose}) {
137 print STDERR "Scanning the following files/directories\n";
138 print STDERR " $_\n" for sort @args;
139 }
140  
141 for my $path (@args) {
142 my $item = File::Spec->file_name_is_absolute($path) ? $path : File::Spec->catfile($self->{base_dir}, $path);
143 -d $item ? $self->_scan_dir($item) :
144 -f $item ? $self->_scan_file($item) :
145 next;
146 }
147  
148 # add test requirements by .pm files used in .t files
149 $self->_add_test_requires($self->{allow_test_pms});
150  
151 $self->_exclude_local_modules;
152  
153 if ($self->{exclude_core}) {
154 $self->_exclude_core_prereqs;
155 }
156  
157 if ($self->{index}) {
158 $self->_dedupe_indexed_prereqs;
159 }
160  
161 $self->_dedupe;
162  
163 if ($self->{print} or $self->{cpanfile}) {
164 if ($self->{json}) {
165 # TODO: feature support (how should we express it?)
166 eval { require JSON::PP } or die "requires JSON::PP";
167 print JSON::PP->new->pretty(1)->canonical->encode($self->{prereqs}->as_string_hash);
168 } elsif ($self->{cpanfile}) {
169 eval { require Perl::PrereqScanner::NotQuiteLite::Util::CPANfile } or die "requires Module::CPANfile";
170 my $file = File::Spec->catfile($self->{base_dir}, "cpanfile");
171 my $cpanfile = Perl::PrereqScanner::NotQuiteLite::Util::CPANfile->load_and_merge($file, $self->{prereqs}, $self->{features});
172  
173 $self->_dedupe_indexed_prereqs($cpanfile->prereqs) if $self->{index};
174  
175 if ($self->{save_cpanfile}) {
176 $cpanfile->save($file);
177 } elsif ($self->{print}) {
178 print $cpanfile->to_string, "\n";
179 }
180 return $cpanfile;
181 } elsif ($self->{print}) {
182 $self->_print_prereqs;
183 }
184 }
185 $self->{prereqs};
186 }
187  
188 sub index { shift->{index} }
189  
190 sub _print_prereqs {
191 my $self = shift;
192  
193 my $combined = CPAN::Meta::Requirements->new;
194  
195 for my $req ($self->_requirements) {
196 $combined->add_requirements($req);
197 }
198 my $hash = $combined->as_string_hash;
199 for my $module (sort keys %$hash) {
200 next if $module eq 'perl';
201 my $version = $hash->{$module} || 0;
202 $version = qq{"$version"} unless $version =~ /^[0-9]+(?:\.[0-9]+)?$/;
203 print $version eq '0' ? "$module\n" : "$module~$version\n";
204 }
205 }
206  
207 sub _requirements {
208 my ($self, $prereqs) = @_;
209  
210 $prereqs ||= $self->{prereqs};
211 my @phases = qw/configure runtime build test/;
212 push @phases, 'develop' if $self->{develop};
213 my @types = $self->{suggests} ? qw/requires recommends suggests/ : $self->{recommends} ? qw/requires recommends/ : qw/requires/;
214 my @requirements;
215 for my $phase (@phases) {
216 for my $type (@types) {
217 my $req = $prereqs->requirements_for($phase, $type);
218 next unless $req->required_modules;
219 push @requirements, $req;
220 }
221 }
222  
223 if ($self->{features}) {
224 my @feature_prereqs = grep defined, map {$self->{features}{$_}{prereqs}} keys %{$self->{features} || {}};
225 for my $feature_prereqs (@feature_prereqs) {
226 for my $phase (@phases) {
227 for my $type (@types) {
228 my $req = $feature_prereqs->requirements_for($phase, $type);
229 next unless $req->required_modules;
230 push @requirements, $req;
231 }
232 }
233 }
234 }
235  
236 @requirements;
237 }
238  
239 sub _exclude_local_modules {
240 my $self = shift;
241  
242 my @local_dirs = ("inc", @{$self->{libs} || []});
243 for my $dir (@local_dirs) {
244 my $local_dir = File::Spec->catdir($self->{base_dir}, $dir);
245 next unless -d $local_dir;
246 find({
247 wanted => sub {
248 my $file = $_;
249 return unless -f $file;
250 my $relpath = File::Spec->abs2rel($file, $local_dir);
251  
252 return unless $relpath =~ /\.pm$/;
253 my $module = $relpath;
254 $module =~ s!\.pm$!!;
255 $module =~ s![\\/]!::!g;
256 $self->{possible_modules}{$module} = 1;
257 $self->{possible_modules}{"inc::$module"} = 1 if $dir eq 'inc';
258 },
259 no_chdir => 1,
260 }, $local_dir);
261 }
262  
263 my $private_re = $self->{private_re};
264 for my $req ($self->_requirements) {
265 for my $module ($req->required_modules) {
266 next unless $self->{possible_modules}{$module} or ($private_re and $module =~ /$private_re/);
267 $req->clear_requirement($module);
268 if ($self->{verbose}) {
269 print STDERR " excluded $module (local)\n";
270 }
271 }
272 }
273 }
274  
275 sub _exclude_core_prereqs {
276 my $self = shift;
277  
278 eval { require Module::CoreList; Module::CoreList->VERSION('2.99') } or die "requires Module::CoreList 2.99";
279  
280 my $perl_version = $self->{perl_version} || $self->_find_used_perl_version || '5.008001';
281 if ($perl_version =~ /^v?5\.(0?[1-9][0-9]?)(?:\.([0-9]))?$/) {
282 $perl_version = sprintf '5.%03d%03d', $1, $2 || 0;
283 }
284 $perl_version = '5.008001' unless exists $Module::CoreList::version{$perl_version};
285  
286 my %core_alias = (
287 'Getopt::Long::Parser' => 'Getopt::Long',
288 'Tie::File::Cache' => 'Tie::File',
289 'Tie::File::Heap' => 'Tie::File',
290 'Tie::StdScalar' => 'Tie::Scalar',
291 'Tie::StdArray' => 'Tie::Array',
292 'Tie::StdHash' => 'Tie::Hash',
293 'Tie::ExtraHash' => 'Tie::Hash',
294 'Tie::RefHash::Nestable' => 'Tie::RefHash',
295 );
296  
297 for my $req ($self->_requirements) {
298 for my $module ($req->required_modules) {
299 $module = $core_alias{$module} if exists $core_alias{$module};
300 if (Module::CoreList::is_core($module, undef, $perl_version) and
301 !Module::CoreList::deprecated_in($module, undef, $perl_version)
302 ) {
303 next unless exists $Module::CoreList::version{$perl_version}{$module};
304 my $core_version = $Module::CoreList::version{$perl_version}{$module};
305 next unless $req->accepts_module($module => $core_version);
306 $req->clear_requirement($module);
307 if ($self->{verbose}) {
308 print STDERR " excluded $module ($perl_version core)\n";
309 }
310 }
311 }
312 }
313 }
314  
315 sub _find_used_perl_version {
316 my $self = shift;
317 my @perl_versions;
318 my $perl_requirements = CPAN::Meta::Requirements->new;
319 for my $req ($self->_requirements) {
320 my $perl_req = $req->requirements_for_module('perl');
321 $perl_requirements->add_string_requirement('perl', $perl_req) if $perl_req;
322 }
323 return $perl_requirements->is_simple ? $perl_requirements->requirements_for_module('perl') : undef;
324 }
325  
326 sub _add_test_requires {
327 my ($self, $force) = @_;
328  
329 if (my $test_reqs = $self->{prereqs}->requirements_for('test', 'requires')) {
330 my @required_modules = $test_reqs->required_modules;
331 for my $module (@required_modules) {
332 $force = 1 if exists $IsTestClassFamily{$module};
333 my $relpath = $self->{possible_modules}{$module} or next;
334 my $context = delete $self->{_test_pm}{$relpath} or next;
335 $test_reqs->add_requirements($context->requires);
336 if ($self->{recommends} or $self->{suggests}) {
337 $self->{prereqs}->requirements_for('test', 'recommends')->add_requirements($context->recommends);
338 }
339 if ($self->{suggests}) {
340 $self->{prereqs}->requirements_for('test', 'suggests')->add_requirements($context->suggests);
341 }
342 }
343 if ($force) {
344 for my $context (values %{$self->{_test_pm} || {}}) {
345 $test_reqs->add_requirements($context->requires);
346 if ($self->{recommends} or $self->{suggests}) {
347 $self->{prereqs}->requirements_for('test', 'recommends')->add_requirements($context->recommends);
348 }
349 if ($self->{suggests}) {
350 $self->{prereqs}->requirements_for('test', 'suggests')->add_requirements($context->suggests);
351 }
352 }
353 }
354 }
355 }
356  
357 sub _dedupe {
358 my $self = shift;
359  
360 my $prereqs = $self->{prereqs};
361  
362 my %features = map {$_ => $self->{features}{$_}{prereqs}} keys %{$self->{features} || {}};
363  
364 dedupe_prereqs_and_features($prereqs, \%features);
365 }
366  
367 sub _get_uri {
368 my ($self, $module) = @_;
369 $self->{uri_cache}{$module} ||= $self->__get_uri($module);
370 }
371  
372 sub __get_uri {
373 my ($self, $module) = @_;
374 my $res = $self->{index}->search_packages({ package => $module }) or return;
375 ## ignore (non-dual) core modules
376 return if _dist_from_uri($res->{uri}) eq 'perl';
377 return $res->{uri};
378 }
379  
380 sub _dist_from_uri {
381 my $uri = shift;
382 $uri =~ s!^cpan:///\w+/!!;
383 Parse::Distname->new($uri)->dist;
384 }
385  
386 sub _dedupe_indexed_prereqs {
387 my ($self, $prereqs) = @_;
388  
389 for my $req ($self->_requirements($prereqs)) {
390 my %uri_map;
391 for my $module ($req->required_modules) {
392 next if $module eq 'perl';
393 my $uri = $self->_get_uri($module) or next;
394 $uri_map{$uri}{$module} = $req->requirements_for_module($module);
395 }
396 for my $uri (keys %uri_map) {
397 my @modules = keys %{$uri_map{$uri}};
398 next if @modules < 2;
399  
400 my @modules_without_version = grep {!$uri_map{$uri}{$_}} @modules;
401 next unless @modules_without_version;
402  
403 # clear unversioned prereqs if a versioned prereq exists
404 if (@modules > @modules_without_version) {
405 $req->clear_requirement($_) for @modules_without_version;
406 next;
407 }
408  
409 # Replace with the main module if none is versioned
410 my $dist = _dist_from_uri($uri);
411 (my $main_module = $dist) =~ s/-/::/g;
412 if ($self->_get_uri($main_module)) {
413 $req->add_minimum($main_module);
414 for my $module (@modules_without_version) {
415 next if $main_module eq $module;
416 $req->clear_requirement($module);
417 if ($self->{verbose}) {
418 print STDERR " deduped $module (in favor of $main_module)\n";
419 }
420 }
421 } else {
422 # special case for distributions without a main module
423 my %score;
424 for my $module (@modules_without_version) {
425 my $depth = $module =~ s/::/::/g;
426 my $length = length $module;
427 $score{$module} = join ".", ($depth || 0), $length;
428 }
429 my $topmost = (sort {$score{$a} <=> $score{$b} or $a cmp $b} @modules_without_version)[0];
430 for my $module (@modules_without_version) {
431 next if $topmost eq $module;
432 $req->clear_requirement($module);
433 if ($self->{verbose}) {
434 print STDERR " deduped $module (in favor of $topmost)\n";
435 }
436 }
437 }
438 }
439 }
440 }
441  
442 sub _scan_dir {
443 my ($self, $dir) = @_;
444 find ({
445 no_chdir => 1,
446 wanted => sub {
447 my $file = $_;
448 return unless -f $file;
449 my $relpath = File::Spec->abs2rel($file, $self->{base_dir});
450  
451 return unless $relpath =~ /\.(?:pl|PL|pm|cgi|psgi|t)$/ or
452 dirname($relpath) =~ m!\b(?:bin|scripts?)$! or
453 ($self->{develop} and $relpath =~ /^(?:author)\b/);
454 $self->_scan_file($file);
455 },
456 }, $dir);
457 }
458  
459 sub _scan_file {
460 my ($self, $file) = @_;
461  
462 $file =~ s|\\|/|g if WIN32;
463 if ($self->{ignore_re}) {
464 return if $file =~ /\b$self->{ignore_re}\b/;
465 }
466  
467 my $optional = $self->{optional_re} && $file =~ /\b$self->{optional_re}\b/ ? 1 : 0;
468  
469 my $context = Perl::PrereqScanner::NotQuiteLite->new(
470 parsers => $self->{parsers},
471 recommends => $self->{recommends},
472 suggests => $self->{suggests},
473 verbose => $self->{verbose},
474 optional => $optional,
475 )->scan_file($file);
476  
477 my $relpath = File::Spec->abs2rel($file, $self->{base_dir});
478 $relpath =~ s|\\|/|g if WIN32;
479  
480 my $prereqs = $self->{prereqs};
481 if ($self->{features}) {
482 for my $identifier (keys %{$self->{features}}) {
483 my $feature = $self->{features}{$identifier};
484 if (grep {$file =~ m!^$_(?:/|$)!} @{$feature->{paths}}) {
485 $prereqs = $feature->{prereqs} ||= CPAN::Meta::Prereqs->new;
486 last;
487 }
488 }
489 }
490  
491 if ($relpath =~ m!(?:^|[\\/])t[\\/]!) {
492 if ($relpath =~ /\.t$/) {
493 $self->_add($prereqs, test => $context);
494 } elsif ($relpath =~ /\.pm$/) {
495 $self->{_test_pm}{$relpath} = $context;
496 }
497 } elsif ($relpath =~ m!(?:^|[\\/])(?:xt|inc|author)[\\/]!) {
498 $self->_add($prereqs, develop => $context);
499 } elsif ($relpath =~ m!(?:(?:^|[\\/])Makefile|^Build)\.PL$!) {
500 $self->_add($prereqs, configure => $context);
501 } elsif ($relpath =~ m!(?:^|[\\/])(?:.+)\.PL$!) {
502 $self->_add($prereqs, build => $context);
503 } else {
504 $self->_add($prereqs, runtime => $context);
505 }
506  
507 if ($relpath =~ /\.pm$/) {
508 my $module = $relpath;
509 $module =~ s!\.pm$!!;
510 $module =~ s![\\/]!::!g;
511 $self->{possible_modules}{$module} = $relpath;
512 $module =~ s!^(?:inc|blib|x?t)::!!;
513 $self->{possible_modules}{$module} = $relpath;
514 $module =~ s!^lib::!!;
515 $self->{possible_modules}{$module} = $relpath;
516 }
517 }
518  
519 sub _add {
520 my ($self, $prereqs, $phase, $context) = @_;
521  
522 $prereqs->requirements_for($phase, 'requires')
523 ->add_requirements($context->requires);
524  
525 if ($self->{suggests} or $self->{recommends}) {
526 $prereqs->requirements_for($phase, 'recommends')
527 ->add_requirements($context->recommends);
528 }
529  
530 if ($self->{suggests}) {
531 $prereqs->requirements_for($phase, 'suggests')
532 ->add_requirements($context->suggests);
533 }
534 }
535  
536 1;
537  
538 __END__