rapydscript-ng 0.7.24 → 0.8.1

package/src/lib/traceback.pyj

@@ -2,26 +2,163 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 # globals: ρσ_str, ρσ_last_exception
 
+_traceback_state = {'source_map': None, 'decoded': None}
+
+_VLQ_BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+
+def set_source_map_data(data):
+    _traceback_state['source_map'] = data
+    _traceback_state['decoded'] = None
+
+
+def serialize_error_for_formatting(err):
+    return {
+        'name': err.name or 'Error',
+        'stack': err.stack or '',
+        'message': err.message or '',
+    }
+
+
+def unserialize_error_for_formatting(err):
+    ans = new Error()
+    ans.name = err.name
+    ans.stack = err.stack
+    ans.message = err.message
+    return ans
+
+
+def _vlq_decode(encoded):
+    result = v'[]'
+    i = 0
+    n = encoded.length
+    while i < n:
+        value = 0
+        shift = 0
+        has_more = True
+        while has_more:
+            digit = _VLQ_BASE64.indexOf(encoded[i])
+            i += 1
+            has_more = (digit & 32) != 0
+            value += (digit & 31) << shift
+            shift += 5
+        if value & 1:
+            value = -(value >> 1)
+        else:
+            value = value >> 1
+        result.push(value)
+    return result
+
+
+def _decode_source_map(smap):
+    sources = smap.sources or v'[]'
+    source_root = smap.sourceRoot or ''
+    mappings_str = smap.mappings or ''
+    mapping_lines = mappings_str.split(';')
+    decoded = v'[]'
+    prev_src_idx = 0
+    prev_src_line = 0
+    prev_src_col = 0
+    for gen_line in range(mapping_lines.length):
+        line_str = mapping_lines[gen_line]
+        line_entries = v'[]'
+        if line_str:
+            segments = line_str.split(',')
+            prev_col = 0
+            for seg_str in segments:
+                if not seg_str:
+                    continue
+                fields = _vlq_decode(seg_str)
+                if fields.length >= 4:
+                    gen_col = prev_col + fields[0]
+                    prev_col = gen_col
+                    src_idx = prev_src_idx + fields[1]
+                    prev_src_idx = src_idx
+                    src_line = prev_src_line + fields[2]
+                    prev_src_line = src_line
+                    src_col = prev_src_col + fields[3]
+                    prev_src_col = src_col
+                    src_file = sources[src_idx] if src_idx >= 0 and src_idx < sources.length else ''
+                    if source_root and src_file:
+                        src_file = source_root + src_file
+                    line_entries.push({'gen_col': gen_col, 'src_file': src_file, 'src_line': src_line, 'src_col': src_col})
+                elif fields.length >= 1:
+                    prev_col += fields[0]
+        decoded.push(line_entries)
+    return decoded
+
+
+def _find_mapping(decoded, gen_line, gen_col):
+    if not decoded or gen_line < 0 or gen_line >= decoded.length:
+        return None
+    line_entries = decoded[gen_line]
+    if not line_entries or not line_entries.length:
+        return None
+    best = None
+    for entry in line_entries:
+        if entry.gen_col <= gen_col:
+            if best is None or entry.gen_col > best.gen_col:
+                best = entry
+    return best
+
+
+def _parse_stack_frame(line):
+    # Chrome/Node: "    at functionName (file:line:col)"
+    m = /^\s*at\s+(.*?)\s+\((.+):(\d+):(\d+)\)/.exec(line)
+    if m:
+        return {'func': m[1] or None, 'file': m[2], 'line': parseInt(m[3], 10) - 1, 'col': parseInt(m[4], 10) - 1}
+    # Chrome/Node: "    at file:line:col"
+    m = /^\s*at (.+):(\d+):(\d+)$/.exec(line)
+    if m:
+        return {'func': None, 'file': m[1], 'line': parseInt(m[2], 10) - 1, 'col': parseInt(m[3], 10) - 1}
+    # Firefox: "functionName@file:line:col"
+    m = /^(.*?)@(.+):(\d+):(\d+)$/.exec(line)
+    if m:
+        return {'func': m[1] or None, 'file': m[2], 'line': parseInt(m[3], 10) - 1, 'col': parseInt(m[4], 10) - 1}
+    return None
+
+
+def _get_decoded_map():
+    if _traceback_state['decoded'] is None and _traceback_state['source_map']:
+        _traceback_state['decoded'] = _decode_source_map(_traceback_state['source_map'])
+    return _traceback_state['decoded']
+
 
 def _get_internal_traceback(err):
-    if isinstance(err, Exception) and err.stack:
-        lines = ρσ_str.splitlines(err.stack)
-        final_lines = v'[]'
-        found_sentinel = False
-        for i, line in enumerate(lines):
-            sline = ρσ_str.strip(line)
-            if i is 0:
-                final_lines.push(line)
-                continue
-            if found_sentinel:
-                final_lines.push(line)
-                continue
-            # These two conditions work on desktop Chrome and Firefox to identify the correct
-            # line in the traceback.
-            if sline.startsWith('at new ' + err.name) or sline.startsWith(err.name + '@'):
-                found_sentinel = True
-        return final_lines.join('\n')
-    return err and err.stack
+    lines = ρσ_str.splitlines(err.stack or '')
+    final_lines = v'[]'
+    start_line_idx = -1
+    for i, line in enumerate(lines):
+        if i > 0:
+            line = line.trim()
+            if line.startsWith('at new ' + err.name) or line.startsWith(err.name + '@'):
+                # this is the constructor for a RapydScript Exception
+                start_line_idx = i + 1
+                break
+    if start_line_idx < 0:
+        start_line_idx = 1
+        for i, xline in enumerate(lines):
+            if i > 0:
+                line = xline.trim()
+                if v"line.startsWith('at ') || line.includes('@') || /:\d+:\d+$/.test(line)":
+                    start_line_idx = i
+                    break
+    frame_lines = lines[start_line_idx:]
+    final_lines = final_lines.concat(frame_lines)
+    decoded = _get_decoded_map()
+    mapped_lines = v'[]'
+    if decoded:
+        for frame_line in frame_lines:
+            frame = _parse_stack_frame(frame_line)
+            if frame:
+                mapping = _find_mapping(decoded, frame.line, frame.col)
+                if mapping:
+                    loc = '  File "' + mapping.src_file + '", line ' + (mapping.src_line + 1) + ', col ' + (mapping.src_col + 1)
+                    if frame.func:
+                        loc += ', in ' + frame.func
+                    mapped_lines.push(loc)
+    return lines[0], final_lines, mapped_lines
+
 
 def format_exception(exc, limit):
     if jstype(exc) is 'undefined':
@@ -30,25 +167,29 @@ def format_exception(exc, limit):
         if exc and exc.toString:
             return [exc.toString()]
         return []
-    tb = _get_internal_traceback(exc)
-    if tb:
-        lines = ρσ_str.splitlines(tb)
-        e = lines[0]
-        lines = lines[1:]
+    e, js_lines, rs_lines = _get_internal_traceback(exc)
+    if js_lines.length > 0:
         if limit:
-            lines = lines[:limit+1] if limit > 0 else lines[limit:]
-        lines.reverse()
-        lines.push(e)
-        lines.insert(0, 'Traceback (most recent call last):')
-        return [l+'\n' for l in lines]
+            js_lines = js_lines[:limit] if limit > 0 else js_lines[limit:]
+            rs_lines = rs_lines[:limit] if limit > 0 else rs_lines[limit:]
+        js_lines.reverse()
+        rs_lines.reverse()
+        js_lines.push(e)
+        js_lines = v"['Traceback (most recent call last):'].concat(js_lines)"
+        if rs_lines.length > 0:
+            js_lines = js_lines.concat(['', 'Mapped Traceback (RapydScript):']).concat(rs_lines)
+        return [l + '\n' for l in js_lines]
     return [exc.toString()]
 
+
 def format_exc(limit):
     return format_exception(ρσ_last_exception, limit).join('')
 
+
 def print_exc(limit):
     print(format_exc(limit))
 
+
 def format_stack(limit):
     stack = Error().stack
     if not stack:
@@ -56,8 +197,9 @@ def format_stack(limit):
     lines = str.splitlines(stack)[2:]
     lines.reverse()
     if limit:
-        lines = lines[:limit+1] if limit > 0 else lines[limit:]
+        lines = lines[:limit + 1] if limit > 0 else lines[limit:]
     return [l + '\n' for l in lines]
 
+
 def print_stack(limit):
     print(format_stack(limit).join(''))

package/src/lib/uuid.pyj

@@ -47,11 +47,11 @@ def uuid4():
 def num_to_string(numbers, alphabet, pad_to_length):
     ans = v'[]'
     alphabet_len = alphabet.length
-    numbers = Array.prototype.slice.call(numbers)
+    numbers = Array.from (numbers)
     for v'var i = 0; i < numbers.length - 1; i++':
         x = divmod(numbers[i], alphabet_len)
         numbers[i] = x[0]
-        numbers[i+1] += x[1]
+        numbers[i + 1] += x[1]
     for v'var i = 0; i < numbers.length; i++':
         number = numbers[i]
         while number:

package/src/output/classes.pyj

@@ -7,6 +7,7 @@ from output.functions import decorate, function_definition, function_annotation
 from output.utils import create_doctring
 from utils import has_prop
 
+
 def print_class(output):
     self = this
     if self.external:
@@ -16,12 +17,12 @@ def print_class(output):
         output.indent()
         self.name.print(output)
         if not is_var and method and has_prop(self.static, method):
-            output.assign("." + method)
+            output.assign('.' + method)
         else:
             if is_var:
-                output.assign(".prototype[" + method + "]")
+                output.assign('.prototype[' + method + ']')
             else:
-                output.assign(".prototype" + (("." + method) if method else ""))
+                output.assign('.prototype' + (('.' + method) if method else ''))
 
     def define_method(stmt, is_property):
         name = stmt.name.name
@@ -33,7 +34,7 @@ def print_class(output):
 
         # decorate the method
         if stmt.decorators and stmt.decorators.length:
-            decorate(stmt.decorators, output, def():function_definition(stmt, output, strip_first, True);)
+            decorate(stmt.decorators, output, def (): function_definition(stmt, output, strip_first, True);)
             output.end_statement()
         else:
             function_definition(stmt, output, strip_first)
@@ -45,7 +46,7 @@ def print_class(output):
     def define_default_method(name, body):
         class_def(name)
         output.spaced('function', name, '()', '')
-        output.with_block(def(): output.indent(), body();)
+        output.with_block(def (): output.indent(), body();)
         output.end_statement()
 
     def add_hidden_property(name, proceed):
@@ -55,23 +56,23 @@ def print_class(output):
 
     # generate constructor
     def write_constructor():
-        output.print("function")
+        output.print('function')
         output.space()
         self.name.print(output)
-        output.print("()")
+        output.print('()')
         output.space()
 
-        output.with_block(def():
+        output.with_block(def ():
             output.indent()
             output.spaced('if', '(this.ρσ_object_id', '===', 'undefined)', 'Object.defineProperty(this,', '"ρσ_object_id",', '{"value":++ρσ_object_counter})')
             output.end_statement()
             if self.bound.length:
                 output.indent()
-                self.name.print(output), output.print(".prototype.__bind_methods__.call(this)")
+                self.name.print(output), output.print('.prototype.__bind_methods__.call(this)')
                 output.end_statement()
             output.indent()
             self.name.print(output)
-            output.print(".prototype.__init__.apply(this"), output.comma(), output.print('arguments)')
+            output.print('.prototype.__init__.apply(this'), output.comma(), output.print('arguments)')
             output.end_statement()
         )
 
@@ -98,8 +99,8 @@ def print_class(output):
     # inheritance
     if self.parent:
         output.indent()
-        output.print("ρσ_extends")
-        output.with_parens(def():
+        output.print('ρσ_extends')
+        output.with_parens(def ():
             self.name.print(output)
             output.comma()
             self.parent.print(output)
@@ -109,9 +110,9 @@ def print_class(output):
     # method binding
     if self.bound.length:
         seen_methods = Object.create(None)
-        add_hidden_property('__bind_methods__', def():
+        add_hidden_property('__bind_methods__', def ():
             output.spaced('function', '()', '')
-            output.with_block(def():
+            output.with_block(def ():
                 if self.bases.length:
                     for v'var i = self.bases.length - 1; i >= 0; i--':
                         base = self.bases[i]
@@ -133,12 +134,12 @@ def print_class(output):
     if property_names.length:
         output.indent()
         output.print('Object.defineProperties')
-        output.with_parens(def():
-            self.name.print(output), output.print('.prototype'), output.comma(), output.space(), output.with_block(def():
+        output.with_parens(def ():
+            self.name.print(output), output.print('.prototype'), output.comma(), output.space(), output.with_block(def ():
                 for name in property_names:
                     prop = self.dynamic_properties[name]
                     output.indent(), output.print(JSON.stringify(name) + ':'), output.space()
-                    output.with_block(def():
+                    output.with_block(def ():
                         output.indent(), output.print('"enumerable":'), output.space(), output.print('true'), output.comma(), output.newline()
                         if prop.getter:
                             output.indent(), output.print('"get":'), output.space()
@@ -157,16 +158,16 @@ def print_class(output):
     # actual methods
     if not self.init:
         # Create a default __init__ method
-        define_default_method('__init__', def():
+        define_default_method('__init__', def ():
             if self.parent:
                 self.parent.print(output)
                 output.spaced('.prototype.__init__', '&&')
                 output.space(), self.parent.print(output)
-                output.print(".prototype.__init__.apply")
-                output.with_parens(def():
-                    output.print("this")
+                output.print('.prototype.__init__.apply')
+                output.with_parens(def ():
+                    output.print('this')
                     output.comma()
-                    output.print("arguments")
+                    output.print('arguments')
                 )
                 output.end_statement()
         )
@@ -195,7 +196,7 @@ def print_class(output):
             console.error('Nested classes aren\'t supported yet')  # noqa:undef
 
     if not defined_methods['__repr__']:
-        define_default_method('__repr__', def():
+        define_default_method('__repr__', def ():
             if self.parent:
                 output.print('if('), self.parent.print(output), output.spaced('.prototype.__repr__)', 'return', self.parent)
                 output.print('.prototype.__repr__.call(this)'), output.end_statement()
@@ -205,7 +206,7 @@ def print_class(output):
         )
 
     if not defined_methods['__str__']:
-        define_default_method('__str__', def():
+        define_default_method('__str__', def ():
             if self.parent:
                 output.print('if('), self.parent.print(output), output.spaced('.prototype.__str__)', 'return', self.parent)
                 output.print('.prototype.__str__.call(this)'), output.end_statement()
@@ -214,7 +215,7 @@ def print_class(output):
         )
 
     # Multiple inheritance
-    add_hidden_property('__bases__', def():
+    add_hidden_property('__bases__', def ():
         output.print('[')
         for v'var i = 0; i < self.bases.length; i++':
             self.bases[i].print(output)
@@ -225,7 +226,7 @@ def print_class(output):
 
     if self.bases.length > 1:
         output.indent()
-        output.print("ρσ_mixin(")
+        output.print('ρσ_mixin(')
         self.name.print(output)
         for v'var i = 1; i < self.bases.length; i++':
             output.comma()
@@ -234,7 +235,7 @@ def print_class(output):
 
     # Docstring
     if self.docstrings and self.docstrings.length and output.options.keep_docstrings:
-        add_hidden_property('__doc__', def():
+        add_hidden_property('__doc__', def ():
             output.print(JSON.stringify(create_doctring(self.docstrings)))
         )