view release on metacpan or  search on metacpan

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

	FALSE => 0,};

use Moo;
with qw(
	App::Midgen::Role::Options
	App::Midgen::Role::Attributes
	App::Midgen::Role::AttributesX
	App::Midgen::Role::InDistribution
	App::Midgen::Role::TestRequires
	App::Midgen::Role::UseOk
	App::Midgen::Role::Eval
	App::Midgen::Role::FindMinVersion
	App::Midgen::Role::Output
	App::Midgen::Role::UseModule
	App::Midgen::Role::Experimental
	App::Midgen::Role::Heuristics
);

# Load time and dependencies negate execution time
# use namespace::clean -except => 'meta';
use version;
our $VERSION = '0.34';
$VERSION = eval $VERSION;    ## no critic

use English qw( -no_match_vars );    # Avoids reg-ex performance penalty
local $OUTPUT_AUTOFLUSH = 1;

use Cwd qw(getcwd);
use Data::Printer {caller_info => 1,};
use File::Find qw(find);
use File::Spec;
use Module::CoreList;
use PPI;
use Term::ANSIColor qw( :constants colored colorstrip );
use Try::Tiny;
use Tie::Static qw(static);
use version;

# stop rlib from Fing all over cwd
our $Working_Dir = getcwd();
our $Min_Version = 0;


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

	$self->_initialise();
	try {
		$self->first_package_name();
	};


	$self->find_runtime_modules();
	$self->find_test_modules();
	$self->find_develop_modules() if $self->experimental;

	#now for some Heuristics :)
	$self->recast_to_runtimerequires($self->{RuntimeRequires},
		$self->{RuntimeRecommends});
	$self->recast_to_testrequires($self->{TestRequires}, $self->{TestSuggests});

	# Now we have switched to MetaCPAN-Api we can hunt for noisy children in tests
	if ($self->experimental) {

		$self->remove_noisy_children($self->{RuntimeRequires});
		$self->remove_twins($self->{RuntimeRequires});

		# Run a second time if we found any twins, this will sort out twins and triplets etc
		$self->remove_noisy_children($self->{RuntimeRequires})
			if $self->found_twins;

		foreach (qw( TestRequires TestSuggests DevelopRequires )) {

			p $self->{$_} if $self->debug;
			$self->remove_noisy_children($self->{$_});
			foreach my $module (keys %{$self->{$_}}) {
				if ($self->{RuntimeRequires}{$module}) {
					warn $module if $self->debug;
					try {
						delete $self->{$_}{$module};
					};
				}
			}
			p $self->{$_} if $self->debug;
		}
	}

	# display chosen output format
	$self->output_header();
	$self->output_main_body('RuntimeRequires',   $self->{RuntimeRequires});
	$self->output_main_body('RuntimeRecommends', $self->{RuntimeRecommends})
		if $self->meta2;
	$self->output_main_body('TestRequires', $self->{TestRequires});
	if ($self->meta2) {
		$self->output_main_body('TestSuggests', $self->{TestSuggests});
		$self->output_main_body('Close', {});
		$self->output_main_body('DevelopRequires', $self->{DevelopRequires});
	}
	else {

		# concatenate hashes
		try {
			%{$self->{recommends}} = (%{$self->{RuntimeRecommends}},);
		};
		try {
			%{$self->{recommends}}
				= (%{$self->{recommends}}, %{$self->{TestSuggests}},);
		};
		try {
			%{$self->{recommends}}
				= (%{$self->{recommends}}, %{$self->{DevelopRequires}},);
		};
		$self->output_main_body('recommends', $self->{recommends});
	}

	$self->output_footer();

	#now for tidy-up Heuristics :)