File Coverage

blib/lib/Gopher/Server/RequestHandler/File.pm

Criterion	Covered	Total	%
statement	19	42	45.2
branch	0	6	0.0
condition	0	8	0.0
subroutine	7	11	63.6
pod			n/a
total	26	67	38.8

package Gopher::Server::RequestHandler::File;
use strict;
use warnings;
use Gopher::Server::Response;
use base 'Gopher::Server::RequestHandler';


sub new
{
	my ($class, $in) = @_;

	die "Need a hashref" unless ref($in) eq 'HASH';

	my $root = $in->{root} || die "Need a root for the server";
	my $host = $in->{host} || die "Need a host for the server";
	my $port = $in->{port} || die "Need a port for the server";

	my $self = {
		root => $root,
		host => $host,
		port => $port,
	};
	bless $self, $class;
}

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


sub process
{
	my ($self, $request) = @_;

	my $path = $self->_canonpath( $request->selector );

	my $response;
	if( -d $path ) { # Directory, send back menu
		$response = $self->_make_menu( $path, $request );
	}
	elsif( -e $path ) { # File, return its contents
		$response = $self->_make_file( $path, $request );
	}
	else { # Nothing found
	}

	return $response;
}


sub _canonpath
{
	my $self = shift;
	my $want = shift || '/';
	my $root = $self->root;

	use File::Spec;
	my @splitpath = File::Spec->splitdir($want);
	my @splitpath_clean = File::Spec->no_upwards(@splitpath);
	return File::Spec->canonpath(
		File::Spec->join( $root, @splitpath_clean )
	);
}

sub _make_menu
{
	my ($self, $path, $request) = @_;

	my $selector = $request->selector;
	opendir( my $dir, $path ) or die "Can't open directory $path: $!\n";

	my @menu_items;
	foreach my $dir_item (readdir($dir)) {
		use Gopher::Server::TypeMapper;
		my $item_type = Gopher::Server::TypeMapper->get_type({
			filename => "$path/$dir_item",
		});

		use Net::Gopher::Response::MenuItem;
		my $item_selector = $selector . "/$dir_item";
		push @menu_items, Net::Gopher::Response::MenuItem->new({
			#request      => $request,
			ItemType     => $item_type->gopher_type,
			Display      => $dir_item,
			Selector     => $item_selector,
			Host         => $self->{host},
			Port         => $self->{port},
		});
	}

	return Gopher::Server::Response->new({
		request     => $request,
		menu_items  => \@menu_items,
	});
}

sub _make_file
{
	my ($self, $path, $request) = @_;

	open(my $fh, '<', $path) or die "Can't open $path: $!\n";

	return Gopher::Server::Response->new({
		request  => $request,
		fh       => $fh,
	});
}


1;
__END__