rapydscript-ng 0.7.24 → 0.8.1

package/src/output/functions.pyj

@@ -1,17 +1,17 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals:regenerate
 from __python__ import hash_literals
 
 from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, is_node_type
-from output.stream import OutputStream
+from output.operators import print_getattr
 from output.statements import print_bracketed
+from output.stream import OutputStream
 from output.utils import create_doctring
-from output.operators import print_getattr
 
 anonfunc = 'ρσ_anonfunc'
 module_name = 'null'
 
+
 def set_module_name(x):
     nonlocal module_name
     module_name = '"' + x + '"' if x else 'null'
@@ -19,30 +19,34 @@ def set_module_name(x):
 
 # Function definition {{{
 
+
 def decorate(decorators, output, func):
     pos = 0
+
     def wrap():
         nonlocal pos
         if pos < decorators.length:
             decorators[pos].expression.print(output)
             pos += 1
-            output.with_parens(def():
+            output.with_parens(def ():
                 wrap()
             )
         else:
             func()
     wrap()
 
+
 def function_args(argnames, output, strip_first):
-    output.with_parens(def():
-        if argnames and argnames.length and (argnames.is_simple_func is True or argnames.is_simple_func is undefined):
-            for i, arg in enumerate((argnames.slice(1) if strip_first else argnames)):
+    output.with_parens(def ():
+        if argnames and argnames.args.length and (argnames.is_simple_func is True or argnames.is_simple_func is undefined):
+            for i, arg in enumerate((argnames.args.slice(1) if strip_first else argnames.args)):
                 if i:
                     output.comma()
                 arg.print(output)
     )
     output.space()
 
+
 def function_preamble(node, output, offset):
     a = node.argnames
     if not a or a.is_simple_func:
@@ -51,11 +55,11 @@ def function_preamble(node, output, offset):
     fname = node.name.name if node.name else anonfunc
     kw = 'arguments[arguments.length-1]'
     # Define all formal parameters
-    for c, arg in enumerate(a):
+    for c, arg in enumerate(a.args):
         i = c - offset
         if i >= 0:
             output.indent()
-            output.print("var")
+            output.print('var')
             output.space()
             output.assign(arg)
             if Object.prototype.hasOwnProperty.call(a.defaults, arg.name):
@@ -84,7 +88,7 @@ def function_preamble(node, output, offset):
             for dname in Object.keys(a.defaults):
                 output.indent()
                 output.spaced('if', '(Object.prototype.hasOwnProperty.call(' + kw + ',', '"' + dname + '"))')
-                output.with_block(def():
+                output.with_block(def ():
                     output.indent()
                     output.spaced(dname, '=', kw + '.' + dname)
                     output.end_statement()
@@ -97,7 +101,7 @@ def function_preamble(node, output, offset):
 
     if a.starargs is not undefined:
         # Define the *args parameter, putting in whatever is left after assigning the formal parameters and the options object
-        nargs = a.length - offset
+        nargs = a.args.length - offset
         output.indent()
         output.spaced('var', a.starargs.name, '=', 'Array.prototype.slice.call(arguments,', nargs + ')')
         output.end_statement()
@@ -107,29 +111,31 @@ def function_preamble(node, output, offset):
         output.print('.pop()')
         output.end_statement()
 
+
 def has_annotations(self):
     if self.return_annotation:
         return True
-    for arg in self.argnames:
+    for arg in self.argnames.args:
         if arg.annotation:
             return True
     return False
 
+
 def function_annotation(self, output, strip_first, name):
     fname = name or (self.name.name if self.name else anonfunc)
     props = Object.create(None)
 
     # Create __annotations__
     if has_annotations(self):
-        props.__annotations__ = def():
+        props.__annotations__ = def ():
             output.print('{')
-            if self.argnames and self.argnames.length:
-                for i, arg in enumerate(self.argnames):
+            if self.argnames and self.argnames.args.length:
+                for i, arg in enumerate(self.argnames.args):
                     if arg.annotation:
                         arg.print(output)
                         output.print(':'), output.space()
                         arg.annotation.print(output)
-                        if i < self.argnames.length - 1 or self.return_annotation:
+                        if i < self.argnames.args.length - 1 or self.return_annotation:
                             output.comma()
             if self.return_annotation:
                 output.print('return:'), output.space()
@@ -140,7 +146,7 @@ def function_annotation(self, output, strip_first, name):
     defaults = self.argnames.defaults
     dkeys = Object.keys(self.argnames.defaults)
     if dkeys.length:
-        props.__defaults__ = def():
+        props.__defaults__ = def ():
             output.print('{')
             for i, k in enumerate(dkeys):
                 output.print(k + ':'), defaults[k].print(output)
@@ -150,27 +156,27 @@ def function_annotation(self, output, strip_first, name):
 
     # Create __handles_kwarg_interpolation__
     if not self.argnames.is_simple_func:
-        props.__handles_kwarg_interpolation__ = def():
+        props.__handles_kwarg_interpolation__ = def ():
             output.print('true')
 
     # Create __argnames__
-    if self.argnames.length > (1 if strip_first else 0):
-        props.__argnames__ = def():
+    if self.argnames.args.length > (1 if strip_first else 0):
+        props.__argnames__ = def ():
             output.print('[')
-            for i, arg in enumerate(self.argnames):
+            for i, arg in enumerate(self.argnames.args):
                 if strip_first and i is 0:
                     continue
                 output.print(JSON.stringify(arg.name))
-                if i is not self.argnames.length - 1:
+                if i is not self.argnames.args.length - 1:
                     output.comma()
             output.print(']')
 
     # Create __doc__
     if output.options.keep_docstrings and self.docstrings and self.docstrings.length:
-        props.__doc__ = def():
+        props.__doc__ = def ():
             output.print(JSON.stringify(create_doctring(self.docstrings)))
 
-    props.__module__ = def():
+    props.__module__ = def ():
         output.print(module_name)
 
     names = Object.keys(props)
@@ -179,7 +185,7 @@ def function_annotation(self, output, strip_first, name):
     # can happen if the function definition is inside a loop, for example.
     output.spaced('if', '(!' + fname + '.' + names[0] + ')', 'Object.defineProperties(' + fname)
     output.comma()
-    output.with_block(def():
+    output.with_block(def ():
         for v'var i = 0; i < names.length; i++':
             name = names[i]
             output.indent(), output.spaced(name, ':', '{value:', ''), props[name](), output.print('}')
@@ -197,28 +203,19 @@ def function_definition(self, output, strip_first, as_expression):
         output.set_indentation(output.next_indent())
         output.spaced('(function()', '{'), output.newline()
         output.indent(), output.spaced('var', anonfunc, '='), output.space()
-    output.print("function"), output.space()
+    if self.is_async:
+        output.print('async'), output.space()
+    output.print('function'), output.space()
     if self.name:
         self.name.print(output)
 
     if self.is_generator:
         output.print('()'), output.space()
-        output.with_block(def():
-            if output.options.js_version >= 6:
-                output.indent()
-                output.print('function* js_generator')
-                function_args(self.argnames, output, strip_first)
-                print_bracketed(self, output, True, function_preamble)
-            else:
-                temp = OutputStream({'beautify':True})
-                temp.print('function* js_generator')
-                function_args(self.argnames, temp, strip_first)
-                print_bracketed(self, temp, True, function_preamble)
-                transpiled = regenerate(temp.get(), output.options.beautify).replace(/regeneratorRuntime.(wrap|mark)/g, 'ρσ_regenerator.regeneratorRuntime.$1')
-                if output.options.beautify:
-                    ci = output.make_indent(0)
-                    transpiled = [ci + x for x in transpiled.split('\n')].join('\n')
-                output.print(transpiled)
+        output.with_block(def ():
+            output.indent()
+            output.print('function* js_generator')
+            function_args(self.argnames, output, strip_first)
+            print_bracketed(self, output, True, function_preamble)
             output.newline()
             output.indent()
             output.spaced('var', 'result', '=', 'js_generator.apply(this,', 'arguments)')
@@ -240,15 +237,16 @@ def function_definition(self, output, strip_first, as_expression):
         function_annotation(self, output, strip_first, anonfunc)
         output.indent(), output.spaced('return', anonfunc), output.end_statement()
         output.set_indentation(orig_indent)
-        output.indent(), output.print("})()")
+        output.indent(), output.print('})()')
+
 
 def print_function(output):
     self = this
     if self.decorators and self.decorators.length:
-        output.print("var")
+        output.print('var')
         output.space()
         output.assign(self.name.name)
-        decorate(self.decorators, output, def():function_definition(self, output, False, True);)
+        decorate(self.decorators, output, def (): function_definition(self, output, False, True);)
         output.end_statement()
     else:
         function_definition(self, output, False)
@@ -259,12 +257,14 @@ def print_function(output):
 
 # Function call {{{
 
+
 def find_this(expression):
     if is_node_type(expression, AST_Dot):
         return expression.expression
     if not is_node_type(expression, AST_SymbolRef):
         return expression
 
+
 def print_this(expression, output):
     obj = find_this(expression)
     if obj:
@@ -272,6 +272,7 @@ def print_this(expression, output):
     else:
         output.print('this')
 
+
 def print_function_call(self, output):
     is_prototype_call = False
 
@@ -281,15 +282,15 @@ def print_function_call(self, output):
             # class methods are called through the prototype unless static
             if self.static:
                 self.class.print(output)
-                output.print(".")
+                output.print('.')
                 output.print(self.method)
             else:
                 is_prototype_call = True
                 self.class.print(output)
-                output.print(".prototype.")
+                output.print('.prototype.')
                 output.print(self.method)
                 if not no_call:
-                    output.print(".call")
+                    output.print('.call')
         else:
             if not is_repeatable:
                 output.print('ρσ_expr_temp')
@@ -338,19 +339,20 @@ def print_function_call(self, output):
     def print_positional_args():
         # basic arguments
         i = 0
-        while i < self.args.length:
-            expr = self.args[i]
+        pargs = self.args.args
+        while i < pargs.length:
+            expr = pargs[i]
             is_first = i is 0
             if not is_first:
                 output.print('.concat(')
             if expr.is_array:
-                expr.print(output)
+                expr.value.print(output)
                 i += 1
             else:
                 output.print('[')
-                while i < self.args.length and not self.args[i].is_array:
-                    self.args[i].print(output)
-                    if i + 1 < self.args.length and not self.args[i+1].is_array:
+                while i < pargs.length and not pargs[i].is_array:
+                    pargs[i].value.print(output)
+                    if i + 1 < pargs.length and not pargs[i + 1].is_array:
                         output.print(',')
                         output.space()
                     i += 1
@@ -364,21 +366,21 @@ def print_function_call(self, output):
     is_new = is_node_type(self, AST_New)
     is_repeatable = True
 
-    if is_new and not self.args.length and not has_kwargs and not self.args.starargs:
+    if is_new and not self.args.args.length and not has_kwargs and not self.args.starargs:
         output.print('new'), output.space()
         print_function_name()
-        return # new A is the same as new A() in javascript
+        return  # new A is the same as new A() in javascript
 
     if not has_kwargs and not self.args.starargs:
         # A simple function call, do nothing special
         if is_new:
             output.print('new'), output.space()
         print_function_name()
-        output.with_parens(def():
-            for i, a in enumerate(self.args):
+        output.with_parens(def ():
+            for i, a in enumerate(self.args.args):
                 if i:
                     output.comma()
-                a.print(output)
+                a.value.print(output)
         )
         return
 
@@ -404,21 +406,21 @@ def print_function_call(self, output):
             output.print('.apply(')
             do_print_this()
 
-    if is_prototype_call and self.args.length > 1:
-        self.args.shift()
+    if is_prototype_call and self.args.args.length > 1:
+        self.args.args.shift()
 
     print_positional_args()
 
     if has_kwargs:
-        if self.args.length:
+        if self.args.args.length:
             output.print('.concat(')
         output.print('[')
         print_kwargs()
         output.print(']')
-        if self.args.length:
+        if self.args.args.length:
             output.print(')')
 
     output.print(')')
     if not is_repeatable:
         output.print(')')
-# }}}
+        # }}}

package/src/output/literals.pyj

@@ -4,28 +4,26 @@ from __python__ import hash_literals
 
 from ast import AST_Binary, is_node_type
 
+
 def print_array(self, output):
-    output.print('ρσ_list_decorate')
-    output.with_parens(def():
-        output.with_square(def():
-            a = self.elements
-            len_ = a.length
-            if len_ > 0:
-                output.space()
-            for i, exp in enumerate(a):
-                if i:
-                    output.comma()
-                exp.print(output)
-            if len_ > 0:
-                output.space()
-        )
+    output.with_square(def ():
+        a = self.elements
+        len_ = a.length
+        if len_ > 0:
+            output.space()
+        for i, exp in enumerate(a):
+            if i:
+                output.comma()
+            exp.print(output)
+        if len_ > 0:
+            output.space()
     )
 
 
 def print_obj_literal(self, output):
-    output.with_parens(def():
+    output.with_parens(def ():
         output.print('function()')
-        output.with_block(def():
+        output.with_block(def ():
             output.indent()
             if self.is_pydict:
                 output.spaced.apply(output, 'var ρσ_d = ρσ_dict()'.split(' '))
@@ -36,14 +34,14 @@ def print_obj_literal(self, output):
                 output.indent()
                 if self.is_pydict:
                     output.print('ρσ_d.set')
-                    output.with_parens(def():
+                    output.with_parens(def ():
                         prop.key.print(output)
                         output.print(','), output.space()
                         prop.value.print(output)
                     )
                 else:
                     output.print('ρσ_d')
-                    output.with_square(def():prop.key.print(output);)
+                    output.with_square(def (): prop.key.print(output);)
                     output.space(), output.print('='), output.space()
                     prop.value.print(output)
                 output.end_statement()
@@ -54,6 +52,7 @@ def print_obj_literal(self, output):
     )
     output.print('.call(this)')
 
+
 def print_object(self, output):
     if self.is_pydict:
         if self.properties.length > 0:
@@ -64,22 +63,23 @@ def print_object(self, output):
         if self.properties.length > 0:
             print_obj_literal(self, output)
         else:
-            output.print("Object.create(null)" if self.is_jshash else '{}')
+            output.print('Object.create(null)' if self.is_jshash else '{}')
+
 
 def print_set(self, output):
     if self.items.length is 0:
         output.print('ρσ_set()')
         return
-    output.with_parens(def():
+    output.with_parens(def ():
         output.print('function()')
-        output.with_block(def():
+        output.with_block(def ():
             output.indent()
             output.spaced.apply(output, 'var s = ρσ_set()'.split(' '))
             output.end_statement()
             for item in self.items:
                 output.indent()
                 output.print('s.jsset.add')
-                output.with_parens(def():item.value.print(output);)
+                output.with_parens(def (): item.value.print(output);)
                 output.end_statement()
             output.indent()
             output.spaced('return', 's')
@@ -88,6 +88,7 @@ def print_set(self, output):
     )
     output.print('()')
 
+
 def print_regexp(self, output):
     str_ = self.value.toString()
     if output.options.ascii_only:
@@ -95,4 +96,4 @@ def print_regexp(self, output):
     output.print(str_)
     p = output.parent()
     if is_node_type(p, AST_Binary) and /^in/.test(p.operator) and p.left is self:
-        output.print(" ")
+        output.print(' ')