rapydscript-ng 0.8.0 → 0.8.2

package/src/lib/traceback.pyj

@@ -19,6 +19,7 @@ def serialize_error_for_formatting(err):
         'message': err.message or '',
     }
 
+
 def unserialize_error_for_formatting(err):
     ans = new Error()
     ans.name = err.name
@@ -177,15 +178,18 @@ def format_exception(exc, limit):
         js_lines = v"['Traceback (most recent call last):'].concat(js_lines)"
         if rs_lines.length > 0:
             js_lines = js_lines.concat(['', 'Mapped Traceback (RapydScript):']).concat(rs_lines)
-        return [l+'\n' for l in js_lines]
+        return [l + '\n' for l in js_lines]
     return [exc.toString()]
 
+
 def format_exc(limit):
     return format_exception(ρσ_last_exception, limit).join('')
 
+
 def print_exc(limit):
     print(format_exc(limit))
 
+
 def format_stack(limit):
     stack = Error().stack
     if not stack:
@@ -193,8 +197,9 @@ def format_stack(limit):
     lines = str.splitlines(stack)[2:]
     lines.reverse()
     if limit:
-        lines = lines[:limit+1] if limit > 0 else lines[limit:]
+        lines = lines[:limit + 1] if limit > 0 else lines[limit:]
     return [l + '\n' for l in lines]
 
+
 def print_stack(limit):
     print(format_stack(limit).join(''))

package/src/lib/uuid.pyj

@@ -47,11 +47,11 @@ def uuid4():
 def num_to_string(numbers, alphabet, pad_to_length):
     ans = v'[]'
     alphabet_len = alphabet.length
-    numbers = Array.from(numbers)
+    numbers = Array.from (numbers)
     for v'var i = 0; i < numbers.length - 1; i++':
         x = divmod(numbers[i], alphabet_len)
         numbers[i] = x[0]
-        numbers[i+1] += x[1]
+        numbers[i + 1] += x[1]
     for v'var i = 0; i < numbers.length; i++':
         number = numbers[i]
         while number:

package/src/output/classes.pyj

@@ -7,6 +7,7 @@ from output.functions import decorate, function_definition, function_annotation
 from output.utils import create_doctring
 from utils import has_prop
 
+
 def print_class(output):
     self = this
     if self.external:
@@ -16,12 +17,12 @@ def print_class(output):
         output.indent()
         self.name.print(output)
         if not is_var and method and has_prop(self.static, method):
-            output.assign("." + method)
+            output.assign('.' + method)
         else:
             if is_var:
-                output.assign(".prototype[" + method + "]")
+                output.assign('.prototype[' + method + ']')
             else:
-                output.assign(".prototype" + (("." + method) if method else ""))
+                output.assign('.prototype' + (('.' + method) if method else ''))
 
     def define_method(stmt, is_property):
         name = stmt.name.name
@@ -33,7 +34,7 @@ def print_class(output):
 
         # decorate the method
         if stmt.decorators and stmt.decorators.length:
-            decorate(stmt.decorators, output, def():function_definition(stmt, output, strip_first, True);)
+            decorate(stmt.decorators, output, def (): function_definition(stmt, output, strip_first, True);)
             output.end_statement()
         else:
             function_definition(stmt, output, strip_first)
@@ -45,7 +46,7 @@ def print_class(output):
     def define_default_method(name, body):
         class_def(name)
         output.spaced('function', name, '()', '')
-        output.with_block(def(): output.indent(), body();)
+        output.with_block(def (): output.indent(), body();)
         output.end_statement()
 
     def add_hidden_property(name, proceed):
@@ -55,23 +56,23 @@ def print_class(output):
 
     # generate constructor
     def write_constructor():
-        output.print("function")
+        output.print('function')
         output.space()
         self.name.print(output)
-        output.print("()")
+        output.print('()')
         output.space()
 
-        output.with_block(def():
+        output.with_block(def ():
             output.indent()
             output.spaced('if', '(this.ρσ_object_id', '===', 'undefined)', 'Object.defineProperty(this,', '"ρσ_object_id",', '{"value":++ρσ_object_counter})')
             output.end_statement()
             if self.bound.length:
                 output.indent()
-                self.name.print(output), output.print(".prototype.__bind_methods__.call(this)")
+                self.name.print(output), output.print('.prototype.__bind_methods__.call(this)')
                 output.end_statement()
             output.indent()
             self.name.print(output)
-            output.print(".prototype.__init__.apply(this"), output.comma(), output.print('arguments)')
+            output.print('.prototype.__init__.apply(this'), output.comma(), output.print('arguments)')
             output.end_statement()
         )
 
@@ -98,8 +99,8 @@ def print_class(output):
     # inheritance
     if self.parent:
         output.indent()
-        output.print("ρσ_extends")
-        output.with_parens(def():
+        output.print('ρσ_extends')
+        output.with_parens(def ():
             self.name.print(output)
             output.comma()
             self.parent.print(output)
@@ -109,9 +110,9 @@ def print_class(output):
     # method binding
     if self.bound.length:
         seen_methods = Object.create(None)
-        add_hidden_property('__bind_methods__', def():
+        add_hidden_property('__bind_methods__', def ():
             output.spaced('function', '()', '')
-            output.with_block(def():
+            output.with_block(def ():
                 if self.bases.length:
                     for v'var i = self.bases.length - 1; i >= 0; i--':
                         base = self.bases[i]
@@ -133,12 +134,12 @@ def print_class(output):
     if property_names.length:
         output.indent()
         output.print('Object.defineProperties')
-        output.with_parens(def():
-            self.name.print(output), output.print('.prototype'), output.comma(), output.space(), output.with_block(def():
+        output.with_parens(def ():
+            self.name.print(output), output.print('.prototype'), output.comma(), output.space(), output.with_block(def ():
                 for name in property_names:
                     prop = self.dynamic_properties[name]
                     output.indent(), output.print(JSON.stringify(name) + ':'), output.space()
-                    output.with_block(def():
+                    output.with_block(def ():
                         output.indent(), output.print('"enumerable":'), output.space(), output.print('true'), output.comma(), output.newline()
                         if prop.getter:
                             output.indent(), output.print('"get":'), output.space()
@@ -157,16 +158,16 @@ def print_class(output):
     # actual methods
     if not self.init:
         # Create a default __init__ method
-        define_default_method('__init__', def():
+        define_default_method('__init__', def ():
             if self.parent:
                 self.parent.print(output)
                 output.spaced('.prototype.__init__', '&&')
                 output.space(), self.parent.print(output)
-                output.print(".prototype.__init__.apply")
-                output.with_parens(def():
-                    output.print("this")
+                output.print('.prototype.__init__.apply')
+                output.with_parens(def ():
+                    output.print('this')
                     output.comma()
-                    output.print("arguments")
+                    output.print('arguments')
                 )
                 output.end_statement()
         )
@@ -195,7 +196,7 @@ def print_class(output):
             console.error('Nested classes aren\'t supported yet')  # noqa:undef
 
     if not defined_methods['__repr__']:
-        define_default_method('__repr__', def():
+        define_default_method('__repr__', def ():
             if self.parent:
                 output.print('if('), self.parent.print(output), output.spaced('.prototype.__repr__)', 'return', self.parent)
                 output.print('.prototype.__repr__.call(this)'), output.end_statement()
@@ -205,7 +206,7 @@ def print_class(output):
         )
 
     if not defined_methods['__str__']:
-        define_default_method('__str__', def():
+        define_default_method('__str__', def ():
             if self.parent:
                 output.print('if('), self.parent.print(output), output.spaced('.prototype.__str__)', 'return', self.parent)
                 output.print('.prototype.__str__.call(this)'), output.end_statement()
@@ -214,7 +215,7 @@ def print_class(output):
         )
 
     # Multiple inheritance
-    add_hidden_property('__bases__', def():
+    add_hidden_property('__bases__', def ():
         output.print('[')
         for v'var i = 0; i < self.bases.length; i++':
             self.bases[i].print(output)
@@ -225,7 +226,7 @@ def print_class(output):
 
     if self.bases.length > 1:
         output.indent()
-        output.print("ρσ_mixin(")
+        output.print('ρσ_mixin(')
         self.name.print(output)
         for v'var i = 1; i < self.bases.length; i++':
             output.comma()
@@ -234,7 +235,7 @@ def print_class(output):
 
     # Docstring
     if self.docstrings and self.docstrings.length and output.options.keep_docstrings:
-        add_hidden_property('__doc__', def():
+        add_hidden_property('__doc__', def ():
             output.print(JSON.stringify(create_doctring(self.docstrings)))
         )
 

package/src/output/codegen.pyj

@@ -2,10 +2,6 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-# globals:console
-
-from utils import noop
-from parse import PRECEDENCE
 from ast import (
     AST_Array, AST_Assign, AST_BaseCall, AST_Binary, AST_BlockStatement, AST_Break,
     AST_Class, AST_Conditional, AST_Constant, AST_Continue,
@@ -20,20 +16,23 @@ from ast import (
     AST_UnaryPrefix, AST_Undefined, AST_Var, AST_VarDef, AST_Assert,
     AST_Verbatim, AST_While, AST_With, AST_Yield, AST_Await, TreeWalker, AST_Existential
 )
-from output.exceptions import print_try
 from output.classes import print_class
+from output.comments import print_comments
+from output.exceptions import print_try
+from output.functions import print_function, print_function_call
 from output.literals import print_array, print_obj_literal, print_object, print_set, print_regexp
 from output.loops import print_do_loop, print_while_loop, print_for_loop_body, print_for_in, print_list_comprehension
 from output.modules import print_top_level, print_imports
-from output.comments import print_comments
 from output.operators import (
     print_getattr, print_getitem, print_rich_getitem, print_splice_assignment,
     print_unary_prefix, print_binary_op, print_assign,
     print_conditional, print_seq, print_existential
 )
-from output.functions import print_function, print_function_call
 from output.statements import print_bracketed, first_in_statement, force_statement, print_with, print_assert
 from output.utils import make_block, make_num
+from parse import PRECEDENCE
+from utils import noop
+
 
 # -----[ code generators ]-----
 def generate_code():
@@ -41,12 +40,12 @@ def generate_code():
     def DEFPRINT(nodetype, generator):
         nodetype.prototype._codegen = generator
 
-    AST_Node.prototype.print = def(stream, force_parens):
+    AST_Node.prototype.print = def (stream, force_parens):
         self = this
         generator = self._codegen
         stream.push_node(self)
         if force_parens or self.needs_parens(stream):
-            stream.with_parens(def():
+            stream.with_parens(def ():
                 self.add_comments(stream)
                 stream.add_mapping(self)
                 generator(self, stream)
@@ -59,7 +58,7 @@ def generate_code():
         stream.pop_node()
 
     # -----[ comments ]-----
-    AST_Node.prototype.add_comments = def(output):
+    AST_Node.prototype.add_comments = def (output):
         if not is_node_type(this, AST_Toplevel):
             print_comments(this, output)
 
@@ -67,51 +66,48 @@ def generate_code():
     def PARENS(nodetype, func):
         nodetype.prototype.needs_parens = func
 
-    PARENS(AST_Node, def():
+    PARENS(AST_Node, def ():
         return False
     )
     # a function expression needs parens around it when it's provably
     # the first token to appear in a statement.
-    PARENS(AST_Function, def(output):
+    PARENS(AST_Function, def (output):
         return first_in_statement(output)
     )
     # same goes for an object literal, because otherwise it would be
     # interpreted as a block of code.
-    PARENS(AST_Object, def(output):
+    PARENS(AST_Object, def (output):
         return first_in_statement(output)
     )
-    PARENS(AST_Unary, def(output):
+    PARENS(AST_Unary, def (output):
         p = output.parent()
         return is_node_type(p, AST_PropAccess) and p.expression is this
     )
-    PARENS(AST_Seq, def(output):
+    PARENS(AST_Seq, def (output):
         p = output.parent()
         return is_node_type(p, AST_Unary) or is_node_type(p, AST_VarDef) or is_node_type(p, AST_Dot) or is_node_type(p, AST_ObjectProperty) or is_node_type(p, AST_Conditional)
     )
-    PARENS(AST_Binary, def(output):
+    PARENS(AST_Binary, def (output):
         p = output.parent()
         # (foo && bar)()
         if is_node_type(p, AST_BaseCall) and p.expression is this:
             return True
-
         # typeof (foo && bar)
         if is_node_type(p, AST_Unary):
             return True
-
         # (foo && bar)["prop"], (foo && bar).prop
         if is_node_type(p, AST_PropAccess) and p.expression is this:
             return True
-
         # this deals with precedence: 3 * (2 + 1)
         if is_node_type(p, AST_Binary):
             po = p.operator
             pp = PRECEDENCE[po]
             so = this.operator
             sp = PRECEDENCE[so]
-            if pp > sp or pp is sp and this is p.right and not (so is po and (so is "*" or so is "&&" or so is "||")):
+            if pp > sp or pp is sp and this is p.right and not (so is po and (so is '*' or so is '&&' or so is '||')):
                 return True
     )
-    PARENS(AST_PropAccess, def(output):
+    PARENS(AST_PropAccess, def (output):
         p = output.parent()
         if is_node_type(p, AST_New) and p.expression is this:
             # i.e. new (foo.bar().baz)
@@ -121,7 +117,7 @@ def generate_code():
             # interpreted as passing the arguments to the upper New
             # expression.
             try:
-                this.walk(new TreeWalker(def(node):
+                this.walk(new TreeWalker(def (node):
                     if is_node_type(node, AST_BaseCall):
                         raise p
                 ))
@@ -130,26 +126,27 @@ def generate_code():
                     raise ex
                 return True
     )
-    PARENS(AST_BaseCall, def(output):
+    PARENS(AST_BaseCall, def (output):
         p = output.parent()
         return is_node_type(p, AST_New) and p.expression is this
     )
-    PARENS(AST_New, def(output):
+    PARENS(AST_New, def (output):
         p = output.parent()
         if this.args.args.length is 0 and (is_node_type(p, AST_PropAccess) or is_node_type(p, AST_BaseCall) and p.expression is this):
             # (new foo)(bar)
             return True
     )
-    PARENS(AST_Number, def(output):
+    PARENS(AST_Number, def (output):
         p = output.parent()
         if this.value < 0 and is_node_type(p, AST_PropAccess) and p.expression is this:
             return True
     )
-    PARENS(AST_NaN, def(output):
+    PARENS(AST_NaN, def (output):
         p = output.parent()
         if is_node_type(p, AST_PropAccess) and p.expression is this:
             return True
     )
+
     def assign_and_conditional_paren_rules(output):
         p = output.parent()
         # !(a = false) → true
@@ -176,18 +173,18 @@ def generate_code():
     PARENS(AST_Conditional, assign_and_conditional_paren_rules)
 
     # -----[ PRINTERS ]-----
-    DEFPRINT(AST_Directive, def(self, output):
+    DEFPRINT(AST_Directive, def (self, output):
         output.print_string(self.value)
         output.semicolon()
     )
-    DEFPRINT(AST_Debugger, def(self, output):
-        output.print("debugger")
+    DEFPRINT(AST_Debugger, def (self, output):
+        output.print('debugger')
         output.semicolon()
     )
-    AST_StatementWithBody.prototype._do_print_body = def(output):
+    AST_StatementWithBody.prototype._do_print_body = def (output):
         force_statement(this.body, output)
 
-    DEFPRINT(AST_Statement, def(self, output):
+    DEFPRINT(AST_Statement, def (self, output):
         self.body.print(output)
         output.semicolon()
     )
@@ -195,16 +192,16 @@ def generate_code():
 
     DEFPRINT(AST_Imports, print_imports)
 
-    DEFPRINT(AST_SimpleStatement, def(self, output):
+    DEFPRINT(AST_SimpleStatement, def (self, output):
         if not (is_node_type(self.body, AST_EmptyStatement)):
             self.body.print(output)
             output.semicolon()
     )
-    DEFPRINT(AST_BlockStatement, def(self, output):
+    DEFPRINT(AST_BlockStatement, def (self, output):
         print_bracketed(self, output)
     )
 
-    DEFPRINT(AST_EmptyStatement, def(self, output):
+    DEFPRINT(AST_EmptyStatement, def (self, output):
         pass
     )
 
@@ -216,19 +213,19 @@ def generate_code():
 
     DEFPRINT(AST_ForIn, print_for_in)
 
-    AST_ForJS.prototype._do_print_body = def(output):
+    AST_ForJS.prototype._do_print_body = def (output):
         self = this
-        output.with_block(def():
+        output.with_block(def ():
             for stmt in self.body.body:
                 output.indent()
                 stmt.print(output)
                 output.newline()
         )
 
-    DEFPRINT(AST_ForJS, def(self, output):
-        output.print("for")
+    DEFPRINT(AST_ForJS, def (self, output):
+        output.print('for')
         output.space()
-        output.with_parens(def():
+        output.with_parens(def ():
             self.condition.print(output)
         )
         output.space()
@@ -243,15 +240,15 @@ def generate_code():
 
     AST_Lambda.prototype._do_print = print_function
 
-    DEFPRINT(AST_Lambda, def(self, output):
+    DEFPRINT(AST_Lambda, def (self, output):
         self._do_print(output)
     )
     AST_Class.prototype._do_print = print_class
-    DEFPRINT(AST_Class, def(self, output):
+    DEFPRINT(AST_Class, def (self, output):
         self._do_print(output)
     )
     # -----[ exits ]-----
-    AST_Exit.prototype._do_print = def(output, kind):
+    AST_Exit.prototype._do_print = def (output, kind):
         self = this
         output.print(kind)
         if self.value:
@@ -260,23 +257,23 @@ def generate_code():
 
         output.semicolon()
 
-    DEFPRINT(AST_Yield, def(self, output):
-        self._do_print(output, "yield" + ('*' if self.is_yield_from else ''))
+    DEFPRINT(AST_Yield, def (self, output):
+        self._do_print(output, 'yield' + ('*' if self.is_yield_from else ''))
     )
-    DEFPRINT(AST_Await, def(self, output):
-        output.print("await")
+    DEFPRINT(AST_Await, def (self, output):
+        output.print('await')
         output.space()
         self.value.print(output)
     )
-    DEFPRINT(AST_Return, def(self, output):
-        self._do_print(output, "return")
+    DEFPRINT(AST_Return, def (self, output):
+        self._do_print(output, 'return')
     )
-    DEFPRINT(AST_Throw, def(self, output):
-        self._do_print(output, "throw")
+    DEFPRINT(AST_Throw, def (self, output):
+        self._do_print(output, 'throw')
     )
 
     # -----[ loop control ]-----
-    AST_LoopControl.prototype._do_print = def(output, kind):
+    AST_LoopControl.prototype._do_print = def (output, kind):
         output.print(kind)
         if this.label:
             output.space()
@@ -284,11 +281,11 @@ def generate_code():
 
         output.semicolon()
 
-    DEFPRINT(AST_Break, def(self, output):
-        self._do_print(output, "break")
+    DEFPRINT(AST_Break, def (self, output):
+        self._do_print(output, 'break')
     )
-    DEFPRINT(AST_Continue, def(self, output):
-        self._do_print(output, "continue")
+    DEFPRINT(AST_Continue, def (self, output):
+        self._do_print(output, 'continue')
     )
 
     # -----[ if ]-----
@@ -330,27 +327,26 @@ def generate_code():
 
         force_statement(self.body, output)
 
-    DEFPRINT(AST_If, def(self, output):
-        output.print("if")
+    DEFPRINT(AST_If, def (self, output):
+        output.print('if')
         output.space()
-        output.with_parens(def(): self.condition.print(output);)
+        output.with_parens(def (): self.condition.print(output);)
         output.space()
         if self.alternative:
             make_then(self, output)
             output.space()
-            output.print("else")
+            output.print('else')
             output.space()
             force_statement(self.alternative, output)
         else:
             self._do_print_body(output)
-
     )
 
     # -----[ exceptions ]-----
     DEFPRINT(AST_Try, print_try)
 
     # -----[ var/const ]-----
-    AST_Definitions.prototype._do_print = def(output, kind):
+    AST_Definitions.prototype._do_print = def (output, kind):
         output.print(kind)
         output.space()
         for i, def_ in enumerate(this.definitions):
@@ -363,9 +359,10 @@ def generate_code():
         if not avoid_semicolon:
             output.semicolon()
 
-    DEFPRINT(AST_Var, def(self, output):
-        self._do_print(output, "var")
+    DEFPRINT(AST_Var, def (self, output):
+        self._do_print(output, 'var')
     )
+
     def parenthesize_for_noin(node, output, noin):
         if not noin:
             node.print(output)
@@ -373,8 +370,8 @@ def generate_code():
             try:
                 # need to take some precautions here:
                 #    https://github.com/mishoo/RapydScript2/issues/60
-                node.walk(new TreeWalker(def(node):
-                    if is_node_type(node, AST_Binary) and node.operator is "in":
+                node.walk(new TreeWalker(def (node):
+                    if is_node_type(node, AST_Binary) and node.operator is 'in':
                         raise output
                 ))
                 node.print(output)
@@ -383,10 +380,10 @@ def generate_code():
                     raise ex
                 node.print(output, True)
 
-    DEFPRINT(AST_VarDef, def(self, output):
+    DEFPRINT(AST_VarDef, def (self, output):
         self.name.print(output)
         if self.value:
-            output.assign("")
+            output.assign('')
             #            output.space()
             #            output.print("=")
             #            output.space()
@@ -400,7 +397,7 @@ def generate_code():
 
     AST_Seq.prototype._do_print = print_seq
 
-    DEFPRINT(AST_Seq, def(self, output):
+    DEFPRINT(AST_Seq, def (self, output):
         self._do_print(output)
     )
     DEFPRINT(AST_Dot, print_getattr)
@@ -428,44 +425,44 @@ def generate_code():
 
     DEFPRINT(AST_Object, print_object)
 
-    DEFPRINT(AST_ObjectKeyVal, def(self, output):
+    DEFPRINT(AST_ObjectKeyVal, def (self, output):
         self.key.print(output)
         output.colon()
         self.value.print(output)
     )
     DEFPRINT(AST_Set, print_set)
 
-    AST_Symbol.prototype.definition = def():
+    AST_Symbol.prototype.definition = def ():
         return this.thedef
 
-    DEFPRINT(AST_Symbol, def(self, output):
+    DEFPRINT(AST_Symbol, def (self, output):
         def_ = self.definition()
         output.print_name((def_.mangled_name or def_.name) if def_ else self.name)
     )
-    DEFPRINT(AST_Undefined, def(self, output):
-        output.print("void 0")
+    DEFPRINT(AST_Undefined, def (self, output):
+        output.print('void 0')
     )
     DEFPRINT(AST_Hole, noop)
 
-    DEFPRINT(AST_Infinity, def(self, output):
-        output.print("1/0")
+    DEFPRINT(AST_Infinity, def (self, output):
+        output.print('1/0')
     )
-    DEFPRINT(AST_NaN, def(self, output):
-        output.print("0/0")
+    DEFPRINT(AST_NaN, def (self, output):
+        output.print('0/0')
     )
-    DEFPRINT(AST_This, def(self, output):
-        output.print("this")
+    DEFPRINT(AST_This, def (self, output):
+        output.print('this')
     )
-    DEFPRINT(AST_Constant, def(self, output):
+    DEFPRINT(AST_Constant, def (self, output):
         output.print(self.value)
     )
-    DEFPRINT(AST_String, def(self, output):
+    DEFPRINT(AST_String, def (self, output):
         output.print_string(self.value)
     )
-    DEFPRINT(AST_Verbatim, def(self, output):
+    DEFPRINT(AST_Verbatim, def (self, output):
         output.print(self.value)
     )
-    DEFPRINT(AST_Number, def(self, output):
+    DEFPRINT(AST_Number, def (self, output):
         output.print(make_num(self.value))
     )
     DEFPRINT(AST_RegExp, print_regexp)