rapydscript-ng 0.7.24 → 0.8.1

package/src/output/modules.pyj

@@ -1,22 +1,18 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: writefile
 from __python__ import hash_literals
 
-from output.statements import declare_vars, display_body
-from output.stream import OutputStream
-from output.utils import create_doctring
 from output.comments import print_comments, output_comments
 from output.functions import set_module_name
-from parse import get_compiler_version
-from utils import cache_file_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)
     )
@@ -54,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()
@@ -63,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)))
@@ -89,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:
@@ -96,21 +96,40 @@ 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()
-    if output.options.js_version > 5:
-        # 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.end_statement()
-    needs_yield = output.options.js_version < 6 and module.baselib['yield']
-    if needs_yield:
-        output.dump_yield()
+    # 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.end_statement()
     # output the baselib
     if not output.options.baselib_plain:
         raise ValueError('The baselib is missing! Remember to set the baselib_plain field on the options for OutputStream')
@@ -130,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)
@@ -158,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)
@@ -176,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)
 
@@ -186,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:
@@ -198,50 +217,18 @@ def print_module(self, output):
                 output.print('"' + self.module_id + '"')
                 output.semicolon()
                 output.newline()
-            def output_key(beautify, keep_docstrings, js_version):
-                return 'beautify:' + beautify + ' keep_docstrings:' + keep_docstrings + ' js_version:' + js_version
-            okey = output_key(output.options.beautify, output.options.keep_docstrings, output.options.js_version)
-            if self.is_cached and okey in self.outputs:
-                output.print(self.outputs[okey])
-            else:
-                output_module(output)
-                if self.srchash and self.filename:
-                    cached = {
-                        'version':get_compiler_version(), 'signature':self.srchash, 'classes': {}, 'baselib':self.baselib,
-                        'nonlocalvars':self.nonlocalvars, 'imported_module_ids':self.imported_module_ids, 'exports':[],
-                        'outputs':{}, 'discard_asserts': v'!!output.options.discard_asserts'
-                    }
-                    for cname in Object.keys(self.classes):
-                        cobj = self.classes[cname]
-                        cached.classes[cname] = {'name':{'name':cobj.name.name}, 'static':cobj.static, 'bound':cobj.bound, 'classvars':cobj.classvars}
-                    for symdef in self.exports:
-                        cached.exports.push({'name':symdef.name})
-                    for beautify in [True, False]:
-                        for keep_docstrings in [True, False]:
-                            for js_version in [5, 6]:
-                                co = OutputStream({
-                                    'beautify':beautify, 'keep_docstrings':keep_docstrings,
-                                    'js_version':js_version, 'private_scope':False,
-                                    'write_name':False, 'discard_asserts':output.options.discard_asserts
-                                })
-                                co.with_indent(output.indentation(), def():
-                                    output_module(co)
-                                )
-                                raw = co.get()
-                                cached.outputs[output_key(beautify, keep_docstrings, js_version)] = raw
-                    try:
-                        writefile(cache_file_name(self.filename, output.options.module_cache_dir), JSON.stringify(cached, None, '\t'))
-                    except Error as e:
-                        console.error('Failed to write output cache file:', self.filename + '-cached', 'with error:', e)
+            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:
@@ -274,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()

package/src/output/operators.pyj

@@ -1,6 +1,7 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
+
 from ast import (
     AST_Array, AST_Assign, AST_BaseCall, AST_Binary, AST_Conditional,
     AST_ItemAccess, AST_Number, AST_Object, AST_Return, AST_Seq, AST_Set,
@@ -16,11 +17,12 @@ def print_getattr(self, output, skip_expression):  # AST_Dot
         expr.print(output)
     if is_node_type(expr, AST_Number) and expr.value >= 0:
         if not /[xa-f.]/i.test(output.last()):
-            output.print(".")
-    output.print(".")
+            output.print('.')
+    output.print('.')
     # the name after dot would be mapped about here.
     output.print_name(self.property)
 
+
 def print_getitem(self, output):  # AST_Sub
     expr = self.expression
     prop = self.property
@@ -28,13 +30,13 @@ def print_getitem(self, output):  # AST_Sub
         expr.print(output)
         output.print('['), prop.print(output), output.print(']')
         return
-    is_negative_number = is_node_type(prop, AST_Unary) and prop.operator is "-" and is_node_type(prop.expression, AST_Number)
+    is_negative_number = is_node_type(prop, AST_Unary) and prop.operator is '-' and is_node_type(prop.expression, AST_Number)
     is_repeatable = is_node_type(expr, AST_SymbolRef)
     if is_repeatable:
         expr.print(output)
     else:
         output.spaced('(ρσ_expr_temp', '=', expr), output.print(')')
-        expr = {'print': def(): output.print('ρσ_expr_temp');}
+        expr = {'print': def (): output.print('ρσ_expr_temp');}
 
     if is_negative_number:
         output.print('['), expr.print(output), output.print('.length'), prop.print(output), output.print(']')
@@ -45,7 +47,7 @@ def print_getitem(self, output):  # AST_Sub
     if is_repeatable:
         output.spaced('[(typeof', prop, '===', '"number"', '&&', prop)
         output.spaced('', '<', '0)', '?', expr), output.spaced('.length', '+', prop, ':', prop)
-        output.print("]")
+        output.print(']')
     else:
         output.print('[ρσ_bound_index('), prop.print(output), output.comma(), expr.print(output), output.print(')]')
 
@@ -68,6 +70,7 @@ def print_rich_getitem(self, output):  # AST_ItemAccess
         self.assignment.print(output)
     output.print(')')
 
+
 def print_splice_assignment(self, output):  # AST_Splice
     # splice assignment via pythonic array[start:end]
     output.print('ρσ_splice(')
@@ -78,6 +81,7 @@ def print_splice_assignment(self, output):  # AST_Splice
         self.property2.print(output)
     output.print(')')
 
+
 def print_delete(self, output):
     if is_node_type(self, AST_Symbol):
         output.assign(self), output.print('undefined')
@@ -86,6 +90,7 @@ def print_delete(self, output):
     else:
         output.spaced('delete', self)
 
+
 def print_unary_prefix(self, output):
     op = self.operator
     if op is 'delete':
@@ -94,14 +99,14 @@ def print_unary_prefix(self, output):
     if /^[a-z]/i.test(op):
         output.space()
     if self.parenthesized:
-        output.with_parens(def():
+        output.with_parens(def ():
             self.expression.print(output)
         )
     else:
         self.expression.print(output)
 
-def write_instanceof(left, right, output):
 
+def write_instanceof(left, right, output):
     def do_many(vals):
         output.print('ρσ_instanceof.apply(null,'), output.space()
         output.print('['), left.print(output), output.comma()
@@ -119,6 +124,7 @@ def write_instanceof(left, right, output):
         output.print('ρσ_instanceof(')
         left.print(output), output.comma(), right.print(output), output.print(')')
 
+
 def write_smart_equality(self, output):
     def is_ok(x):
         return not (
@@ -141,14 +147,14 @@ def write_smart_equality(self, output):
 
 
 comparators = {
-    "<": True,
-    ">": True,
-    "<=": True,
-    ">=": True,
+    '<': True,
+    '>': True,
+    '<=': True,
+    '>=': True,
 }
 
 function_ops = {
-    "in": "ρσ_in",
+    'in': 'ρσ_in',
     'nin': '!ρσ_in',
 }
 
@@ -156,7 +162,7 @@ function_ops = {
 def print_binary_op(self, output):
     if function_ops[self.operator]:
         output.print(function_ops[self.operator])
-        output.with_parens(def():
+        output.with_parens(def ():
             self.left.print(output)
             output.comma()
             self.right.print(output)
@@ -174,15 +180,15 @@ def print_binary_op(self, output):
             output.space()
             output.print(self.left.operator)
             output.space()
-            output.with_parens(def():
+            output.with_parens(def ():
                 nonlocal leftvar
-                output.assign("ρσ_cond_temp")
+                output.assign('ρσ_cond_temp')
                 self.left.right.print(output)
-                leftvar = "ρσ_cond_temp"
+                leftvar = 'ρσ_cond_temp'
             )
 
         output.space()
-        output.print("&&")
+        output.print('&&')
         output.space()
         output.print(leftvar)
         output.space()
@@ -191,7 +197,7 @@ def print_binary_op(self, output):
         self.right.print(output)
     elif self.operator is '//':
         output.print('Math.floor')
-        output.with_parens(def():
+        output.with_parens(def ():
             self.left.print(output)
             output.space()
             output.print('/')
@@ -228,7 +234,8 @@ def print_binary_op(self, output):
     else:
         output.spaced(self.left, self.operator, self.right)
 
-after_map = {'.':'d', '(':'c', '[':'d', 'g':'g', 'null':'n'}
+after_map = {'.': 'd', '(': 'c', '[': 'd', 'g': 'g', 'null': 'n'}
+
 
 def print_existential(self, output):
     key = after_map[self.after] if self.after is None or jstype(self.after) is 'string' else 'e'
@@ -253,15 +260,16 @@ def print_existential(self, output):
         output.comma(), self.after.print(output)
     output.print(')')
 
+
 def print_assignment(self, output):
     flattened = False
     left = self.left
     if is_node_type(left, AST_Seq):
-        left = new AST_Array({'elements':v'[left.car, left.cdr]'})
+        left = new AST_Array({'elements': v'[left.car, left.cdr]'})
     if is_node_type(left, AST_Array):
         flat = left.flatten()
         flattened = flat.length > left.elements.length
-        output.print("ρσ_unpack")
+        output.print('ρσ_unpack')
     else:
         left.print(output)
     output.space()
@@ -269,7 +277,7 @@ def print_assignment(self, output):
     output.space()
     if flattened:
         output.print('ρσ_flatten')
-        output.with_parens(def():self.right.print(output);)
+        output.with_parens(def (): self.right.print(output);)
     else:
         self.right.print(output)
     if is_node_type(left, AST_Array):
@@ -280,11 +288,12 @@ def print_assignment(self, output):
             output.end_statement()
         unpack_tuple(flat, output, True)
 
+
 def print_assign(self, output):
     if self.operator is '//=':
         output.assign(self.left)
         output.print('Math.floor')
-        output.with_parens(def():
+        output.with_parens(def ():
             self.left.print(output)
             output.space()
             output.print('/')
@@ -300,11 +309,11 @@ def print_assign(self, output):
                 is_compound_assign = True
                 break
         if is_compound_assign:
-            temp_rhs = new AST_SymbolRef({'name':'ρσ_chain_assign_temp'})
-            print_assignment(new AST_Assign({'left':temp_rhs, 'operator':'=', 'right':rhs}), output)
+            temp_rhs = new AST_SymbolRef({'name': 'ρσ_chain_assign_temp'})
+            print_assignment(new AST_Assign({'left': temp_rhs, 'operator': '=', 'right': rhs}), output)
             for lhs in left_hand_sides:
                 output.end_statement(), output.indent()
-                print_assignment(new AST_Assign({'left':lhs, 'right':temp_rhs, 'operator':self.operator}), output)
+                print_assignment(new AST_Assign({'left': lhs, 'right': temp_rhs, 'operator': self.operator}), output)
         else:
             for lhs in left_hand_sides:
                 output.spaced(lhs, '=', '')
@@ -312,21 +321,23 @@ def print_assign(self, output):
     else:
         print_assignment(self, output)
 
+
 def print_conditional(self, output, condition, consequent, alternative):
     condition, consequent, alternative = self.condition, self.consequent, self.alternative
-    output.with_parens(def():condition.print(output);)
+    output.with_parens(def (): condition.print(output);)
     output.space()
-    output.print("?")
+    output.print('?')
     output.space()
     consequent.print(output)
     output.space()
     output.colon()
     alternative.print(output)
 
+
 def print_seq(output):
     self = this
     p = output.parent()
-    print_seq = def():
+    print_seq = def ():
         self.car.print(output)
         if self.cdr:
             output.comma()

package/src/output/statements.pyj

@@ -8,14 +8,15 @@ from ast import (
     AST_Conditional, AST_Binary, AST_BlockStatement, is_node_type
 )
 
+
 def force_statement(stat, output):
     if output.options.bracketize:
         if not stat or is_node_type(stat, AST_EmptyStatement):
-            output.print("{}")
+            output.print('{}')
         elif is_node_type(stat, AST_BlockStatement):
             stat.print(output)
         else:
-            output.with_block(def():
+            output.with_block(def ():
                 output.indent()
                 stat.print(output)
                 output.newline()
@@ -26,6 +27,7 @@ def force_statement(stat, output):
         else:
             stat.print(output)
 
+
 # return true if the node at the top of the stack (that means the
 # innermost node in the current output) is lexically the first in
 # a statement.
@@ -54,7 +56,7 @@ def declare_vars(vars, output):
     # declare all variables as local, unless explictly set otherwise
     if vars.length:
         output.indent()
-        output.print("var")
+        output.print('var')
         output.space()
         for i, arg in enumerate(vars):
             if i:
@@ -64,6 +66,7 @@ def declare_vars(vars, output):
         output.semicolon()
         output.newline()
 
+
 def display_body(body, is_toplevel, output):
     last = body.length - 1
     for i, stmt in enumerate(body):
@@ -80,10 +83,10 @@ def display_complex_body(node, is_toplevel, output, function_preamble):
     # this is a method, add 'var self = this'
     if is_node_type(node, AST_Method) and not node.static:
         output.indent()
-        output.print("var")
+        output.print('var')
         output.space()
-        output.assign(node.argnames[0])
-        output.print("this")
+        output.assign(node.argnames.args[0])
+        output.print('this')
         output.semicolon()
         output.newline()
         offset += 1
@@ -95,18 +98,19 @@ def display_complex_body(node, is_toplevel, output, function_preamble):
     elif is_node_type(node, AST_Except):
         if node.argname:
             output.indent()
-            output.print("var")
+            output.print('var')
             output.space()
             output.assign(node.argname)
-            output.print("ρσ_Exception")
+            output.print('ρσ_Exception')
             output.semicolon()
             output.newline()
 
     display_body(node.body, is_toplevel, output)
 
+
 def print_bracketed(node, output, complex, function_preamble, before, after):
     if node.body.length > 0:
-        output.with_block(def():
+        output.with_block(def ():
             if before:
                 before(output)
             if complex:
@@ -118,14 +122,15 @@ def print_bracketed(node, output, complex, function_preamble, before, after):
         )
     else:
         if before or after:
-            output.with_block(def():
+            output.with_block(def ():
                 if before:
                     before(output)
                 if after:
                     after(output)
             )
         else:
-            output.print("{}")
+            output.print('{}')
+
 
 def print_with(self, output):
     exits = v'[]'
@@ -143,22 +148,22 @@ def print_with(self, output):
         output.print(clause_name + '.__enter__()')
         output.end_statement()
     output.indent(), output.print('try'), output.space()
-    output.with_block(def():
+    output.with_block(def ():
         output.indent()
         self._do_print_body(output)
         output.newline()
     )
     output.space(), output.print('catch(e)')
-    output.with_block(def():
+    output.with_block(def ():
         output.indent(), output.assign('ρσ_with_exception'), output.print('e'), output.end_statement()
     )
     output.newline(), output.indent(), output.spaced('if', '(ρσ_with_exception', '===', 'undefined)')
-    output.with_block(def():
+    output.with_block(def ():
         for clause in exits:
             output.indent(), output.print(clause + '.__exit__()'), output.end_statement()
     )
     output.space(), output.print('else'), output.space()
-    output.with_block(def():
+    output.with_block(def ():
         output.indent(), output.assign('ρσ_with_suppress'), output.print('false'), output.end_statement()
         for clause in exits:
             output.indent()
@@ -168,6 +173,7 @@ def print_with(self, output):
         output.indent(), output.spaced('if', '(!ρσ_with_suppress)', 'throw ρσ_with_exception'), output.end_statement()
     )
 
+
 def print_assert(self, output):
     if output.options.discard_asserts:
         return