Merge pull request #15 from mamod/v1.0.0_7

V1.0.0 7

Author: mamod

Makefile.PL

@@ -21,5 +21,9 @@ WriteMakefile(
     PREREQ_PM         => {
         'Inline'      => '0.80',
         'Inline::C'   => '0.75',
+    },
+    TEST_REQUIRES     => {
+        'Test::Fatal'   => '0.014',
+        'Try::Tiny'     => '0.24',
     }
 );

lib/JavaScript/Duktape.pm

@@ -175,9 +175,8 @@ sub new {
         return 1;
     };
 
-    $duk->push_perl_function($self->{call}, -1, 1);
+    $duk->push_perl_function($self->{call}, -1);
     $duk->put_global_string('perlCall');
-
     return $self;
 }
 
@@ -265,11 +264,20 @@ sub eval {
 sub vm  { shift->{duk}; }
 sub duk { shift->{duk}; }
 
+sub destroy {
+    my $self = shift;
+    return if !$self->{duk};
+    local $@; #duk_desatroy_heap mess with $@!!
+    $self->{duk}->gc(0);
+    $self->{duk}->destroy_heap();
+    delete $self->{duk};
+}
+
 sub DESTROY {
     my $self = shift;
     my $duk = $self->duk;
     if ($self->{pid} == $$){
-        $duk->destroy_heap();
+        $self->destroy();
     }
 }
 
@@ -512,7 +520,6 @@ sub push_c_function {
     my $self  = shift;
     my $sub   = shift;
     my $nargs = shift || -1;
-    my $nofinalizer = shift;
 
     $GlobalRef->{"$sub"} = sub {
         my @args = @_;
@@ -540,16 +547,13 @@ sub push_c_function {
         }, $top, 1);
 
         if ($died){
-            $self->push_error_object(100, $died);
             croak $died;
         }
 
         return $ret;
     };
 
     $self->perl_push_function($GlobalRef->{"$sub"}, $nargs);
-
-    return if $nofinalizer;
     $self->eval_string("(function(){perlFinalizer('$sub')})");
     $self->set_finalizer(-2);
 }

t/nested.t

@@ -0,0 +1,158 @@
+use lib './lib';
+use strict;
+use warnings;
+use JavaScript::Duktape;
+use Test::More;
+use Test::Fatal;
+
+use Try::Tiny;
+
+subtest 'try-tiny interaction' => sub {
+    sub eval_js {
+        my $code = shift;
+
+        my $js = JavaScript::Duktape->new;
+
+        try {
+            $js->eval( $code );
+        } catch {
+            my $err = $_;
+            warn "CAUGHT ERR: $err";
+            die "JS ERR: $err";
+        };
+    }
+
+    eval {
+        eval_js(q{
+            throw new Error('oh boy!');
+        });
+    };
+    isnt $@, '', 'error message comes through';
+};
+
+subtest 'simple nested thrown exception' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( each => sub{
+        my $arr = shift;
+        my $cb = shift;
+        for(@$arr) {
+            $cb->($_);
+        }
+    });
+    like exception { $js->eval(q{
+        var x=0; each([11,22], function(i){
+            throw new Error('foo error!');
+        });
+    }) }, qr/foo error/;
+};
+
+subtest 'try-catch caught nested thrown exception' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( each => sub{
+        my $arr = shift;
+        my $cb = shift;
+        for(@$arr) {
+            $cb->($_);
+        }
+    });
+    my $ret;
+    ok !exception { $ret =$js->eval(q{
+        var x=0;
+        try {
+            each([11,22], function(i){
+                x+=i;
+                throw new Error('foo error!');
+            });
+        } catch(e) {
+        }
+        x;
+    }) };
+    is $ret, 11;
+};
+
+subtest 'rewrap func with nested call' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( inc => sub{
+        return 1 + shift();
+    });
+    $js->set( each => sub{
+        my $arr = shift;
+        my $cb = shift;
+        for(@$arr) {
+            $cb->($_);
+        }
+    });
+    my $ret = $js->eval(q{
+        var x=0; each([11,22], function(i){ x+=i; x=inc(x); }); x
+    });
+    is $ret, 35,
+};
+
+subtest 'trap callback error' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( each => sub{
+        die "foo here";
+    });
+    like exception { $js->eval(q{
+        var x=0; each([11,22], function(i){ x+=i });
+    }) }, qr/foo here/;
+};
+
+subtest 'exception javascript' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( each => sub{
+        my $arr = shift;
+        my $cb = shift;
+        for(@$arr) {
+            $cb->($_);
+        }
+    });
+    like exception { $js->eval(q{
+        var x=0; var foo={};
+        each([11,22], function(i){ foo.bar() });
+    }) }, qr/not callable/;
+};
+
+subtest 'exception in perl' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( each => sub{
+        die('no good');
+    });
+    like exception { $js->eval(q{
+        var x=0; var foo={};
+        each([11,22], function(i){ return 33 });
+    }) }, qr/no good/;
+};
+
+subtest 'exception in callback function' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( each => sub{
+        my $arr = shift;
+        my $cb = shift;
+        for(@$arr) {
+            $cb->($_);
+        }
+    });
+    like exception { $js->eval(q{
+        var x=0; each([11,22], function(i){ not_a_function() });
+    }) }, qr/not_a_function.*undefined/;
+};
+
+subtest 'trap rewrap func error within nested call' => sub{
+    my $js = JavaScript::Duktape->new();
+    $js->set( inc => sub{
+        die "error bar here";
+    });
+    $js->set( each => sub{
+        my $arr = shift;
+        my $cb = shift;
+        for(@$arr) {
+            $cb->($_);
+        }
+    });
+    like exception { $js->eval(q{
+        var x=0; each([11,22], function(i){ x+=i; x=inc(x); });
+    }) }, qr/error bar here/;
+};
+
+done_testing;