rapydscript-ns 0.9.1 → 0.9.3

package/test/python_modulo.pyj

@@ -0,0 +1,76 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# python_modulo.pyj
+# Tests for Python-style modulo: result takes the sign of the divisor.
+# python_modulo defaults to True; no __python__ import needed.
+
+ae = assrt.equal
+ok = assrt.ok
+
+# ── Positive operands ────────────────────────────────────────────────────────
+ae(7 % 3, 1)
+ae(0 % 5, 0)
+ae(6 % 3, 0)
+
+# ── Negative dividend ────────────────────────────────────────────────────────
+ae(-7 % 3, 2)
+ae(-1 % 3, 2)
+ae(-6 % 3, 0)
+
+# ── Negative divisor ─────────────────────────────────────────────────────────
+ae(7 % -3, -2)
+ae(1 % -3, -2)
+ae(6 % -3, 0)
+
+# ── Both negative ────────────────────────────────────────────────────────────
+ae(-7 % -3, -1)
+ae(-1 % -3, -1)
+ae(-6 % -3, 0)
+
+# ── Floats ───────────────────────────────────────────────────────────────────
+ae(-7.5 % 2, 0.5)
+ae(7.5 % -2, -0.5)
+ae(2.5 % 1, 0.5)
+
+# ── Booleans (treated as numbers) ────────────────────────────────────────────
+ae(5 % True, 0)
+ae(False % 3, 0)
+
+# ── Augmented `%=` ───────────────────────────────────────────────────────────
+x = -7
+x %= 3
+ae(x, 2)
+
+y = 7
+y %= -3
+ae(y, -2)
+
+z = -7
+z %= -3
+ae(z, -1)
+
+# ── Inside expressions ───────────────────────────────────────────────────────
+ae((-7 % 3) + 10, 12)
+ae(((-10) % 3) * 2, 4)
+
+# ── Variables (not just literals) ────────────────────────────────────────────
+a = -7
+b = 3
+ae(a % b, 2)
+
+# ── BigInt (Python semantics already worked; regression guard) ───────────────
+ae(BigInt(-7) % BigInt(3), BigInt(2))
+ae(BigInt(7) % BigInt(-3), BigInt(-2))
+
+# ── Custom __mod__ wins over numeric path ────────────────────────────────────
+# python_modulo routes through ρσ_op_mod_ns which dispatches __mod__/__rmod__
+# even without overload_operators.
+class Mod:
+    def __init__(self, v):
+        self.v = v
+    def __mod__(self, other):
+        return 'mod-' + self.v + '-' + other
+
+m = Mod('a')
+ae(m % 'b', 'mod-a-b')

package/test/python_modulo_off.pyj

@@ -0,0 +1,21 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# python_modulo_off.pyj
+# Tests for opting out of Python-style modulo via no_python_modulo.
+# With the flag off, `%` emits raw JS modulo (sign of dividend).
+
+from __python__ import no_python_modulo
+
+ae = assrt.equal
+
+# JS modulo: result takes the sign of the dividend.
+ae(-7 % 3, -1)   # Python would give 2
+ae(7 % -3, 1)    # Python would give -2
+ae(-7 % -3, -1)  # same as Python here
+ae(7 % 3, 1)     # positive case identical
+
+# Augmented `%=` follows the same flag.
+x = -7
+x %= 3
+ae(x, -1)        # Python would give 2

package/test/str.pyj

@@ -221,3 +221,17 @@ ae('{{}}'.format(), '{}')
 ae('{x}}}'.format(x=1), '1}')
 a = 1
 ae(f'{{ {a} }}', '{ 1 }')
+
+# str.replace — Python semantics (replace all by default)
+ae('bbb', 'aaa'.replace('a', 'b'))
+ae('hello world', 'hello earth'.replace('earth', 'world'))
+ae('baa', 'aaa'.replace('a', 'b', 1))
+ae('bba', 'aaa'.replace('a', 'b', 2))
+ae('aaa', 'aaa'.replace('a', 'b', 0))
+ae('aaa', 'aaa'.replace('x', 'y'))
+ae('', 'aaa'.replace('a', ''))
+ae('xbxbxb', 'ababab'.replace('a', 'x'))
+ae('a$b$c', 'a-b-c'.replace('-', '$'))
+# negative count replaces all (same as omitting count)
+ae('bbb', 'aaa'.replace('a', 'b', -1))
+ae('bbb', 'aaa'.replace('a', 'b', -99))

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'))