l1ving_youtube-dl/youtube_dl/jsinterp/jsbuilt_ins.py

from __future__ import unicode_literals

from types import FunctionType

from ..compat import compat_str


def _to_js(o):
    if isinstance(o, JSProtoBase):
        return o
    elif o is None:
        return undefined
    elif isinstance(o, _native_bool):
        return JSBooleanPrototype(o)
    elif isinstance(o, _native_string):
        return JSStringPrototype(o)
    elif isinstance(o, _native_number):
        return JSNumberPrototype(o)
    elif isinstance(o, _native_object):
        return JSObjectPrototype(o)
    elif isinstance(o, _native_function) or (isinstance(o, JSBase) and hasattr(o, 'call')):
        return JSFunctionPrototype(o)
    elif isinstance(o, _native_array):
        return JSArrayPrototype(o)
    else:
        raise Exception('Not allowed conversion %s to js' % type(o))


def js(func):
    def wrapper(*args, **kwargs):
        return _to_js(func(*args, **kwargs))
    return wrapper


def _type(o):
    if o is undefined:
        return _undefined_type
    elif o is None or o is null:
        return _null_type
    elif isinstance(o, _native_bool) or isinstance(o, JSBooleanPrototype):
        return _boolean_type
    elif isinstance(o, _native_string) or isinstance(o, JSStringPrototype):
        return _string_type
    elif isinstance(o, _native_number) or isinstance(o, JSNumberPrototype):
        return _number_type
    elif isinstance(o, _native_object) or isinstance(o, JSObjectPrototype):
        return _object_type
    return None


def to_object(o):
    if o is undefined or o is null:
        raise Exception('TypeError: Cannot convert undefined or null to object')
    elif isinstance(o, JSBooleanPrototype):
        return JSBooleanPrototype(o)
    elif isinstance(o, JSNumberPrototype):
        return JSNumberPrototype(o)
    elif isinstance(o, JSStringPrototype):
        return JSStringPrototype(o)
    elif isinstance(o, JSObjectPrototype):
        return o


class JSBase(object):

    def __init__(self, name, value):
        self.props = self.__class__.props.copy()
        self.name = name
        self.value = value

    def __str__(self):
        return '[native code]'

    props = {}


class JSProtoBase(JSBase):

    def __init__(self):
        cls = self.__class__
        while cls is not JSProtoBase:
            cls = cls.__base__
            props = cls.props.copy()
            props.update(self.props)
            self.props = props
        super(JSProtoBase, self).__init__('', {})

    def __str__(self):
        return ''

    def __get_prop(self, prop):
        result = self.value.get(prop)
        if result is None:
            result = self.props.get(prop)
        return result

    @js
    def get_prop(self, prop):
        return self.__get_prop(prop)

    @js
    def call_prop(self, prop, *args, **kwargs):
        func = self.__get_prop(prop)
        if isinstance(func, FunctionType):
            return func(self, *args, **kwargs)
        elif isinstance(func, staticmethod):
            return func.__func__(*args, **kwargs)
        elif isinstance(func, classmethod):
            return func.__func__(self.__class__, *args, **kwargs)
        elif isinstance(func, JSBase) and hasattr(func, 'call'):
            return func.call(*args, **kwargs)
        else:
            # FIXME instead of prop should return the whole expression
            # needs to use internal exception
            # interpreter should raise JSTypeError
            raise Exception('TypeError: %s is not a function' % prop)


class JSObjectPrototype(JSProtoBase):

    def __init__(self, value=None):
        super(JSObjectPrototype, self).__init__()
        if value is not None:
            self.value = value

    @staticmethod
    def _constructor(value=None):
        value = _to_js(value)
        if value is undefined or value is null:
            return JSObjectPrototype()
        elif isinstance(value, JSObjectPrototype):
            return value
        elif isinstance(value, (JSStringPrototype, JSNumberPrototype, JSBooleanPrototype)):
            return to_object(value)

    def _to_string(self):
        return 'object to string'

    def _to_locale_string(self):
        return 'object to locale string'

    def _value_of(self):
        return 'object value of'

    def _has_own_property(self, v):
        return v in self.value

    def _is_prototype_of(self, v):
        return 'object has own prop'

    def _is_property_enumerable(self, v):
        return 'object is property enumerable'

    props = {
        'constructor': _constructor,
        'toString': _to_string,
        'toLocaleString': _to_locale_string,
        'valueOf': _value_of,
        'hasOwnProperty': _has_own_property,
        'isPrototypeOf': _is_prototype_of,
        'propertyIsEnumerable': _is_property_enumerable
    }


class JSObject(JSBase):

    def __init__(self):
        super(JSObject, self).__init__(self.name, self.props)

    @staticmethod
    def construct(value=None):
        return JSObjectPrototype._constructor(value)

    @staticmethod
    def call(value=None):
        return JSObject.construct(value)

    def _get_prototype_of(self, o):
        return 'object get prototype of'

    def _get_own_property_descriptor(self, o, p):
        return 'object desc'

    def _get_own_property_names(self, o):
        return list(o.value.keys())

    def _create(self, o, props=None):
        return 'object create'

    def _define_property(self, o, p, attr):
        return 'object define prop'

    def _define_properties(self, o, props):
        return 'object define properties'

    def _seal(self, o):
        return 'object seal'

    def _freeze(self, o):
        return 'object freeze'

    def _prevent_extensions(self, o):
        return 'object prevent extension'

    def _is_sealed(self, o):
        return 'object is sealed'

    def _is_frozen(self, o):
        return 'object is frozen'

    def _is_extensible(self, o):
        return 'object is extensible'

    def _keys(self, o):
        return 'object keys'

    name = 'Object'
    props = {
        'length': 1,
        'prototype': JSObjectPrototype(),
        'getPrototypeOf': _get_prototype_of,
        'getOwnPropertyDescriptor': _get_own_property_descriptor,
        'getOwnPropertyNames': _get_own_property_names,
        'create': _create,
        'defineProperty': _define_property,
        'defineProperties': _define_properties,
        'seal': _seal,
        'freeze': _freeze,
        'preventExtensions': _prevent_extensions,
        'isSealed': _is_sealed,
        'isFrozen': _is_frozen,
        'isExtensible': _is_extensible,
        'keys': _keys
    }


class JSFunctionPrototype(JSObjectPrototype):

    def __init__(self, *args):
        body = args[-1] if args else ''
        if isinstance(body, JSBase):
            super(JSFunctionPrototype, self).__init__(body.props)
            self.fname = body.name
        else:
            super(JSFunctionPrototype, self).__init__()
            self.fname = 'anonymous'

        # FIXME: JSProtoBase sets body to '' instead of None
        self.body = str(body)
        self.args = [sarg.strip() for arg in args[:-1] for sarg in str(arg).split(',')]
        # TODO check if self._args can be parsed as formal parameter list
        # TODO check if self._body can be parsed as function body
        # TODO set strict
        # TODO throw strict mode exceptions
        # (double argument, "eval" or "arguments" in arguments, function identifier is "eval" or "arguments")

    @property
    def _length(self):
        # FIXME: returns maximum instead of "typical" number of arguments
        # Yeesh, I dare you to find anything like that in the python specification.
        return len(self.args)

    def _to_string(self):
        if self.body is not None:
            body = '\n'
            body += '\t' + self.body if self.body else self.body
        else:
            body = ''
        return 'function %s(%s) {%s\n}' % (self.fname, ', '.join(self.args), body)

    def _apply(self, this_arg, arg_array):
        return 'function apply'

    def _call(self, this_arg, *args):
        return 'function call'

    def _bind(self, this_arg, *args):
        return 'function bind'

    props = {
        'length': 0,
        'constructor': __init__,
        'toString': _to_string,
        'apply': _apply,
        'call': _call,
        'bind': _bind
    }


class JSFuction(JSObject):

    name = 'Function'
    props = {
        'length': 1,
        'prototype': JSFunctionPrototype()
    }


class JSArrayPrototype(JSObjectPrototype):

    def __init__(self, value=None, length=0):
        super(JSArrayPrototype, self).__init__()
        self.list = [] if value is None else value
        self.value['length'] = self._length

    @property
    def _length(self):
        return len(self.list)

    def __str__(self):
        return 'JSArrayPrototype: %s' % self.list

    def __repr__(self):
        return 'JSArrayPrototype(%s, %s)' % (self.list, self._length)

    def _to_string(self):
        return 'array to string'

    def _to_locale_string(self):
        return 'array to locale string'

    def _concat(self, *items):
        return 'array concat'

    def _join(self, sep):
        return 'array join'

    def _pop(self):
        return 'array pop'

    def _push(self, *items):
        return 'array push'

    def _reverse(self):
        return 'array reverse'

    def _shift(self):
        return 'array shift'

    def _slice(self, start, end):
        return 'array slice'

    def _sort(self, cmp):
        return 'array sort'

    def _splice(self, start, delete_count, *items):
        return 'array splice'

    def _unshift(self, *items):
        return 'array unshift'

    def _index_of(self, elem, from_index=0):
        return 'array index of'

    def _last_index_of(self, elem, from_index=None):
        if from_index is None:
            from_index = len(self.value) - 1
        return 'array index of'

    def _every(self, callback, this_arg=None):
        return 'array every'

    def _some(self, callback, this_arg=None):
        return 'array some'

    def _for_each(self, callback, this_arg=None):
        return 'array for_each'

    def _map(self, callback, this_arg=None):
        return 'array map'

    def _filter(self, callback, this_arg=None):
        return 'array filter'

    def _reduce(self, callback, init=None):
        return 'array reduce'

    def _reduce_right(self, callback, init=None):
        return 'array reduce right'

    props = {
        'length': 0,
        'constructor': __init__,
        'toString': _to_string,
        'toLocaleString': _to_locale_string,
        'concat': _concat,
        'join': _join,
        'pop': _pop,
        'push': _push,
        'reverse': _reverse,
        'shift': _shift,
        'slice': _slice,
        'sort': _sort,
        'splice': _splice,
        'unshift': _unshift,
        'indexOf': _index_of,
        'lastIndexOf': _last_index_of,
        'every': _every,
        'some': _some,
        'forEach': _for_each,
        'map': _map,
        'filter': _filter,
        'reduce': _reduce,
        'reduceRight': _reduce_right
    }


class JSArray(JSObject):

    def _is_array(self, arg):
        return 'array is array'

    name = 'Array'
    props = {
        'length': 1,
        'prototype': JSArrayPrototype.props,
        'isArray': _is_array
    }


class JSStringPrototype(JSObjectPrototype):
    pass


class JSString(JSObject):
    pass


class JSBooleanPrototype(JSObjectPrototype):
    pass


class JSBoolean(JSObject):
    pass


class JSNumberPrototype(JSObjectPrototype):
    pass


class JSNumber(JSObject):
    pass


undefined = object()
null = object()
true = JSBooleanPrototype(True)
false = JSBooleanPrototype(False)

_native_bool = bool
_native_string = compat_str
_native_number = (int, float)
_native_object = dict
_native_array = (list, tuple)
_native_function = FunctionType

_undefined_type = object()
_null_type = object()
_boolean_type = object()
_string_type = object()
_number_type = object()
_object_type = object()

global_obj = JSObjectPrototype({'Object': JSObject(),
                                'Array': JSArray(),
                                'Function': JSFuction()})