[jsinterp] Actual JS interpreter

requirements.txt

@@ -0,0 +1 @@
+unittest2 ; python_version < '2.7'

test/jstests/__init__.py

@@ -0,0 +1,69 @@
+# TODO use json instead of py
+# TODO create devscript to generate ASTs (using e.g. acorn)
+
+from __future__ import unicode_literals
+
+__doc__ = """
+This package contains templates for `test_jsinterp` and `test_interp_parse` to create test methods.
+These modules will create a test method for each module in this package. A test method consist of one or more subtest.
+Each subtest initializes an instance of the tested class and runs one or more assertion.
+
+Any module should have a `list` of `dict` named ``tests`` and optionally a `dict` named ``skip``.
+
+Each `dict` in ``tests`` may have the following keys:
+
+    code: If missing subtest is skipped, Otherwise it's value is used as code to initialize the tested class.
+    globals: Optional. Used only by `test_jsinterp`. If set used as argument `variables` initializing `JSInterperter`.
+    asserts: Used only by `test_jsinterp`. If this is missing subtest is skipped, Should be a list of `dict`, each
+             used as an assertion for the initialized `JSInterpreter`. Each `dict` may have the following keys:
+                value: If missing assertion is skipped. Otherwise it's value is used as expected value in
+                       an `assertEqual` call.
+                call: Optional. If set used as arguments of a `call_function` call of the initialized `JSInterpreter`
+                      and the actual value of the created `assertEqual` call will be the return value of it.
+                      Otherwise the actual value will be the return value of the `run` call.
+    ast: Used only by `test_interp_parse`. If missing subtest is skipped, Otherwise it's value is used as
+         expected value in an `assertEqual` call. The actual value will be the return value of the `parse` call
+         converted to `list`. Both on expected anc actual value `traverse` is called first to flatten and handle `zip`
+         objects.
+
+In the `dict` named ``skip`` is optional and may have the following keys:
+    jsinterp
+    interpret
+    parse
+Each used as the argument of `skipTest` decorator of the created test method in `test_jsinterp`
+and `test_jsinterp_parse` respectably. Unless they're value is `True`, that case the test method is skipped entirely,
+or `False`, which is the default value and has no effect.
+
+Example:
+    This is not a functional template, rather a skeleton:
+
+        skip = {'interpret': 'Test not yet implemented',
+                'parse': 'Test not yet implemented'}
+
+        tests = [
+            {
+                'code': '',
+                'globals': {},
+                'asserts': [{'value': 0, 'call': ('f',)}],
+                'ast': []
+            }
+        ]
+"""
+
+
+def gettestcases():
+    import os
+
+    modules = [module[:-3] for module in os.listdir(os.path.dirname(__file__))
+               if module != '__init__.py' and module[-3:] == '.py']
+    me = __import__(__name__, globals(), locals(), modules)
+
+    for module_name in modules:
+        module = getattr(me, module_name)
+        if hasattr(module, 'tests'):
+            case = {
+                'name': module.__name__[len(__name__) + 1:],
+                'subtests': module.tests,
+                'skip': getattr(module, 'skip', {})
+            }
+            yield case

test/jstests/array_access.py

@@ -0,0 +1,82 @@
+from __future__ import unicode_literals
+
+from youtube_dl.jsinterp2.jsgrammar import Token
+from youtube_dl.jsinterp2.tstream import _ASSIGN_OPERATORS
+
+tests = [
+    {'code': 'function f() { var x = [1,2,3]; x[0] = 4; x[0] = 5; x[2] = 7; return x; }',
+     'asserts': [{'value': [5, 2, 7], 'call': ('f',)}],
+     'ast': [
+         (Token.FUNC, 'f', [], [
+             (Token.VAR,
+              zip(['x'],
+                  [(Token.ASSIGN,
+                    None,
+                    (Token.OPEXPR, [
+                        (Token.MEMBER, (Token.ARRAY, [
+                            (Token.ASSIGN, None, (Token.OPEXPR, [
+                                (Token.MEMBER, (Token.INT, 1), None, None)]), None),
+                            (Token.ASSIGN, None, (Token.OPEXPR, [
+                                (Token.MEMBER, (Token.INT, 2), None, None)]), None),
+                            (Token.ASSIGN, None, (Token.OPEXPR, [
+                                (Token.MEMBER, (Token.INT, 3), None, None)]), None)
+                        ]), None, None),
+                    ]),
+                    None)
+                   ])
+              ),
+             (Token.EXPR, [
+                 (Token.ASSIGN,
+                  _ASSIGN_OPERATORS['='][1],
+                  (Token.OPEXPR, [
+                      (Token.MEMBER, (Token.ID, 'x'),
+                       None,
+                       (Token.ELEM,
+                        (Token.EXPR, [
+                            (Token.ASSIGN,
+                             None,
+                             (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 0), None, None)]),
+                             None)
+                        ]),
+                        None))
+                  ]),
+                  (Token.ASSIGN, None, (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 4), None, None)]), None)
+                  )
+             ]),
+             (Token.EXPR, [
+                 (Token.ASSIGN,
+                  _ASSIGN_OPERATORS['='][1],
+                  (Token.OPEXPR, [(Token.MEMBER, (Token.ID, 'x'),
+                                   None,
+                                   (Token.ELEM, (Token.EXPR, [
+                                       (Token.ASSIGN,
+                                        None,
+                                        (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 0), None, None)]),
+                                        None)
+                                   ]), None))
+                                  ]),
+                  (Token.ASSIGN, None, (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 5), None, None)]), None))
+             ]),
+             (Token.EXPR, [
+                 (Token.ASSIGN,
+                  _ASSIGN_OPERATORS['='][1],
+                  (Token.OPEXPR, [(Token.MEMBER, (Token.ID, 'x'),
+                                   None,
+                                   (Token.ELEM, (Token.EXPR, [
+                                       (Token.ASSIGN,
+                                        None,
+                                        (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 2), None, None)]),
+                                        None)
+                                   ]), None))
+                                  ]),
+                  (Token.ASSIGN, None, (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 7), None, None)]), None))
+             ]),
+             (Token.RETURN,
+              (Token.EXPR, [
+                  (Token.ASSIGN, None, (Token.OPEXPR, [(Token.MEMBER, (Token.ID, 'x'), None, None)]), None)
+              ])
+              )
+         ])
+     ]
+     }
+]

test/jstests/assignments.py

@@ -0,0 +1,46 @@
+from __future__ import unicode_literals
+
+from youtube_dl.jsinterp2.jsgrammar import Token
+from youtube_dl.jsinterp2.tstream import _OPERATORS, _ASSIGN_OPERATORS
+
+tests = [
+    {
+        'code': 'function f() { var x = 20; x = 30 + 1; return x; }',
+        'asserts': [{'value': 31, 'call': ('f',)}],
+        'ast': [
+            (Token.FUNC, 'f', [], [
+                (Token.VAR, zip(
+                    ['x'],
+                    [(Token.ASSIGN,
+                      None,
+                      (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 20), None, None)]),
+                      None)]
+                )),
+                (Token.EXPR, [
+                    (Token.ASSIGN,
+                     _ASSIGN_OPERATORS['='][1],
+                     (Token.OPEXPR, [(Token.MEMBER, (Token.ID, 'x'), None, None)]),
+                     (Token.ASSIGN, None,
+                      (Token.OPEXPR, [
+                          (Token.MEMBER, (Token.INT, 30), None, None),
+                          (Token.MEMBER, (Token.INT, 1), None, None),
+                          (Token.OP, _OPERATORS['+'][1])]),
+                      None))
+                ]),
+
+                (Token.RETURN, (Token.EXPR, [
+                    (Token.ASSIGN, None,
+                     (Token.OPEXPR, [
+                         (Token.MEMBER, (Token.ID, 'x'), None, None)
+                     ]), None)
+                ]))
+            ])
+        ]
+    }, {
+        'code': 'function f() { var x = 20; x += 30 + 1; return x;}',
+        'asserts': [{'value': 51, 'call': ('f',)}],
+    }, {
+        'code': 'function f() { var x = 20; x -= 30 + 1; return x;}',
+        'asserts': [{'value': -11, 'call': ('f',)}],
+    }
+]

test/jstests/basic.py

@@ -0,0 +1,32 @@
+from __future__ import unicode_literals
+
+from youtube_dl.jsinterp2.jsgrammar import Token
+
+tests = [
+    {
+        'code': 'function f() { return 42; }',
+        'asserts': [{'value': 42, 'call': ('f',)}],
+        'ast': [
+            (Token.FUNC, 'f', [], [
+                (Token.RETURN,
+                 (Token.EXPR, [
+                     (Token.ASSIGN,
+                      None,
+                      (Token.OPEXPR, [(Token.MEMBER, (Token.INT, 42), None, None)]),
+                      None)
+                 ]))
+            ])
+        ]
+    },
+    {
+        'code': 'function x() {;}',
+        'asserts': [{'value': None, 'call': ('x',)}],
+        'ast': [(Token.FUNC, 'x', [], [None])]
+    },
+    {
+        # FIXME: function expression needs to be implemented
+        'exclude': ('jsinterp2',),
+        'code': 'var x5 = function x5(){return 42;}',
+        'asserts': [{'value': 42, 'call': ('x5',)}]
+    }
+]

test/jstests/branch.py

@@ -0,0 +1,37 @@
+from __future__ import unicode_literals
+
+from youtube_dl.jsinterp2.jsgrammar import Token
+from youtube_dl.jsinterp2.tstream import _RELATIONS
+
+skip = {
+    'jsinterp': 'Branching is not supported',
+    'interpret': 'Interpreting if statement not yet implemented'
+}
+
+tests = [
+    {
+        'code': '''
+            function a(x) {
+                if (x > 0)
+                    return true;
+                else
+                    return false;
+            }
+            ''',
+        'asserts': [{'value': True, 'call': ('a', 1)}, {'value': False, 'call': ('a', 0)}],
+        'ast': [
+            (Token.FUNC, 'a', ['x'], [
+                (Token.IF,
+                 (Token.EXPR, [(Token.ASSIGN, None, (Token.OPEXPR, [
+                     (Token.MEMBER, (Token.ID, 'x'), None, None),
+                     (Token.MEMBER, (Token.INT, 0), None, None),
+                     (Token.REL, _RELATIONS['>'][1])
+                 ]), None)]),
+                 (Token.RETURN, (Token.EXPR, [(Token.ASSIGN, None, (Token.OPEXPR, [
+                     (Token.MEMBER, (Token.BOOL, True), None, None)]), None)])),
+                 (Token.RETURN, (Token.EXPR, [(Token.ASSIGN, None, (Token.OPEXPR, [
+                     (Token.MEMBER, (Token.BOOL, False), None, None)]), None)])))
+            ])
+        ]
+    }
+]

test/jstests/calc.py

@@ -0,0 +1,29 @@
+from __future__ import unicode_literals
+
+from youtube_dl.jsinterp2.jsgrammar import Token
+from youtube_dl.jsinterp2.tstream import _OPERATORS
+
+tests = [
+    {'code': 'function x4(a){return 2*a+1;}',
+     'asserts': [{'value': 7, 'call': ('x4', 3)}],
+     'ast': [
+         (Token.FUNC, 'x4', ['a'], [
+            (Token.RETURN,
+             (Token.EXPR, [
+                  (Token.ASSIGN,
+                   None,
+                   (Token.OPEXPR, [
+                       # Reverse Polish Notation!
+                       (Token.MEMBER, (Token.INT, 2), None, None),
+                       (Token.MEMBER, (Token.ID, 'a'), None, None),
+                       (Token.OP, _OPERATORS['*'][1]),
+                       (Token.MEMBER, (Token.INT, 1), None, None),
+                       (Token.OP, _OPERATORS['+'][1])
+                   ]),
+                   None)
+             ])
+             )
+         ])
+     ]
+     }
+]