rapydscript-ng 0.8.0 → 0.8.2

package/src/output/loops.pyj

@@ -5,48 +5,53 @@ from __python__ import hash_literals
 from ast import AST_BaseCall, AST_SymbolRef, AST_Array, AST_Unary, AST_Number, has_calls, AST_Seq, AST_ListComprehension, is_node_type
 from output.stream import OutputStream
 
+
 def unpack_tuple(elems, output, in_statement):
     for i, elem in enumerate(elems):
         output.indent()
         output.assign(elem)
-        output.print("ρσ_unpack")
-        output.with_square(def():
+        output.print('ρσ_unpack')
+        output.with_square(def ():
             output.print(i)
         )
         if not in_statement or i < elems.length - 1:
             output.semicolon()
             output.newline()
 
+
 def print_do_loop(self, output):
-    output.print("do")
+    output.print('do')
     output.space()
     self._do_print_body(output)
     output.space()
-    output.print("while")
+    output.print('while')
     output.space()
-    output.with_parens(def(): self.condition.print(output);)
+    output.with_parens(def (): self.condition.print(output);)
     output.semicolon()
 
+
 def print_while_loop(self, output):
-    output.print("while")
+    output.print('while')
     output.space()
-    output.with_parens(def(): self.condition.print(output);)
+    output.with_parens(def (): self.condition.print(output);)
     output.space()
     self._do_print_body(output)
 
+
 def is_simple_for_in(self):
     # return true if this loop can be simplified into a basic for (i in j) loop
     if is_node_type(self.object, AST_BaseCall)
     and is_node_type(self.object.expression, AST_SymbolRef)
-    and self.object.expression.name is "dir" and self.object.args.args.length is 1:
+    and self.object.expression.name is 'dir' and self.object.args.args.length is 1:
         return True
     return False
 
+
 def is_simple_for(self):
     # returns true if this loop can be simplified into a basic for(i=n;i<h;i++) loop
     if (is_node_type(self.object, AST_BaseCall) and
             is_node_type(self.object.expression, AST_SymbolRef) and
-            self.object.expression.name is "range" and
+            self.object.expression.name is 'range' and
             not (is_node_type(self.init, AST_Array))):
         a = self.object.args.args
         l = a.length
@@ -58,16 +63,17 @@ def is_simple_for(self):
                 return True
     return False
 
+
 def print_for_loop_body(output):
     self = this
-    output.with_block(def():
+    output.with_block(def ():
         if not (self.simple_for_index or is_simple_for_in(self)):
             # if we're using multiple iterators, unpack them
             output.indent()
-            itervar = "ρσ_Index" + output.index_counter
+            itervar = 'ρσ_Index' + output.index_counter
             if is_node_type(self.init, AST_Array):
                 flat = self.init.flatten()
-                output.assign("ρσ_unpack")
+                output.assign('ρσ_unpack')
                 if flat.length > self.init.elements.length:
                     output.print('ρσ_flatten(' + itervar + ')')
                 else:
@@ -78,30 +84,30 @@ def print_for_loop_body(output):
                 output.assign(self.init)
                 output.print(itervar)
                 output.end_statement()
-
             output.index_counter += 1
         if self.simple_for_index:
             output.indent()
             output.assign(self.init)
             output.print(self.simple_for_index)
             output.end_statement()
-
         for stmt in self.body.body:
             output.indent()
             stmt.print(output)
             output.newline()
     )
 
+
 def init_es6_itervar(output, itervar):
     output.indent()
     output.spaced(itervar, '=', '((typeof', itervar + '[Symbol.iterator]', '===', '"function")', '?',
-                    '('+itervar, 'instanceof', 'Map', '?', itervar + '.keys()', ':', itervar+')', ':', 'Object.keys(' + itervar + '))')
+                    '(' + itervar, 'instanceof', 'Map', '?', itervar + '.keys()', ':', itervar + ')', ':', 'Object.keys(' + itervar + '))')
     output.end_statement()
 
+
 def print_for_in(self, output):
     def write_object():
         if self.object.constructor is AST_Seq:
-            (new AST_Array({'elements':self.object.to_array()})).print(output)
+            (new AST_Array({'elements': self.object.to_array()})).print(output)
         else:
             self.object.print(output)
 
@@ -123,39 +129,39 @@ def print_for_in(self, output):
 
         self.simple_for_index = idx = 'ρσ_Index' + output.index_counter
         output.index_counter += 1
-        output.print("for")
+        output.print('for')
         output.space()
-        output.with_parens(def():
+        output.with_parens(def ():
             output.spaced('var', idx, '='), output.space()
             start.print(output) if start.print else output.print(start)
             output.semicolon()
             output.space()
             output.print(idx)
             output.space()
-            output.print(">") if is_node_type(increment, AST_Unary) else output.print("<")
+            output.print('>') if is_node_type(increment, AST_Unary) else output.print('<')
             output.space()
             end.print(output)
             output.semicolon()
             output.space()
             output.print(idx)
-            if increment and (not (is_node_type(increment, AST_Unary)) or increment.expression.value is not "1"):
+            if increment and (not (is_node_type(increment, AST_Unary)) or increment.expression.value is not '1'):
                 if is_node_type(increment, AST_Unary):
-                    output.print("-=")
+                    output.print('-=')
                     increment.expression.print(output)
                 else:
-                    output.print("+=")
+                    output.print('+=')
                     increment.print(output)
             else:
                 if is_node_type(increment, AST_Unary):
-                    output.print("--")
+                    output.print('--')
                 else:
-                    output.print("++")
+                    output.print('++')
         )
     elif is_simple_for_in(self):
         # optimize dir() into a simple for in loop
-        output.print("for")
+        output.print('for')
         output.space()
-        output.with_parens(def():
+        output.with_parens(def ():
             self.init.print(output)
             output.space()
             output.print('in')
@@ -164,8 +170,8 @@ def print_for_in(self, output):
         )
     else:
         # regular loop
-        itervar = "ρσ_Iter" + output.index_counter
-        output.assign("var " + itervar)
+        itervar = 'ρσ_Iter' + output.index_counter
+        output.assign('var ' + itervar)
         write_object()
         output.end_statement()
         init_es6_itervar(output, itervar)
@@ -175,62 +181,63 @@ def print_for_in(self, output):
     output.space()
     self._do_print_body(output)
 
+
 def print_list_comprehension(self, output):
     tname = self.constructor.name.slice(4)
-    result_obj = {'ListComprehension':'[]', 'DictComprehension':('Object.create(null)' if self.is_jshash else '{}'), 'SetComprehension':'ρσ_set()'}[tname]
+    result_obj = {'ListComprehension': '[]', 'DictComprehension': ('Object.create(null)' if self.is_jshash else '{}'), 'SetComprehension': 'ρσ_set()'}[tname]
     is_generator = tname is 'GeneratorComprehension'
     if tname is 'DictComprehension':
         if self.is_pydict:
             result_obj = 'ρσ_dict()'
-            add_to_result = def(output):
+            add_to_result = def (output):
                 output.indent()
                 output.print('ρσ_Result.set')
-                output.with_parens(def():
+                output.with_parens(def ():
                     self.statement.print(output)
                     output.space(), output.print(','), output.space()
-                    output.with_parens(def():
+                    output.with_parens(def ():
                         if self.value_statement.constructor is AST_Seq:
-                            output.with_square(def():self.value_statement.print(output);)
+                            output.with_square(def (): self.value_statement.print(output);)
                         else:
                             self.value_statement.print(output)
                     )
                 )
                 output.end_statement()
         else:
-            add_to_result = def(output):
+            add_to_result = def (output):
                 output.indent()
                 output.print('ρσ_Result')
-                output.with_square(def():
+                output.with_square(def ():
                     self.statement.print(output)
                 )
                 output.space(), output.print('='), output.space()
-                output.with_parens(def():
+                output.with_parens(def ():
                     if self.value_statement.constructor is AST_Seq:
-                        output.with_square(def():self.value_statement.print(output);)
+                        output.with_square(def (): self.value_statement.print(output);)
                     else:
                         self.value_statement.print(output)
                 )
                 output.end_statement()
     else:
-        push_func = "ρσ_Result." + ('push' if self.constructor is AST_ListComprehension else 'add')
+        push_func = 'ρσ_Result.' + ('push' if self.constructor is AST_ListComprehension else 'add')
         if is_generator:
             push_func = 'yield '
-        add_to_result = def(output):
+        add_to_result = def (output):
             output.indent()
             output.print(push_func)
-            output.with_parens(def():
+            output.with_parens(def ():
                 if self.statement.constructor is AST_Seq:
-                    output.with_square(def():self.statement.print(output);)
+                    output.with_square(def (): self.statement.print(output);)
                 else:
                     self.statement.print(output)
             )
             output.end_statement()
 
-    output.with_parens(def():
-        output.print("function")
-        output.print("()")
+    output.with_parens(def ():
+        output.print('function')
+        output.print('()')
         output.space()
-        output.with_block(def():
+        output.with_block(def ():
             body_out = output
             if is_generator:
                 body_out.indent()
@@ -239,12 +246,11 @@ def print_list_comprehension(self, output):
                 previous_indentation = output.indentation()
                 output.set_indentation(output.next_indent())
             body_out.indent()
-            body_out.assign("var ρσ_Iter")
+            body_out.assign('var ρσ_Iter')
             self.object.print(body_out)
-
             if result_obj:
                 body_out.comma()
-                body_out.assign("ρσ_Result")
+                body_out.assign('ρσ_Result')
                 body_out.print(result_obj)
             # make sure to locally scope loop variables
             if is_node_type(self.init, AST_Array):
@@ -255,21 +261,20 @@ def print_list_comprehension(self, output):
                 body_out.comma()
                 self.init.print(body_out)
             body_out.end_statement()
-
             init_es6_itervar(body_out, 'ρσ_Iter')
             body_out.indent()
-            body_out.print("for")
+            body_out.print('for')
             body_out.space()
-            body_out.with_parens(def():
+            body_out.with_parens(def ():
                 body_out.spaced('var', 'ρσ_Index', 'of', 'ρσ_Iter')
             )
             body_out.space()
-            body_out.with_block(def():
+            body_out.with_block(def ():
                 body_out.indent()
                 itervar = 'ρσ_Index'
                 if is_node_type(self.init, AST_Array):
                     flat = self.init.flatten()
-                    body_out.assign("ρσ_unpack")
+                    body_out.assign('ρσ_unpack')
                     if flat.length > self.init.elements.length:
                         body_out.print('ρσ_flatten(' + itervar + ')')
                     else:
@@ -280,14 +285,13 @@ def print_list_comprehension(self, output):
                     body_out.assign(self.init)
                     body_out.print(itervar)
                     body_out.end_statement()
-
                 if self.condition:
                     body_out.indent()
-                    body_out.print("if")
+                    body_out.print('if')
                     body_out.space()
-                    body_out.with_parens(def(): self.condition.print(body_out);)
+                    body_out.with_parens(def (): self.condition.print(body_out);)
                     body_out.space()
-                    body_out.with_block(def():
+                    body_out.with_block(def ():
                         add_to_result(body_out)
                     )
                     body_out.newline()
@@ -301,7 +305,7 @@ def print_list_comprehension(self, output):
                 body_out.end_statement()
             if not is_generator:
                 body_out.indent()
-                body_out.print("return ρσ_Result")
+                body_out.print('return ρσ_Result')
                 body_out.end_statement()
             if is_generator:
                 output.set_indentation(previous_indentation)
@@ -318,4 +322,4 @@ def print_list_comprehension(self, output):
                 output.end_statement()
         )
     )
-    output.print("()")
+    output.print('()')

package/src/output/modules.pyj

@@ -2,17 +2,17 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from output.statements import declare_vars, display_body
-from output.utils import create_doctring
 from output.comments import print_comments, output_comments
 from output.functions import set_module_name
+from output.statements import declare_vars, display_body
+from output.utils import create_doctring
 
 
 def write_imports(module, output):
     imports = []
     for import_id in Object.keys(module.imports):
         imports.push(module.imports[import_id])
-    imports.sort(def(a, b):
+    imports.sort(def (a, b):
         a, b = a.import_order, b.import_order
         return -1 if a < b else (1 if a > b else 0)
     )
@@ -50,6 +50,7 @@ def write_imports(module, output):
         if module_.module_id is not '__main__':
             print_module(module_, output)
 
+
 def write_main_name(output):
     if output.options.write_name:
         output.newline()
@@ -59,16 +60,18 @@ def write_main_name(output):
         output.newline()
         output.newline()
 
+
 def const_decl(js_version):
     # return 'const' if js_version > 5 else 'var'
     # Workaround for bug in Chrome eval(). eval() barfs if it sees const before a function.
     # See https://github.com/kovidgoyal/rapydscript-ng/issues/29
     return 'var'
 
+
 def declare_exports(module_id, exports, output, docstrings):
     seen = {}
     if output.options.keep_docstrings and docstrings and docstrings.length:
-        exports.push({'name':'__doc__', 'refname': 'ρσ_module_doc__'})
+        exports.push({'name': '__doc__', 'refname': 'ρσ_module_doc__'})
         output.newline(), output.indent()
         v = const_decl(output.options.js_version)
         output.assign(v + ' ρσ_module_doc__'), output.print(JSON.stringify(create_doctring(docstrings)))
@@ -85,6 +88,7 @@ def declare_exports(module_id, exports, output, docstrings):
             seen[symbol.name] = True
             output.end_statement()
 
+
 def prologue(module, output):
     # any code that should appear before the main body
     if output.options.omit_baselib:
@@ -92,16 +96,39 @@ def prologue(module, output):
     output.indent()
     v = const_decl(output.options.js_version)
     output.print(v), output.space()
-    output.spaced.apply(output, (('ρσ_iterator_symbol = (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") ? Symbol.iterator : "iterator-Symbol-5d0927e5554349048cf0e3762a228256"'.split(' '))))
+    output.spaced.apply(
+        output,
+        (('ρσ_iterator_symbol = (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") ? Symbol.iterator : "iterator-Symbol-5d0927e5554349048cf0e3762a228256"'.split(' ')))
+    )
     output.end_statement()
     output.indent(), output.print(v), output.space()
-    output.spaced.apply(output, (('ρσ_kwargs_symbol = (typeof Symbol === "function") ? Symbol("kwargs-object") : "kwargs-object-Symbol-5d0927e5554349048cf0e3762a228256"'.split(' '))))
+    output.spaced.apply(
+        output,
+        (('ρσ_kwargs_symbol = (typeof Symbol === "function") ? Symbol("kwargs-object") : "kwargs-object-Symbol-5d0927e5554349048cf0e3762a228256"'.split(' ')))
+    )
     output.end_statement()
     output.indent(), output.spaced('var', 'ρσ_cond_temp,', 'ρσ_expr_temp,', 'ρσ_last_exception'), output.end_statement()
     output.indent(), output.spaced('var', 'ρσ_object_counter', '=', '0'), output.end_statement()
     # Needed for Chrome < 51 and Edge as of August 2016
-    output.indent(), output.spaced('if(', 'typeof', 'HTMLCollection', '!==', '"undefined"', '&&', 'typeof', 'Symbol', '===', '"function")',
-        'NodeList.prototype[Symbol.iterator]', '=', 'HTMLCollection.prototype[Symbol.iterator]', '=', 'NamedNodeMap.prototype[Symbol.iterator]', '=', 'Array.prototype[Symbol.iterator]')
+    output.indent(), output.spaced(
+        'if(',
+        'typeof',
+        'HTMLCollection',
+        '!==',
+        '"undefined"',
+        '&&',
+        'typeof',
+        'Symbol',
+        '===',
+        '"function")',
+        'NodeList.prototype[Symbol.iterator]',
+        '=',
+        'HTMLCollection.prototype[Symbol.iterator]',
+        '=',
+        'NamedNodeMap.prototype[Symbol.iterator]',
+        '=',
+        'Array.prototype[Symbol.iterator]'
+    )
     output.end_statement()
     # output the baselib
     if not output.options.baselib_plain:
@@ -122,22 +149,21 @@ def print_top_level(self, output):
             output.end_statement()
 
     if output.options.private_scope and is_main:
-        output.with_parens(def():
-            output.print("function()")
-            output.with_block(def():
+        output.with_parens(def ():
+            output.print('function()')
+            output.with_block(def ():
                 # strict mode is more verbose about errors, and less forgiving about them
                 # kind of like Python
                 output.indent()
                 output.print('"use strict"')
                 output.end_statement()
-
                 prologue(self, output)
                 write_imports(self, output)
                 output.newline()
                 output.indent()
-                output.with_parens(def():
-                    output.print("function()")
-                    output.with_block(def():
+                output.with_parens(def ():
+                    output.print('function()')
+                    output.with_block(def ():
                         write_main_name(output)
                         output.newline()
                         declare_vars(self.localvars, output)
@@ -150,12 +176,12 @@ def print_top_level(self, output):
                             output.newline()
                     )
                 )
-                output.print("();")
+                output.print('();')
                 output.newline()
             )
         )
-        output.print("();")
-        output.print("")
+        output.print('();')
+        output.print('')
     else:
         if is_main:
             prologue(self, output)
@@ -168,6 +194,7 @@ def print_top_level(self, output):
             output_comments(self.comments_after, output)
     set_module_name()
 
+
 def print_module(self, output):
     set_module_name(self.module_id)
 
@@ -178,9 +205,9 @@ def print_module(self, output):
 
     output.newline()
     output.indent()
-    output.with_parens(def():
-        output.print("function()")
-        output.with_block(def():
+    output.with_parens(def ():
+        output.print('function()')
+        output.with_block(def ():
             # dump the logic of this module
             print_comments(self, output)
             if output.options.write_name:
@@ -193,13 +220,15 @@ def print_module(self, output):
             output_module(output)
         )
     )
-    output.print("()")
+    output.print('()')
     output.semicolon()
     output.newline()
     set_module_name()
 
+
 def print_imports(container, output):
     is_first_aname = True
+
     def add_aname(aname, key, from_import):
         nonlocal is_first_aname
         if is_first_aname:
@@ -232,7 +261,7 @@ def print_imports(container, output):
                     if i is 0:
                         add_aname(part, part, False)
                     else:
-                        q = parts[:i+1].join('.')
+                        q = parts[:i + 1].join('.')
                         output.indent()
                         output.spaced(q, '=', 'ρσ_modules["' + q + '"]')
                         output.end_statement()