view release on metacpan or  search on metacpan

lib/App/Midgen.pm  view on Meta::CPAN

	return;
}


#######
# find_runtime_modules
#######
sub find_runtime_modules {
	my $self = shift;

	my @posiable_directories_to_search
		= map { File::Spec->catfile($Working_Dir, $_) }
		qw( bin share script lib );

	my @directories_to_search = ();
	foreach my $directory (@posiable_directories_to_search) {
		if (defined -d $directory) {
			push @directories_to_search, $directory;
		}
	}
	p @directories_to_search if $self->debug;

	try {
		find(sub { _find_runtime_requirments($self); }, @directories_to_search);
	};

	return;

}
#######
# _find_runtime_requirments
#######
sub _find_runtime_requirments {
	my $self     = shift;
	my $filename = $_;

	return if $self->is_perlfile($filename) == FALSE;
 
	my $relative_dir = $File::Find::dir;
	$relative_dir =~ s/$Working_Dir//;
	$self->_set_looking_infile(File::Spec->catfile($relative_dir, $filename));
	$self->_set_ppi_document(PPI::Document->new($filename));

	# do extra test early check for use_module before hand
	$self->xtests_use_module('RuntimeRecommends');

	# ToDo add eval/try here -> prereqs { runtime { suggests or recommends {...}}}
	$self->xtests_eval('RuntimeRecommends');

	# normal pps -> RuntimeRequires
	my $prereqs = $self->scanner->scan_ppi_document($self->ppi_document);
	my @modules = $prereqs->required_modules;


	foreach my $mod_ver (@modules) {
		$self->{found_version}{$mod_ver}
			= $prereqs->requirements_for_module($mod_ver);
	}

	$self->{skip_not_mcpan_stamp} = 0;

	if (grep { $_ =~ m/^Dist::Zilla::Role::PluginBundle/ } @modules) {

		$self->{skip_not_mcpan_stamp} = 1;

		my $ppi_tqs = $self->ppi_document->find('PPI::Token::Quote::Single');
		if ($ppi_tqs) {

			foreach my $include (@{$ppi_tqs}) {

				my $module = $include->content;
				$module =~ s/^[']//;
				$module =~ s/[']$//;

				next if $module =~ m/^Dist::Zilla::Role::PluginBundle/;
				next if $module =~ m{\A[-|:|\d]};
				next if $module !~ m{\A(?:[[a-zA-Z])};
				next if $module =~ m{[.|$|\\|/|\-|\[|%|@|]};
				next if $module eq NONE;

				push @modules, 'Dist::Zilla::Plugin::' . $module;
			}
		}
	}

	if (scalar @modules > 0) {
		for (0 .. $#modules) {
			try {
				$self->_process_found_modules('RuntimeRequires', $modules[$_],
					$prereqs->requirements_for_module($modules[$_]),
					'Perl::PrereqScanner', 'RuntimeRequires',);
			};
		}
	}

	#run pmv now
	$self->min_version($self->looking_infile) if $self->format ne 'infile';

	return;
}


#######
# find_test_modules
#######
sub find_test_modules {
	my $self = shift;

	my $directory = 't';
	if (defined -d $directory) {

		find(sub { _find_test_develop_requirments($self, $directory); },
			$directory);

	}

	return;

}
#######
# find_develop_modules
#######
sub find_develop_modules {
	my $self = shift;

lib/App/Midgen.pm  view on Meta::CPAN

			next;
		}
		elsif ($module =~ /^inc::Module::Install/sxm) {

			# don't inc::Module::Install as it is really Module::Install
			next;
		}
		elsif ($module =~ /Mojo/sxm) {
			if ($self->experimental) {
				if ($self->_check_mojo_core($module, $require_type)) {
					if (not $self->quiet) {
						print BRIGHT_BLACK;
						print "swapping out $module for Mojolicious\n";
						print CLEAR;
					}
					next;
				}
			}
		}
		elsif ($module =~ /^Padre/sxm) {

			# mark all Padre core as just Padre only, for plugins
			$module = 'Padre';
		}
	}

	# lets keep track of how many times a module include is found
	$self->{modules}{$module}{count} += 1;
	try {
		push @{$self->{modules}{$module}{infiles}},
			[$self->looking_infile(), $version, $extra_scanner, $pr_location,];
	};

	# don't process already found modules
	p $self->{modules}{$module}{prereqs} if $self->debug;

	next if defined $self->{modules}{$module}{prereqs};
	p $module if $self->debug;

	# add skip for infile as we don't need to get v-string from metacpan-api
	$self->_store_modules($require_type, $module) if $self->format ne 'infile';

	return;
}

#######
# composed method - _store_modules
#######
sub _store_modules {
	my $self         = shift;
	my $require_type = shift;
	my $module       = shift;
	p $module if $self->debug;

	$self->_in_corelist($module)
		if not defined $self->{modules}{$module}{corelist};
	my $version = $self->get_module_version($module, $require_type);

	if ($version eq '!mcpan') {
		$self->{$require_type}{$module} = colored('!mcpan', 'magenta')
			if not $self->{skip_not_mcpan_stamp};
		$self->{modules}{$module}{prereqs} = $require_type;
		$self->{modules}{$module}{version} = '!mcpan';
	}
	elsif ($version eq 'core') {
		$self->{$require_type}{$module} = $version if $self->core;
		$self->{$require_type}{$module} = '0'      if $self->zero;
		$self->{modules}{$module}{prereqs} = $require_type;
		$self->{modules}{$module}{version} = $version if $self->core;
	}
	else {
		if ($self->{modules}{$module}{corelist}) {

			$self->{$require_type}{$module} = colored($version, 'bright_yellow')
				if ($self->dual_life || $self->core);
			$self->{modules}{$module}{prereqs} = $require_type
				if ($self->dual_life || $self->core);
			$self->{modules}{$module}{version} = $version
				if ($self->dual_life || $self->core);
			$self->{modules}{$module}{dual_life} = 1;
			$self->{modules}{$module}{prereqs} = $require_type;
			$self->{modules}{$module}{version} = $version;

		}
		else {
			$self->{$require_type}{$module} = colored($version, 'yellow');
			$self->{$require_type}{$module}
				= colored(version->parse($version)->numify, 'yellow')
				if $self->numify;

			$self->{modules}{$module}{prereqs} = $require_type;
			$self->{modules}{$module}{version} = $version;

			$self->{$require_type}{$module} = colored($version, 'bright_cyan')
				if $self->{modules}{$module}{'distribution'};
		}
	}
	p $self->{modules}{$module} if $self->debug;

	return;
}

#######
# composed method _in_corelist
#######
sub _in_corelist {
	my $self   = shift;
	my $module = shift;

	#return TRUE (1) if defined $self->{modules}{$module}{corelist};

	# hash with core modules to process regardless
	my $ignore_core = {'File::Path' => 1, 'Test::More' => 1,};

	if (!$ignore_core->{$module}) {

		if ( Module::CoreList->first_release($module) ) {
			$self->{modules}{$module}{corelist} = 1;
			return TRUE;
		}
		else {