rapydscript-ns 0.8.3 → 0.9.0

package/src/output/jsx.pyj

@@ -0,0 +1,164 @@
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+from ast import AST_String, AST_JSXText, AST_JSXSpread, AST_JSXExprContainer, is_node_type
+
+def _is_component_tag(tag):
+    # Components start with uppercase or use dot notation (e.g. Router.Route)
+    first = tag[0]
+    return (first >= 'A' and first <= 'Z') or '.' in tag
+
+def _needs_quoting(name):
+    # Attribute names containing non-identifier chars (e.g. aria-label) need quoting
+    return not v'/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)'
+
+def _decode_html_entities(text):
+    # Decode HTML entities in a single pass to avoid double-decoding (e.g. &amp;lt; -> &lt;)
+    return text.replace(/&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z]+));/g, def(match, hex, dec, name):
+        if hex:
+            return String.fromCharCode(parseInt(hex, 16))
+        if dec:
+            return String.fromCharCode(parseInt(dec, 10))
+        if name is 'amp':
+            return '&'
+        if name is 'lt':
+            return '<'
+        if name is 'gt':
+            return '>'
+        if name is 'quot':
+            return '"'
+        if name is 'apos':
+            return "'"
+        if name is 'nbsp':
+            return '\u00a0'
+        return match
+    )
+
+def _normalize_jsx_whitespace(text):
+    # Implements the Babel JSX whitespace algorithm:
+    # - Split by newlines; trim leading whitespace from all lines except the first,
+    #   trailing whitespace from all lines except the last.
+    # - Lines that are empty after trimming are dropped.
+    # - Remaining non-empty lines are joined; each line except the last non-empty
+    #   gets a trailing space to separate it from the next.
+    lines = text.split('\n')
+    last_non_empty = -1
+    for i in range(lines.length):
+        if /[^ \t]/.test(lines[i]):
+            last_non_empty = i
+    result = ''
+    for i in range(lines.length):
+        line = lines[i].replace(/\t/g, ' ')
+        is_first = (i is 0)
+        is_last = (i is lines.length - 1)
+        if not is_first:
+            line = line.replace(/^[ ]+/, '')
+        if not is_last:
+            line = line.replace(/[ ]+$/, '')
+        if line:
+            if i is not last_non_empty:
+                line += ' '
+            result += line
+    return result
+
+def _process_jsx_text(text):
+    text = _normalize_jsx_whitespace(text)
+    if text:
+        text = _decode_html_entities(text)
+    return text
+
+def _print_tag(tag, output):
+    if _is_component_tag(tag):
+        output.print(tag)
+    else:
+        output.print('"')
+        output.print(tag)
+        output.print('"')
+
+def _print_props(props, output):
+    if not props or not props.length:
+        output.print('null')
+        return
+    output.print('{')
+    first = True
+    for prop in props:
+        if not first:
+            output.print(', ')
+        first = False
+        if is_node_type(prop, AST_JSXSpread):
+            output.print('...')
+            prop.expression.print(output)
+        else:
+            if _needs_quoting(prop.name):
+                output.print('"')
+                output.print(prop.name)
+                output.print('"')
+            else:
+                output.print(prop.name)
+            output.print(': ')
+            if prop.value is None:
+                output.print('true')
+            elif is_node_type(prop.value, AST_String):
+                output.print_string(prop.value.value)
+            else:
+                prop.value.print(output)
+    output.print('}')
+
+def _print_children(children, output):
+    for child in children:
+        if is_node_type(child, AST_JSXText):
+            text = _process_jsx_text(child.value)
+            if text:
+                output.print(', ')
+                output.print_string(text)
+        elif is_node_type(child, AST_JSXExprContainer):
+            output.print(', ')
+            child.expression.print(output)
+        else:
+            output.print(', ')
+            child.print(output)
+
+def print_jsx_element(self, output):
+    output.print('React.createElement(')
+    _print_tag(self.tag, output)
+    output.print(', ')
+    _print_props(self.props, output)
+    if not self.self_closing:
+        _print_children(self.children, output)
+    output.print(')')
+
+def print_jsx_fragment(self, output):
+    output.print('React.createElement(React.Fragment, null')
+    _print_children(self.children, output)
+    output.print(')')
+
+def print_jsx_attribute(self, output):
+    # Handled directly by _print_props; kept for completeness
+    if _needs_quoting(self.name):
+        output.print('"')
+        output.print(self.name)
+        output.print('"')
+    else:
+        output.print(self.name)
+    if self.value is not None:
+        output.print(': ')
+        if is_node_type(self.value, AST_String):
+            output.print_string(self.value.value)
+        else:
+            self.value.print(output)
+
+def print_jsx_spread(self, output):
+    # Handled directly by _print_props; kept for completeness
+    output.print('...')
+    self.expression.print(output)
+
+def print_jsx_text(self, output):
+    # Handled directly by _print_children; kept for completeness
+    text = _process_jsx_text(self.value)
+    if text:
+        output.print_string(text)
+
+def print_jsx_expr_container(self, output):
+    # Handled directly by _print_children; kept for completeness
+    self.expression.print(output)

package/src/output/literals.pyj

@@ -2,7 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from ast import AST_Binary, AST_ObjectSpread, is_node_type
+from ast import AST_Binary, AST_ObjectSpread, AST_Spread, AST_SetItem, is_node_type
 
 def print_array(self, output):
     output.print('ρσ_list_decorate')
@@ -15,7 +15,11 @@ def print_array(self, output):
             for i, exp in enumerate(a):
                 if i:
                     output.comma()
-                exp.print(output)
+                if is_node_type(exp, AST_Spread):
+                    output.print('...')
+                    exp.expression.print(output)
+                else:
+                    exp.print(output)
             if len_ > 0:
                 output.space()
         )
@@ -78,6 +82,28 @@ def print_object(self, output):
             output.print("Object.create(null)" if self.is_jshash else '{}')
 
 def print_set(self, output):
+    # Check for spread items: {*a, 1, 2, *b}
+    has_spread = False
+    for item in self.items:
+        if is_node_type(item, AST_Spread):
+            has_spread = True
+            break
+    if has_spread:
+        # Compile as ρσ_set([...a, 1, 2, ...b])
+        output.print('ρσ_set')
+        output.with_parens(def():
+            output.with_square(def():
+                for i, item in enumerate(self.items):
+                    if i:
+                        output.comma()
+                    if is_node_type(item, AST_Spread):
+                        output.print('...')
+                        item.expression.print(output)
+                    else:
+                        item.value.print(output)
+            )
+        )
+        return
     if self.items.length is 0:
         output.print('ρσ_set()')
         return

package/src/output/loops.pyj

@@ -456,10 +456,13 @@ def print_list_comprehension(self, output):
                 body_out.print(result_obj)
             # Locally scope all loop variables (outer and inner clauses)
             def decl_loop_vars(init_node):
+                # Recursively declare all leaf variable names from nested tuples/seqs
                 if is_node_type(init_node, AST_Array):
                     for i in init_node.elements:
-                        body_out.comma()
-                        i.print(body_out)
+                        decl_loop_vars(i)
+                elif is_node_type(init_node, AST_Seq):
+                    for i in init_node.to_array():
+                        decl_loop_vars(i)
                 else:
                     body_out.comma()
                     init_node.print(body_out)

package/src/output/modules.pyj

@@ -183,7 +183,7 @@ def print_top_level(self, output):
             write_imports(self, output)
             write_main_name(output)
 
-        declare_vars(self.localvars, output)
+        declare_vars(self.localvars, output, "var" if output.options.repl_mode else "let")
         display_body(self.body, True, output)
         if self.comments_after and self.comments_after.length:
             output_comments(self.comments_after, output)

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()):
@@ -38,7 +43,7 @@ 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) and not prop.overloaded
     is_repeatable = is_node_type(expr, AST_SymbolRef)
     if is_repeatable:
         expr.print(output)
@@ -182,7 +187,7 @@ function_ops = {
     'nin': '!ρσ_in',
 }
 
-# Maps binary operators to their overloading helper function names.
+# Maps binary operators to their overloading helper function names (strict_arithmetic on).
 overloaded_binary_ops = {
     '+':  'ρσ_op_add',
     '-':  'ρσ_op_sub',
@@ -196,9 +201,34 @@ overloaded_binary_ops = {
     '^':  'ρσ_op_xor',
     '<<': 'ρσ_op_lshift',
     '>>': 'ρσ_op_rshift',
+    '<':  'ρσ_op_lt',
+    '>':  'ρσ_op_gt',
+    '<=': 'ρσ_op_le',
+    '>=': 'ρσ_op_ge',
 }
 
-# Maps augmented-assignment operators to their overloading helper names.
+# Maps binary operators to no-strict helpers (overload_operators on, strict_arithmetic off).
+# Operators that never threw TypeError reuse the same helper; others use _ns variants.
+overloaded_binary_ops_ns = {
+    '+':  'ρσ_op_add_ns',
+    '-':  'ρσ_op_sub_ns',
+    '*':  'ρσ_op_mul_ns',
+    '/':  'ρσ_op_truediv_ns',
+    '//': 'ρσ_op_floordiv_ns',
+    '%':  'ρσ_op_mod_ns',
+    '**': 'ρσ_op_pow_ns',
+    '&':  'ρσ_op_and',
+    '|':  'ρσ_op_or',
+    '^':  'ρσ_op_xor',
+    '<<': 'ρσ_op_lshift',
+    '>>': 'ρσ_op_rshift',
+    '<':  'ρσ_op_lt_ns',
+    '>':  'ρσ_op_gt_ns',
+    '<=': 'ρσ_op_le_ns',
+    '>=': 'ρσ_op_ge_ns',
+}
+
+# Maps augmented-assignment operators to their overloading helper names (strict_arithmetic on).
 overloaded_augmented_ops = {
     '+=':  'ρσ_op_iadd',
     '-=':  'ρσ_op_isub',
@@ -214,10 +244,78 @@ overloaded_augmented_ops = {
     '>>=': 'ρσ_op_irshift',
 }
 
+# Maps augmented-assignment operators to no-strict helpers (strict_arithmetic off).
+overloaded_augmented_ops_ns = {
+    '+=':  'ρσ_op_iadd_ns',
+    '-=':  'ρσ_op_isub_ns',
+    '*=':  'ρσ_op_imul_ns',
+    '/=':  'ρσ_op_itruediv_ns',
+    '//=': 'ρσ_op_ifloordiv_ns',
+    '%=':  'ρσ_op_imod_ns',
+    '**=': 'ρσ_op_ipow_ns',
+    '&=':  'ρσ_op_iand',
+    '|=':  'ρσ_op_ior',
+    '^=':  'ρσ_op_ixor',
+    '<<=': 'ρσ_op_ilshift',
+    '>>=': 'ρσ_op_irshift',
+}
+
 
 def print_binary_op(self, output):
-    if self.overloaded and overloaded_binary_ops[self.operator]:
-        output.print(overloaded_binary_ops[self.operator] + '(')
+    if comparators[self.operator] and is_node_type(self.left, AST_Binary) and comparators[self.left.operator]:
+        # A chained comparison such as a < b < c
+        # With overload_operators: ρσ_op_lt(a, b) && ρσ_op_lt(b, c)
+        # Without:                 a < b && b < c
+        if is_node_type(self.left.right, AST_Symbol):
+            # Middle is a simple variable — no caching needed.
+            # self.left.print recurses into print_binary_op and handles overloaded case.
+            self.left.print(output)
+            leftvar = self.left.right.name
+        else:
+            # Middle is a complex expression — must cache to avoid double evaluation.
+            left_ops_map = overloaded_binary_ops if self.left.strict_arith else overloaded_binary_ops_ns
+            if self.left.overloaded and left_ops_map[self.left.operator]:
+                output.print(left_ops_map[self.left.operator] + '(')
+                self.left.left.print(output)
+                output.comma()
+                output.with_parens(def():
+                    nonlocal leftvar
+                    output.assign("ρσ_cond_temp")
+                    self.left.right.print(output)
+                    leftvar = "ρσ_cond_temp"
+                )
+                output.print(')')
+            else:
+                self.left.left.print(output)
+                output.space()
+                output.print(self.left.operator)
+                output.space()
+                output.with_parens(def():
+                    nonlocal leftvar
+                    output.assign("ρσ_cond_temp")
+                    self.left.right.print(output)
+                    leftvar = "ρσ_cond_temp"
+                )
+        ops_map = overloaded_binary_ops if self.strict_arith else overloaded_binary_ops_ns
+        output.space()
+        output.print("&&")
+        output.space()
+        if self.overloaded and ops_map[self.operator]:
+            output.print(ops_map[self.operator] + '(')
+            output.print(leftvar)
+            output.comma()
+            self.right.print(output)
+            output.print(')')
+        else:
+            output.print(leftvar)
+            output.space()
+            output.print(self.operator)
+            output.space()
+            self.right.print(output)
+        return
+    ops_map = overloaded_binary_ops if self.strict_arith else overloaded_binary_ops_ns
+    if self.overloaded and ops_map[self.operator]:
+        output.print(ops_map[self.operator] + '(')
         self.left.print(output)
         output.comma()
         self.right.print(output)
@@ -230,34 +328,6 @@ def print_binary_op(self, output):
             output.comma()
             self.right.print(output)
         )
-    elif comparators[self.operator] and is_node_type(self.left, AST_Binary) and comparators[self.left.operator]:
-        # A chained comparison such as a < b < c
-        if is_node_type(self.left.right, AST_Symbol):
-            # left side compares against a regular variable,
-            # no caching needed
-            self.left.print(output)
-            leftvar = self.left.right.name
-        else:
-            # some logic is being performed, let's cache it
-            self.left.left.print(output)
-            output.space()
-            output.print(self.left.operator)
-            output.space()
-            output.with_parens(def():
-                nonlocal leftvar
-                output.assign("ρσ_cond_temp")
-                self.left.right.print(output)
-                leftvar = "ρσ_cond_temp"
-            )
-
-        output.space()
-        output.print("&&")
-        output.space()
-        output.print(leftvar)
-        output.space()
-        output.print(self.operator)
-        output.space()
-        self.right.print(output)
     elif self.operator is '//':
         output.print('Math.floor')
         output.with_parens(def():
@@ -395,7 +465,8 @@ def print_assignment(self, output):
 
 def print_assign(self, output):
     if self.overloaded and overloaded_augmented_ops[self.operator]:
-        helper = overloaded_augmented_ops[self.operator]
+        aug_map = overloaded_augmented_ops if self.strict_arith else overloaded_augmented_ops_ns
+        helper = aug_map[self.operator]
         output.assign(self.left)
         output.print(helper + '(')
         self.left.print(output)
@@ -482,7 +553,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

@@ -56,6 +56,7 @@ output_stream_defaults = {
     'write_name': True,
     'omit_function_metadata': False,
     'pythonize_strings': False,
+    'repl_mode': False,
 }
 
 class OutputStream: