File Coverage

lib/Git/Background/Future.pm

Criterion	Covered	Total	%
statement	81	85	95.2
branch	18	20	90.0
condition	13	17	76.4
subroutine	16	17	94.1
pod	11	11	100.0
total	139	150	92.6

# 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_02';

use Future 0.49;
use parent 'Future';

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;
    {
        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;

    my $stdout_file = $run->{_stdout};
    my $stderr_file = $run->{_stderr};
    my @stdout;
    my @stderr;
    {
        local $@;    ## no critic (Variables::RequireInitializationForLocalVars)
        $ok = eval {
            $e      = 'Cannot read stdout';
            @stdout = $stdout_file->lines_utf8( { chomp => 1 } );

            $e      = 'Cannot read stderr';
            @stderr = $stderr_file->lines_utf8( { chomp => 1 } );

            1;
        };

        if ( !$ok ) {
            if ( defined $@ && $@ ne q{} ) {
                $e .= ": $@";
            }
        }
    }
    return $self->fail( $e, 'Path::Tiny' ) if !$ok;

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

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

    # 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 $message = join "\n", @stderr;
        if ( !length $message ) {
            $message = "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) = @_;
    return ( $self->get )[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 path_stderr {
    my ($self) = @_;
    return ( $self->get )[4];
}

sub path_stdout {
    my ($self) = @_;
    return ( $self->get )[3];
}

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

sub stderr {
    my ($self) = @_;
    return @{ ( $self->get )[1] };
}

sub stdout {
    my ($self) = @_;
    return @{ ( $self->get )[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__