File Coverage

blib/lib/File/Tasks.pm

Criterion	Covered	Total	%
statement	77	133	57.8
branch	16	74	21.6
condition	3	6	50.0
subroutine	22	32	68.7
pod	14	15	93.3
total	132	260	50.7

package File::Tasks;

# See POD at end for docs

use 5.005;
use strict;
use Clone                 ();
use Params::Util          '_INSTANCE';
use Params::Coerce        ();
use File::Tasks::Provider ();
use File::Tasks::Add      ();
use File::Tasks::Edit     ();
use File::Tasks::Remove   ();
use constant 'FFR'  => 'File::Find::Rule';
use overload 'bool' => sub () { 1 };
use overload '+'    => '_overlay';

use vars qw{$VERSION};
BEGIN {
	$VERSION = '0.07';
}





#####################################################################
# Constructor and Accessors

sub new {
	my $class  = ref $_[0] ? ref shift : shift;
	my %params = (ref $_[0] eq 'HASH') ? %{shift()} : @_;

	# Create the basic object
	my $self = bless {
		provider => 'File::Tasks::Provider',
		tasks    => {},
		ignore   => undef,
		}, $class;

	# Accept an alternate provider
	if ( _INSTANCE($params{provider}, 'File::Tasks::Provider') ) {
		$self->{provider} = $params{provider};
	}

	# Set the auto-ignore
	if ( _INSTANCE($params{ignore}, FFR) ) {
		$self->{ignore} = $params{ignore}->prune->discard;
	}

	$self;
}

sub provider { $_[0]->{provider} }

sub ignore { $_[0]->{ignore} }

# We need to do this ourself, as sort in scalar context returns undef
sub paths {
	wantarray
		? sort keys %{$_[0]->{tasks}}
		: scalar(keys %{$_[0]->{tasks}});
}

sub tasks {
	my $tasks = $_[0]->{tasks};
	map { $tasks->{$_} } $_[0]->paths;
}

sub task {
	my $self = shift;
	my $path = defined $_[0] ? shift : return undef;
	$self->{tasks}->{$path};
}





#####################################################################
# Building the File::Tasks

sub add {
	$_[0]->set(File::Tasks::Add->new(@_));
}

sub edit {
	$_[0]->set(File::Tasks::Edit->new(@_));
}

sub remove {
	$_[0]->set(File::Tasks::Remove->new(@_));
}

sub remove_dir {
	my $self = shift;
	my $dir  = -d $_[0] ? shift : return undef;
	require File::Find::Rule; # Only load as needed
	my $Rule = _INSTANCE(shift, 'File::Find::Rule') || FFR->new;
	$Rule = FFR->or( $self->{ignore} || (), $Rule )->relative->file;

	# Execute the file and add all resulting files as Remove entries
	my @files = $Rule->in($dir);
	foreach my $file ( @files ) {
		$self->remove( $file ) or return undef;
	}

	scalar @files;
}

sub set {
	my $self = shift;
	my $Task = _INSTANCE(shift, 'File::Tasks::Task') or return undef;
	$self->clashes($Task->path) and return undef;
	$self->{tasks}->{$Task} = $Task;
}

sub clashes {
	my $self = shift;
	my $path = defined $_[0] ? shift : return undef;
	return '' if $self->{tasks}->{$path};
	foreach ( sort keys %{$self->{tasks}} ) {
		return 1 if $path eq $_;
		return 1 if $_ =~ m!^$path/!;
		return 1 if $path =~ m!$_/!;
	}
	'';
}





#####################################################################
# Actions for the File::Tasks

sub test {
	my $self = shift;
	foreach my $path ( sort keys %{$self->{tasks}} ) {
		my $Task = $self->{tasks}->{$path} or return undef;
		$Task->test or return undef;
	}
	1;
}

sub execute {
	my $self = shift;
	foreach my $path ( sort keys %{$self->{tasks}} ) {
		my $Task = $self->{tasks}->{$path} or return undef;
		$Task->execute or return undef;
	}
	1;
}





#####################################################################
# Higher Order Methods

sub overlay {
	my $self  = Clone::clone shift;
	my $other = Params::Coerce::coerce('File::Tasks', shift) or return undef;
	foreach my $Task ( $other->tasks ) {
		my $Current = $self->task($Task->path);
		unless ( $Current ) {
			$self->set($Current) or return undef;
			next;
		}
		if ( $Task->type eq 'add' ) {
			if ( $Current->type eq 'add' ) {
				# Add over Add - Replace existing object
				$self->{tasks}->{$Task} = $Task;
			} else {
				# Add over Edit - Convert Add to Edit and replace
				# Add over Delete - Convert Add to Edit and replace
				my $Edit = File::Tasks::Edit->new(
					$self, $Task->path, $Task->source,
					) or return undef;
				$self->{tasks}->{$Edit} = $Edit;
			}
		} elsif ( $Task->type eq 'edit' ) {
			if ( $Current->type eq 'add' ) {
				# Edit over Add - Convert Edit to Add and replace
				my $Add = File::Tasks::Add->new(
					$self, $Task->path, $Task->source,
					) or return undef;
				$self->{tasks}->{$Add} = $Add;
			} else {
				# Edit over Edit - Replace existing object
				# Edit over Delete - Replace existing object
				$self->{tasks}->{$Task} = $Task;
			}
		} else {
			if ( $Current->type eq 'add' ) {
				# Delete over Add - Tasks cancel each other out
				delete $self->{tasks}->{$Task};
			} elsif ( $Current->type eq 'edit' ) {
				# Delete over Edit - Replace existing object
				$self->{tasks}->{$Task} = $Task;
			} else {
				# Nothing to do
			}
		}
	}
	$self;
}

# A thin wrapper to handle the way overloaded arguments are provided
sub _overlay {
	my $left  = _INSTANCE(shift, 'File::Tasks') ? shift : return undef;
	my $right = Params::Coerce::coerce('File::Tasks', shift) or return undef;
	($left, $right) = ($right, $left) if $_[0];
	$left->overlay($right);
}





#####################################################################
# Coercion Support

# From an entire builder
sub __from_Archive_Builder {
	my $self    = shift->new;
	my $Builder = _INSTANCE(shift, 'Archive::Builder') or return undef;
	my $files   = $Builder->files;
	foreach my $path ( keys %$files ) {
		$self->add( $path, $files->{$path} ) or return undef;
	}
	$self;
}

# From a single Section
sub __from_Archive_Builder_Section {
	my $self    = shift->new;
	my $Section = _INSTANCE(shift, 'Archive::Builder::Section') or return undef;
	my $files   = $Section->files;
	foreach my $path ( keys %$files ) {
		$self->add( $path, $files->{$path} ) or return undef;
	}
	$self;
}

1;

__END__