JavaScript-Duktape-XS

 view release on metacpan or  search on metacpan

duktape.c  view on Meta::CPAN

	/* coercion order matters */
	h_v = duk_to_hstring_acceptsymbol(thr, 0);
	DUK_ASSERT(h_v != NULL);

	h_obj = duk_push_this_coercible_to_object(thr);
	DUK_ASSERT(h_obj != NULL);

	ret = duk_hobject_get_own_propdesc(thr, h_obj, h_v, &desc, 0 /*flags*/); /* don't push value */

	duk_push_boolean(thr, ret && ((desc.flags & required_desc_flags) == required_desc_flags));
	return 1;
}

/*
 *  Object.seal() and Object.freeze()  (E5 Sections 15.2.3.8 and 15.2.3.9)
 *
 *  Since the algorithms are similar, a helper provides both functions.
 *  Freezing is essentially sealing + making plain properties non-writable.
 *
 *  Note: virtual (non-concrete) properties which are non-configurable but

lib/JavaScript/Duktape/XS.pm  view on Meta::CPAN

    $vm->reset_msgs();

    my $globals = $vm->global_objects();

    my $rounds = $vm->run_gc();

    my $info = $vm->get_version_info();

    $vm->set('perl_module_resolve', \&module_resolve);
    $vm->set('perl_module_load',    \&module_load);
    $vm->eval('var badger = require("badger");');

=head1 DESCRIPTION

This module provides an XS wrapper to call Duktape from Perl.

The wrapper is used in an OO way: you create an instance of
C<JavaScript::Duktape::XS> and then invoke functions on it.

=head1 METHODS/ATTRIBUTES

t/13_module.t  view on Meta::CPAN

sub _module_load {
    my ($module_name, $exports, $module) = @_;

    # printf STDERR ("load_cb module_name='%s'\n", $module_name);

    my $source;
    if ($module_name eq 'pig.js') {
        $source = sprintf("module.exports = 'you\\'re about to get eaten by %s';", $module_name);
    }
    elsif ($module_name eq 'cow.js') {
        $source = "module.exports = require('pig');";
    }
    elsif ($module_name eq 'ape.js') {
        $source = "module.exports = { module: module, __filename: __filename, wasLoaded: module.loaded };";
    }
    elsif ($module_name eq 'badger.js') {
        $source = "exports.foo = 123; exports.bar = 234;";
    }
    elsif ($module_name eq 'comment.js') {
        $source = "exports.foo = 123; exports.bar = 234; // comment";
    }

t/13_module.t  view on Meta::CPAN

    return $source;
}

sub test_module {
    my $vm = $CLASS->new();
    $vm->set('perl_module_resolve', \&_module_resolve);
    $vm->set('perl_module_load', \&_module_load);
    ok($vm, "created $CLASS object");

    $vm->eval('var p = require("pig");');
    is($vm->typeof('p'), 'string', 'basic require()');

    $vm->eval('var r = require("cow"); var c = r.indexOf("pig");');
    # printf STDERR ("cow: %s", Dumper($vm->get('r')));
    ok($vm->get('c') >= 0, 'nested require()');

    $vm->eval('var ape1 = require("ape"); var ape2 = require("ape");');
    my $a1 = $vm->get('ape1');
    my $a2 = $vm->get('ape2');
    is_deeply($a1, $a2, 'cached require');

    $vm->eval('var ape1 = require("ape"); var inCache = "ape.js" in require.cache; delete require.cache["ape.js"]; var ape2 = require("ape");');
    ok($vm->get('inCache'), 'cached required, inCache');
    ok($vm->get('ape2') ne $vm->get('ape1'), 'cached require, not equal');

    $vm->eval('var ape3 = require("ape");');

    is($vm->typeof('ape3.module.require'), "function", "module.require is a function");

    my $a30 = $vm->get('ape3');
    my $a31 = $vm->get('ape3.module.exports');
    my $a32 = $vm->get('ape3.module.id');
    my $a33 = $vm->get('ape3.module.filename');
    my $a34 = $vm->get('ape3.module.loaded');
    my $a35 = $vm->get('ape3.wasLoaded');
    my $a36 = $vm->get('ape3.__filename');

t/13_module.t  view on Meta::CPAN

    is($a32, 'ape.js', 'ape module id');

    is($a32, $a33, 'ape module filename');

    ok( $a34, 'module loaded');
    ok(!$a35, 'wasLoaded');

    is($a36, 'ape.js', 'ape __filename');

    $vm->eval('var badger = require("badger");');
    # printf STDERR ("badger: %s", Dumper($vm->get('badger')));
    is($vm->get('badger.foo'), 123, 'exports.foo assignment');
    is($vm->get('badger.bar'), 234, 'exports.bar assignment');

    $vm->eval('var comment = require("comment");');
    # printf STDERR ("comment %s", Dumper($vm->get('comment')));
    is($vm->get('comment.foo'), 123, 'comment.foo, last line with // comment');
    is($vm->get('comment.bar'), 234, 'comment.bar, last line with // comment');

    $vm->eval('var shebang = require("shebang");');
    is($vm->get('shebang.foo'), 123, 'shebang.foo');
    is($vm->get('shebang.bar'), 234, 'shebang.bar');
}

sub test_module_die {
    foreach my $die_resolve (0..1) {
        foreach my $die_load (0..1) {
            my $vm = $CLASS->new();
            $vm->set('perl_module_resolve', sub {
                if ($die_resolve) {

t/60_resolve.t  view on Meta::CPAN

use strict;
use warnings;

use Test::More;
use Test::Exception;

my $CLASS = 'JavaScript::Duktape::XS';

use constant SUCCESSFUL_REQUIRE => <<'EOF';
var p = require('find_it');
'require successful';
EOF

use constant FAILED_REQUIRE => <<'EOF';
var retval;
try {
	require('not_there');
} catch(e) {
	retval = 'Perl exception: ' + e.message;
}