File Coverage

lib/Git/Background/Future.pm

Criterion	Covered	Total	%
statement	80	84	95.2
branch	21	22	95.4
condition	12	14	85.7
subroutine	15	16	93.7
pod	9	9	100.0
total	137	145	94.4

# vim: ts=4 sts=4 sw=4 et: syntax=perl
#
# Copyright (c) 2021-2023 Sven Kirmess
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

use 5.010;
use strict;
use warnings;

package Git::Background::Future;

our $VERSION = '0.007_01';

use Future 0.49;

use parent 'Future';

use File::Temp qw(:seekable);

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

    my $self = $class->SUPER::new;
    $self->set_udata( '_run', $run );
    return $self;
}

sub await {
    my ($self) = @_;

    my $run = $self->udata('_run');

    return $self if !defined $run;

    $self->set_udata( '_run', undef );

    my $e;
    my $ok = 1;
    {
        local $@;    ## no critic (Variables::RequireInitializationForLocalVars)
        $ok = eval {

            # prevent the "(in cleanup) process is already terminated" message
            $run->{_proc}->autoterminate(0);

            # wait for the process to finish
            $run->{_proc}->wait;

            1;
        };

        if ( !$ok ) {

            # The Future->fail exception must be true
            $e = qq{$@} || 'Failed to wait on Git process with Proc::Background';
        }
    }
    return $self->fail( $e, 'Proc::Background' ) if !$ok;

    # slurp back stdout
    my $stdout_fh = $run->{_stdout};
    $stdout_fh->seek( 0, SEEK_SET ) or return $self->fail( "Cannot seek stdout: $stdout_fh: $!", 'seek' );
    my @stdout = split /\r?\n/m, do {    ## no critic (RegularExpressions::RequireDotMatchAnything, RegularExpressions::RequireExtendedFormatting])
        local $/;                        ## no critic (Variables::RequireInitializationForLocalVars)
        scalar <$stdout_fh>;
    };
    return $self->fail( "Cannot read stdout: $stdout_fh: $!", 'readline' ) if $stdout_fh->error;

    # slurp back stderr
    my $stderr_fh = $run->{_stderr};
    $stderr_fh->seek( 0, SEEK_SET ) or return $self->fail( "Cannot seek stderr: $stderr_fh: $!", 'seek' );
    my @stderr = split /\r?\n/m, do {    ## no critic (RegularExpressions::RequireDotMatchAnything, RegularExpressions::RequireExtendedFormatting])
        local $/;                        ## no critic (Variables::RequireInitializationForLocalVars)
        scalar <$stderr_fh>;
    };
    return $self->fail( "Cannot read stderr: $stderr_fh: $!", 'readline' ) if $stderr_fh->error;

    # get exit code and signal from git process
    my $exit_code = $run->{_proc}->exit_code;

    my @result = (
        \@stdout,
        \@stderr,
        $exit_code,
    );

    # git died by a signal
    return $self->fail( 'Git was terminated by a signal', 'Proc::Background', @result ) if $run->{_proc}->exit_signal;

    if (
        # fatal error
        ( $exit_code == 128 ) ||

        # usage error
        ( $exit_code == 129 ) ||

        # non-zero return code
        ( $exit_code && $run->{_fatal} )
      )
    {

        my $stderr  = join "\n", @stderr;
        my $message = length $stderr ? $stderr : "git exited with fatal exit code $exit_code but had no output to stderr";

        # $run goes out of scope and the file handles and the proc object are freed
        return $self->fail( $message, 'git', @result );
    }

    # $run goes out of scope and the file handles and the proc object are freed
    return $self->done(@result);
}

sub exit_code {
    my ($self) = @_;

    my @result = $self->get;
    return $result[2];
}

sub is_done {
    my ($self) = @_;
    $self->_await_if_git_is_done;
    return $self->SUPER::is_done;
}

sub is_failed {
    my ($self) = @_;
    $self->_await_if_git_is_done;
    return $self->SUPER::is_failed;
}

sub is_ready {
    my ($self) = @_;
    $self->_await_if_git_is_done;
    return $self->SUPER::is_ready;
}

sub state {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
    my ($self) = @_;
    $self->_await_if_git_is_done;
    return $self->SUPER::state;
}

sub stderr {
    my ($self) = @_;

    my @result = $self->get;
    return @{ $result[1] };
}

sub stdout {
    my ($self) = @_;

    my @result = $self->get;
    return @{ $result[0] };
}

sub _await_if_git_is_done {
    my ($self) = @_;

    my $run = $self->udata('_run');
    if ( defined $run && !$run->{_proc}->alive ) {
        $self->await;
    }

    return;
}

1;

__END__