File Coverage

blib/lib/Net/NodeTransformator.pm

Criterion	Covered	Total	%
statement	36	112	32.1
branch	0	38	0.0
condition	0	25	0.0
subroutine	12	25	48.0
pod	10	10	100.0
total	58	210	27.6

use strict;
use warnings;

package Net::NodeTransformator;

# ABSTRACT: interface to node transformator

use AnyEvent;
use AnyEvent::Handle;
use AnyEvent::Socket;
use AnyEvent::Proc 0.101;
use Try::Tiny;
use Env::Path;
use File::Temp qw(tempdir);
use POSIX qw(getcwd);
use CBOR::XS ();
use Carp;

our $VERSION = '0.105';    # VERSION

sub new {
    my ( $class, $hostport ) = @_;
    if ( $hostport !~ m{:} ) {
        if ( $hostport =~ m{^\d+$} ) {
            $hostport = "localhost:$hostport";
        }
        else {
            $hostport = "unix/:$hostport";
        }
    }
    my ( $host, $port ) = parse_hostport($hostport);
    if ( $host eq 'unix/' and $port !~ m{^/} ) {
        $port = getcwd . '/' . $port;
    }
    bless {
        host => $host,
        port => $port,
      } => ref $class
      || $class;
}

sub standalone {
    my $class = shift;

    my %options;
    if ( @_ > 1 and !( @_ % 2 ) ) {
        %options = @_;
    }
    elsif ( @_ == 1 ) {
        $options{connect} = shift;
    }
    elsif (@_) {
        croak "wrong paramater given for $class->standalone";
    }

    $options{bin} ||= 'transformator';
    my $path =
        $options{bin} =~ m{/}
      ? $options{bin}
      : ( Env::Path->PATH->Whence( $options{bin} ) )[0];

    unless ($path) {
        croak "binary " . $options{bin} . " not found";
    }

    unless ( $options{connect} ) {
        my $tmpdir = tempdir( CLEANUP => 1 );
        $options{connect} = "$tmpdir/~sock";
    }

    my $errstr = '';

    my $cv = $options{cv} // AE::cv;

    my $server = AnyEvent::Proc->new(
        bin         => $path,
        args        => [ $options{connect} ],
        rtimeout    => 10,
        errstr      => \$errstr,
        on_rtimeout => sub {
            shift->fire_and_kill(
                10,
                sub {
                    $cv->croak( 'timeout (' . $errstr . ')' );
                }
            );
        },
    );

    $server->readlines_cb(
        sub {
            if ( shift =~ m{server bound} ) {
                $server->stop_rtimeout;
                my $client = $class->new( $options{connect} );
                $client->{_server} = $server;
                $cv->send($client);
            }
        }
    );

    if ( $options{cb} or $options{cv} ) {
        $cv->cb( $options{cb} ) if $options{cb};
        return $cv;
    }
    else {
        return $cv->recv;
    }
}

sub cleanup {
    my ($self) = @_;
    if ( exists $self->{_server} ) {
        my $server = delete $self->{_server};
        $server->fire_and_kill(10);
    }
    else {
        AE::log note =>
          "$self->cleanup called when no standalone server active";
    }

}

sub transform_cv {
    my ( $self, %options ) = @_;

    if ( $options{on_error} ) {
        confess
"on_error option is deprecated. the returned condvar will now croak on receive if there is an error.";
    }

    my $cv = $options{cv} || AE::cv;

    my $host = $self->{host};
    my $port = $self->{port};

    tcp_connect(
        $host, $port,
        sub {
            return $cv->croak("Connect to $host:$port failed: $!") unless @_;
            my ($fh) = @_;
            my $AEH;
            $AEH = AnyEvent::Handle->new(
                fh       => $fh,
                on_error => sub {
                    my ( $handle, $fatal, $message ) = @_;
                    $handle->destroy;
                    $cv->croak("Socket error: $message");
                },
                on_eof => sub {
                    $AEH->destroy;
                },
            );
            $AEH->push_read(
                cbor => sub {
                    my $answer = $_[1];
                    if ( defined $answer and ref $answer eq 'HASH' ) {
                        if ( exists $answer->{error} ) {
                            $cv->croak( "Service error: " . $answer->{error} );
                        }
                        elsif ( exists $answer->{result} ) {
                            $cv->send( $answer->{result} );
                        }
                        else {
                            $cv->croak(
                                "Something is wrong: no result and no error");
                        }
                    }
                    else {
                        $cv->croak("No answer");
                    }
                }
            );
            $AEH->push_write( cbor =>
                  [ $options{engine}, $options{input}, $options{data} || {} ] );
            $AEH->push_shutdown;
        }
    );

    $cv->cb( $options{cb} ) if $options{cb};

    $cv;
}

sub transform {
    my ( $self, $engine, $input, $data ) = @_;
    $self->transform_cv(
        engine => $engine,
        input  => $input,
        data   => $data,
    )->recv;
}

sub jade { shift->transform( jade => @_ ) }

sub coffeescript { shift->transform( coffeescript => @_ ) }

sub minify_html { shift->transform( minify_html => @_ ) }

sub minify_css { shift->transform( minify_css => @_ ) }

sub minify_js { shift->transform( minify_js => @_ ) }

1;

__END__