« blib/lib/Perl/PrereqScanner/NotQuiteLite.pm
↑ Summary
blib/lib/Perl/PrereqScanner/NotQuiteLite/Context.pm »
| 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__ |