rapydscript-ng 0.8.0 → 0.8.1

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.args[0])
-        output.print("this")
+        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

package/src/output/stream.pyj

@@ -2,8 +2,8 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from utils import make_predicate, defaults, repeat_string
 from tokenizer import is_identifier_char
+from utils import make_predicate, defaults, repeat_string
 
 DANGEROUS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g
 
@@ -11,6 +11,7 @@ DANGEROUS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u2
 # hot path. Avoids the full unicode-aware is_identifier_char() for the common case.
 _IDENT_CHARS = v'(function(){var t=new Uint8Array(128),s="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$";for(var i=0;i<s.length;i++)t[s.charCodeAt(i)]=1;return t;})()'
 
+
 def _is_ident_char(ch):
     code = ch.charCodeAt(0)
     if code < 128:
@@ -26,20 +27,20 @@ def as_hex(code, sz):
 
 
 def to_ascii(str_, identifier):
-    return str_.replace(/[\u0080-\uffff]/g, def(ch):
+    return str_.replace(/[\u0080-\uffff]/g, def (ch):
         code = ch.charCodeAt(0).toString(16)
         if code.length <= 2 and not identifier:
-            return "\\x" + as_hex(code, 2)
+            return '\\x' + as_hex(code, 2)
         else:
             return '\\u' + as_hex(code, 4)
-
     )
 
+
 def encode_string(str_):
-    return JSON.stringify(str_).replace(DANGEROUS, def(a):
+    return JSON.stringify(str_).replace(DANGEROUS, def (a):
             return '\\u' + as_hex(a.charCodeAt(0), 4)
     )
-require_semi_colon_chars = make_predicate("( [ + * / - , .")
+require_semi_colon_chars = make_predicate('( [ + * / - , .')
 
 output_stream_defaults = {
     'indent_start': 0,
@@ -63,12 +64,12 @@ output_stream_defaults = {
     'keep_docstrings': False,
     'discard_asserts': False,
     'module_cache_dir': '',
-    'js_version':6,
+    'js_version': 6,
     'write_name': True,
 }
 
-class OutputStream:
 
+class OutputStream:
     def __init__(self, options):
         self.options = defaults(options, output_stream_defaults, True)
         self._indentation = 0
@@ -86,11 +87,11 @@ class OutputStream:
         self._source_map_segments = v'[]' if self.options.source_map else None
         # Indentation string cache: avoids repeat_string() on every indent() call
         self._indent_cache_val = -1
-        self._indent_cache_str = ""
+        self._indent_cache_str = ''
         # Install no-op add_mapping on the instance when source maps are disabled,
         # avoiding a null check and array push per node in the hot output walk.
         if not self.options.source_map:
-            self.add_mapping = def(node): pass
+            self.add_mapping = def (node): pass
 
     def new_try_else_counter(self):
         self.try_else_counter += 1
@@ -110,7 +111,7 @@ class OutputStream:
         target = self.options.indent_start + self._indentation - (back or 0) * self.options.indent_level
         if target == self._indent_cache_val:
             return self._indent_cache_str
-        s = repeat_string(" ", target)
+        s = repeat_string(' ', target)
         self._indent_cache_val = target
         self._indent_cache_str = s
         return s
@@ -121,19 +122,19 @@ class OutputStream:
 
     def maybe_newline(self):
         if self.options.max_line_len and self.current_col > self.options.max_line_len:
-            self.print("\n")
+            self.print('\n')
 
     def print(self, str_):
         str_ = v"String(str_)"
         ch = str_.charAt(0)
         if self.might_need_semicolon:
-            if (not ch or ";}".indexOf(ch) < 0) and not /[;]$/.test(self._last):
+            if (not ch or ';}'.indexOf(ch) < 0) and not /[;]$/.test(self._last):
                 if self.options.semicolons or require_semi_colon_chars[ch]:
-                    self._fragments.push(";")
+                    self._fragments.push(';')
                     self.current_col += 1
                     self.current_pos += 1
                 else:
-                    self._fragments.push("\n")
+                    self._fragments.push('\n')
                     self.current_pos += 1
                     self.current_line += 1
                     self.current_col = 0
@@ -141,25 +142,23 @@ class OutputStream:
                 if not self.options.beautify:
                     self.might_need_space = False
 
-
             self.might_need_semicolon = False
             self.maybe_newline()
 
         if not self.options.beautify and self.options.preserve_line and self._stack[self._stack.length - 1]:
             target_line = self._stack[self._stack.length - 1].start.line
             while self.current_line < target_line:
-                self._fragments.push("\n")
+                self._fragments.push('\n')
                 self.current_pos += 1
                 self.current_line += 1
                 self.current_col = 0
                 self.might_need_space = False
 
-
         if self.might_need_space:
             prev = self.last_char()
-            if _is_ident_char(prev) and (_is_ident_char(ch) or ch is "\\")
+            if _is_ident_char(prev) and (_is_ident_char(ch) or ch is '\\')
             or /^[\+\-\/]$/.test(ch) and ch is prev:
-                self._fragments.push(" ")
+                self._fragments.push(' ')
                 self.current_col += 1
                 self.current_pos += 1
 
@@ -211,17 +210,17 @@ class OutputStream:
 
     def newline(self):
         if self.options.beautify:
-            self.print("\n")
+            self.print('\n')
 
     def semicolon(self):
         if self.options.beautify:
-            self.print(";")
+            self.print(';')
         else:
             self.might_need_semicolon = True
 
     def force_semicolon(self):
         self.might_need_semicolon = False
-        self.print(";")
+        self.print(';')
 
     def next_indent(self):
         return self._indentation + self.options.indent_level
@@ -241,34 +240,34 @@ class OutputStream:
 
     def with_block(self, cont):
         ret = None
-        self.print("{")
+        self.print('{')
         self.newline()
-        self.with_indent(self.next_indent(), def():
+        self.with_indent(self.next_indent(), def ():
             nonlocal ret
             ret = cont()
         )
         self.indent()
-        self.print("}")
+        self.print('}')
         return ret
 
     def with_parens(self, cont):
-        self.print("(")
+        self.print('(')
         ret = cont()
-        self.print(")")
+        self.print(')')
         return ret
 
     def with_square(self, cont):
-        self.print("[")
+        self.print('[')
         ret = cont()
-        self.print("]")
+        self.print(']')
         return ret
 
     def comma(self):
-        self.print(",")
+        self.print(',')
         self.space()
 
     def colon(self):
-        self.print(":")
+        self.print(':')
         if self.options.space_colon:
             self.space()
 
@@ -278,12 +277,12 @@ class OutputStream:
 
     def assign(self, name):
         # generates: '[name] = '
-        if jstype(name) is "string":
+        if jstype(name) is 'string':
             self.print(name)
         else:
             name.print(self)
         self.space()
-        self.print("=")
+        self.print('=')
         self.space()
 
     def current_width(self):

package/src/output/utils.pyj

@@ -4,6 +4,7 @@ from __python__ import hash_literals
 
 from ast import AST_BlockStatement, is_node_type
 
+
 def best_of(a):
     best = a[0]
     len_ = best.length
@@ -13,38 +14,41 @@ def best_of(a):
             len_ = best.length
     return best
 
+
 def make_num(num):
     str_ = num.toString(10)
-    a = [ str_.replace(/^0\./, ".").replace("e+", "e") ]
+    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))
+            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))
+            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)
+            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(".")))
+        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.with_block(def ():
         output.indent()
         stmt.print(output)
         output.newline()
     )
 
+
 def create_doctring(docstrings):
     ans = v'[]'
     for ds in docstrings: