rapydscript-ns 0.9.3 → 0.9.4

package/src/lib/collections.pyj

@@ -2,10 +2,11 @@
 # License: BSD
 # RapydScript implementation of Python's collections standard library.
 #
-# Supported: namedtuple, deque, Counter, OrderedDict, defaultdict
+# Supported: namedtuple, deque, Counter, OrderedDict, defaultdict, ChainMap
 #
-# Note: Counter, OrderedDict, and defaultdict use __getitem__/__setitem__.
-# For Python-compatible subscript syntax (obj[key]) in user code, add:
+# Note: Counter, OrderedDict, defaultdict, and ChainMap use
+# __getitem__/__setitem__. For Python-compatible subscript syntax (obj[key])
+# in user code, add:
 #   from __python__ import overload_getitem
 
 
@@ -693,3 +694,226 @@ class defaultdict:
             if self._data[k] != src[k]:
                 return False
         return True
+
+
+class ChainMap:
+    """Combine several mappings into a single, updateable view.
+
+    Lookups search the underlying mappings in order, so the first mapping
+    wins. Writes, updates, and deletions affect only the first mapping.
+    Mirrors Python's collections.ChainMap.
+    """
+
+    def __init__(self, *maps):
+        if maps.length == 0:
+            self.maps = [{}]
+        else:
+            self.maps = list(maps)
+
+    # ── internal mapping-access helpers ───────────────────────────────────
+    # A "map" may be a plain JS object, a RapydScript dict (ρσ_dict, used for
+    # {...} literals in the web-repl), or any RapydScript mapping defining
+    # __getitem__/__setitem__/__contains__ (OrderedDict, defaultdict, Counter,
+    # or a nested ChainMap).
+
+    def _is_rdict(self, m):
+        return v'!!(m && m.jsmap && typeof m.jsmap.get === "function")'
+
+    def _is_mapping(self, m):
+        return v'!!(m && typeof m.__getitem__ === "function" && typeof m.__contains__ === "function")'
+
+    def _mkeys(self, m):
+        if self._is_rdict(m):
+            return v'Array.from(m.jsmap.keys())'
+        if self._is_mapping(m):
+            return list(m.keys())
+        return Object.keys(m)
+
+    def _mhas(self, m, key):
+        if self._is_rdict(m):
+            return v'm.jsmap.has(key)'
+        if self._is_mapping(m):
+            return m.__contains__(key)
+        return v'Object.prototype.hasOwnProperty.call(m, key)'
+
+    def _mget(self, m, key):
+        if self._is_rdict(m):
+            return v'm.jsmap.get(key)'
+        if self._is_mapping(m):
+            return m.__getitem__(key)
+        return v'm[key]'
+
+    def _mset(self, m, key, value):
+        if self._is_rdict(m):
+            v'm.jsmap.set(key, value)'
+        elif self._is_mapping(m):
+            m.__setitem__(key, value)
+        else:
+            v'm[key] = value'
+
+    def _mdel(self, m, key):
+        if self._is_rdict(m):
+            v'm.jsmap["delete"](key)'
+        elif self._is_mapping(m):
+            m.__delitem__(key)
+        else:
+            v'delete m[key]'
+
+    def _all_keys(self):
+        # Unique keys across every map. Maps are scanned last-to-first so that
+        # earlier maps keep their key positions, matching Python's iteration.
+        seen = {}
+        result = []
+        i = self.maps.length - 1
+        while i >= 0:
+            for k in self._mkeys(self.maps[i]):
+                if k not in seen:
+                    seen[k] = True
+                    result.push(k)
+            i -= 1
+        return result
+
+    def __getitem__(self, key):
+        for m in self.maps:
+            if self._mhas(m, key):
+                return self._mget(m, key)
+        raise KeyError(repr(key))
+
+    def __setitem__(self, key, value):
+        self._mset(self.maps[0], key, value)
+
+    def __delitem__(self, key):
+        if not self._mhas(self.maps[0], key):
+            raise KeyError('Key not found in the first mapping: ' + repr(key))
+        self._mdel(self.maps[0], key)
+
+    def __contains__(self, key):
+        for m in self.maps:
+            if self._mhas(m, key):
+                return True
+        return False
+
+    def __len__(self):
+        return self._all_keys().length
+
+    def __iter__(self):
+        return iter(self._all_keys())
+
+    def __bool__(self):
+        for m in self.maps:
+            if self._mkeys(m).length > 0:
+                return True
+        return False
+
+    def _map_repr(self, m):
+        pairs = [repr(k) + ': ' + repr(self._mget(m, k)) for k in self._mkeys(m)]
+        return '{' + pairs.join(', ') + '}'
+
+    def __repr__(self):
+        parts = [self._map_repr(m) for m in self.maps]
+        return 'ChainMap(' + parts.join(', ') + ')'
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        is_mapish = self._is_rdict(other) or self._is_mapping(other) or (jstype(other) is 'object' and not Array.isArray(other))
+        if not is_mapish:
+            return False
+        a = self._all_keys()
+        b = self._mkeys(other)
+        if a.length != b.length:
+            return False
+        for k in a:
+            if not self._mhas(other, k):
+                return False
+            if self.__getitem__(k) != self._mget(other, k):
+                return False
+        return True
+
+    def get(self, key, dflt=None):
+        if self.__contains__(key):
+            return self.__getitem__(key)
+        return dflt
+
+    def keys(self):
+        return self._all_keys()
+
+    def values(self):
+        return [self.__getitem__(k) for k in self._all_keys()]
+
+    def items(self):
+        return [[k, self.__getitem__(k)] for k in self._all_keys()]
+
+    @property
+    def parents(self):
+        cm = ChainMap()
+        cm.maps = self.maps.slice(1)
+        return cm
+
+    def new_child(self, m=None):
+        if m is None:
+            m = {}
+        cm = ChainMap()
+        cm.maps = [m].concat(self.maps)
+        return cm
+
+    def _copy_map(self, m):
+        if jstype(m.copy) is 'function':
+            return m.copy()
+        result = {}
+        for k in Object.keys(m):
+            result[k] = m[k]
+        return result
+
+    def copy(self):
+        cm = ChainMap()
+        cm.maps = [self._copy_map(self.maps[0])].concat(self.maps.slice(1))
+        return cm
+
+    def pop(self, key, *rest):
+        first = self.maps[0]
+        if self._mhas(first, key):
+            val = self._mget(first, key)
+            self._mdel(first, key)
+            return val
+        if len(rest) > 0:
+            return rest[0]
+        raise KeyError('Key not found in the first mapping: ' + repr(key))
+
+    def popitem(self):
+        first = self.maps[0]
+        keys = self._mkeys(first)
+        if keys.length == 0:
+            raise KeyError('No keys found in the first mapping.')
+        k = keys[keys.length - 1]
+        val = self._mget(first, k)
+        self._mdel(first, k)
+        return [k, val]
+
+    def setdefault(self, key, dflt=None):
+        if not self.__contains__(key):
+            self._mset(self.maps[0], key, dflt)
+        return self.__getitem__(key)
+
+    def clear(self):
+        first = self.maps[0]
+        if jstype(first.clear) is 'function':
+            first.clear()
+        else:
+            for k in Object.keys(first):
+                v'delete first[k]'
+
+    def update(self, other=None, **kwargs):
+        first = self.maps[0]
+        if other is not None:
+            if self._is_rdict(other) or self._is_mapping(other):
+                for k in self._mkeys(other):
+                    self._mset(first, k, self._mget(other, k))
+            elif jstype(other) is 'object' and not Array.isArray(other):
+                for k in Object.keys(other):
+                    self._mset(first, k, other[k])
+            else:
+                for pair in other:
+                    self._mset(first, pair[0], pair[1])
+        for k in kwargs:
+            self._mset(first, k, kwargs[k])

package/src/lib/copy.pyj

@@ -1,120 +1,120 @@
-# vim:fileencoding=utf-8
-# License: BSD
-# RapydScript implementation of Python's copy standard library.
-#
-# Supported: copy, deepcopy
-# Classes may define __copy__() and __deepcopy__(memo) for custom behaviour.
-
-
-def _is_primitive(x):
-    t = jstype(x)
-    return x is None or t is 'number' or t is 'boolean' or t is 'string' or t is 'undefined'
-
-
-def copy(x):
-    """Return a shallow copy of x.
-
-    For immutable primitives (numbers, strings, booleans, None) the object
-    itself is returned unchanged.  For containers a new container of the same
-    type is created whose top-level items are the same objects as in the
-    original.
-
-    Dispatch order:
-      1. Primitive → return as-is.
-      2. ``__copy__`` method → call and return.
-      3. list  → ``list(x)`` (slice).
-      4. set   → ``set(x)``.
-      5. frozenset → ``frozenset(x)``.
-      6. dict (ρσ_dict) → ``x.copy()``.
-      7. Plain JS object (constructor is Object or null-proto) → Object.assign.
-      8. Other object (class instance) → Object.create + Object.assign.
-    """
-    if _is_primitive(x):
-        return x
-    if jstype(x.__copy__) is 'function':
-        return x.__copy__()
-    if Array.isArray(x):
-        return list(x)
-    if isinstance(x, set):
-        return set(x)
-    if isinstance(x, frozenset):
-        return frozenset(x)
-    if isinstance(x, dict):
-        return x.copy()
-    proto = Object.getPrototypeOf(x)
-    if x.constructor is Object or proto is None:
-        return Object.assign({}, x)
-    # Class instance: create a same-prototype object and copy own properties.
-    result = Object.create(proto)
-    Object.assign(result, x)
-    return result
-
-
-def deepcopy(x, memo=None):
-    """Return a deep (recursive) copy of x.
-
-    Circular references are handled via the *memo* mapping (a JS Map), which
-    stores already-copied objects so that they are only copied once.
-
-    Dispatch order (same structure as ``copy`` but recursive):
-      1. Primitive → return as-is.
-      2. Memo hit → return the previously copied object.
-      3. ``__deepcopy__(memo)`` method → call and return.
-      4. list        → recurse into elements.
-      5. set         → recurse into elements, build new set.
-      6. frozenset   → recurse into elements, build new frozenset.
-      7. dict        → recurse into keys and values.
-      8. Plain JS object → recurse into own-enumerable properties.
-      9. Class instance  → recurse into own-enumerable properties.
-    """
-    if memo is None:
-        memo = v'new Map()'
-    if _is_primitive(x):
-        return x
-    if memo.has(x):
-        return memo.get(x)
-    if jstype(x.__deepcopy__) is 'function':
-        result = x.__deepcopy__(memo)
-        memo.set(x, result)
-        return result
-    if Array.isArray(x):
-        result = []
-        memo.set(x, result)
-        for i in range(x.length):
-            result.push(deepcopy(x[i], memo))
-        return result
-    if isinstance(x, set):
-        result = set()
-        memo.set(x, result)
-        iterator = x[ρσ_iterator_symbol]()
-        r = iterator.next()
-        while not r.done:
-            result.add(deepcopy(r.value, memo))
-            r = iterator.next()
-        return result
-    if isinstance(x, frozenset):
-        items = []
-        iterator = x[ρσ_iterator_symbol]()
-        r = iterator.next()
-        while not r.done:
-            items.push(deepcopy(r.value, memo))
-            r = iterator.next()
-        result = frozenset(items)
-        memo.set(x, result)
-        return result
-    if isinstance(x, dict):
-        result = dict()
-        memo.set(x, result)
-        iterator = x.items()
-        r = iterator.next()
-        while not r.done:
-            result.set(deepcopy(r.value[0], memo), deepcopy(r.value[1], memo))
-            r = iterator.next()
-        return result
-    proto = Object.getPrototypeOf(x)
-    result = Object.create(proto)
-    memo.set(x, result)
-    keys = Object.keys(x)
-    for i in range(keys.length):
-        result[keys[i]] = deepcopy(x[keys[i]], memo)
-    return result
+# vim:fileencoding=utf-8
+# License: BSD
+# RapydScript implementation of Python's copy standard library.
+#
+# Supported: copy, deepcopy
+# Classes may define __copy__() and __deepcopy__(memo) for custom behaviour.
+
+
+def _is_primitive(x):
+    t = jstype(x)
+    return x is None or t is 'number' or t is 'boolean' or t is 'string' or t is 'undefined'
+
+
+def copy(x):
+    """Return a shallow copy of x.
+
+    For immutable primitives (numbers, strings, booleans, None) the object
+    itself is returned unchanged.  For containers a new container of the same
+    type is created whose top-level items are the same objects as in the
+    original.
+
+    Dispatch order:
+      1. Primitive → return as-is.
+      2. ``__copy__`` method → call and return.
+      3. list  → ``list(x)`` (slice).
+      4. set   → ``set(x)``.
+      5. frozenset → ``frozenset(x)``.
+      6. dict (ρσ_dict) → ``x.copy()``.
+      7. Plain JS object (constructor is Object or null-proto) → Object.assign.
+      8. Other object (class instance) → Object.create + Object.assign.
+    """
+    if _is_primitive(x):
+        return x
+    if jstype(x.__copy__) is 'function':
+        return x.__copy__()
+    if Array.isArray(x):
+        return list(x)
+    if isinstance(x, set):
+        return set(x)
+    if isinstance(x, frozenset):
+        return frozenset(x)
+    if isinstance(x, dict):
+        return x.copy()
+    proto = Object.getPrototypeOf(x)
+    if x.constructor is Object or proto is None:
+        return Object.assign({}, x)
+    # Class instance: create a same-prototype object and copy own properties.
+    result = Object.create(proto)
+    Object.assign(result, x)
+    return result
+
+
+def deepcopy(x, memo=None):
+    """Return a deep (recursive) copy of x.
+
+    Circular references are handled via the *memo* mapping (a JS Map), which
+    stores already-copied objects so that they are only copied once.
+
+    Dispatch order (same structure as ``copy`` but recursive):
+      1. Primitive → return as-is.
+      2. Memo hit → return the previously copied object.
+      3. ``__deepcopy__(memo)`` method → call and return.
+      4. list        → recurse into elements.
+      5. set         → recurse into elements, build new set.
+      6. frozenset   → recurse into elements, build new frozenset.
+      7. dict        → recurse into keys and values.
+      8. Plain JS object → recurse into own-enumerable properties.
+      9. Class instance  → recurse into own-enumerable properties.
+    """
+    if memo is None:
+        memo = v'new Map()'
+    if _is_primitive(x):
+        return x
+    if memo.has(x):
+        return memo.get(x)
+    if jstype(x.__deepcopy__) is 'function':
+        result = x.__deepcopy__(memo)
+        memo.set(x, result)
+        return result
+    if Array.isArray(x):
+        result = []
+        memo.set(x, result)
+        for i in range(x.length):
+            result.push(deepcopy(x[i], memo))
+        return result
+    if isinstance(x, set):
+        result = set()
+        memo.set(x, result)
+        iterator = x[ρσ_iterator_symbol]()
+        r = iterator.next()
+        while not r.done:
+            result.add(deepcopy(r.value, memo))
+            r = iterator.next()
+        return result
+    if isinstance(x, frozenset):
+        items = []
+        iterator = x[ρσ_iterator_symbol]()
+        r = iterator.next()
+        while not r.done:
+            items.push(deepcopy(r.value, memo))
+            r = iterator.next()
+        result = frozenset(items)
+        memo.set(x, result)
+        return result
+    if isinstance(x, dict):
+        result = dict()
+        memo.set(x, result)
+        iterator = x.items()
+        r = iterator.next()
+        while not r.done:
+            result.set(deepcopy(r.value[0], memo), deepcopy(r.value[1], memo))
+            r = iterator.next()
+        return result
+    proto = Object.getPrototypeOf(x)
+    result = Object.create(proto)
+    memo.set(x, result)
+    keys = Object.keys(x)
+    for i in range(keys.length):
+        result[keys[i]] = deepcopy(x[keys[i]], memo)
+    return result

package/src/lib/elementmaker.pyj

@@ -1,83 +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)
+# 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)