File Coverage

blib/lib/App/Scaffolder/Command.pm

Criterion	Covered	Total	%
statement	90	112	80.3
branch	17	32	53.1
condition	9	17	52.9
subroutine	22	23	95.6
pod	12	12	100.0
total	150	196	76.5

package App::Scaffolder::Command;
{
  $App::Scaffolder::Command::VERSION = '0.002000';
}

# ABSTRACT: Base class for App::Scaffolder commands

use strict;
use warnings;

use Carp;

use App::Cmd::Setup -command;
use File::HomeDir;
use File::ShareDir;
use Path::Class::Dir;
use MRO::Compat;
use Config;

use App::Scaffolder::Template;


sub opt_spec {
	my ($class, $app) = @_;
	return (
		[ 'list|l'              => 'List the search path and the available templates' ],
		[ 'template|t=s'        => 'Name of the template that should be used' ],
		[ 'target=s'            => 'Target directory where output should go - '
			. 'defaults to current directory, but commands may override this' ],
		[ 'create-template-dir' => 'Create directory for custom user templates' ],
		[ 'overwrite'           => 'Overwrite existing files', { default => 0 }],
		[ 'quiet'               => 'Do not print the list of created files' ],
		[], ['Command-specific options:'],
		$class->get_options($app),
	)
}

sub validate_args {
	my ($self, $opt, $args) = @_;

	$self->next::method($opt, $args);
	unless ($self->contains_base_args($opt) || $opt->template()) {
		$self->usage_error("Parameter 'template' required");
	}
	return;
}



sub contains_base_args {
	my ($self, $opt) = @_;
	return $opt->list() || $opt->create_template_dir();
}


sub get_options {
	my ($class, $app) = @_;
	return ();
}



sub get_template_dirs {
	my ($self) = @_;

	my @dirs;
	my $command_name = $self->command_names();
	my $user_template_dir = $self->_get_user_template_dir($command_name);
	if ($user_template_dir) {
		push @dirs, $user_template_dir;
	}
	push @dirs, $self->get_extra_template_dirs($command_name);
	my $command_dir = Path::Class::Dir->new(
		File::ShareDir::dist_dir($self->get_dist_name())
	)->subdir($command_name);
	if (-d $command_dir) {
		push @dirs, $command_dir;
	}

	return @dirs;
}

sub _get_user_template_dir {
	my ($self, $command, $create) = @_;
	my $my_dist_data = File::HomeDir->my_dist_data(
		$self->get_dist_name(),
		$create ? { create => 1} : ()
	);
	if ($my_dist_data) {
		my $my_command_dir = Path::Class::Dir->new($my_dist_data)->subdir($command);
		if (-d $my_command_dir) {
			return $my_command_dir;
		}
		elsif ($create) {
			$my_command_dir->mkpath()
				or confess("Unable to create template dir $my_command_dir");
			return $my_command_dir
		}
	}
	return;
}



sub get_extra_template_dirs {
	my ($self, $command) = @_;

	if (! defined $command || $command eq '') {
		croak("Required 'command' parameter not passed or empty");
	}

	my $scaffolder_template_path = $ENV{SCAFFOLDER_TEMPLATE_PATH};
	my @extra_template_dirs;
	if (defined $scaffolder_template_path && $scaffolder_template_path ne '') {
		push @extra_template_dirs, grep { -d $_ } map {
			Path::Class::Dir->new($_)->subdir($command)
		} split(/$Config::Config{path_sep}/x, $scaffolder_template_path);
	}

	return @extra_template_dirs;
}



sub get_templates {
	my ($self) = @_;

	my $template = {};
	for my $dir ($self->get_template_dirs()) {
		for my $template_dir (grep { $_->is_dir() } $dir->children()) {
			my $name = $template_dir->dir_list(-1, 1);
			if (exists $template->{$name}) {
				$template->{$name}->add_path_entry($template_dir);
			}
			else {
				$template->{$name} = App::Scaffolder::Template->new({
					name => $name,
					path => [ $template_dir ],
				});
			}
		}
	}
	return $template;
}



sub get_template {
	my ($self, $name) = @_;

	if (! defined $name || $name eq '') {
		croak("Required 'name' parameter not passed or empty");
	}

	my $template = $self->get_templates();
	unless (exists $template->{$name}) {
		croak("No template called '$name' found");
	}
	return $template->{$name}
}



sub get_target {
	my ($self, $opt) = @_;
	return Path::Class::Dir->new($opt->target() || '.');
}



sub get_variables {
	my ($self, $opt) = @_;
	return {};
}



sub get_dist_name {
	confess("get_dist_name must be implemented by scaffolder commands");
}



sub execute {
	my ($self, $opt, $args) = @_;

	if ($opt->list()) {
		print "Template search path for ".$self->command_names().":\n ";
		print join "\n ", $self->get_template_dirs();
		print "\nAvailable templates for ".$self->command_names().":\n ";
		print join "\n ", sort keys %{$self->get_templates()};
		print "\n";
		return;
	}
	if ($opt->create_template_dir()) {
		$self->_get_user_template_dir($self->command_names(), 1);
		print "Template search path after creating template dir for "
			.$self->command_names().":\n ";
		print join "\n ", $self->get_template_dirs();
		print "\n";
		return;
	}

	my @files = $self->get_template($opt->template())->process({
		target    => $self->get_target($opt),
		variables => $self->get_variables($opt),
		overwrite => $opt->overwrite(),
	});
	unless ($opt->quiet()) {
		print join("\n", sort @files) . "\n";
	}

	return;
}

1;


__END__