File Coverage

blib/lib/Term/Spinner/Lite.pm

Criterion	Covered	Total	%
statement	80	85	94.1
branch	22	26	84.6
condition	1	2	50.0
subroutine	18	20	90.0
pod	7	7	100.0
total	128	140	91.4

use strict;
use warnings;
package Term::Spinner::Lite;
{
  $Term::Spinner::Lite::VERSION = '0.03';
}

# ABSTRACT: A spinner without so much Moose in it

use 5.010;
use IO::Handle;
use Time::HiRes qw(usleep);
use Carp qw( croak );



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

    my $self = bless \%args, $class;

    $self->_setup_signal_handler;

    return $self;
}

# We need to restore the cursor if the user hits Contol-C or a TERM signal
sub _setup_signal_handler {
    my $self = shift;

    $SIG{INT} = sub { $self->done; exit 0; };
    $SIG{TERM} = sub { $self->done; exit 0; };
}


sub output_handle {
    my $self = shift;
    my $handle = shift;
    my $encoding = shift || ":utf8";

    if ( not $handle ) {
        if ( exists $self->{'output_handle'} ) {
            return $self->{'output_handle'};
        }
        $handle = \*STDERR;
    }

    binmode($handle, $encoding);
    $handle->autoflush(1);

    $self->{'output_handle'} = $handle;
}


sub spin_chars {
    my $self = shift;
    my $aref = shift;

    if ( not $aref ) {
        if ( exists $self->{'spin_chars'} ) {
            return $self->{'spin_chars'};
        }
        $aref = [ qw(- \ | /) ];
    }

    if ( ref($aref) ne 'ARRAY' ) {
        croak "spin_chars must be an array ref";
    }

    $self->{'spin_chars'} = $aref;
}


sub delay {
    my $self = shift;
    my $microseconds = shift;

    if ( not $microseconds ) {
        if ( exists $self->{'delay'} ) {
            return $self->{'delay'};
        }
        $microseconds = 0;
    }

    $self->{'delay'} = $microseconds;
}

sub _clear {
    my $self = shift;

    print {$self->output_handle()} "\010 \010";
}

# https://github.com/verigak/progress/blob/master/progress/helpers.py#L19
sub _show_cursor {
    my $self = shift;

    print {$self->output_handle()} "\x1b[?25h";
}

# https://github.com/verigak/progress/blob/master/progress/helpers.py#L18
sub _hide_cursor {
    my $self = shift;

    print {$self->output_handle()} "\x1b[?25l";
}

sub _spin_char_size {
    my $self = shift;

    if ( exists $self->{'spin_char_size'} ) {
        return $self->{'spin_char_size'};
    }

    $self->{'spin_char_size'} = scalar @{ $self->spin_chars() };
}


sub count {
    my $self = shift;

    return 0 if not exists $self->{'count'};

    return $self->{'count'};
}


sub next {
    my $self = shift;

    state $pos = 0;

    $self->_clear if $self->count;
    $self->_hide_cursor if not $pos;
    print {$self->output_handle()} "${$self->spin_chars()}[$pos]";
    $pos = ($self->{'count'}++) % $self->_spin_char_size();
    usleep($self->delay) if $self->delay;
}


sub done {
    my $self = shift;

    $self->_clear;
    $self->_show_cursor;
    print "\n" if $_[0];
}

1;

__END__