rapydscript-ns 0.9.3 → 0.9.4

package/test/unit/language-service.js

@@ -900,13 +900,14 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             description: "Importing all collections classes produces no errors",
             run: function () {
                 var markers = d().check([
-                    "from collections import defaultdict, Counter, OrderedDict, deque, namedtuple",
+                    "from collections import defaultdict, Counter, OrderedDict, deque, namedtuple, ChainMap",
                     "d = defaultdict(list)",
                     "c = Counter([1, 2, 2, 3])",
                     "od = OrderedDict()",
                     "dq = deque([1, 2, 3])",
                     "Point = namedtuple('Point', 'x y')",
-                    "print(d, c, od, dq, Point)",
+                    "cm = ChainMap({'a': 1}, {'b': 2})",
+                    "print(d, c, od, dq, Point, cm)",
                 ].join("\n"),
                     { virtualFiles: { mymod: "def foo(): pass" } }
                 );
@@ -930,6 +931,36 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             },
         },
 
+        {
+            name: "stdlib_statistics_no_bad_import",
+            description: "Importing and using statistics functions produces no errors",
+            run: function () {
+                var markers = d().check([
+                    "from statistics import mean, median, mode, stdev, variance",
+                    "from statistics import quantiles, correlation, linear_regression",
+                    "from statistics import NormalDist, StatisticsError",
+                    "data = [1, 2, 3, 4, 5]",
+                    "m = mean(data)",
+                    "md = median(data)",
+                    "mo = mode(data)",
+                    "sd = stdev(data)",
+                    "v = variance(data)",
+                    "q = quantiles(data)",
+                    "c = correlation(data, data)",
+                    "lr = linear_regression(data, data)",
+                    "nd = NormalDist(0, 1)",
+                    "print(m, md, mo, sd, v, q, c, lr.slope, lr.intercept)",
+                    "print(nd.mean, nd.stdev, nd.cdf(0), nd.pdf(0), StatisticsError)",
+                ].join("\n"),
+                    { virtualFiles: { sentinel: "x = 1" } }
+                );
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors for statistics imports and usage, got: " +
+                    JSON.stringify(errors.map(function (m) { return m.message; })));
+            },
+        },
+
         {
             name: "copy_no_bad_import",
             description: "from copy import copy, deepcopy produces no bad-import error",
@@ -1591,6 +1622,36 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             },
         },
 
+        // ── BigInt literals ──────────────────────────────────────────────
+
+        {
+            name: "bigint_literal_no_errors",
+            description: "BigInt literals (42n, 0xFFn, 0b1010n, 0o77n) produce no markers",
+            run: function () {
+                var markers = d().check([
+                    "x = 42n",
+                    "y = 0xFFn",
+                    "z = 0b1010n",
+                    "w = 0o77n",
+                ].join("\n"));
+                assert.deepStrictEqual(markers, [],
+                    "Expected no markers for bigint literals, got: " + JSON.stringify(markers));
+            },
+        },
+
+        {
+            name: "bigint_literal_assignment_no_errors",
+            description: "BigInt literal assignment and arithmetic produce no markers",
+            run: function () {
+                var markers = d().check([
+                    "x = 42n",
+                    "y = x + 1n",
+                ].join("\n"));
+                assert.deepStrictEqual(markers, [],
+                    "Expected no markers for bigint assignment, got: " + JSON.stringify(markers));
+            },
+        },
+
     ];
 
     return TESTS;

package/test/unit/web-repl.js

@@ -270,6 +270,95 @@ var TESTS = [
         },
     },
 
+    {
+        name: "bundle_chainmap_basic",
+        description: "ChainMap construction and first-map-wins lookup work in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "defaults = {'color': 'red', 'user': 'guest'}",
+                "overrides = {'user': 'admin'}",
+                "cm = ChainMap(overrides, defaults)",
+                "assrt.equal(cm['user'], 'admin')",
+                "assrt.equal(cm['color'], 'red')",
+                "assrt.equal(len(cm), 2)",
+                "assrt.ok('color' in cm)",
+                "assrt.ok('missing' not in cm)",
+                "assrt.equal(cm.get('missing', 'fallback'), 'fallback')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_chainmap_writes",
+        description: "ChainMap writes, deletes and updates affect only the first map in the bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "defaults = {'depth': 1}",
+                "cm = ChainMap({}, defaults)",
+                "cm['depth'] = 99",
+                "assrt.equal(cm['depth'], 99)",
+                "assrt.equal(defaults['depth'], 1)",
+                "del cm['depth']",
+                "assrt.equal(cm['depth'], 1)",
+                "cm.update({'a': 1}, b=2)",
+                "assrt.equal(cm['a'], 1)",
+                "assrt.equal(cm['b'], 2)",
+                "assrt.equal(cm.pop('a'), 1)",
+                "assrt.equal(cm.pop('depth', 'dflt'), 'dflt')",
+                "assrt.equal(cm.setdefault('new', 7), 7)",
+                "assrt.equal(cm['new'], 7)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_chainmap_new_child",
+        description: "ChainMap new_child and parents work in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "base = ChainMap({'x': 1})",
+                "child = base.new_child({'x': 2, 'y': 3})",
+                "assrt.equal(child['x'], 2)",
+                "assrt.equal(child['y'], 3)",
+                "assrt.equal(base['x'], 1)",
+                "assrt.equal(child.maps.length, 2)",
+                "parents = child.parents",
+                "assrt.equal(parents['x'], 1)",
+                "assrt.equal(parents.maps.length, 1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_chainmap_iteration",
+        description: "ChainMap keys/values/items, iteration order and copy work in the bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "cm = ChainMap({'a': 1, 'b': 2}, {'c': 3})",
+                "assrt.deepEqual(list(cm), ['c', 'a', 'b'])",
+                "assrt.deepEqual(cm.keys(), ['c', 'a', 'b'])",
+                "assrt.deepEqual(cm.values(), [3, 1, 2])",
+                "dup = cm.copy()",
+                "dup['a'] = 100",
+                "assrt.equal(cm['a'], 1)",
+                "assrt.equal(dup['a'], 100)",
+                "assrt.equal(dup['c'], 3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     {
         name: "bundle_operator_overloading",
         description: "overload_operators flag works in the web-repl bundle",
@@ -3914,6 +4003,121 @@ var TESTS = [
         },
     },
 
+    // ── pprint stdlib ────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_pprint_basic",
+        description: "pprint stdlib: pformat of atoms and short containers in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import pformat",
+                // atoms -> repr()
+                "assrt.equal(pformat(None), 'None')",
+                "assrt.equal(pformat(True), 'True')",
+                "assrt.equal(pformat(42), '42')",
+                "assrt.equal(pformat('hi'), '\"hi\"')",
+                // empty containers
+                "assrt.equal(pformat([]), '[]')",
+                "assrt.equal(pformat({}), '{}')",
+                "assrt.equal(pformat(set()), 'set()')",
+                // short containers fit on one line
+                "assrt.equal(pformat([1, 2, 3]), '[1, 2, 3]')",
+                "assrt.equal(pformat({'a': 1, 'b': 2}), '{\"a\": 1, \"b\": 2}')",
+                "assrt.equal(pformat(frozenset([1])), 'frozenset({1})')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_pprint_wrap",
+        description: "pprint stdlib: wide containers break across lines in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import pformat",
+                // wide list breaks one element per line
+                "assrt.equal(pformat([1, 2, 3], width=5), '[1,\\n 2,\\n 3]')",
+                // wide dict breaks, keys sorted by default
+                "assrt.equal(pformat({'name': 'Al', 'age': 3}, width=12), '{\"age\": 3,\\n \"name\": \"Al\"}')",
+                // indent parameter widens inner indentation
+                "assrt.equal(pformat([1, 2, 3], width=5, indent=4), '[   1,\\n    2,\\n    3]')",
+                // single-element containers never break
+                "assrt.equal(pformat([42], width=1), '[42]')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_pprint_features",
+        description: "pprint stdlib: depth, compact, sort_dicts, and pp() in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import pformat, pp",
+                // depth limits expansion
+                "assrt.equal(pformat([1, [2, [3]]], depth=1), '[1, [...]]')",
+                "assrt.equal(pformat([1, [2, [3]]], depth=2), '[1, [2, [...]]]')",
+                // sort_dicts=False keeps insertion order (ρσ_dict preserves it)
+                "d = dict()",
+                "d.set('c', 1)",
+                "d.set('a', 2)",
+                "assrt.equal(pformat(d, sort_dicts=False), '{\"c\": 1, \"a\": 2}')",
+                "assrt.equal(pformat(d, sort_dicts=True), '{\"a\": 2, \"c\": 1}')",
+                // compact packs multiple items per line
+                "compact_out = pformat([1, 2, 3, 4, 5, 6, 7, 8], compact=True, width=15)",
+                "assrt.equal(compact_out, '[1, 2, 3, 4, 5,\\n 6, 7, 8]')",
+                // pp() writes to a custom stream and defaults sort_dicts=False
+                "class _C:",
+                "    def __init__(self):",
+                "        self.parts = []",
+                "    def write(self, s):",
+                "        self.parts.push(s)",
+                "col = _C()",
+                "pp(d, stream=col)",
+                "assrt.equal(col.parts.join(''), '{\"c\": 1, \"a\": 2}\\n')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_pprint_safe",
+        description: "pprint stdlib: saferepr, isreadable, isrecursive, PrettyPrinter in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import saferepr, isreadable, isrecursive, PrettyPrinter",
+                // saferepr of normal structures == single-line repr
+                "assrt.equal(saferepr([1, 2, 3]), '[1, 2, 3]')",
+                "assrt.equal(saferepr({'a': 1}), '{\"a\": 1}')",
+                // isreadable / isrecursive on plain structures
+                "assrt.ok(isreadable([1, 2, 3]))",
+                "assrt.ok(not isrecursive([1, 2, 3]))",
+                // self-referential list -> recursion detected and marked
+                "cyclic = [1, 2]",
+                "cyclic.push(cyclic)",
+                "assrt.ok(isrecursive(cyclic))",
+                "assrt.ok(not isreadable(cyclic))",
+                "assrt.ok(saferepr(cyclic).indexOf('<Recursion on') >= 0)",
+                // PrettyPrinter class: pformat + instance predicates
+                "p = PrettyPrinter(indent=2, width=8)",
+                "assrt.equal(p.pformat([10, 20, 30]), '[ 10,\\n  20,\\n  30]')",
+                "assrt.ok(p.isrecursive(cyclic))",
+                // invalid args raise ValueError
+                "caught = False",
+                "try:",
+                "    PrettyPrinter(depth=0)",
+                "except ValueError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     {
         name: "bundle_type_enforcement_basic",
         description: "type_enforcement: max args, missing required, type annotations",
@@ -4275,6 +4479,125 @@ var TESTS = [
         },
     },
 
+    // ── statistics ───────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_statistics_averages",
+        description: "statistics stdlib: averages and central location in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import mean, fmean, median, median_low, median_high",
+                "from statistics import mode, multimode, harmonic_mean, geometric_mean",
+                "assrt.equal(mean([1, 2, 3, 4]), 2.5)",
+                "assrt.equal(mean([1, 2, 3]), 2)",
+                "assrt.equal(fmean([1, 2, 3, 4]), 2.5)",
+                "assrt.equal(median([1, 3, 5]), 3)",
+                "assrt.equal(median([1, 3, 5, 7]), 4)",
+                "assrt.equal(median([5, 1, 3]), 3)",            // unsorted input
+                "assrt.equal(median_low([1, 3, 5, 7]), 3)",
+                "assrt.equal(median_high([1, 3, 5, 7]), 5)",
+                "assrt.equal(mode([1, 1, 2, 3, 3, 3]), 3)",
+                "assrt.equal(mode(['x', 'y', 'x']), 'x')",
+                "assrt.deepEqual(multimode([1, 1, 2, 2, 3]), [1, 2])",
+                "assrt.ok(Math.abs(harmonic_mean([40, 60]) - 48.0) < 1e-9)",
+                "assrt.ok(Math.abs(geometric_mean([2, 8]) - 4.0) < 1e-9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_statistics_spread",
+        description: "statistics stdlib: variance, stdev and quantiles in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import variance, pvariance, stdev, pstdev, quantiles",
+                "assrt.equal(variance([1, 2, 3, 4, 5]), 2.5)",
+                "assrt.equal(pvariance([1, 2, 3, 4, 5]), 2.0)",
+                "assrt.ok(Math.abs(stdev([1, 2, 3, 4, 5]) - Math.sqrt(2.5)) < 1e-9)",
+                "assrt.ok(Math.abs(pstdev([1, 2, 3, 4, 5]) - Math.sqrt(2.0)) < 1e-9)",
+                "assrt.deepEqual(quantiles([1, 2, 3, 4]), [1.25, 2.5, 3.75])",
+                "q = quantiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], n=10)",
+                "assrt.equal(q.length, 9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_statistics_relations",
+        description: "statistics stdlib: covariance, correlation, linear_regression in the bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import covariance, correlation, linear_regression",
+                "x = [1, 2, 3, 4, 5, 6, 7, 8, 9]",
+                "y = [1, 2, 3, 1, 2, 3, 1, 2, 3]",
+                "assrt.ok(Math.abs(covariance(x, y) - 0.75) < 1e-9)",
+                "assrt.ok(Math.abs(correlation(x, x) - 1.0) < 1e-9)",
+                "lr = linear_regression([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])",
+                "assrt.ok(Math.abs(lr.slope - 2.0) < 1e-9)",
+                "assrt.ok(Math.abs(lr.intercept - 0.0) < 1e-9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_statistics_normaldist",
+        description: "statistics stdlib: NormalDist in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import NormalDist",
+                "nd = NormalDist(100, 15)",
+                "assrt.equal(nd.mean, 100)",
+                "assrt.equal(nd.stdev, 15)",
+                "assrt.equal(nd.variance, 225)",
+                "assrt.ok(Math.abs(nd.cdf(100) - 0.5) < 1e-6)",
+                "assrt.equal(nd.inv_cdf(0.5), 100)",
+                "assrt.equal(nd.zscore(115), 1.0)",
+                "fs = NormalDist.from_samples([1, 2, 3, 4, 5])",
+                "assrt.ok(Math.abs(fs.mean - 3.0) < 1e-9)",
+                // operator overloading dispatches to __add__
+                "combined = nd + NormalDist(50, 20)",
+                "assrt.equal(combined.mean, 150)",
+                "assrt.equal(combined.stdev, 25)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── list sort: comparator detection + __lt__ dispatch ────────────────────
+
+    {
+        name: "bundle_sort_comparator_and_lt",
+        description: "list sort: positional comparator and __lt__ dispatch in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                // a positional two-argument function is treated as a comparator
+                "assrt.deepEqual(sorted([3, 1, 2, 10], def(x, y): return x - y;), [1, 2, 3, 10])",
+                "m = [5, 2, 8, 1]",
+                "m.sort(def(x, y): return y - x;)",
+                "assrt.deepEqual(m, [8, 5, 2, 1])",
+                // a one-argument function is still a key function
+                "assrt.deepEqual(sorted([3, 1, 2], key=def(x): return -x;), [3, 2, 1])",
+                // custom objects are ordered through their __lt__ method
+                "class Ord:",
+                "    def __init__(self, v):",
+                "        self.v = v",
+                "    def __lt__(self, other):",
+                "        return self.v < other.v",
+                "s = sorted([Ord(3), Ord(1), Ord(2)])",
+                "assrt.deepEqual([s[0].v, s[1].v, s[2].v], [1, 2, 3])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
 ];
 
 // ---------------------------------------------------------------------------