rapydscript-ns 0.8.0

package/src/lib/elementmaker.pyj

@@ -0,0 +1,83 @@
+# vim:fileencoding=utf-8
+# License: GPL v3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+html_elements = {
+    'a', 'abbr', 'acronym', 'address', 'area',
+    'article', 'aside', 'audio', 'b', 'base', 'big', 'body', 'blockquote', 'br', 'button',
+    'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup',
+    'command', 'datagrid', 'datalist', 'dd', 'del', 'details', 'dfn',
+    'dialog', 'dir', 'div', 'dl', 'dt', 'em', 'event-source', 'fieldset',
+    'figcaption', 'figure', 'footer', 'font', 'form', 'header', 'h1',
+    'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'head', 'i', 'iframe', 'img', 'input', 'ins',
+    'keygen', 'kbd', 'label', 'legend', 'li', 'm', 'map', 'menu', 'meter',
+    'multicol', 'nav', 'nextid', 'ol', 'output', 'optgroup', 'option',
+    'p', 'pre', 'progress', 'q', 's', 'samp', 'script', 'section', 'select',
+    'small', 'sound', 'source', 'spacer', 'span', 'strike', 'strong', 'style',
+    'sub', 'sup', 'table', 'tbody', 'td', 'textarea', 'time', 'tfoot',
+    'th', 'thead', 'tr', 'tt', 'u', 'ul', 'var', 'video'
+}
+
+mathml_elements = {
+    'maction', 'math', 'merror', 'mfrac', 'mi',
+    'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom',
+    'mprescripts', 'mroot', 'mrow', 'mspace', 'msqrt', 'mstyle', 'msub',
+    'msubsup', 'msup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder',
+    'munderover', 'none'
+}
+
+svg_elements = {
+    'a', 'animate', 'animateColor', 'animateMotion',
+    'animateTransform', 'clipPath', 'circle', 'defs', 'desc', 'ellipse',
+    'font-face', 'font-face-name', 'font-face-src', 'g', 'glyph', 'hkern',
+    'linearGradient', 'line', 'marker', 'metadata', 'missing-glyph',
+    'mpath', 'path', 'polygon', 'polyline', 'radialGradient', 'rect',
+    'set', 'stop', 'svg', 'switch', 'text', 'title', 'tspan', 'use'
+}
+
+html5_tags = html_elements.union(mathml_elements).union(svg_elements)
+
+def _makeelement(tag, *args, **kwargs):
+    ans = this.createElement(tag)
+
+    for attr in kwargs:
+        vattr = str.replace(str.rstrip(attr, '_'), '_', '-')
+        val = kwargs[attr]
+        if callable(val):
+            if str.startswith(attr, 'on'):
+                attr = attr[2:]
+            ans.addEventListener(attr, val)
+        elif val is True:
+            ans.setAttribute(vattr, vattr)
+        elif jstype(val) is 'string':
+            ans.setAttribute(vattr, val)
+
+    for arg in args:
+        if jstype(arg) is 'string':
+            arg = this.createTextNode(arg)
+        ans.appendChild(arg)
+    return ans
+
+def maker_for_document(document):
+    # Create an elementmaker to be used with the specified document
+    E = _makeelement.bind(document)
+    Object.defineProperties(E, {
+        tag: {
+            'value':_makeelement.bind(document, tag)
+        } for tag in html5_tags
+    })
+    return E
+
+if jstype(document) is 'undefined':
+    E = maker_for_document({
+        'createTextNode': def(value): return value;,
+        'createElement': def(name):
+            return  {
+                'name':name,
+                'children':[],
+                'attributes':{},
+                'setAttribute': def(name, val): this.attributes[name] = val;,
+                'appendChild': def(child): this.children.push(child);,
+            }
+    })
+else:
+    E = maker_for_document(document)

package/src/lib/encodings.pyj

@@ -0,0 +1,126 @@
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+
+def base64encode(bytes, altchars, pad_char):
+    # Convert an array of bytes into a base-64 encoded string
+    l = bytes.length
+    remainder = l % 3
+    main_length = l - remainder
+    encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' + (altchars or '+/')
+    pad_char = '=' if pad_char is undefined else pad_char
+    ans = v'[]'
+    for v'var i = 0; i < main_length; i += 3':
+        chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]
+        ans.push(encodings[(chunk & 16515072) >> 18], encodings[(chunk & 258048) >> 12], encodings[(chunk & 4032) >> 6], encodings[chunk & 63])
+    if remainder is 1:
+        chunk = bytes[main_length]
+        ans.push(encodings[(chunk & 252) >> 2], encodings[(chunk & 3) << 4], pad_char, pad_char)
+    elif remainder is 2:
+        chunk = (bytes[main_length] << 8) | bytes[main_length + 1]
+        ans.push(encodings[(chunk & 64512) >> 10], encodings[(chunk & 1008) >> 4], encodings[(chunk & 15) << 2], pad_char)
+    return ans.join('')
+
+def base64decode(string):
+    # convert the output of base64encode back into an array of bytes
+    # (Uint8Array) only works with the standard altchars and pad_char
+    if jstype(window) is not 'undefined':
+        chars = window.atob(string)
+    else:
+        chars = new Buffer(string, 'base64').toString('binary')  # noqa: undef
+    ans = Uint8Array(chars.length)
+    for i in range(ans.length):
+        ans[i] = chars.charCodeAt(i)
+    return ans
+
+def urlsafe_b64encode(bytes, pad_char):
+    return base64encode(bytes, '-_', pad_char)
+
+def urlsafe_b64decode(string):
+    string = String.prototype.replace.call(string, /[_-]/g, def(m): return '+' if m is '-' else '/';)
+    return base64decode(string)
+
+def hexlify(bytes):
+    ans = v'[]'
+    for v'var i = 0; i < bytes.length; i++':
+        x = bytes[i].toString(16)
+        if x.length is 1:
+            x = '0' + x
+        ans.push(x)
+    return ans.join('')
+
+def unhexlify(string):
+    num = string.length // 2
+    if num * 2 is not string.length:
+        raise ValueError('string length is not a multiple of two')
+    ans = Uint8Array(num)
+    for v'var i = 0; i < num; i++':
+        x = parseInt(string[i*2:i*2+2], 16)
+        if isNaN(x):
+            raise ValueError('string is not hex-encoded')
+        ans[i] = x
+    return ans
+
+utf8_decoder_table = v'''[
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
+  8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
+  0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
+  0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
+  0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
+  1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
+  1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
+  1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
+]'''
+
+def _from_code_point(x):
+    if x <= 0xFFFF:
+        return String.fromCharCode(x)
+    x -= 0x10000
+    return String.fromCharCode((x >> 10) + 0xD800, (x % 0x400) + 0xDC00)
+
+def utf8_decode(bytes, errors, replacement):
+    # Convert an array of UTF-8 encoded bytes into a string
+    state = 0
+    ans = v'[]'
+
+    for v'var i = 0, l = bytes.length; i < l; i++':  # noqa
+        byte = bytes[i]
+        typ = utf8_decoder_table[byte]
+        codep = (byte & 0x3f) | (codep << 6) if state is not 0 else (0xff >> typ) & (byte)
+        state = utf8_decoder_table[256 + state*16 + typ]
+        if state is 0:
+            ans.push(_from_code_point(codep))
+        elif state is 1:
+            if not errors or errors is 'strict':
+                raise UnicodeDecodeError(str.format('The byte 0x{:02x} at position {} is not valid UTF-8', byte, i))
+            elif errors is 'replace':
+                ans.push(replacement or '?')
+    return ans.join('')
+
+def utf8_encode_js(string):
+    # Encode a string as an array of UTF-8 bytes
+    escstr = encodeURIComponent(string)
+    ans = v'[]'
+    for v'var i = 0; i < escstr.length; i++':
+        ch = escstr[i]
+        if ch is '%':
+            ans.push(parseInt(escstr[i+1:i+3], 16))
+            i += 2
+        else:
+            ans.push(ch.charCodeAt(0))
+    return Uint8Array(ans)
+
+if jstype(TextEncoder) is 'function':
+    _u8enc = TextEncoder('utf-8')
+    utf8_encode = _u8enc.encode.bind(_u8enc)
+    _u8enc = undefined
+else:
+    utf8_encode = utf8_encode_js
+
+def utf8_encode_native(string):
+    return _u8enc.encode(string)

package/src/lib/functools.pyj

@@ -0,0 +1,148 @@
+# vim:fileencoding=utf-8
+# License: BSD
+# RapydScript implementation of Python's functools standard library.
+#
+# Supported: reduce, partial, wraps, lru_cache, cache, total_ordering, cmp_to_key
+
+def reduce(func, iterable, *rest):
+    """Apply func cumulatively to items of iterable, from left to right."""
+    it = iter(iterable)
+    r = it.next()
+    if len(rest) == 0:
+        if r.done:
+            raise TypeError('reduce() of empty sequence with no initial value')
+        value = r.value
+        r = it.next()
+    else:
+        value = rest[0]
+    while not r.done:
+        value = func(value, r.value)
+        r = it.next()
+    return value
+
+
+def partial(func, *args, **kwargs):
+    """Return a new function with partial application of args and kwargs."""
+    stored_args = args
+    stored_kwargs = kwargs
+    def wrapper(*more_args, **more_kwargs):
+        return func(*stored_args.concat(more_args), **stored_kwargs, **more_kwargs)
+    wrapper.func = func
+    wrapper.args = stored_args
+    wrapper.keywords = stored_kwargs
+    return wrapper
+
+
+def wraps(wrapped):
+    """Decorator factory: copy metadata from wrapped onto the wrapper function."""
+    def decorator(wrapper):
+        wrapper.__name__ = wrapped.name or wrapped.__name__
+        wrapper.__doc__ = wrapped.__doc__
+        wrapper.__wrapped__ = wrapped
+        return wrapper
+    return decorator
+
+
+def _make_lru_cached(func, maxsize):
+    state = v"{'cache': new Map(), 'order': [], 'hits': 0, 'misses': 0}"
+    def wrapper(*args):
+        key = JSON.stringify(args)
+        if state.cache.has(key):
+            state.hits += 1
+            return state.cache.get(key)
+        state.misses += 1
+        result = func(*args)
+        if maxsize is None or state.order.length < maxsize:
+            state.cache.set(key, result)
+            state.order.push(key)
+        elif maxsize > 0:
+            old = state.order.shift()
+            state.cache.delete(old)
+            state.cache.set(key, result)
+            state.order.push(key)
+        return result
+    def cache_clear():
+        v'state.cache.clear(); state.order.length = 0;'
+        state.hits = 0
+        state.misses = 0
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = def():
+        return {'hits': state.hits, 'misses': state.misses,
+                'maxsize': maxsize, 'currsize': state.cache.size}
+    wrapper.__wrapped__ = func
+    return wrapper
+
+
+def lru_cache(maxsize=128):
+    """Memoizing decorator. Use as @lru_cache or @lru_cache(maxsize=N)."""
+    if callable(maxsize):
+        return _make_lru_cached(maxsize, 128)
+    def decorator(func):
+        return _make_lru_cached(func, maxsize)
+    return decorator
+
+
+def cache(func):
+    """Simple unbounded memoizing decorator (equivalent to lru_cache(maxsize=None))."""
+    return _make_lru_cached(func, None)
+
+
+def total_ordering(cls):
+    """Class decorator that fills in missing ordering methods from one root method."""
+    p = cls.prototype
+    has_eq = jstype(p.__eq__) is 'function'
+    if jstype(p.__lt__) is 'function':
+        if jstype(p.__gt__) is not 'function':
+            p.__gt__ = v'function(other) { return other.__lt__(this); }'
+        if jstype(p.__le__) is not 'function':
+            if has_eq:
+                p.__le__ = v'function(other) { return this.__lt__(other) || this.__eq__(other); }'
+            else:
+                p.__le__ = v'function(other) { return this.__lt__(other) || this === other; }'
+        if jstype(p.__ge__) is not 'function':
+            p.__ge__ = v'function(other) { return !this.__lt__(other); }'
+    elif jstype(p.__gt__) is 'function':
+        if jstype(p.__lt__) is not 'function':
+            p.__lt__ = v'function(other) { return other.__gt__(this); }'
+        if jstype(p.__ge__) is not 'function':
+            if has_eq:
+                p.__ge__ = v'function(other) { return this.__gt__(other) || this.__eq__(other); }'
+            else:
+                p.__ge__ = v'function(other) { return this.__gt__(other) || this === other; }'
+        if jstype(p.__le__) is not 'function':
+            p.__le__ = v'function(other) { return !this.__gt__(other); }'
+    elif jstype(p.__le__) is 'function':
+        if jstype(p.__ge__) is not 'function':
+            p.__ge__ = v'function(other) { return other.__le__(this); }'
+        if jstype(p.__lt__) is not 'function':
+            if has_eq:
+                p.__lt__ = v'function(other) { return this.__le__(other) && !this.__eq__(other); }'
+            else:
+                p.__lt__ = v'function(other) { return this.__le__(other) && this !== other; }'
+        if jstype(p.__gt__) is not 'function':
+            p.__gt__ = v'function(other) { return !this.__le__(other); }'
+    elif jstype(p.__ge__) is 'function':
+        if jstype(p.__le__) is not 'function':
+            p.__le__ = v'function(other) { return other.__ge__(this); }'
+        if jstype(p.__gt__) is not 'function':
+            if has_eq:
+                p.__gt__ = v'function(other) { return this.__ge__(other) && !this.__eq__(other); }'
+            else:
+                p.__gt__ = v'function(other) { return this.__ge__(other) && this !== other; }'
+        if jstype(p.__lt__) is not 'function':
+            p.__lt__ = v'function(other) { return !this.__ge__(other); }'
+    return cls
+
+
+def cmp_to_key(mycmp):
+    """Convert a comparison function (returning negative/zero/positive) to a key class."""
+    v"""var K = function K(obj) {
+        if (!(this instanceof K)) return new K(obj);
+        this.obj = obj;
+    };
+    K.prototype.__lt__ = function(other) { return mycmp(this.obj, other.obj) < 0; };
+    K.prototype.__gt__ = function(other) { return mycmp(this.obj, other.obj) > 0; };
+    K.prototype.__eq__ = function(other) { return mycmp(this.obj, other.obj) === 0; };
+    K.prototype.__le__ = function(other) { return mycmp(this.obj, other.obj) <= 0; };
+    K.prototype.__ge__ = function(other) { return mycmp(this.obj, other.obj) >= 0; };"""
+    return K