File Coverage

blib/lib/Term/ProgressSpinner.pm

Criterion	Covered	Total	%
statement	208	330	63.0
branch	60	152	39.4
condition	17	34	50.0
subroutine	38	51	74.5
pod	41	43	95.3
total	364	610	59.6

package Term::ProgressSpinner;
our $VERSION = '1.00';
use 5.006; use strict; use warnings;
use IO::Handle; use Term::ANSIColor; use Time::HiRes qw//;
use Term::Size::Any qw/chars/;
if ($^O eq 'MSWin32') { eval "use Win32::Console::ANSI; use Win32::Console;"; }
our (%SPINNERS, %PROGRESS, %VALIDATE);

BEGIN {
	%VALIDATE = (
		colours => {
			map {
				my $c = $_;
				(
					$c => 1,
					"bright_${c}" => 1,
					(map { (
						"${c} on_${_}" => 1,
						"${c} on_bright_${_}" => 1,
						"bright_${c} on_${_}" => 1,
						"bright_${c} on_bright_${_}" => 1,
					) } qw/black red green yellow blue magenta cyan white/)
				)
			} qw/black red green yellow blue magenta cyan white/
		},
		msg_regex => qr/\{(total|progress|spinner|percents|percentage|percentages|percent|counter|elapsed|elapsed_second|estimate|estimate_second|start_epoch|start_epoch_second|epoch|epoch_second|per_second|last_advance_epoch|last_advance_epoch_second|last_elapsed|last_elapsed_second|elapsed|elapsed_second)\}/
	);
	%SPINNERS = (
		bar => {
			width => 3,
			index => [4, 2, 6],
			chars => [
				"▁",
				"▂",
				"▃",
				"▄",
				"▅",
				"▆",
				"▇",
				"█"
			]
		},
		dots => {
			width => 1,
			index => [1],
			chars => [
				"⠋",
				"⠙",
				"⠹",
				"⠸",
				"⠼",
				"⠴",
				"⠦",
				"⠧",
				"⠇",
				"⠏"
			]
		},
		around => {
			width => 1,
			index => [1],
			chars => [
				"⢀⠀",
				"⡀⠀",
				"⠄⠀",
				"⢂⠀",
				"⡂⠀",
				"⠅⠀",
				"⢃⠀",
				"⡃⠀",
				"⠍⠀",
				"⢋⠀",
				"⡋⠀",
				"⠍⠁",
				"⢋⠁",
				"⡋⠁",
				"⠍⠉",
				"⠋⠉",
				"⠋⠉",
				"⠉⠙",
				"⠉⠙",
				"⠉⠩",
				"⠈⢙",
				"⠈⡙",
				"⢈⠩",
				"⡀⢙",
				"⠄⡙",
				"⢂⠩",
				"⡂⢘",
				"⠅⡘",
				"⢃⠨",
				"⡃⢐",
				"⠍⡐",
				"⢋⠠",
				"⡋⢀",
				"⠍⡁",
				"⢋⠁",
				"⡋⠁",
				"⠍⠉",
				"⠋⠉",
				"⠋⠉",
				"⠉⠙",
				"⠉⠙",
				"⠉⠩",
				"⠈⢙",
				"⠈⡙",
				"⠈⠩",
				"⠀⢙",
				"⠀⡙",
				"⠀⠩",
				"⠀⢘",
				"⠀⡘",
				"⠀⠨",
				"⠀⢐",
				"⠀⡐",
				"⠀⠠",
				"⠀⢀",
				"⠀⡀"
			]
		},
		pipe => {
			width => 1,
			index => [1],
			chars => [
				"┤",
				"┘",
				"┴",
				"└",
				"├",
				"┌",
				"┬",
				"┐"
			]
		},
		moon => {
			width => 1,
			index => [1],
			chars => [
				"🌑 ",
				"🌒 ",
				"🌓 ",
				"🌔 ",
				"🌕 ",
				"🌖 ",
				"🌗 ",
				"🌘 "
			]
		},
		circle => {
			width => 1,
			index => [1],
			chars => [
				"・",
				"◦",
				"●",
				"○",
				"◎",
				"◉",
				"⦿",
				"◉",
				"◎",
				"○",
				"◦",
				"・",
			]
		},
		color_circle => {
			width => 1,
			index => [1],
			chars => [
				"🔴",
				"🟠",
				"🟡",
				"🟢",
				"🔵",
				"🟣",
				"⚫️",
				"⚪️",
				"🟤"
			]
		},
		color_circles => {
			width => 3,
			index => [1, 4, 7],
			chars => [
				"🔴",
				"🟠",
				"🟡",
				"🟢",
				"🔵",
				"🟣",
				"⚫️",
				"⚪️",
				"🟤"
			]
		},
		color_square => {
			width => 1,
			index => [1],
			chars => [
				"🟥",
				"🟧",
				"🟨",
				"🟩",
				"🟦",
				"🟪",
				"⬛️",
				"⬜️",
				"🟫"
			]
		},
		color_squares => {
			width => 3,
			index => [1, 3, 6],
			chars => [
				"🟥",
				"🟧",
				"🟨",
				"🟩",
				"🟦",
				"🟪",
				"⬛️",
				"⬜️",
				"🟫"
			]
		},
		earth => {
			width => 1,
			index => [1],
			chars => [
				"🌎",
				"🌍",
				"🌏"
			]
		},
		circle_half => {
			width => 1,
			index => [1],
			chars => [
				'◐',
				'◓',
				'◑',
				'◒'
			]
		},
		clock => {
			width => 1,
			index => [1],
			chars => [
				"🕛 ",
				"🕐 ",
				"🕑 ",
				"🕒 ",
				"🕓 ",
				"🕔 ",
				"🕕 ",
				"🕖 ",
				"🕗 ",
				"🕘 ",
				"🕙 ",
				"🕚 "
			]
		},
		pong => {
			width => 1,
			index => [1],
			chars => [
				"▐⠂       ▌",
				"▐⠈       ▌",
				"▐ ⠂      ▌",
				"▐ ⠠      ▌",
				"▐  ⡀     ▌",
				"▐  ⠠     ▌",
				"▐   ⠂    ▌",
				"▐   ⠈    ▌",
				"▐    ⠂   ▌",
				"▐    ⠠   ▌",
				"▐     ⡀  ▌",
				"▐     ⠠  ▌",
				"▐      ⠂ ▌",
				"▐      ⠈ ▌",
				"▐       ⠂▌",
				"▐       ⠠▌",
				"▐       ⡀▌",
				"▐      ⠠ ▌",
				"▐      ⠂ ▌",
				"▐     ⠈  ▌",
				"▐     ⠂  ▌",
				"▐    ⠠   ▌",
				"▐    ⡀   ▌",
				"▐   ⠠    ▌",
				"▐   ⠂    ▌",
				"▐  ⠈     ▌",
				"▐  ⠂     ▌",
				"▐ ⠠      ▌",
				"▐ ⡀      ▌",
				"▐⠠       ▌"
			]
		},
		material => {
			width => 1,
			index => [1],
			chars => [
				"█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"███▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"████▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"███████▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"████████▁▁▁▁▁▁▁▁▁▁▁▁",
				"█████████▁▁▁▁▁▁▁▁▁▁▁",
				"█████████▁▁▁▁▁▁▁▁▁▁▁",
				"██████████▁▁▁▁▁▁▁▁▁▁",
				"███████████▁▁▁▁▁▁▁▁▁",
				"█████████████▁▁▁▁▁▁▁",
				"██████████████▁▁▁▁▁▁",
				"██████████████▁▁▁▁▁▁",
				"▁██████████████▁▁▁▁▁",
				"▁██████████████▁▁▁▁▁",
				"▁██████████████▁▁▁▁▁",
				"▁▁██████████████▁▁▁▁",
				"▁▁▁██████████████▁▁▁",
				"▁▁▁▁█████████████▁▁▁",
				"▁▁▁▁██████████████▁▁",
				"▁▁▁▁██████████████▁▁",
				"▁▁▁▁▁██████████████▁",
				"▁▁▁▁▁██████████████▁",
				"▁▁▁▁▁██████████████▁",
				"▁▁▁▁▁▁██████████████",
				"▁▁▁▁▁▁██████████████",
				"▁▁▁▁▁▁▁█████████████",
				"▁▁▁▁▁▁▁█████████████",
				"▁▁▁▁▁▁▁▁████████████",
				"▁▁▁▁▁▁▁▁████████████",
				"▁▁▁▁▁▁▁▁▁███████████",
				"▁▁▁▁▁▁▁▁▁███████████",
				"▁▁▁▁▁▁▁▁▁▁██████████",
				"▁▁▁▁▁▁▁▁▁▁██████████",
				"▁▁▁▁▁▁▁▁▁▁▁▁████████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁██████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
				"█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
				"██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
				"██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
				"███▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
				"████▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
				"█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
				"█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
				"██████▁▁▁▁▁▁▁▁▁▁▁▁▁█",
				"████████▁▁▁▁▁▁▁▁▁▁▁▁",
				"█████████▁▁▁▁▁▁▁▁▁▁▁",
				"█████████▁▁▁▁▁▁▁▁▁▁▁",
				"█████████▁▁▁▁▁▁▁▁▁▁▁",
				"█████████▁▁▁▁▁▁▁▁▁▁▁",
				"███████████▁▁▁▁▁▁▁▁▁",
				"████████████▁▁▁▁▁▁▁▁",
				"████████████▁▁▁▁▁▁▁▁",
				"██████████████▁▁▁▁▁▁",
				"██████████████▁▁▁▁▁▁",
				"▁██████████████▁▁▁▁▁",
				"▁██████████████▁▁▁▁▁",
				"▁▁▁█████████████▁▁▁▁",
				"▁▁▁▁▁████████████▁▁▁",
				"▁▁▁▁▁████████████▁▁▁",
				"▁▁▁▁▁▁███████████▁▁▁",
				"▁▁▁▁▁▁▁▁█████████▁▁▁",
				"▁▁▁▁▁▁▁▁█████████▁▁▁",
				"▁▁▁▁▁▁▁▁▁█████████▁▁",
				"▁▁▁▁▁▁▁▁▁█████████▁▁",
				"▁▁▁▁▁▁▁▁▁▁█████████▁",
				"▁▁▁▁▁▁▁▁▁▁▁████████▁",
				"▁▁▁▁▁▁▁▁▁▁▁████████▁",
				"▁▁▁▁▁▁▁▁▁▁▁▁███████▁",
				"▁▁▁▁▁▁▁▁▁▁▁▁███████▁",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
				"▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁"

			]

		}
	);
	$SPINNERS{default} = $SPINNERS{bar};
	%PROGRESS = (
		bar => {
			chars =>  ['│', "█", '│']
		},
		equal => {
			chars =>  ['[', "=", ']']
		},
		arrow => {
			chars =>  ['│', "→", '│']
		},
		boxed_arrow => {
			chars =>  ['│', "⍈", '│']
		},
		lines => {
			chars =>  ['│', "≡", '│']
		},
		horizontal_lines => {
			chars =>  ['│', "▤", '│']
		},
		vertical_lines => {
			chars =>  ['│', "▥", '│']
		},
		hash => {
			chars =>  ['[', "#", ']']
		},
		triangle => {
			chars => ['│', '▶︎', '│' ]
		},
		den_triangle => {
			chars => ['│', '⏅', '│' ]
		},
		circle => {
			chars => ['│', 'Ⓞ', '│' ]
		},
		den_circle => {
			chars => ['│', '⏂', '│' ]
		},
		shekel => {
			chars => ['│', '₪', '│' ]
		},
		dots => {
			chars => ['│', '▒', '│' ]
		},
		square => {
			chars => ['│', '■', '│' ]
		},
		block => {
			chars => ["【", "=", "】"]
		}
	);
	$PROGRESS{default} = $PROGRESS{bar};
}

sub new {
	my ($pkg, %args) = (shift, ref $_[0] ? %{$_[0]} : @_);
	$args{$_} and ($VALIDATE{colours}{$args{$_}} or die "Invalid color for $_")
		for qw/text_color total_color counter_color percent_color percentage_color percentages_color percents_color spinner_color progress_color elapsed_color last_elapsed_color estimate_color last_advance_epoch_color start_epoch_color epoch_color/;
	$args{precision} ||= 3;
	return bless {
		text_color => 'white',
		total_color => 'white',
		counter_color => 'white',
		percent_color => 'white',
		percentage_color => 'white',
		percentages_color => 'white',
		percents_color => 'white',
		spinner_color => 'white',
		elapsed_color => 'white',
		start_epoch_color => 'white',
		last_elapsed_color => 'white',
		last_advance_epoch_color => 'white',
		estimate_color => 'white',
		epoch_color => 'white',
		per_second_color => 'white',
		spinner_options => $SPINNERS{ $args{spinner} || 'default' },
		progress_color => 'white',
		progress_width => 20,
		progress_options => $PROGRESS{ $args{progress} || 'default' },
		output => \*STDERR,
		progress_spinner_index => 0,
		progress_spinners => [],
		message => "{progress} {spinner} processed {percents} of {counter}/{total} {elapsed}/{estimate}",
		terminal_height => 0,
		terminal_line => 0,
		%args
	}, ref $pkg || $pkg;
}

sub progress_spinner_index {
	my ($self, $val) = @_;
	if (defined $val) {
		if (ref $val || $val !~ m/\d+/) {
			die 'progress_spinner_index should be a integer';
		}
		$self->{progress_spinner_index} = $val;
	}
	return $self->{progress_spinner_index};
}

sub terminal_height {
	my ($self, $val) = @_;
	if (defined $val) {
		if (ref $val || $val !~ m/\d+/) {
			die 'terminal_height should be a integer';
		}
		$self->{terminal_height} = $val;
	}
	return $self->{terminal_height};
}

sub terminal_line {
	my ($self, $val) = @_;
	if (defined $val) {
		if (ref $val || $val !~ m/\d+/) {
			die 'terminal_line should be a integer';
		}
		$self->{terminal_line} = $val;
	}
	return $self->{terminal_line};
}

sub progress_spinners {
	my ($self, $val) = @_;
	if (defined $val) {
		if (ref $val || "" ne 'ARRAY') {
			die 'progress_spinners should be a array';
		}
		$self->{progress_spinners} = $val;
	}
	return $self->{progress_spinners};
}

sub savepos {
	my $self = shift;
	my ($col, $rows) = $self->terminal_height ? (0, $self->terminal_height) : (Term::Size::Any::chars($self->output));
	my $x = '';
	if ($self->terminal_line) {
		$x = $self->terminal_line;
	} elsif ($^O eq 'MSWin32') {
		my $CONSOLE = Win32::Console->new(Win32::Console::STD_OUTPUT_HANDLE());
		($x) = $CONSOLE->Cursor();
	} else {
		system "stty cbreak /dev/tty 2>&1";
		$self->output->print("\e[6n");
		$x .= getc STDIN for 0 .. 5;
		system "stty -cbreak /dev/tty 2>&1";
		my($n, $m)=$x=~m/(\d+)\;(\d+)/;
		$x = $n;
		$self->clear();
	}
	if ($x == $rows) {
		$x--;
		for (@{ $self->progress_spinners }) {
			$_->{savepos} = $_->{savepos} - 1;
		}
	}
	$self->{savepos} = $x;
}

sub loadpos {
	my $self = shift;
	my $pos = $self->{savepos};
	$self->output->print("\e[$pos;1f");
}

sub start {
	my ($self, $total) = @_;
	$self->total($total) if $total;
	$self->start_epoch(Time::HiRes::time);
	$self->output->print("\e[?25l");
	$self->savepos;
	$self->output->print("\n");
	my $ps = $self->new(%{$self});
	push @{ $self->progress_spinners }, $ps;
	$self->progress_spinner_index($self->progress_spinner_index + 1);
	return $ps;
}

sub advance {
	my ($self, $ps, $prevent) = @_;
	if ($ps) {
		if ($ps->counter < $ps->total) {
			$ps->counter($ps->counter + 1);
			my $spinner = $ps->spinner;
			for (1 .. $spinner->{width}) {
				my $index = $spinner->{index}->[$_ - 1];
				$spinner->{index}->[$_ - 1] = ($index + 1) % scalar @{$spinner->{chars}};
			}
			select(undef, undef, undef, $ps->slowed) if $ps->slowed;
			$ps->draw() unless $prevent;
		} else {
			$self->finish($ps);
		}
	} else {
		for my $spinner (@{$self->progress_spinners}) {
			$self->advance($spinner, 1);
		}
		scalar @{$self->{progress_spinners}} ? $self->draw() : $self->finish;
	}
}

sub time_advance_elapsed {
	my ($self) = @_;
	my %time = ();
	$time{epoch} = sprintf($self->precision, Time::HiRes::time);
	$time{start_epoch} = sprintf($self->precision, $self->start_epoch);
	$time{last_advance_epoch} = $self->last_advance_epoch || $time{start_epoch};
	$time{last_elapsed} = sprintf($self->precision, $time{epoch} - $time{last_advance_epoch}) + 0;
	$time{elapsed} = sprintf($self->precision, $time{epoch} - $time{start_epoch}) + 0;
	for (qw/epoch start_epoch last_advance_epoch last_elapsed elapsed/) {
		$time{"${_}_second"} = int($time{$_});
	}
	$self->last_advance_epoch($time{epoch});
	return %time;
}

sub draw {
	my ($self, $ps) = @_;
	if ($ps) {
		$ps->loadpos;
		$ps->clear();
		my ($spinner, $progress, $available, %options) = ($ps->spinner, $ps->progress, $ps->progress_width, $ps->time_advance_elapsed);
		$options{total} = $ps->total;
		$options{counter} = $ps->counter;
		$options{spinner} = color($ps->spinner_color);
		$options{spinner} .= $spinner->{chars}->[
			$spinner->{index}->[$_ - 1]
		] for (1 .. $spinner->{width});
		$options{spinner} .= color($ps->text_color);
		$options{percent} = int( ( $options{counter} / $options{total} ) * 100 );
		$options{percentage} = ($available / 100) * $options{percent};
		$options{estimate} = $options{percent} ? sprintf($self->precision, (($options{elapsed} / $options{percent}) * 100) - $options{elapsed}) + 0 : 0;
		$options{estimate_second} = int($options{estimate} + 0.5);
		$options{per_second} = $options{elapsed_seconds} ?
			int(($options{counter} / int($options{elapsed_second})) + 0.5)
			: 0;
		$options{progress} = sprintf("%s%s%s%s%s",
			color($ps->progress_color),
			$progress->{chars}->[0],
			( $progress->{chars}->[1] x int($options{percentage} + 0.5) ) . ( ' ' x int( ($available - $options{percentage}) + 0.5 ) ),
			$progress->{chars}->[2],
			color($ps->text_color)
		);
		$options{percentages} = $options{percentage} . '%';
		$options{percents} = $options{percent} . '%';
		$options{$_} = sprintf ("%s%s%s",
			color($ps->{$_ . "_color"}),
			$options{$_},
			color($ps->text_color)
		) for (qw/total percent percents percentage counter per_second/);
		for (qw/elapsed last_elapsed estimate last_advance_epoch start_epoch epoch/) {
			$options{$_} = sprintf ("%s%s%s",
				color($ps->{$_ . "_color"}),
				$options{$_},
				color($ps->text_color)
			);
			$options{"${_}_second"} = sprintf ("%s%s%s",
				color($ps->{$_ . "_color"}),
				$options{"${_}_second"},
				color($ps->text_color)
			);
		}
		my $message = $ps->message;
		$message =~ s/$VALIDATE{msg_regex}/$options{$1}/ig;
		$message .= color('reset') . "\n";
		$ps->output->print($message);
		return $ps->drawn(1);
	} else {
		for my $spinner (@{$self->progress_spinners}) {
			$self->draw($spinner);
		}
		return $self->drawn(1);
	}
}

sub finish {
	my ($self, $sp) = @_;
	if ($sp && scalar @{$self->progress_spinners}) {
		my $i = 0;
		for (@{ $self->progress_spinners }) {
			if ($sp->progress_spinner_index == $_->progress_spinner_index) {
				last;
			}
			$i++;
		}
		splice @{$self->progress_spinners}, $i, 1;

	} else {
		$self->output->print("\e[?25h");
		$self->finished(1);
	}
	return 0;
}

sub finished {
	if (defined $_[1]) {
		$_[0]->{finished} = $_[1];
	}
	$_[0]->{finished};
}

sub drawn {
	my ($self, $val) = @_;
	if (defined $val) {
		$self->{drawn} = $val;
	}
	return $self->{drawn};
}

sub clear {
	my ($self) = @_;
	$self->output->print("\r\e[2K");
	$self->drawn(0);
}

sub message {
	my ($self, $val) = @_;
	if (defined $val) {
		if (ref $val) {
			die 'message should be a string';
		}
		$self->{message} = $val;
	}
	return $self->{message};
}

sub output {
	my ($self, $val) = @_;
	if (defined $val) {
		$self->{output} = $val;
	}
	return $self->{output};
}

sub total {
	my ($self, $val) = @_;
	if (defined $val) {
		if ($val !~ m/\d+/) {
			die "total should be a integer";
		}
		$self->{total} = $val;
		$self->{counter} = 0;
	}
	return $self->{total};
}

sub slowed {
	my ($self, $val) = @_;
	if (defined $val) {
		if ($val !~ m/\d+(\.\d+)?/) {
			die "slowed should be a float";
		}
		$self->{slowed} = $val;
	}
	return $self->{slowed};
}

sub counter {
	my ($self, $val) = @_;
	if (defined $val) {
		if ($val !~ m/\d+/) {
			die "counter should be a integer";
		}
		$self->{counter} = $val;
	}
	return $self->{counter};
}

sub start_epoch {
	my ($self, $val) = @_;
	if (defined $val) {
		if ($val !~ m/\d+(\.\d+)?/) {
			die "start_epoch should be a epoch";
		}
		$self->{start_epoch} = $val;
	}
	return $self->{start_epoch};
}

sub last_advance_epoch {
	my ($self, $val) = @_;
	if (defined $val) {
		if ($val !~ m/\d+(\.\d+)?/) {
			die "last_advance_epoch should be a epoch";
		}
		$self->{last_advance_epoch} = $val;
	}
	return $self->{last_advance_epoch};
}

sub precision {
	my ($self, $val) = @_;
	if (defined $val) {
		if ($val !~ m/\d+/) {
			die "last_advance_epoch should be a epoch";
		}
		$self->{precision} = $val;
	}
	$val = $self->{precision};
	return "%.${val}f";
}

sub text_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{text_color} = $val;
	}
	return $self->{text_color};
}

sub spinner {
	my ($self, $spinner) = @_;
	$self->{spinner_options} = $SPINNERS{$spinner} or die "Invalid spinner $spinner" if $spinner;
	$self->{spinner_options};
}

sub spinner_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{spinner_color} = $val;
	}
	return $self->{spinner_color};
}

sub progress {
	my ($self, $progress) = @_;
	$self->{progress_options} = $PROGRESS{$progress} or die "Invalid progress $progress" if $progress;
	$self->{progress_options};
}

sub progress_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{progress_color} = $val;
	}
	return $self->{progress_color};
}

sub progress_width {
	my ($self, $val) = @_;
	if (defined $val) {
		$self->{progress_width} = $val;
	}
	return $self->{progress_width};
}

sub percent_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{percent_color} = $val;
	}
	return $self->{percent_color};
}

sub percents_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{percents_color} = $val;
	}
	return $self->{percents_color};
}

sub percentage_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{percentage_color} = $val;
	}
	return $self->{percentage_color};
}

sub percentages_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{percentages_color} = $val;
	}
	return $self->{percentages_color};
}

sub total_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{total_color} = $val;
	}
	return $self->{total_color};
}

sub counter_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{counter_color} = $val;
	}
	return $self->{counter_color};
}

sub elapsed_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{elapsed_color} = $val;
	}
	return $self->{elapsed_color};
}

sub last_elapsed_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{last_elapsed_color} = $val;
	}
	return $self->{last_elapsed_color};
}

sub estimate_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{estimate_elapsed_color} = $val;
	}
	return $self->{estimate_elapsed_color};
}

sub last_advance_epoch_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{last_advance_epoch_color} = $val;
	}
	return $self->{last_advance_epoch_color};
}

sub start_epoch_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{start_epoch_color} = $val;
	}
	return $self->{start_epoch_color};
}

sub epoch_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{epoch_color} = $val;
	}
	return $self->{epoch_color};
}

sub per_second_color {
	my ($self, $val) = @_;
	if (defined $val) {
		unless ($VALIDATE{colours}{$val}) {
			die "$val is not a valid color";
		}
		$self->{per_second_color} = $val;
	}
	return $self->{per_second_color};
}

sub sleep {
	select(undef, undef, undef, $_[1]);
}

1;

__END__;