File Coverage

blib/lib/Mooish/Base.pm

Criterion	Covered	Total	%
statement	67	80	83.7
branch	20	28	71.4
condition	7	12	58.3
subroutine	12	12	100.0
pod			n/a
total	106	132	80.3

package Mooish::Base;
$Mooish::Base::VERSION = '1.005';
use v5.10;
use strict;
use warnings;
use Import::Into;

require Mooish::AttributeBuilder;
require Type::Tiny;
require namespace::autoclean;

use constant FLAVOUR => $ENV{MOOISH_BASE_FLAVOUR} // 'Moo';
use constant ROLE_FLAVOUR => $ENV{MOOISH_BASE_ROLE_FLAVOUR} // (FLAVOUR . '::Role');

use constant EXTRA_MODULES => $ENV{MOOISH_BASE_EXTRA_MODULES} // join ';', qw(
	Hook::AfterRuntime
	MooX::TypeTiny
	MooseX::XSAccessor
);

use constant EXTRA_MODULES_AVAILABLE => {
	'Hook::AfterRuntime' => !!eval { require Hook::AfterRuntime; Hook::AfterRuntime->VERSION('0.003'); 1 },
	'MooX::TypeTiny' => !!eval { require MooX::TypeTiny; MooX::TypeTiny->VERSION('0.002002'); 1 },
	'MooX::XSConstructor' => !!eval { require MooX::XSConstructor; MooX::XSConstructor->VERSION('0.003002'); 1 },
	'MooseX::XSConstructor' => !!
		eval { require MooseX::XSConstructor; MooseX::XSConstructor->VERSION('0.001002'); 1 },
	'MooseX::XSAccessor' => !!eval { require MooseX::XSAccessor; MooseX::XSAccessor->VERSION('0.010'); 1 },
};

use constant EXTRA_MODULES_RULES => {
	'Hook::AfterRuntime' => {type => 'Moose'},
	'MooX::TypeTiny' => {type => 'Moo'},
	'MooX::XSConstructor' => {type => 'Moo'},
	'MooseX::XSConstructor' => {type => 'Moose'},
	'MooseX::XSAccessor' => {type => 'Moose', role => !!1},
};

BEGIN {
	eval 'require ' . FLAVOUR or die $@;
	eval 'require ' . ROLE_FLAVOUR or die $@;
}

our $DEBUG;

sub _uses_extra_module
{
	my ($module, $class_type, $role) = @_;

	state $wanted_modules = {
		map { $_ => 1 }
			map { s{^\s+}{}; s{\s+$}{}; $_ }
			split ';', EXTRA_MODULES
	};

	return $wanted_modules->{$module}
		&& EXTRA_MODULES_AVAILABLE->{$module}
		&& EXTRA_MODULES_RULES->{$module}{type} eq $class_type
		&& (!$role || EXTRA_MODULES_RULES->{$module}{role})
		;
}

sub import
{
	my $me = shift;
	my $pkg = caller;

	my $class_type = FLAVOUR;
	my $role_type = ROLE_FLAVOUR;
	my $role = !!0;
	my $standard = !!0;

	foreach my $arg (@_) {
		if ($arg eq -role) {
			$role = !!1;
		}
		elsif ($arg eq -standard) {
			$standard = !!1;
		}
	}

	# Moo is the best choice for module development
	if ($standard) {
		$class_type = 'Moo';
		$role_type = 'Moo::Role';
	}

	my $engine = $role ? $role_type : $class_type;
	$engine->import::into($pkg);
	Mooish::AttributeBuilder->import::into($pkg, ($standard ? (-standard) : ()));
	Types::Common->import::into($pkg, -types);
	namespace::autoclean->import(-cleanee => $pkg);

	# install extra modules

	my %extra_modules = map { $_ => _uses_extra_module($_, $class_type, $role) }
		keys %{(EXTRA_MODULES_RULES)};

	MooX::TypeTiny->import::into($pkg)
		if $extra_modules{'MooX::TypeTiny'};

	MooX::XSConstructor->import::into($pkg)
		if $extra_modules{'MooX::XSConstructor'};

	MooseX::XSConstructor->import::into($pkg)
		if $extra_modules{'MooseX::XSConstructor'};

	MooseX::XSAccessor->import::into($pkg)
		if $extra_modules{'MooseX::XSAccessor'};

	# special handling for Hook::AfterRuntime - warn if it can't be used on Moose
	if ($extra_modules{'Hook::AfterRuntime'}) {
		Hook::AfterRuntime::after_runtime { $pkg->meta->make_immutable };
	}
	elsif ($class_type eq 'Moose' && !$role) {
		warn "Mooish::Base can't make $pkg Moose class immutable - please install Hook::AfterRuntime module";
	}

	# put debug information if requested
	$DEBUG->{$pkg} = {
		class_type => $class_type,
		role_type => $role_type,
		role => $role,
		standard => $standard,
		extra_modules => \%extra_modules,
	} if $DEBUG;
}

1;

__END__