File Coverage

blib/lib/FFI/Build/File/VMod.pm

Criterion	Covered	Total	%
statement	69	98	70.4
branch	9	30	30.0
condition	1	6	16.6
subroutine	16	17	94.1
pod	3	3	100.0
total	98	154	63.6

use warnings;
use 5.020;
use experimental qw( signatures );
use stable qw( postderef );
use true;

package FFI::Build::File::VMod 0.03 {

    # ABSTRACT: Class to track V source in FFI::Build

    use parent qw( FFI::Build::File::Base );
    use constant default_suffix => '.mod';
    use constant default_encoding => ':utf8';
    use File::Which qw( which );
    use PerlX::Maybe qw( maybe );
    use Path::Tiny 0.130 ();
    use File::chdir;


    sub accept_suffix {
        (qr/\/v\.mod\z/)
    }

    sub build_all ($self, $) {
        $self->build_item;
    }

    sub build_item ($self) {

        my $vmod = Path::Tiny->new($self->path);

        my $platform;
        my $buildname;
        my $lib;

        my($name) = map { /name:\s*'(.*)'/ ? ($1) : () } $vmod->lines_utf8;
        die "unable to find name in $vmod" unless defined $name;

        if($self->build) {
            $platform = $self->build->platform;
            $buildname = $self->build->buildname;
            $lib = $self->build->file;
        } else {
            $platform = FFI::Build::Platform->new;
            $buildname = "_build";

            $lib = FFI::Build::File::Library->new(
                $vmod->sibling("$name" . scalar($platform->library_suffix))->stringify,
                platform => $self->platform,
            );
        }

        if($self->_have_v_compiler) {

            return $lib if -f $lib->path && !$lib->needs_rebuild($self->_deps($vmod->parent));

            my $lib_path = Path::Tiny->new($lib->path)->relative($vmod->parent);
            say "+cd @{[ $vmod->parent ]}";
            local $CWD = $vmod->parent;
            say "+mkdir -p @{[ $lib_path->parent->mkdir ]}";
            $lib_path->parent->mkdir;
            $platform->run('v', '-prod', '-shared', -o => "$lib_path", '.');
            die "command failed" if $?;
            die "no shared library" unless -f $lib_path;
            say "+cd -";

        } else {

            my $c_source = $vmod->sibling("$name.c");
            die "module requires v compiler" unless -f $c_source;
            return $lib if -f $lib->path && !$lib->needs_rebuild($c_source->stringify);
            require FFI::Build;

            my @args;
            if($self->build) {
                foreach my $key (qw( alien buildname cflags export file libs verbose )) {
                    push @args, $key => $self->build->$key;
                }
            } else {
                push @args,
                    buildname => $buildname,
                    file => $lib,
                ;
            }

            warn "c_source = $c_source";

            my $bx = FFI::Build->new(
                $name,
                source => ["$c_source"],
                platform => $platform,
                dir => $vmod->parent->stringify,
                @args,
            );

            return $bx->build;

        }

        return $lib;

    }

    sub _deps ($self, $path)
    {
        my @ret;
        foreach my $path ($path->children) {
            next if -l $path;  # skip symlinks to avoid recursion
            push @ret, $self->_deps($path) if -d $path;
            push @ret, $path->stringify if $path->basename =~ /^(.*\.(v|c|h)|v\.mod)\z/;
        }
        return @ret;
    }

    sub _have_v_compiler ($self) {
        return 0 if $ENV{FFI_PLATYPUS_LANG_VMOD_SKIP_V};
        return 1 if which 'v';
        return 0;
    }

}

__END__