rapydscript-ns 0.8.2 → 0.8.4

package/src/output/operators.pyj

@@ -5,7 +5,7 @@ from ast import (
     AST_Array, AST_Assign, AST_BaseCall, AST_Binary, AST_Conditional,
     AST_ItemAccess, AST_NamedExpr, AST_Number, AST_Object, AST_Return, AST_Seq, AST_Set,
     AST_SimpleStatement, AST_Statement, AST_String, AST_Sub, AST_Symbol,
-    AST_SymbolRef, AST_Starred, AST_Unary, is_node_type
+    AST_SymbolRef, AST_Starred, AST_Unary, AST_AnnotatedAssign, is_node_type
 )
 from output.loops import unpack_tuple
 
@@ -13,6 +13,11 @@ from output.loops import unpack_tuple
 def print_getattr(self, output, skip_expression):  # AST_Dot
     if not skip_expression:
         expr = self.expression
+        # Redirect JSON.parse → ρσ_json_parse so RapydScript code gets dict-aware
+        # parsing without polluting the global JSON.parse for other JS on the page.
+        if is_node_type(expr, AST_SymbolRef) and expr.name == 'JSON' and self.property == 'parse':
+            output.print('ρσ_json_parse')
+            return
         expr.print(output)
     if is_node_type(expr, AST_Number) and expr.value >= 0:
         if not /[xa-f.]/i.test(output.last()):
@@ -280,6 +285,12 @@ def print_binary_op(self, output):
         write_smart_equality(self, output)
     elif self.operator is 'instanceof':
         write_instanceof(self.left, self.right, output)
+    elif self.operator is '+':
+        output.print('ρσ_list_add(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
     elif self.operator is '*' and is_node_type(self.left, AST_String):
         self.left.print(output), output.print('.repeat('), self.right.print(output), output.print(')')
     elif self.operator is '===' or self.operator is '!==':
@@ -415,6 +426,14 @@ def print_assign(self, output):
         else:
             output.print('Math.pow('), self.left.print(output), output.comma(), self.right.print(output), output.print(')')
         return
+    if self.operator is '+=':
+        output.assign(self.left)
+        output.print('ρσ_list_iadd(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
+        return
     if self.operator is '=' and self.is_chained():
         left_hand_sides, rhs = self.traverse_chain()
         is_compound_assign = False
@@ -468,7 +487,8 @@ def print_seq(output):
     or is_node_type(p, AST_Return)
     or is_node_type(p, AST_Array)
     or is_node_type(p, AST_BaseCall)
-    or is_node_type(p, AST_SimpleStatement):
+    or is_node_type(p, AST_SimpleStatement)
+    or is_node_type(p, AST_AnnotatedAssign):
         output.with_square(print_seq)
     else:
         print_seq()

package/src/output/statements.pyj

@@ -54,11 +54,11 @@ def first_in_statement(output):
             return False
 
 
-def declare_vars(vars, output):
+def declare_vars(vars, output, kind="var"):
     # declare all variables as local, unless explictly set otherwise
     if vars.length:
         output.indent()
-        output.print("var")
+        output.print(kind)
         output.space()
         for i, arg in enumerate(vars):
             if i:

package/src/output/stream.pyj

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals:regenerate
 from __python__ import hash_literals
 
 from utils import make_predicate, defaults, repeat_string
@@ -57,6 +56,7 @@ output_stream_defaults = {
     'write_name': True,
     'omit_function_metadata': False,
     'pythonize_strings': False,
+    'repl_mode': False,
 }
 
 class OutputStream:
@@ -255,18 +255,6 @@ class OutputStream:
         if self.options.space_colon:
             self.space()
 
-    def dump_yield(self):
-        self.indent()
-        self.spaced('var', 'ρσ_regenerator', '=', '{}')
-        self.end_statement()
-        code = 'ρσ_regenerator.regeneratorRuntime = ' + regenerate(False, self.options.beautify)
-        if self.options.beautify:
-            code = code.replace(/\/\/.*$/mg, '\n').replace(/^\s*$/gm, '')  # strip comments
-            ci = self.make_indent(0)
-            code = [ci + x for x in code.split('\n')].join('\n')
-        self.print(code + '})(ρσ_regenerator)')
-        self.end_statement()
-
     def get(self):
         return self.OUTPUT
     toString = get

package/src/output/treeshake.pyj

@@ -1,182 +1,182 @@
-# vim:fileencoding=utf-8
-# License: BSD
-from __python__ import hash_literals
-
-from ast import (
-    AST_Function, AST_Class, AST_SimpleStatement, AST_Assign,
-    AST_SymbolRef, AST_Dot, AST_Sub, AST_Imports, TreeWalker, is_node_type
-)
-from utils import has_prop
-
-
-def get_top_level_name(stmt):
-    if is_node_type(stmt, AST_Function) or is_node_type(stmt, AST_Class):
-        if stmt.name:
-            return stmt.name.name
-        return None
-    if is_node_type(stmt, AST_SimpleStatement):
-        body = stmt.body
-        if is_node_type(body, AST_Assign):
-            lhs = body.left
-            if is_node_type(lhs, AST_SymbolRef):
-                return lhs.name
-    return None
-
-
-def collect_refs_in_node(stmt, top_level_set, refs):
-    def visit_fn(node, descend):
-        if is_node_type(node, AST_SymbolRef):
-            if has_prop(top_level_set, node.name):
-                refs[node.name] = True
-    stmt.walk(TreeWalker(visit_fn))
-
-
-def compute_transitive_closure(body, direct_names, nonlocalvars):
-    nonlocal_set = {}
-    if nonlocalvars:
-        for nv in nonlocalvars:
-            nonlocal_set[nv] = True
-
-    name_map = {}
-    unnamed_stmts = []
-    for stmt in body:
-        name = get_top_level_name(stmt)
-        if name is not None:
-            name_map[name] = stmt
-        else:
-            unnamed_stmts.push(stmt)
-
-    top_level_set = {}
-    for name in Object.keys(name_map):
-        top_level_set[name] = True
-
-    needed = {}
-    queue = []
-
-    # Always include top-level assignments to nonlocal vars — they affect the
-    # global JavaScript scope and must never be filtered out.
-    for name in Object.keys(name_map):
-        if has_prop(nonlocal_set, name):
-            needed[name] = True
-            queue.push(name)
-
-    # Add directly imported names
-    for name in Object.keys(direct_names):
-        if not has_prop(needed, name):
-            needed[name] = True
-            queue.push(name)
-
-    # Unnamed statements (imports, if-blocks, bare expressions) are always
-    # included in output, so their references to named top-level items must
-    # also be included transitively.
-    always_refs = {}
-    for stmt in unnamed_stmts:
-        collect_refs_in_node(stmt, top_level_set, always_refs)
-    for ref_name in Object.keys(always_refs):
-        if not has_prop(needed, ref_name):
-            needed[ref_name] = True
-            queue.push(ref_name)
-
-    while queue.length > 0:
-        current = queue.shift()
-        if not has_prop(name_map, current):
-            continue
-        refs = {}
-        collect_refs_in_node(name_map[current], top_level_set, refs)
-        for ref_name in Object.keys(refs):
-            if not has_prop(needed, ref_name):
-                needed[ref_name] = True
-                queue.push(ref_name)
-
-    return needed
-
-
-def check_module_attr_access(main_body, info, alias_set):
-    def visit_fn(node, descend):
-        if is_node_type(node, AST_Dot):
-            expr = node.expression
-            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
-                info.direct_names[node.property] = True
-                return True
-        if is_node_type(node, AST_Sub):
-            expr = node.expression
-            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
-                info.can_tree_shake = False
-    for stmt in main_body:
-        stmt.walk(TreeWalker(visit_fn))
-
-
-def analyze_imports(main_body):
-    result = {}
-
-    # First pass: walk the entire AST recursively to collect all from-imports
-    # (including those nested inside functions or other scopes).
-    def visit_from_imports(node, descend):
-        if is_node_type(node, AST_Imports):
-            for imp in node.imports:
-                if imp.argnames:
-                    key = imp.key
-                    if not has_prop(result, key):
-                        result[key] = {'direct_names': {}, 'can_tree_shake': True}
-                    for argname in imp.argnames:
-                        result[key].direct_names[argname.name] = True
-    for stmt in main_body:
-        stmt.walk(TreeWalker(visit_from_imports))
-
-    # Second pass: handle top-level plain imports (import X as Y, import X).
-    # Attribute tracking via check_module_attr_access applies to main_body scope.
-    for stmt in main_body:
-        if not is_node_type(stmt, AST_Imports):
-            continue
-        for imp in stmt.imports:
-            if imp.argnames:
-                continue  # already handled in first pass
-            key = imp.key
-            if not has_prop(result, key):
-                result[key] = {'direct_names': {}, 'can_tree_shake': True}
-            info = result[key]
-            if imp.alias:
-                alias_set = {}
-                alias_set[imp.alias.name] = True
-                check_module_attr_access(main_body, info, alias_set)
-            else:
-                parts = key.split('.')
-                if parts.length > 1:
-                    # import X.Y with no alias: user accesses via X.Y.attr which
-                    # requires two-level dot traversal — disable tree-shaking safely
-                    info.can_tree_shake = False
-                else:
-                    alias_set = {}
-                    alias_set[parts[0]] = True
-                    check_module_attr_access(main_body, info, alias_set)
-
-    return result
-
-
-def tree_shake(ast, context):
-    import_infos = analyze_imports(ast.body)
-    for mod_key in Object.keys(import_infos):
-        info = import_infos[mod_key]
-        if not info.can_tree_shake:
-            continue
-        if not has_prop(ast.imports, mod_key):
-            continue
-        mod = ast.imports[mod_key]
-        # If body is missing (cached module), re-parse to get it
-        if not mod.body and mod.src_code:
-            parsed = context.parse(mod.src_code, {
-                'filename': mod.filename,
-                'module_id': mod_key,
-                'libdir': context.libdir,
-                'import_dirs': context.import_dirs or [],
-                'discard_asserts': context.discard_asserts,
-                'for_linting': True,
-            })
-            mod.body = parsed.body
-            mod.localvars = parsed.localvars
-            if not mod.nonlocalvars:
-                mod.nonlocalvars = parsed.nonlocalvars
-        if not mod.body:
-            continue
-        needed = compute_transitive_closure(mod.body, info.direct_names, mod.nonlocalvars)
-        mod.needed_names = needed
+# vim:fileencoding=utf-8
+# License: BSD
+from __python__ import hash_literals
+
+from ast import (
+    AST_Function, AST_Class, AST_SimpleStatement, AST_Assign,
+    AST_SymbolRef, AST_Dot, AST_Sub, AST_Imports, TreeWalker, is_node_type
+)
+from utils import has_prop
+
+
+def get_top_level_name(stmt):
+    if is_node_type(stmt, AST_Function) or is_node_type(stmt, AST_Class):
+        if stmt.name:
+            return stmt.name.name
+        return None
+    if is_node_type(stmt, AST_SimpleStatement):
+        body = stmt.body
+        if is_node_type(body, AST_Assign):
+            lhs = body.left
+            if is_node_type(lhs, AST_SymbolRef):
+                return lhs.name
+    return None
+
+
+def collect_refs_in_node(stmt, top_level_set, refs):
+    def visit_fn(node, descend):
+        if is_node_type(node, AST_SymbolRef):
+            if has_prop(top_level_set, node.name):
+                refs[node.name] = True
+    stmt.walk(TreeWalker(visit_fn))
+
+
+def compute_transitive_closure(body, direct_names, nonlocalvars):
+    nonlocal_set = {}
+    if nonlocalvars:
+        for nv in nonlocalvars:
+            nonlocal_set[nv] = True
+
+    name_map = {}
+    unnamed_stmts = []
+    for stmt in body:
+        name = get_top_level_name(stmt)
+        if name is not None:
+            name_map[name] = stmt
+        else:
+            unnamed_stmts.push(stmt)
+
+    top_level_set = {}
+    for name in Object.keys(name_map):
+        top_level_set[name] = True
+
+    needed = {}
+    queue = []
+
+    # Always include top-level assignments to nonlocal vars — they affect the
+    # global JavaScript scope and must never be filtered out.
+    for name in Object.keys(name_map):
+        if has_prop(nonlocal_set, name):
+            needed[name] = True
+            queue.push(name)
+
+    # Add directly imported names
+    for name in Object.keys(direct_names):
+        if not has_prop(needed, name):
+            needed[name] = True
+            queue.push(name)
+
+    # Unnamed statements (imports, if-blocks, bare expressions) are always
+    # included in output, so their references to named top-level items must
+    # also be included transitively.
+    always_refs = {}
+    for stmt in unnamed_stmts:
+        collect_refs_in_node(stmt, top_level_set, always_refs)
+    for ref_name in Object.keys(always_refs):
+        if not has_prop(needed, ref_name):
+            needed[ref_name] = True
+            queue.push(ref_name)
+
+    while queue.length > 0:
+        current = queue.shift()
+        if not has_prop(name_map, current):
+            continue
+        refs = {}
+        collect_refs_in_node(name_map[current], top_level_set, refs)
+        for ref_name in Object.keys(refs):
+            if not has_prop(needed, ref_name):
+                needed[ref_name] = True
+                queue.push(ref_name)
+
+    return needed
+
+
+def check_module_attr_access(main_body, info, alias_set):
+    def visit_fn(node, descend):
+        if is_node_type(node, AST_Dot):
+            expr = node.expression
+            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
+                info.direct_names[node.property] = True
+                return True
+        if is_node_type(node, AST_Sub):
+            expr = node.expression
+            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
+                info.can_tree_shake = False
+    for stmt in main_body:
+        stmt.walk(TreeWalker(visit_fn))
+
+
+def analyze_imports(main_body):
+    result = {}
+
+    # First pass: walk the entire AST recursively to collect all from-imports
+    # (including those nested inside functions or other scopes).
+    def visit_from_imports(node, descend):
+        if is_node_type(node, AST_Imports):
+            for imp in node.imports:
+                if imp.argnames:
+                    key = imp.key
+                    if not has_prop(result, key):
+                        result[key] = {'direct_names': {}, 'can_tree_shake': True}
+                    for argname in imp.argnames:
+                        result[key].direct_names[argname.name] = True
+    for stmt in main_body:
+        stmt.walk(TreeWalker(visit_from_imports))
+
+    # Second pass: handle top-level plain imports (import X as Y, import X).
+    # Attribute tracking via check_module_attr_access applies to main_body scope.
+    for stmt in main_body:
+        if not is_node_type(stmt, AST_Imports):
+            continue
+        for imp in stmt.imports:
+            if imp.argnames:
+                continue  # already handled in first pass
+            key = imp.key
+            if not has_prop(result, key):
+                result[key] = {'direct_names': {}, 'can_tree_shake': True}
+            info = result[key]
+            if imp.alias:
+                alias_set = {}
+                alias_set[imp.alias.name] = True
+                check_module_attr_access(main_body, info, alias_set)
+            else:
+                parts = key.split('.')
+                if parts.length > 1:
+                    # import X.Y with no alias: user accesses via X.Y.attr which
+                    # requires two-level dot traversal — disable tree-shaking safely
+                    info.can_tree_shake = False
+                else:
+                    alias_set = {}
+                    alias_set[parts[0]] = True
+                    check_module_attr_access(main_body, info, alias_set)
+
+    return result
+
+
+def tree_shake(ast, context):
+    import_infos = analyze_imports(ast.body)
+    for mod_key in Object.keys(import_infos):
+        info = import_infos[mod_key]
+        if not info.can_tree_shake:
+            continue
+        if not has_prop(ast.imports, mod_key):
+            continue
+        mod = ast.imports[mod_key]
+        # If body is missing (cached module), re-parse to get it
+        if not mod.body and mod.src_code:
+            parsed = context.parse(mod.src_code, {
+                'filename': mod.filename,
+                'module_id': mod_key,
+                'libdir': context.libdir,
+                'import_dirs': context.import_dirs or [],
+                'discard_asserts': context.discard_asserts,
+                'for_linting': True,
+            })
+            mod.body = parsed.body
+            mod.localvars = parsed.localvars
+            if not mod.nonlocalvars:
+                mod.nonlocalvars = parsed.nonlocalvars
+        if not mod.body:
+            continue
+        needed = compute_transitive_closure(mod.body, info.direct_names, mod.nonlocalvars)
+        mod.needed_names = needed

package/src/output/utils.pyj

@@ -1,72 +1,72 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-from __python__ import hash_literals
-
-from ast import AST_BlockStatement, is_node_type
-
-def best_of(a):
-    best = a[0]
-    len_ = best.length
-    for i in range(1, a.length):
-        if a[i].length < len_:
-            best = a[i]
-            len_ = best.length
-    return best
-
-def make_num(num):
-    str_ = num.toString(10)
-    a = [ str_.replace(/^0\./, ".").replace("e+", "e") ]
-    m = None
-
-    if Math.floor(num) is num:
-        if num >= 0:
-            a.push("0x" + num.toString(16).toLowerCase(), # probably pointless
-            "0" + num.toString(8))
-        else:
-            a.push("-0x" + (-num).toString(16).toLowerCase(), # probably pointless
-            "-0" + (-num).toString(8))
-
-        if m = /^(.*?)(0+)$/.exec(num):
-            a.push(m[1] + "e" + m[2].length)
-
-    elif m = /^0?\.(0+)(.*)$/.exec(num):
-        a.push(m[2] + "e-" + (m[1].length + m[2].length), str_.substr(str_.indexOf(".")))
-
-    return best_of(a)
-
-def make_block(stmt, output):
-    if is_node_type(stmt, AST_BlockStatement):
-        stmt.print(output)
-        return
-
-    output.with_block(def():
-        output.indent()
-        stmt.print(output)
-        output.newline()
-    )
-
-def create_doctring(docstrings):
-    ans = v'[]'
-    for ds in docstrings:
-        ds = str.rstrip(ds.value)
-        lines = v'[]'
-        min_leading_whitespace = ''
-        for line in ds.split(/$/gm):
-            r = /^\s+/.exec(line)
-            leading_whitespace = ''
-            if r:
-                leading_whitespace = r[0].replace(/[\n\r]/g, '') if r else ''
-                line = line[r[0].length:]
-            if not str.strip(line):
-                lines.push(v'["", ""]')
-            else:
-                leading_whitespace = leading_whitespace.replace(/\t/g, '    ')
-                if leading_whitespace and (not min_leading_whitespace or leading_whitespace.length < min_leading_whitespace.length):
-                    min_leading_whitespace = leading_whitespace
-                lines.push(v'[leading_whitespace, line]')
-        for lw, l in lines:
-            if min_leading_whitespace:
-                lw = lw[min_leading_whitespace.length:]
-            ans.push(lw + l)
-        ans.push('')
-    return str.rstrip(ans.join('\n'))
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+from ast import AST_BlockStatement, is_node_type
+
+def best_of(a):
+    best = a[0]
+    len_ = best.length
+    for i in range(1, a.length):
+        if a[i].length < len_:
+            best = a[i]
+            len_ = best.length
+    return best
+
+def make_num(num):
+    str_ = num.toString(10)
+    a = [ str_.replace(/^0\./, ".").replace("e+", "e") ]
+    m = None
+
+    if Math.floor(num) is num:
+        if num >= 0:
+            a.push("0x" + num.toString(16).toLowerCase(), # probably pointless
+            "0" + num.toString(8))
+        else:
+            a.push("-0x" + (-num).toString(16).toLowerCase(), # probably pointless
+            "-0" + (-num).toString(8))
+
+        if m = /^(.*?)(0+)$/.exec(num):
+            a.push(m[1] + "e" + m[2].length)
+
+    elif m = /^0?\.(0+)(.*)$/.exec(num):
+        a.push(m[2] + "e-" + (m[1].length + m[2].length), str_.substr(str_.indexOf(".")))
+
+    return best_of(a)
+
+def make_block(stmt, output):
+    if is_node_type(stmt, AST_BlockStatement):
+        stmt.print(output)
+        return
+
+    output.with_block(def():
+        output.indent()
+        stmt.print(output)
+        output.newline()
+    )
+
+def create_doctring(docstrings):
+    ans = v'[]'
+    for ds in docstrings:
+        ds = str.rstrip(ds.value)
+        lines = v'[]'
+        min_leading_whitespace = ''
+        for line in ds.split(/$/gm):
+            r = /^\s+/.exec(line)
+            leading_whitespace = ''
+            if r:
+                leading_whitespace = r[0].replace(/[\n\r]/g, '') if r else ''
+                line = line[r[0].length:]
+            if not str.strip(line):
+                lines.push(v'["", ""]')
+            else:
+                leading_whitespace = leading_whitespace.replace(/\t/g, '    ')
+                if leading_whitespace and (not min_leading_whitespace or leading_whitespace.length < min_leading_whitespace.length):
+                    min_leading_whitespace = leading_whitespace
+                lines.push(v'[leading_whitespace, line]')
+        for lw, l in lines:
+            if min_leading_whitespace:
+                lw = lw[min_leading_whitespace.length:]
+            ans.push(lw + l)
+        ans.push('')
+    return str.rstrip(ans.join('\n'))