def test_js_decorator_for_function():
@js
def foo():
pass
def bar():
pass
bar_js = js(bar)
# js produces a JSCode object
assert isinstance(foo, JSCode)
assert isinstance(bar_js, JSCode)
# Applying js twice has no effect
assert js(foo) == foo
# JSCode objects cannot be called
raises(RuntimeError, foo)
raises(RuntimeError, bar_js)
raises(RuntimeError, foo, 1, 2, bar=3)
raises(ValueError, js, "foo")
raises(ValueError, js, isinstance) # buildins are not FunctionType
def test_inheritance_and_super(self):
class MyClass1:
def __init__(self):
self.bar = 7
def add(self, x=1):
self.bar += x
def addTwo(self):
self.bar += 2
class MyClass2(MyClass1):
def addTwo(self):
super().addTwo()
self.bar += 1 # haha, we add three!
class MyClass3(MyClass2):
def addTwo(self):
super().addTwo()
self.bar += 1 # haha, we add four!
def addFour(self):
super().add(4)
code = js(MyClass1).jscode + js(MyClass2).jscode + js(MyClass3).jscode
code += 'var m1=new MyClass1(), m2=new MyClass2(), m3=new MyClass3();'
# m1
assert evaljs(code + 'm1.bar;') == '7'
assert evaljs(code + 'm1.add();m1.bar;') == '8'
assert evaljs(code + 'm1.addTwo();m1.bar;') == '9'
# m2
assert evaljs(code + 'm2.bar;') == '7'
assert evaljs(code + 'm2.add();m2.bar;') == '8'
assert evaljs(code + 'm2.addTwo();m2.bar;') == '10'
# m3
assert evaljs(code + 'm3.bar;') == '7'
assert evaljs(code + 'm3.add();m3.bar;') == '8'
assert evaljs(code + 'm3.addTwo();m3.bar;') == '11'
assert evaljs(code + 'm3.addFour();m3.bar;') == '11' # super with args
# Inhertance m1
assert evaljs(code + 'm1 instanceof MyClass3;') == 'false'
assert evaljs(code + 'm1 instanceof MyClass2;') == 'false'
assert evaljs(code + 'm1 instanceof MyClass1;') == 'true'
assert evaljs(code + 'm1 instanceof Object;') == 'true'
# Inhertance m2
assert evaljs(code + 'm2 instanceof MyClass3;') == 'false'
assert evaljs(code + 'm2 instanceof MyClass2;') == 'true'
assert evaljs(code + 'm2 instanceof MyClass1;') == 'true'
assert evaljs(code + 'm2 instanceof Object;') == 'true'
# Inhertance m3
assert evaljs(code + 'm3 instanceof MyClass3;') == 'true'
assert evaljs(code + 'm3 instanceof MyClass2;') == 'true'
assert evaljs(code + 'm3 instanceof MyClass1;') == 'true'
assert evaljs(code + 'm3 instanceof Object;') == 'true'
def test_scope2(self):
# Avoid regression for bug with lambda and scoping
def func1(self):
x = 1
def func2(self):
x = 1
y = lambda : None
def func3(self):
x = 1
def y():
pass
assert 'var x' in js(func1).jscode
assert 'var x' in js(func2).jscode
assert 'var x' in js(func3).jscode
def test_inheritance_super_more(self):
class MyClass4:
def foo(self):
return self
class MyClass5(MyClass4):
def foo(self, test):
return super().foo()
def foo():
return super().foo()
code = js(MyClass4).jscode + js(MyClass5).jscode
code += 'var foo = ' + js(foo).jscode.replace('super()', 'MyClass4.prototype')
code += 'var m4=new MyClass4(), m5=new MyClass5();'
assert evaljs(code + 'm4.foo() === m4') == 'true'
assert evaljs(code + 'm4.foo() === m4') == 'true'
assert evaljs(code + 'foo.call(m4) === m4') == 'true'
def test_name_mangling():
@js
def foo__js():
pass
def bar__js():
pass
bar_js = js(bar__js)
assert foo__js.name == 'foo'
assert bar_js.name == 'bar'
def test_name_mangling():
@js
def foo__js():
pass
def bar__js():
pass
bar_js = js(bar__js)
assert foo__js.name == 'foo'
assert bar_js.name == 'bar'
def test_calling_method_from_init(self):
# Note that all class names inside a module need to be unique
# for js() to find the correct source.
class MyClass11:
def __init__(self):
self._res = self.m1() + self.m2() + self.m3()
def m1(self):
return 100
def m2(self):
return 10
class MyClass12(MyClass11):
def m2(self):
return 20
def m3(self):
return 2
code = js(MyClass11).jscode + js(MyClass12).jscode
assert evaljs(code + 'm = new MyClass12(); m._res') == '122'
assert evaljs(code + 'm = new MyClass12(); m.m1()') == '100'
def test_js_decorator_for_class():
@js
class XFoo1:
pass
class XFoo2:
pass
Foo_js = js(XFoo2)
# js produces a JSCode object
assert isinstance(XFoo1, JSCode)
assert isinstance(Foo_js, JSCode)
# Applying js twice has no effect
assert js(XFoo1) == XFoo1
# JSCode objects cannot be called
raises(RuntimeError, XFoo1)
raises(RuntimeError, Foo_js)
raises(RuntimeError, XFoo1, 1, 2, bar=3)
raises(ValueError, js, "foo")
raises(ValueError, js, str) # buildins fail
def test_js_decorator_for_class():
@js
class XFoo1:
pass
class XFoo2:
pass
Foo_js = js(XFoo2)
# js produces a JSCode object
assert isinstance(XFoo1, JSCode)
assert isinstance(Foo_js, JSCode)
# Applying js twice has no effect
assert js(XFoo1) == XFoo1
# JSCode objects cannot be called
raises(RuntimeError, XFoo1)
raises(RuntimeError, Foo_js)
raises(RuntimeError, XFoo1, 1, 2, bar=3)
raises(ValueError, js, "foo")
raises(ValueError, js, str) # buildins fail
def test_js_decorator_for_function():
@js
def foo():
pass
def bar():
pass
bar_js = js(bar)
# js produces a JSCode object
assert isinstance(foo, JSCode)
assert isinstance(bar_js, JSCode)
# Applying js twice has no effect
assert js(foo) == foo
# JSCode objects cannot be called
raises(RuntimeError, foo)
raises(RuntimeError, bar_js)
raises(RuntimeError, foo, 1, 2, bar=3)
raises(ValueError, js, "foo")
raises(ValueError, js, isinstance) # buildins are not FunctionType
"""
Example to demonstrate simple transpiling and evaluating.
"""
from flexx.pyscript import js, py2js, evaljs, evalpy
def foo(a, b=1, *args):
print(a)
return b
# Create jscode object
jscode = js(foo)
# Print some info that we have on the code
print(jscode.name)
print(jscode.pycode)
print(jscode.jscode)
# Convert strings of Python to JS
print(py2js('isinstance(x, str)'))
print(py2js('isinstance(x, Bar)'))
# Evaluate js in nodejs
print(evaljs('10 * 10'))
# Evaluate PyScript in nodejs
print(evalpy('10**10'))
