File Coverage

blib/lib/Text/NumericData/App.pm

Criterion	Covered	Total	%
statement	95	108	87.9
branch	49	76	64.4
condition	3	9	33.3
subroutine	9	10	90.0
pod	4	6	66.6
total	160	209	76.5

package Text::NumericData::App;

use Text::NumericData;
use Config::Param;
use Storable;
use strict;

# This is just a placeholder because of a past build system bug.
# The one and only version for Text::NumericData is kept in
# the Text::NumericData module itself.
our $VERSION = '1';
$VERSION = eval $VERSION;

my %shorts = (strict=>'S', text=>'T', numformat=>'N');

sub new
{
	my $class = shift;
	my $self = {};
	bless $self, $class;
	$self->{setup} = shift; # main, parconf, pardef, exclude_pars
	$self->{state} = {};

	# safety check for misspelled keys
	my @known_setup =
	(qw(
		parconf
		pardef
		exclude
		filemode
		pipemode
		pipe_init
		pipe_file
		pipe_prefilter
		pipe_begin
		pipe_line
		pipe_end
		pipe_allend
		pipe_header
		pipe_data
		pipe_first_data
	));
	my @unknown_keys = grep {my $k = $_; not grep {$_ eq $k} @known_setup;} (keys %{$self->{setup}});
	print STDERR "WARNING: Text::NumericData::App got unknown setup keys (@unknown_keys)\n" if @unknown_keys;

	if($self->{setup}{pipemode})
	{
		# Activate pipe processing only on request.
		require Text::ASCIIPipe;
	}

	$self->{setup}{parconf} = {} unless defined $self->{setup}{parconf};
	# Always return.
	$self->{setup}{parconf}{noexit} = 1;

	# Lazyness ... why specify this again and again?
	$self->{setup}{parconf}{copyright} = $Text::NumericData::copyright
		unless defined $self->{setup}{parconf}{copyright};
	$self->{setup}{parconf}{version} = $Text::NumericData::version
		unless defined $self->{setup}{parconf}{version};
	$self->{setup}{parconf}{author} = $Text::NumericData::author
		unless defined $self->{setup}{parconf}{author};

	$self->{setup}{pardef}  = [] unless defined $self->{setup}{pardef};
	my $prob = Config::Param::sane_pardef($self->{setup}{parconf}, $self->{setup}{pardef});
	if($prob ne '')
	{
		print STDERR  "Error in given parameter definiton: $prob\nThis is a fatal programming error.\n";
		return undef;
	}
	# I'm sure this can be done more elegantly.
	$self->add_param('Text::NumericData'
	, \%Text::NumericData::defaults, \%Text::NumericData::help)
		or return undef;
	$self->add_param('Text::NumericData::File'
	, \%Text::NumericData::File::defaults, \%Text::NumericData::File::help)
		or return undef;

	return $self;
}

sub add_param
{
	my $self = shift;
	my ($pkgname, $defaults, $help) = @_;
	for my $pn (keys %{$defaults})
	{
		next if (defined $self->{setup}{exclude} and grep {$_ eq $pn} @{$self->{setup}{exclude}});
		my $help = $help->{$pn};
		$help = "some $pkgname parameter" unless defined $help;
		$help .= " (from $pkgname)";
		my $thisdef =
		{
		  long=>$pn
		, short=>$shorts{$pn}
		# No deep copy here, as the calls to Config::Param get copies of this.
		, value=>$defaults->{$pn}
		, help=>$help
		};
		if(Config::Param::sane_pardef($self->{setup}{parconf}, [$thisdef]) ne '')
		{
			print STDERR "Unexpected failure to sanitize param definiton for $pn.\n";
			return undef;
		}
		push(@{$self->{setup}{pardef}}, $thisdef);
	}
	return 1;
}

sub run
{
	my ($self, $argv, $in, $out) = @_;
	$argv = \@ARGV unless defined $argv;
	$in  = \*STDIN  unless defined $in;
	$out = \*STDOUT unless defined $out;
	binmode $in;
	binmode $out;
	$self->{argv} = $argv;
	$self->{in}  = $in;
	$self->{out} = $out;

	my $errors;
	# Ensure that Config::Param cannot mess with our default values by
	# providing deep copies of configuration. Even if it behaves nice,
	# better safe than sorry.
	$self->{param} = Config::Param::get(
		Storable::dclone($self->{setup}{parconf})
	,	Storable::dclone($self->{setup}{pardef})
	,	$self->{argv}, $errors );

	if(@{$errors})
	{
		print STDERR "Stopping here because of parameter parsing errors.\n";
		return 1;
	}
	return 0 if($self->{param}{help} or $self->{param}{version});

	if($self->{setup}{pipemode})
	{
		if(defined $self->{setup}{pipe_init})
		{
			my $err = $self->{setup}{pipe_init}->($self);
			if($err)
			{
				print STDERR "Pipe init handler failed, aborting.\n";
				return $err;
			}
		}
		if($self->{setup}{filemode})
		{
			# Not wholly sure about that logic, have to really test and then delete this comment.
			while(1)
			{
				$self->new_txd();
				my $ret = $self->{txd}->read_all($self->{in});
				$self->{setup}{pipe_file}->($self)
					if ($ret >= 0 and defined $self->{setup}{pipe_file});
				last if $ret <= 0;
			}
			$self->{setup}{pipe_allend}->($self)
				if defined $self->{setup}{pipe_allend};
			Text::ASCIIPipe::done($self->{out})
				if $self->{txd}{config}{pipemode};
		}
		else
		{
			Text::ASCIIPipe::process
			(
				 handle => $self
				,in     => $self->{in}
				,out    => $self->{out}
				,pre    => $self->{setup}{pipe_prefilter}
				,begin  => defined $self->{setup}{pipe_begin} ? $self->{setup}{pipe_begin} : \&new_txd
				,line   => defined $self->{setup}{pipe_line} ? $self->{setup}{pipe_line} : \&default_line_hook
				,end    => $self->{setup}{pipe_end}
				,allend => $self->{setup}{pipe_allend}
			);
		}
		return 0;
	}
	else
	{
		$self->new_txd();
		return $self->main();
	}
}

sub new_txd
{
	my $self = shift;
	require Text::NumericData::File if $self->{setup}{filemode};

	$self->{txd} = $self->{setup}{filemode}
		? Text::NumericData::File->new($self->{param})
		: Text::NumericData->new($self->{param});

	$self->{state}{data} = 0;
}


sub default_line_hook
{
	my $self = shift;
	my $prefix = undef;
	if(!$self->{state}{data})
	{
		if($self->{txd}->line_check($_[0]))
		{
			$self->{state}{data} = 1;
			$prefix = $self->{setup}{pipe_first_data}->($self, @_)
				if defined $self->{setup}{pipe_first_data};
		}
		else
		{
			$self->{setup}{pipe_header}->($self, @_)
				if defined $self->{setup}{pipe_header};
			return;
		}
	}
	# If still here, $self->{state}{data} == 1 is implied.
	$self->{setup}{pipe_data}->($self, @_)
		if defined $self->{setup}{pipe_data};
	$_[0] = ${$prefix}.$_[0]
		if defined $prefix;
}

sub error
{
	my $self = shift;
	print STDERR "$_[0]\n" if defined $_[0];
	return defined $_[1] ? $_[1] : -1;
}

1;

__END__