rapydscript-ns 0.9.2 → 0.9.3

package/test/string.pyj

@@ -0,0 +1,245 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# string.pyj
+# Tests for the string standard library module.
+
+from string import (
+    ascii_lowercase, ascii_uppercase, ascii_letters,
+    digits, hexdigits, octdigits,
+    punctuation, whitespace, printable,
+    Template, Formatter,
+)
+
+ae     = assrt.equal
+ade    = assrt.deepEqual
+ok     = assrt.ok
+throws = assrt.throws
+
+
+# ── 1. Character constants ────────────────────────────────────────────────────
+
+ae(len(ascii_lowercase), 26)
+ae(ascii_lowercase[0],  'a')
+ae(ascii_lowercase[25], 'z')
+
+ae(len(ascii_uppercase), 26)
+ae(ascii_uppercase[0],  'A')
+ae(ascii_uppercase[25], 'Z')
+
+ae(ascii_letters, ascii_lowercase + ascii_uppercase)
+ae(len(ascii_letters), 52)
+
+ae(digits, '0123456789')
+ae(len(digits), 10)
+
+ae(hexdigits, '0123456789abcdefABCDEF')
+ae(len(hexdigits), 22)
+
+ae(octdigits, '01234567')
+ae(len(octdigits), 8)
+
+# punctuation: 32 chars, contains known members
+ae(len(punctuation), 32)
+ok(punctuation.indexOf('!') >= 0)
+ok(punctuation.indexOf('~') >= 0)
+ok(punctuation.indexOf('\\') >= 0)   # backslash present
+ok(punctuation.indexOf('`') >= 0)    # backtick present
+ok(punctuation.indexOf("'") >= 0)    # single-quote present
+
+# whitespace: space, tab, newline, carriage-return, vertical-tab, form-feed
+ae(len(whitespace), 6)
+ok(whitespace.indexOf(' ') >= 0)
+ok(whitespace.indexOf('\t') >= 0)
+ok(whitespace.indexOf('\n') >= 0)
+
+# printable is a concatenation of the four sets
+ae(len(printable), len(digits) + len(ascii_letters) + len(punctuation) + len(whitespace))
+ok(printable.indexOf('A') >= 0)
+ok(printable.indexOf('0') >= 0)
+ok(printable.indexOf('!') >= 0)
+ok(printable.indexOf(' ') >= 0)
+
+
+# ── 2. Template — basic substitution ─────────────────────────────────────────
+
+t1 = Template('Hello $name!')
+ae(t1.substitute({'name': 'World'}), 'Hello World!')
+
+# $$ → literal $
+t2 = Template('Price: $$5.00')
+ae(t2.substitute({}), 'Price: $5.00')
+
+# ${identifier} brace form
+t3 = Template('${foo}bar')
+ae(t3.substitute({'foo': 'baz'}), 'bazbar')
+
+# template attribute
+ae(t1.template, 'Hello $name!')
+
+# multiple substitutions in one string
+t4 = Template('$a + $b = $c')
+ae(t4.substitute({'a': '1', 'b': '2', 'c': '3'}), '1 + 2 = 3')
+
+# numeric values coerced to string
+t5 = Template('$x items')
+ae(t5.substitute({'x': 42}), '42 items')
+
+# None → 'None'
+t6 = Template('val=$v')
+ae(t6.substitute({'v': None}), 'val=None')
+
+
+# ── 3. Template — missing key errors ─────────────────────────────────────────
+
+err_missing = False
+try:
+    Template('Hello $missing').substitute({})
+except KeyError:
+    err_missing = True
+ok(err_missing)
+
+# safe_substitute leaves unknown placeholder intact
+ae(Template('Hello $missing').safe_substitute({}), 'Hello $missing')
+ae(Template('${missing} world').safe_substitute({}), '${missing} world')
+
+# safe_substitute replaces known, leaves unknown
+t7 = Template('$a and $b')
+ae(t7.safe_substitute({'a': 'yes'}), 'yes and $b')
+
+
+# ── 4. Template — edge cases ─────────────────────────────────────────────────
+
+# leading/trailing dollar
+ae(Template('$$').substitute({}), '$')
+ae(Template('$$$$').substitute({}), '$$')
+
+# empty template
+ae(Template('').substitute({}), '')
+ae(Template('').safe_substitute({}), '')
+
+# no placeholders
+ae(Template('plain text').substitute({}), 'plain text')
+
+# trailing $ — safe_substitute leaves it, substitute raises ValueError
+ae(Template('end$').safe_substitute({}), 'end$')
+
+err_dollar = False
+try:
+    Template('end$').substitute({})
+except ValueError:
+    err_dollar = True
+ok(err_dollar)
+
+# class attributes
+ae(Template.delimiter, '$')
+
+
+# ── 5. Formatter — positional args ───────────────────────────────────────────
+
+f = Formatter()
+
+ae(f.format('Hello {}!', 'World'), 'Hello World!')
+ae(f.format('{0} {1}', 'a', 'b'), 'a b')
+ae(f.format('{1} {0}', 'a', 'b'), 'b a')
+ae(f.format('no fields'), 'no fields')
+ae(f.format('{0}{0}{0}', 'x'), 'xxx')
+
+
+# ── 6. Formatter — format specs ──────────────────────────────────────────────
+
+ae(f.format('{:.2f}', 3.14159), '3.14')
+ae(f.format('{:d}', 42), '42')
+ae(f.format('{:05d}', 7), '00007')
+ae(f.format('{:>10}', 'hi'), '        hi')
+ae(f.format('{:<10}', 'hi'), 'hi        ')
+ae(f.format('{:^5}', 'x'), '  x  ')
+ae(f.format('{:x}', 255), 'ff')
+ae(f.format('{:X}', 255), 'FF')
+ae(f.format('{:b}', 10), '1010')
+ae(f.format('{:o}', 8), '10')
+ae(f.format('{:e}', 100000.0), '1.000000e+5')
+
+# {{ }} escaping
+ae(f.format('{{ }}'), '{ }')
+ae(f.format('{{{0}}}', 'inner'), '{inner}')
+
+
+# ── 7. Formatter — conversion flags ──────────────────────────────────────────
+
+ae(f.format('{0!s}', 42), '42')
+
+# repr adds quotes around strings
+_repr_result = f.format('{0!r}', 'hi')
+ok(_repr_result.indexOf('hi') >= 0)
+
+
+# ── 8. Formatter — vformat with named kwargs ─────────────────────────────────
+
+ae(f.vformat('{name}', [], {'name': 'Alice'}), 'Alice')
+ae(f.vformat('{x} + {y}', [], {'x': '1', 'y': '2'}), '1 + 2')
+ae(f.vformat('{0} {name}', ['hi'], {'name': 'Bob'}), 'hi Bob')
+
+
+# ── 9. Formatter — parse() ───────────────────────────────────────────────────
+
+_parsed = f.parse('literal {0} more {name!r:.5}')
+ae(len(_parsed), 3)
+# first item: literal before first field
+ae(_parsed[0][0], 'literal ')
+ae(_parsed[0][1], '0')
+ae(_parsed[0][2], '')
+ae(_parsed[0][3], None)
+# second item
+ae(_parsed[1][0], ' more ')
+ae(_parsed[1][1], 'name')
+ae(_parsed[1][2], '.5')
+ae(_parsed[1][3], 'r')
+# trailing literal
+ae(_parsed[2][0], '')
+ae(_parsed[2][1], None)
+
+# parse with only a trailing literal
+_p2 = f.parse('no fields here')
+ae(len(_p2), 1)
+ae(_p2[0][0], 'no fields here')
+ae(_p2[0][1], None)
+
+
+# ── 10. Formatter — subclassing ──────────────────────────────────────────────
+
+class UpperFormatter(Formatter):
+    def format_field(self, value, format_spec):
+        result = Formatter.format_field(self, value, format_spec)
+        return v'result.toUpperCase()'
+
+uf = UpperFormatter()
+ae(uf.format('Hello {0}!', 'world'), 'Hello WORLD!')
+ae(uf.format('{0}', 'lower'), 'LOWER')
+
+
+# ── 11. Formatter — get_value / get_field ────────────────────────────────────
+
+ae(f.get_value(0, ['a', 'b'], {}), 'a')
+ae(f.get_value(1, ['a', 'b'], {}), 'b')
+ae(f.get_value('x', [], {'x': 99}), 99)
+
+# get_field with dotted access
+_obj = {'name': 'Alice'}
+_gf = f.get_field('0', [_obj], {})
+ae(_gf[1], '0')  # first key used
+
+
+# ── 12. Formatter — convert_field ────────────────────────────────────────────
+
+ae(f.convert_field(42, 's'), '42')
+ok(f.convert_field(42, 'r').indexOf('42') >= 0)
+ae(f.convert_field('x', None), 'x')
+ae(f.convert_field('x', undefined), 'x')
+
+_bad_conv = False
+try:
+    f.convert_field(1, 'z')
+except ValueError:
+    _bad_conv = True
+ok(_bad_conv)

package/test/textwrap.pyj

@@ -0,0 +1,172 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# textwrap.pyj
+# Tests for the textwrap standard library module.
+
+from textwrap import wrap, fill, dedent, indent, shorten, TextWrapper
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. wrap — basic ──────────────────────────────────────────────────────────
+
+# Short text fits on one line
+ade(wrap('hello world', 20), ['hello world'])
+
+# Empty string
+ade(wrap('', 10), [])
+
+# Single word
+ade(wrap('hello', 10), ['hello'])
+
+# Width-limited: "one two" (7), "three four" (10), "five" (4)
+_r1 = wrap('one two three four five', 10)
+ae(_r1.length, 3)
+ae(_r1[0], 'one two')
+ae(_r1[1], 'three four')
+ae(_r1[2], 'five')
+
+# Single word exactly equal to width
+ade(wrap('hello', 5), ['hello'])
+
+# Word longer than width with break_long_words=True (default)
+_r2 = wrap('superlongword', 5)
+ae(_r2[0], 'super')
+ae(_r2[1], 'longw')
+ae(_r2[2], 'ord')
+
+# ── 2. wrap — break_long_words=False ─────────────────────────────────────────
+
+_r3 = wrap('superlongword short', 5, break_long_words=False)
+ae(_r3[0], 'superlongword')
+ae(_r3[1], 'short')
+
+# ── 3. wrap — initial_indent / subsequent_indent ─────────────────────────────
+
+# Line 1 avail=12-2=10: "one two" (7); line 2 avail=10: "three four" (10)
+_r4 = wrap('one two three four', 12, initial_indent='> ', subsequent_indent='  ')
+ae(_r4.length, 2)
+ae(_r4[0], '> one two')
+ae(_r4[1], '  three four')
+
+# ── 4. fill ───────────────────────────────────────────────────────────────────
+
+ae(fill('one two three', 8), 'one two\nthree')
+ae(fill('hello', 20), 'hello')
+ae(fill('', 10), '')
+
+# ── 5. fill — initial/subsequent indent ──────────────────────────────────────
+
+ae(fill('one two three four', 12, initial_indent='> ', subsequent_indent='  '),
+   '> one two\n  three four')
+
+# ── 6. TextWrapper — basic ───────────────────────────────────────────────────
+
+_tw1 = TextWrapper(width=10)
+ade(_tw1.wrap('one two three'), ['one two', 'three'])
+ae(_tw1.fill('one two three'), 'one two\nthree')
+
+# ── 7. TextWrapper — max_lines with placeholder ──────────────────────────────
+
+# width=15, max_lines=2, placeholder=' ...' (4 chars)
+# Line 1: "alpha beta" (10), fits; line 2 needs truncation with placeholder.
+_tw2 = TextWrapper(width=15, max_lines=2, placeholder=' ...')
+_r5 = _tw2.wrap('alpha beta gamma delta epsilon')
+ae(_r5.length, 2)
+ae(_r5[0], 'alpha beta')
+ae(_r5[1], 'gamma delta ...')
+
+# ── 8. TextWrapper — fix_sentence_endings ────────────────────────────────────
+
+_tw3 = TextWrapper(width=70, fix_sentence_endings=True)
+_r6 = _tw3.wrap('end of sentence. New sentence.')
+ae(_r6.length, 1)
+ae(_r6[0], 'end of sentence.  New sentence.')
+
+# Without fix_sentence_endings: single space stays
+_tw4 = TextWrapper(width=70, fix_sentence_endings=False)
+_r7 = _tw4.wrap('end of sentence. New sentence.')
+ae(_r7[0], 'end of sentence. New sentence.')
+
+# ── 9. dedent — common indent removed ────────────────────────────────────────
+
+ae(dedent('  hello\n  world'), 'hello\nworld')
+
+# Tab-based common indent
+ae(dedent('\thello\n\tworld'), 'hello\nworld')
+
+# No common indent → unchanged
+ae(dedent('hello\n  world'), 'hello\n  world')
+
+# Empty lines ignored when computing margin
+ae(dedent('  hello\n\n  world'), 'hello\n\nworld')
+
+# Partial common indent: "    " vs "  " → margin is "  "
+ae(dedent('    foo\n  bar'), '  foo\nbar')
+
+# Already no indent
+ae(dedent('hello\nworld'), 'hello\nworld')
+
+# Leading blank line, then indented
+ae(dedent('\n    foo\n    bar'), '\nfoo\nbar')
+
+# ── 10. indent — basic ───────────────────────────────────────────────────────
+
+ae(indent('hello\nworld', '  '), '  hello\n  world')
+
+# Empty lines not indented by default (strip() == '')
+ae(indent('hello\n\nworld', '  '), '  hello\n\n  world')
+
+# Whitespace-only line not indented by default
+ae(indent('hello\n   \nworld', '> '), '> hello\n   \n> world')
+
+# ── 11. indent — custom predicate ────────────────────────────────────────────
+
+# Indent ALL lines including empty
+_pred_all = def(line): return True;
+ae(indent('hello\n\nworld', '> ', _pred_all), '> hello\n> \n> world')
+
+# Indent only lines starting with '#'
+_pred_hash = def(line): return line.startsWith('#');
+ae(indent('# comment\ncode\n# another', '!! ', _pred_hash),
+   '!! # comment\ncode\n!! # another')
+
+# ── 12. shorten — no truncation needed ───────────────────────────────────────
+
+ae(shorten('hello world', 20), 'hello world')
+
+# ── 13. shorten — truncation ─────────────────────────────────────────────────
+
+# "one two three [...]": "one two three" (13) + " [...]" (6) = 19 ≤ 20
+ae(shorten('one two three four five', 20), 'one two three [...]')
+
+# Custom placeholder
+ae(shorten('hello world foo bar', 14, placeholder='...'), 'hello world...')
+
+# ── 14. shorten — normalises internal whitespace ─────────────────────────────
+
+# Multiple spaces collapsed
+ae(shorten('hello    world', 20), 'hello world')
+
+# ── 15. wrap — drop_whitespace=False ─────────────────────────────────────────
+
+# With drop_whitespace=False trailing space is kept on the line.
+_r8 = wrap('  hello world', 10, drop_whitespace=False)
+ok(_r8.length >= 1)
+ae(_r8[0], '  hello ')
+
+# ── 16. wrap — replace_whitespace=False ──────────────────────────────────────
+
+# Newlines in source are treated as whitespace separators normally;
+# with replace_whitespace=False they appear in chunks.
+_r9 = wrap('hello\nworld extra long line here', 15, replace_whitespace=False)
+ok(_r9.length >= 1)
+
+# ── 17. wrap — max_lines=1 on module-level wrap ──────────────────────────────
+
+# "one two" (7) + " ..." (4) = 11 ≤ 15; "one two three" (13) + " ..." (4) = 17 > 15
+_r10 = wrap('one two three four five', 15, max_lines=1, placeholder=' ...')
+ae(_r10.length, 1)
+ae(_r10[0], 'one two ...')

package/test/type_display.pyj

@@ -0,0 +1,48 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+
+ae  = assrt.equal
+ok  = assrt.ok
+
+# ── type() display: <class 'name'> formatting ─────────────────────────────────
+
+# Built-in Python-mapped types
+ae(str(type([])),       "<class 'list'>")
+ae(str(type('hello')),  "<class 'str'>")
+ae(str(type(42)),       "<class 'float'>")
+ae(str(type(True)),     "<class 'bool'>")
+ae(str(type(None)),     "<class 'NoneType'>")
+
+# Explicit dict/set
+ae(str(type(dict())),   "<class 'dict'>")
+ae(str(type(set())),    "<class 'set'>")
+
+# User-defined classes
+class Dog:
+    def __init__(self, name):
+        self.name = name
+
+d = Dog('Rex')
+ae(str(type(d)), "<class 'Dog'>")
+
+class Cat(Dog):
+    pass
+
+c = Cat('Mittens')
+ae(str(type(c)), "<class 'Cat'>")
+
+# type() identity is preserved (type(x) is Cls still works)
+ok(type(d) is Dog)
+ok(type(c) is Cat)
+ok(type(c) is not Dog)
+ok(type([]) is list)
+ok(type(None) is type(None))
+
+# __name__ attribute is accessible on the returned type
+ae(type([]) .__name__, 'list')
+ae(type(d)  .__name__, 'Dog')
+ae(type(None).__name__, 'NoneType')
+
+# Same type called twice returns same constructor (no double-patching issue)
+ok(type([]) is type([]))
+ok(type('a') is type('b'))

package/test/type_enforcement.pyj

@@ -0,0 +1,164 @@
+# vim:fileencoding=utf-8
+# Tests for from __python__ import type_enforcement
+# globals: assrt
+
+from __python__ import type_enforcement
+
+eq     = assrt.equal
+de     = assrt.deepEqual
+throws = assrt.throws
+ok     = assrt.ok
+
+def _err(fn):
+    """Call fn and return the TypeError message, or raise if no error."""
+    try:
+        fn()
+        raise AssertionError("Expected TypeError but none was raised")
+    except TypeError as e:
+        return e.message or str(e)
+
+# ---------------------------------------------------------------------------
+# 1. Max positional-arg count
+# ---------------------------------------------------------------------------
+
+def _fixed(a, b):
+    return a + b
+
+throws(def(): _fixed(1, 2, 3);, TypeError)
+eq(_fixed(1, 2), 3)
+
+# With defaults
+def _with_def(a, b=10):
+    return a + b
+
+throws(def(): _with_def(1, 2, 3);, TypeError)
+eq(_with_def(5), 15)
+eq(_with_def(5, 20), 25)
+
+# With *args: no max limit
+def _varargs(a, *rest):
+    return [a] + list(rest)
+
+de(_varargs(1, 2, 3), [1, 2, 3])
+
+# ---------------------------------------------------------------------------
+# 2. Missing required positional arg
+# ---------------------------------------------------------------------------
+
+msg = _err(def(): _fixed(1);)
+ok(msg.indexOf('missing required positional argument') >= 0)
+ok(msg.indexOf('b') >= 0)
+
+# Simple function (no defaults)
+def _simple(x):
+    return x * 2
+
+throws(def(): _simple();, TypeError)
+eq(_simple(7), 14)
+
+# Required arg can be provided as kwarg (valid for non-posonly)
+eq(_fixed(a=3, b=4), 7)
+
+# ---------------------------------------------------------------------------
+# 3. Positional-only enforcement
+# ---------------------------------------------------------------------------
+
+def _po(a, b, /):
+    return a - b
+
+eq(_po(10, 3), 7)
+throws(def(): _po(a=10, b=3);, TypeError)
+throws(def(): _po(b=3);, TypeError)
+
+# Mixed: posonly + normal
+def _mixed(x, /, y=5):
+    return x + y
+
+eq(_mixed(1), 6)
+eq(_mixed(1, y=10), 11)
+throws(def(): _mixed(x=1);, TypeError)
+
+# ---------------------------------------------------------------------------
+# 4. Keyword-only enforcement (bare *)
+# ---------------------------------------------------------------------------
+
+def _ko(a, *, b):
+    return a + b
+
+# b is required kwonly; must be passed as keyword
+eq(_ko(1, b=2), 3)
+throws(def(): _ko(1);, TypeError)   # b missing
+
+def _ko_opt(a, *, b=100):
+    return a + b
+
+eq(_ko_opt(1), 101)
+eq(_ko_opt(1, b=200), 201)
+
+# Cannot pass kwonly positionally (it goes to *args slot which doesn't exist here)
+# Passing positionally puts value into wrong position; enforce checks that b is set
+# In RapydScript, _ko(1, 2) passes 2 positionally but b is kwonly → b === undefined
+throws(def(): _ko(1, 2);, TypeError)
+
+# ---------------------------------------------------------------------------
+# 5. Positional-only + keyword-only combined
+# ---------------------------------------------------------------------------
+
+def _combo(a, b, /, c=1, *, d):
+    return a + b + c + d
+
+eq(_combo(1, 2, d=10), 14)
+eq(_combo(1, 2, c=3, d=10), 16)
+throws(def(): _combo(a=1, b=2, d=10);, TypeError)   # a is posonly
+throws(def(): _combo(1, 2);, TypeError)              # d is required kwonly
+
+# ---------------------------------------------------------------------------
+# 6. Type annotation enforcement
+# ---------------------------------------------------------------------------
+
+def _typed(x: int, y: str):
+    return str(x) + y
+
+eq(_typed(1, 'a'), '1a')
+throws(def(): _typed('bad', 'a');, TypeError)
+throws(def(): _typed(1, 42);, TypeError)
+
+# Type error message mentions the arg name
+msg = _err(def(): _typed('bad', 'ok');)
+ok(msg.indexOf("argument 'x' must be") >= 0)
+
+# Annotated with default: type checked when provided
+def _ann_def(n: int = 0):
+    return n + 1
+
+eq(_ann_def(), 1)
+eq(_ann_def(5), 6)
+throws(def(): _ann_def('five');, TypeError)
+
+# ---------------------------------------------------------------------------
+# 7. Class method enforcement
+# ---------------------------------------------------------------------------
+
+class Calc:
+    def add(self, a: int, b: int):
+        return a + b
+
+    def greet(self, name, /, *, loud=False):
+        return name.upper() if loud else name
+
+c = Calc()
+eq(c.add(3, 4), 7)
+throws(def(): c.add(3, 'x');, TypeError)       # b must be int
+throws(def(): c.add(3, 4, 5);, TypeError)      # too many args
+throws(def(): c.greet(name='Alice');, TypeError)  # name is posonly
+
+# ---------------------------------------------------------------------------
+# 8. Return annotation stored but not enforced (Python-compatible)
+# ---------------------------------------------------------------------------
+
+def _ret(x: int) -> int:
+    return x * 2
+
+eq(_ret(3), 6)
+# Return type is metadata only — no TypeError from returning wrong type
+# (this matches Python's own behaviour without beartype etc.)

package/test/unit/index.js

@@ -1831,13 +1831,13 @@ assrt.equal(fib(15), 610)
 
     {
         name: "print_compiles_to_console_log",
-        description: "print(x) compiles directly to console.log(x)",
+        description: "print(x) compiles to console.log(ρσ_str(x)) for Python-style string conversion",
         src: [
             "# globals: assrt",
             "print('hello')",
             "print(1, 2, 3)",
         ].join("\n"),
-        js_checks: ["console.log(\"hello\")", "console.log(1, 2, 3)"],
+        js_checks: ["console.log(ρσ_str(\"hello\"))", "console.log(ρσ_str(1), ρσ_str(2), ρσ_str(3))"],
     },
 
     {
@@ -1883,7 +1883,7 @@ assrt.equal(fib(15), 610)
             "print('test')",
         ].join("\n"),
         // The compiled JS must NOT contain 'var print = ' (which would overwrite window.print)
-        js_checks: [/console\.log\("test"\)/],
+        js_checks: [/console\.log\(ρσ_str\("test"\)\)/],
     },
 
     {
@@ -5376,12 +5376,20 @@ function run_tests(filter) {
                     "  –  " + test.description);
     });
 
+    var passed = tests.length - failures.length;
     console.log("");
     if (failures.length) {
-        console.log(colored(failures.length + " test(s) failed.", "red"));
-    } else {
-        console.log(colored("All " + tests.length + " unit tests passed!", "green"));
+        console.log(colored("Failed tests:", "red"));
+        failures.forEach(function (name) {
+            console.log(colored("  ✗ " + name, "red"));
+        });
+        console.log("");
     }
+    var summary = "unit tests — " +
+        colored("passed: " + passed, "green") + "  " +
+        (failures.length ? colored("failed: " + failures.length, "red") : colored("failed: 0", "green")) +
+        "  total: " + tests.length;
+    console.log(summary);
     process.exit(failures.length ? 1 : 0);
 }