rapydscript-ns 0.8.0

package/src/output/classes.pyj

@@ -0,0 +1,296 @@
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+from ast import AST_Class, AST_Method, is_node_type
+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:
+        return
+
+    def class_def(method, is_var):
+        output.indent()
+        self.name.print(output)
+        if not is_var and method and has_prop(self.static, method):
+            output.assign("." + method)
+        else:
+            if is_var:
+                output.assign(".prototype[" + method + "]")
+            else:
+                output.assign(".prototype" + (("." + method) if method else ""))
+
+    def define_method(stmt, is_property):
+        name = stmt.name.name
+        is_static = has_prop(self.static, name)
+        is_classmethod = stmt.is_classmethod
+        # classmethods are defined on the class itself (like statics), with cls=this
+        strip_first = not is_static
+
+        if is_classmethod:
+            # define on the class object (not prototype): ClassName.method = function(...)
+            output.indent()
+            self.name.print(output)
+            output.assign("." + name)
+        elif not is_property:
+            class_def(name)
+
+        # decorate the method
+        if stmt.decorators and stmt.decorators.length:
+            decorate(stmt.decorators, output, def():function_definition(stmt, output, strip_first, True);)
+            output.end_statement()
+        else:
+            function_definition(stmt, output, strip_first)
+            if not is_property:
+                output.end_statement()
+                if is_classmethod:
+                    fname = self.name.name + '.' + name
+                    function_annotation(stmt, output, strip_first, fname)
+                    # prototype delegation so instances can call the classmethod
+                    output.indent()
+                    self.name.print(output)
+                    output.assign('.prototype.' + name)
+                    clsname = self.name.name
+                    output.print('function() { return ' + clsname + '.' + name + '.apply(this.constructor, arguments); }')
+                    output.end_statement()
+                else:
+                    fname = self.name.name + ('.' if is_static else '.prototype.') + name
+                    function_annotation(stmt, output, strip_first, fname)
+
+    def define_default_method(name, body):
+        class_def(name)
+        output.spaced('function', name, '()', '')
+        output.with_block(def(): output.indent(), body();)
+        output.end_statement()
+
+    def add_hidden_property(name, proceed):
+        output.indent(), output.print('Object.defineProperty(')
+        self.name.print(output), output.print('.prototype'), output.comma(), output.print(JSON.stringify(name)), output.comma()
+        output.spaced('{value:', ''), proceed(), output.print('})'), output.end_statement()
+
+    # generate constructor
+    def write_constructor():
+        output.print("function")
+        output.space()
+        self.name.print(output)
+        output.print("()")
+        output.space()
+
+        output.with_block(def():
+            output.indent()
+            cname = self.name.name
+            output.print('if (!(this instanceof ' + cname + ')) return new ' + cname + '(...arguments);')
+            output.newline()
+            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)")
+                output.end_statement()
+            output.indent()
+            self.name.print(output)
+            output.print(".prototype.__init__.apply(this"), output.comma(), output.print('arguments)')
+            output.end_statement()
+        )
+
+    decorators = self.decorators or v'[]'
+    if decorators.length:
+        output.print('var ')
+        output.assign(self.name)
+        write_constructor()
+        output.semicolon()
+    else:
+        write_constructor()
+    output.newline()
+    if decorators.length:
+        output.indent()
+        self.name.print(output)
+        output.spaced('.ρσ_decorators', '=', '[')
+        num = decorators.length
+        for i in range(num):
+            decorators[i].expression.print(output)
+            output.spaced(',' if i < num - 1 else ']')
+        output.semicolon()
+        output.newline()
+
+    # inheritance
+    if self.parent:
+        output.indent()
+        output.print("ρσ_extends")
+        output.with_parens(def():
+            self.name.print(output)
+            output.comma()
+            self.parent.print(output)
+        )
+        output.end_statement()
+
+    # method binding
+    if self.bound.length:
+        seen_methods = Object.create(None)
+        add_hidden_property('__bind_methods__', def():
+            output.spaced('function', '()', '')
+            output.with_block(def():
+                if self.bases.length:
+                    for v'var i = self.bases.length - 1; i >= 0; i--':
+                        base = self.bases[i]
+                        output.indent(), base.print(output), output.spaced('.prototype.__bind_methods__', '&&', '')
+                        base.print(output), output.print('.prototype.__bind_methods__.call(this)')
+                        output.end_statement()
+                for bname in self.bound:
+                    if seen_methods[bname] or self.dynamic_properties[bname]:
+                        continue
+                    seen_methods[bname] = True
+                    output.indent(), output.assign('this.' + bname)
+                    self.name.print(output), output.print('.prototype.' + bname + '.bind(this)')
+                    output.end_statement()
+            )
+        )
+
+    # dynamic properties
+    property_names = Object.keys(self.dynamic_properties)
+    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():
+                for name in property_names:
+                    prop = self.dynamic_properties[name]
+                    output.indent(), output.print(JSON.stringify(name) + ':'), output.space()
+                    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()
+                            define_method(prop.getter, True), output.comma(), output.newline()
+                        output.indent(), output.print('"set":'), output.space()
+                        if prop.setter:
+                            define_method(prop.setter, True), output.newline()
+                        else:
+                            output.spaced('function', '()', '{', '''throw new AttributeError("can't set attribute")''', '}'), output.newline()
+                    )
+                    output.comma(), output.newline()
+            )
+        )
+        output.end_statement()
+
+    # actual methods
+    if not self.init:
+        # Create a default __init__ method
+        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.comma()
+                    output.print("arguments")
+                )
+                output.end_statement()
+        )
+
+    defined_methods = {}
+
+    for stmt in self.body:
+        if is_node_type(stmt, AST_Method):
+            if stmt.is_getter or stmt.is_setter:
+                continue
+            define_method(stmt)
+            defined_methods[stmt.name.name] = True
+            sname = stmt.name.name
+            if sname is '__init__':
+                # Copy argument handling data so that kwarg interpolation works when calling the constructor
+                for attr in ['.__argnames__', '.__handles_kwarg_interpolation__']:
+                    output.indent(), self.name.print(output), output.assign(attr)
+                    self.name.print(output), output.print('.prototype.__init__' + attr), output.end_statement()
+            if sname is '__iter__':
+                class_def('ρσ_iterator_symbol', True)
+                self.name.print(output)
+                output.print('.prototype.' + stmt.name.name)
+                output.end_statement()
+
+        elif is_node_type(stmt, AST_Class):
+            console.error('Nested classes aren\'t supported yet')  # noqa:undef
+
+    if not defined_methods['__repr__']:
+        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()
+            output.indent(), output.spaced('return', '"<"', '+', '__name__', '+', '"."', '+', 'this.constructor.name', '')
+            output.spaced('+', '" #"', '+', 'this.ρσ_object_id', '+', '">"')
+            output.end_statement()
+        )
+
+    if not defined_methods['__str__']:
+        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()
+            output.spaced('return', 'this.__repr__()')
+            output.end_statement()
+        )
+
+    # Multiple inheritance
+    add_hidden_property('__bases__', def():
+        output.print('[')
+        for v'var i = 0; i < self.bases.length; i++':
+            self.bases[i].print(output)
+            if i < self.bases.length - 1:
+                output.comma()
+        output.print(']')
+    )
+
+    # Python-compatible class identity properties
+    cname_str = JSON.stringify(self.name.name)
+    output.indent(), self.name.print(output), output.print('.__name__ = ' + cname_str), output.end_statement()
+    output.indent(), self.name.print(output), output.print('.__qualname__ = ' + cname_str), output.end_statement()
+    output.indent(), self.name.print(output), output.print('.__module__ = ' + JSON.stringify(self.module_id)), output.end_statement()
+    output.indent()
+    output.print('Object.defineProperty(')
+    self.name.print(output)
+    output.print('.prototype, "__class__", {get: function() { return this.constructor; }, configurable: true})')
+    output.end_statement()
+
+    if self.bases.length > 1:
+        output.indent()
+        output.print("ρσ_mixin(")
+        self.name.print(output)
+        for v'var i = 1; i < self.bases.length; i++':
+            output.comma()
+            self.bases[i].print(output)
+        output.print(')'), output.end_statement()
+
+    # Docstring
+    if self.docstrings and self.docstrings.length and output.options.keep_docstrings:
+        add_hidden_property('__doc__', def():
+            output.print(JSON.stringify(create_doctring(self.docstrings)))
+        )
+
+    # Other statements in the class context
+    for stmt in self.statements:
+        if not is_node_type(stmt, AST_Method):
+            output.indent()
+            stmt.print(output)
+            output.newline()
+
+    if decorators.length:
+        output.indent()
+        output.assign(self.name)
+        for di in range(decorators.length):
+            self.name.print(output)
+            output.print(f'.ρσ_decorators[{di}](')
+        self.name.print(output)
+        output.print(')' * decorators.length)
+        output.semicolon()
+        output.newline()
+        output.indent()
+        output.spaced('delete ')
+        self.name.print(output)
+        output.print('.ρσ_decorators')
+        output.semicolon()
+        output.newline()