File Coverage

lib/Git/Background.pm

Criterion	Covered	Total	%
statement	119	119	100.0
branch	54	56	96.4
condition	21	26	80.7
subroutine	12	12	100.0
pod	3	3	100.0
total	209	216	96.7

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

our $VERSION = '0.008';

use Carp ();
use Path::Tiny 0.125 ();
use Proc::Background 1.30;
use Scalar::Util ();

use Git::Background::Future;

# Git::Background->new;
# Git::Background->new($dir);
# Git::Background->new( { %options } );
# Git::Background->new( $dir, { %options } );
# options:
#   - dir
#   - fatal     (default 1)
sub new {
    my $class = shift;

  NEW: {
        my $self;

        last NEW if @_ > 2;

        my $dir;

        if (
            @_
            && (
                # first argument is a scalar
                !defined Scalar::Util::reftype( $_[0] )

                # or object
                || defined Scalar::Util::blessed( $_[0] )
            )
          )
        {
            my $arg = shift @_;

            # stringify objects (e.g. Path::Tiny)
            $dir = "$arg";
        }

        last NEW if @_ > 1;

        if (@_) {
            last NEW if !defined Scalar::Util::reftype( $_[0] ) || Scalar::Util::reftype( $_[0] ) ne 'HASH';

            # first/remaining argument is a hash ref
            my $args = shift @_;
            $self = $class->_process_args($args);
        }
        else {
            $self = $class->_process_args;
        }

        if ( defined $dir ) {
            Carp::croak 'Cannot specify dir as positional argument and in argument hash' if exists $self->{_dir};
            $self->{_dir} = $dir;
        }

        bless $self, $class;
        return $self;
    }

    # unknown args
    Carp::croak 'usage: new( [DIR], [ARGS] )';
}

# Git::Background->run( @cmd );
# Git::Background->run( @cmd, { %options } );
sub run {
    my ( $self, @cmd ) = @_;

    Carp::croak 'Cannot use run() in void context. (The git process would immediately get killed.)' if !defined wantarray;    ## no critic (Community::Wantarray)

    my $config;
    if ( @cmd && defined Scalar::Util::reftype( $cmd[-1] ) && Scalar::Util::reftype( $cmd[-1] ) eq 'HASH' ) {
        my $args = pop @cmd;
        $config = $self->_process_args($args);
    }
    else {
        $config = $self->_process_args;
    }

    my $stdout;
    my $stdout_fh;
    my $stderr;
    my $stderr_fh;
    my $e;
    my $ok;
    {
        local $@;    ## no critic (Variables::RequireInitializationForLocalVars)
        $ok = eval {
            $e         = 'Cannot create temporary file for stdout';
            $stdout    = Path::Tiny->tempfile;
            $e         = 'Cannot obtain file handle for stdout temp file';
            $stdout_fh = $stdout->filehandle('>');
            $e         = 'Cannot create temporary file for stdout';
            $stderr    = Path::Tiny->tempfile;
            $e         = 'Cannot obtain file handle for stderr temp file';
            $stderr_fh = $stderr->filehandle('>');
            1;
        };

        if ( !$ok ) {
            if ( defined $@ && $@ ne q{} ) {
                $e .= ": $@";
            }
        }
    }
    Carp::croak $e if !$ok;

    # Proc::Background
    my $proc_args = {
        stdin         => undef,
        stdout        => $stdout_fh,
        stderr        => $stderr_fh,
        command       => [ @{ $config->{_git} }, @cmd ],
        autodie       => 1,
        autoterminate => 1,
        ( defined $config->{_dir} ? ( cwd => $config->{_dir} ) : () ),
    };

    my $proc;
    {
        local @_;    ## no critic (Variables::RequireInitializationForLocalVars)
        local $Carp::Internal{ (__PACKAGE__) } = 1;

        $proc = eval { Proc::Background->new($proc_args); };

        if ( !defined $proc ) {

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

    return Git::Background::Future->new(
        {
            _fatal  => $config->{_fatal},
            _proc   => $proc,
            _stdout => $stdout,
            _stderr => $stderr,
        },
    );
}

sub version {
    my ( $self, $args ) = @_;

    my @cmd = qw(--version);
    if ( defined $args ) {
        Carp::croak 'usage: Git::Background->version([ARGS])' if !defined Scalar::Util::reftype($args) || Scalar::Util::reftype($args) ne 'HASH';

        push @cmd, $args;
    }

    my $version = eval {
        for my $line ( $self->run(@cmd)->stdout ) {
            if ( $line =~ s{ \A git \s version \s }{}xsm ) {
                return $line;
            }
        }

        return;
    };

    return $version;
}

sub _process_args {
    my ( $self, $args ) = @_;

    if ( !defined Scalar::Util::blessed($self) ) {
        $self = {};
    }

    my %args_keys = map { $_ => 1 } keys %{$args};
    my %config    = (
        _fatal => !!1,
        _git   => ['git'],
    );

    # dir
    if ( exists $args->{dir} ) {

        # stringify objects (e.g. Path::Tiny)
        $config{_dir} = "$args->{dir}";
        delete $args_keys{dir};
    }
    elsif ( exists $self->{_dir} ) {
        $config{_dir} = $self->{_dir};
    }

    # fatal
    if ( exists $args->{fatal} ) {
        $config{_fatal} = !!$args->{fatal};
        delete $args_keys{fatal};
    }
    elsif ( exists $self->{_fatal} ) {
        $config{_fatal} = $self->{_fatal};
    }

    # git
    if ( exists $args->{git} ) {
        my $git = $args->{git};
        $config{_git} = [
            ( defined Scalar::Util::reftype($git) && Scalar::Util::reftype($git) eq 'ARRAY' )
            ? @{ $args->{git} }
            : $git,
        ];
        delete $args_keys{git};
    }
    elsif ( exists $self->{_git} ) {
        $config{_git} = [ @{ $self->{_git} } ];
    }

    #
    my @unknown = sort keys %args_keys;
    Carp::croak 'Unknown argument' . ( @unknown > 1 ? 's' : q{} ) . q{: '} . join( q{', '}, sort @unknown ) . q{'} if @unknown;

    return \%config;
}

1;

__END__