rapydscript-ns 0.8.3 → 0.9.0

package/src/tokenizer.pyj

@@ -90,7 +90,7 @@ KEYWORDS_ATOM = "False None True"
 # see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar
 RESERVED_WORDS = ("break case class catch const continue debugger default delete do else export extends"
 " finally for function if import in instanceof new return switch this throw try typeof var void"
-" while with yield enum implements static private package let public protected interface await null true false" )
+" while with yield implements static private package let public protected interface await null true false" )
 
 KEYWORDS_BEFORE_EXPRESSION = "return yield new del raise elif else if"
 
@@ -104,7 +104,7 @@ IDENTIFIER_PAT = /^[a-z_$][_a-z0-9$]*$/i
 
 def is_string_modifier(val):
     for ch in val:
-        if 'vrufVRUF'.indexOf(ch) is -1:
+        if 'vrufbVRUFB'.indexOf(ch) is -1:
             return False
     return True
 
@@ -177,6 +177,7 @@ def tokenizer(raw_text, filename):
         'index_or_slice': v'[ false ]',
         'expecting_object_literal_key': False,  # This is set by the parser when it is expecting an object literal key
         'prev_was_comma': False,  # True when the previous token was a ',' — used to detect positional-only '/' separator
+        'jsx_depth': 0,  # >0 when inside JSX children content
     }
     def peek():
         return S.text.charAt(S.pos)
@@ -362,6 +363,8 @@ def tokenizer(raw_text, filename):
                 return False
             elif ch is '.':
                 return (has_dot = True) if not has_dot and not has_x and not has_e else False
+            elif ch is 'j' or ch is 'J':
+                return False  # imaginary suffix — stop here; handled after loop
             return is_alphanumeric_char(ch.charCodeAt(0))
         )
         if prefix:
@@ -369,6 +372,9 @@ def tokenizer(raw_text, filename):
 
         valid = parse_js_number(num)
         if not isNaN(valid):
+            if peek() is 'j' or peek() is 'J':
+                next()
+                return token("imaginary", valid)
             return token("num", valid)
         else:
             parse_error("Invalid syntax: " + num)
@@ -639,6 +645,23 @@ def tokenizer(raw_text, filename):
         if not ch:
             return token("eof")
 
+        # JSX children mode: when inside JSX content, read raw text until { or <
+        if S.jsx_depth > 0 and ch is not '{' and ch is not '<':
+            result = ""
+            while S.pos < S.text.length:
+                c = S.text.charAt(S.pos)
+                if c is '{' or c is '<':
+                    break
+                if c is '\n':
+                    S.line += 1
+                    S.col = 0
+                    S.newline_before = True
+                else:
+                    S.col += 1
+                result += c
+                S.pos += 1
+            return token("jsx_text", result)
+
         code = ch.charCodeAt(0)
         tmp_ = code
         if tmp_ is 34 or tmp_ is 39:    # double-quote (") or single quote (')
@@ -680,7 +703,7 @@ def tokenizer(raw_text, filename):
 
         if is_identifier_start(code):
             tok = read_word()
-            if '\'"'.indexOf(peek()) is not -1 and is_string_modifier(tok.value):
+            if (peek() is "'" or peek() is '"') and is_string_modifier(tok.value):
                 mods = tok.value.toLowerCase()
                 start_pos_for_string = S.tokpos
                 stok = read_string(mods.indexOf('r') is not -1, mods.indexOf('v') is not -1)
@@ -689,7 +712,7 @@ def tokenizer(raw_text, filename):
                     tok.col += start_pos_for_string - tok.pos
                     return handle_interpolated_string(stok.value, tok)
                 tok.value = stok.value
-                tok.type = stok.type
+                tok.type = 'bytes_literal' if mods.indexOf('b') is not -1 else stok.type
             return tok
 
         parse_error("Unexpected character «" + ch + "»")
@@ -700,4 +723,15 @@ def tokenizer(raw_text, filename):
             S = nc
         return S
 
+    next_token.jsx_enter = def():
+        S.jsx_depth += 1
+        S.indentation_matters.push(False)
+
+    next_token.jsx_exit = def():
+        if S.jsx_depth > 0:
+            S.jsx_depth -= 1
+            S.indentation_matters.pop()
+        # After < in JSX context, / is always an operator (e.g. </tag>), never a regex
+        S.regex_allowed = False
+
     return next_token

package/test/abc.pyj

@@ -0,0 +1,291 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# abc.pyj — tests for the abc standard library module.
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+from abc import ABC, ABCMeta, abstractmethod, Protocol, runtime_checkable, get_cache_token
+
+# ── 1. @abstractmethod marks the function ─────────────────────────────────────
+
+def _tagged(): pass
+abstractmethod(_tagged)
+ok(_tagged.__isabstractmethod__)
+
+# ── 2. Abstract class cannot be instantiated ──────────────────────────────────
+
+class _Shape(ABC):
+    @abstractmethod
+    def area(self): pass
+
+_raised = False
+try:
+    _Shape()
+except TypeError:
+    _raised = True
+ok(_raised)
+
+# The error message contains the abstract method name
+_msg = ''
+try:
+    _Shape()
+except TypeError as e:
+    _msg = str(e)
+ok('_Shape' in _msg)
+ok('area' in _msg)
+
+# ── 3. Concrete subclass CAN be instantiated ──────────────────────────────────
+
+class _Circle(_Shape):
+    def __init__(self, r):
+        self.r = r
+    def area(self):
+        return 3.14159 * self.r * self.r
+
+_c = _Circle(5)
+ok(_c is not None)
+ae(_c.r, 5)
+ok(abs(_c.area() - 78.53975) < 0.001)
+
+# ── 4. isinstance checks work for concrete subclasses ─────────────────────────
+
+ok(isinstance(_c, _Circle))
+ok(isinstance(_c, _Shape))
+ok(isinstance(_c, ABC))
+
+# ── 5. Multiple abstract methods listed in TypeError (alphabetical order) ──────
+
+class _Multi(ABC):
+    @abstractmethod
+    def bar(self): pass
+    @abstractmethod
+    def foo(self): pass
+
+_m_raised = False
+_m_msg = ''
+try:
+    _Multi()
+except TypeError as e:
+    _m_raised = True
+    _m_msg = str(e)
+ok(_m_raised)
+ok('bar' in _m_msg)
+ok('foo' in _m_msg)
+ok('methods' in _m_msg)   # plural
+
+# ── 6. Partial implementation still raises TypeError ──────────────────────────
+
+class _PartialMulti(_Multi):
+    def foo(self):
+        return 1
+
+_partial_raised = False
+try:
+    _PartialMulti()
+except TypeError:
+    _partial_raised = True
+ok(_partial_raised)
+
+# Full implementation works
+class _FullMulti(_Multi):
+    def foo(self): return 1
+    def bar(self): return 2
+
+_fm = _FullMulti()
+ae(_fm.foo(), 1)
+ae(_fm.bar(), 2)
+
+# ── 7. __abstractmethods__ set on the class ───────────────────────────────────
+
+ok('area' in _Shape.__abstractmethods__)
+ae(len(_Shape.__abstractmethods__), 1)
+ae(len(_Circle.__abstractmethods__), 0)
+
+# ── 8. Abstract class with own __init__ ───────────────────────────────────────
+
+class _Vehicle(ABC):
+    def __init__(self, name):
+        self.name = name
+
+    @abstractmethod
+    def drive(self): pass
+
+class _Car(_Vehicle):
+    def drive(self):
+        return 'driving ' + self.name
+
+_car = _Car('Tesla')
+ae(_car.name, 'Tesla')
+ae(_car.drive(), 'driving Tesla')
+
+_veh_raised = False
+try:
+    _Vehicle('Bus')
+except TypeError:
+    _veh_raised = True
+ok(_veh_raised)
+
+# ── 9. Multi-level abstract inheritance ───────────────────────────────────────
+
+class _A(ABC):
+    @abstractmethod
+    def m1(self): pass
+
+class _B(_A):
+    @abstractmethod
+    def m2(self): pass
+
+_b_raised = False
+try:
+    _B()
+except TypeError:
+    _b_raised = True
+ok(_b_raised)
+
+class _C(_B):
+    def m1(self): return 'one'
+    def m2(self): return 'two'
+
+_cobj = _C()
+ae(_cobj.m1(), 'one')
+ae(_cobj.m2(), 'two')
+
+# ── 10. ABC.register() — virtual subclass isinstance ─────────────────────────
+
+class _MyABC(ABC):
+    @abstractmethod
+    def do_it(self): pass
+
+class _External:
+    def do_it(self):
+        return 42
+
+_MyABC.register(_External)
+ok(isinstance(_External(), _MyABC))
+
+# Non-registered class without inheritance is NOT an instance
+class _Unrelated:
+    def do_it(self): return 99
+
+ok(not isinstance(_Unrelated(), _MyABC))
+
+# ── 11. ABC.register() used as a class decorator ──────────────────────────────
+
+class _Base(ABC):
+    @abstractmethod
+    def compute(self): pass
+
+@_Base.register
+class _Virtual:
+    def compute(self): return 7
+
+ok(isinstance(_Virtual(), _Base))
+
+# ── 12. get_cache_token() returns 0 ──────────────────────────────────────────
+
+ae(get_cache_token(), 0)
+
+# ── 13. Protocol + @runtime_checkable — structural isinstance ──────────────────
+
+@runtime_checkable
+class _Drawable(Protocol):
+    def draw(self): pass
+
+class _Canvas:
+    def draw(self):
+        return 'painting'
+
+class _NotDrawable:
+    def paint(self): pass
+
+ok(isinstance(_Canvas(), _Drawable))
+ok(not isinstance(_NotDrawable(), _Drawable))
+ok(not isinstance(42, _Drawable))
+ok(not isinstance(None, _Drawable))
+
+# ── 14. Protocol without @runtime_checkable — normal inheritance check ─────────
+
+class _Closeable(Protocol):
+    def close(self): pass
+
+class _ManagedFile(_Closeable):
+    def close(self):
+        return 'closed'
+
+ok(isinstance(_ManagedFile(), _ManagedFile))
+ok(isinstance(_ManagedFile(), _Closeable))   # direct subclass => True
+
+class _OtherFile:
+    def close(self): return 'also closed'
+
+# Without runtime_checkable, structural check does NOT happen
+ok(not isinstance(_OtherFile(), _Closeable))
+
+# ── 15. Protocol with @abstractmethod enforces instantiation guard ─────────────
+
+class _AbstractProto(Protocol):
+    @abstractmethod
+    def required(self): pass
+
+_ap_raised = False
+try:
+    _AbstractProto()
+except TypeError:
+    _ap_raised = True
+ok(_ap_raised)
+
+# Concrete implementation is instantiable
+class _ConcreteProto(_AbstractProto):
+    def required(self): return 'done'
+
+ok(_ConcreteProto() is not None)
+
+# ── 16. Protocol __protocol_attrs__ contains non-dunder method names ───────────
+
+@runtime_checkable
+class _Sizeable(Protocol):
+    def size(self): pass
+    def count(self): pass
+
+ok('size' in _Sizeable.__protocol_attrs__)
+ok('count' in _Sizeable.__protocol_attrs__)
+
+class _Box:
+    def size(self): return 10
+    def count(self): return 5
+
+class _Half:
+    def size(self): return 3
+
+ok(isinstance(_Box(), _Sizeable))
+ok(not isinstance(_Half(), _Sizeable))
+
+# ── 17. Protocol protocol_attrs inheritance (sub-protocols) ───────────────────
+
+@runtime_checkable
+class _Reader(Protocol):
+    def read(self): pass
+
+@runtime_checkable
+class _Writer(Protocol):
+    def write(self, data): pass
+
+@runtime_checkable
+class _ReadWriter(_Reader, _Writer, Protocol):
+    pass
+
+ok('read' in _ReadWriter.__protocol_attrs__)
+ok('write' in _ReadWriter.__protocol_attrs__)
+
+class _FullRW:
+    def read(self): return 'data'
+    def write(self, data): pass
+
+class _ReadOnly:
+    def read(self): return 'data'
+
+ok(isinstance(_FullRW(), _ReadWriter))
+ok(not isinstance(_ReadOnly(), _ReadWriter))

package/test/arithmetic_nostrict.pyj

@@ -0,0 +1,88 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# arithmetic_nostrict.pyj
+# Tests for no_strict_arithmetic: when strict_arithmetic is disabled, incompatible
+# operand types fall back to JavaScript's native coercion instead of raising TypeError.
+# overload_operators must be active for the ρσ_op_*_ns helpers to be dispatched.
+
+from __python__ import overload_operators, no_strict_arithmetic
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+def _no_error(fn):
+    try:
+        fn()
+        return True
+    except:
+        return False
+
+# ── 1. Valid numeric arithmetic still works ───────────────────────────────────
+
+ae(1 + 2, 3)
+ae(10 - 3, 7)
+ae(3 * 4, 12)
+ae(7 / 2, 3.5)
+ae(7 // 2, 3)
+ae(7 % 3, 1)
+ae(2 ** 8, 256)
+
+# ── 2. Valid string concatenation still works ─────────────────────────────────
+
+ae('hello' + ' world', 'hello world')
+
+# ── 3. Valid list concatenation still works ───────────────────────────────────
+
+ade([1, 2] + [3, 4], [1, 2, 3, 4])
+
+# ── 4. String / list repetition still works ──────────────────────────────────
+
+ae('ha' * 3, 'hahaha')
+ae(3 * 'ha', 'hahaha')
+ade([0] * 3, [0, 0, 0])
+
+# ── 5. Mixed types do NOT raise TypeError ─────────────────────────────────────
+
+ok(_no_error(def(): return 1 + 'x';))
+ok(_no_error(def(): return 'x' + 1;))
+ok(_no_error(def(): return 1 - 'x';))
+ok(_no_error(def(): return None + 1;))
+
+# ── 6. JS coercion semantics for mixed types ──────────────────────────────────
+
+# int + str coerces via JS (number becomes string)
+ae(1 + 'x', '1x')
+ae('x' + 2, 'x2')
+
+# number - string coerces string to NaN
+ok(isNaN(1 - 'x'))
+
+# ── 7. Dunder methods still dispatch ──────────────────────────────────────────
+
+class _Meter:
+    def __init__(self, n):
+        self.n = n
+    def __add__(self, other):
+        return _Meter(self.n + other.n)
+    def __mul__(self, scalar):
+        return _Meter(self.n * scalar)
+
+m = _Meter(3) + _Meter(4)
+ae(m.n, 7)
+m2 = _Meter(5) * 2
+ae(m2.n, 10)
+
+# ── 8. Augmented assignment does not raise TypeError ──────────────────────────
+
+ok(_no_error(def():
+    x = 1
+    x += 'oops'
+))
+
+# ── 9. Comparison operators fall through to JS ────────────────────────────────
+
+# JS comparisons with mixed types don't throw; they may produce surprising results
+ok(_no_error(def(): return 1 < 'x';))
+ok(_no_error(def(): return None >= 0;))

package/test/arithmetic_types.pyj

@@ -0,0 +1,169 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# arithmetic_types.pyj
+# Tests for Python-style arithmetic type coercion: incompatible operand types
+# raise TypeError instead of silently coercing (as JavaScript would).
+# overload_operators must be active for the ρσ_op_* helpers to be dispatched.
+
+from __python__ import overload_operators, strict_arithmetic
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+def _raises_type_error(fn):
+    try:
+        fn()
+        return False
+    except TypeError:
+        return True
+
+# ── 1. Valid numeric arithmetic ──────────────────────────────────────────────
+
+ae(1 + 2, 3)
+ae(1.5 + 2.5, 4.0)
+ae(10 - 3, 7)
+ae(3 * 4, 12)
+ae(7 / 2, 3.5)
+ae(7 // 2, 3)
+ae(7 % 3, 1)
+ae(2 ** 8, 256)
+
+# ── 2. Valid string concatenation ────────────────────────────────────────────
+
+ae('hello' + ' world', 'hello world')
+ae('a' + 'b' + 'c', 'abc')
+
+# ── 3. Valid list concatenation ──────────────────────────────────────────────
+
+ade([1, 2] + [3, 4], [1, 2, 3, 4])
+ade([] + [1], [1])
+
+# ── 4. Valid string/list repetition ──────────────────────────────────────────
+
+ae('ha' * 3, 'hahaha')
+ae(3 * 'ha', 'hahaha')
+ade([0] * 3, [0, 0, 0])
+ade(3 * [1, 2], [1, 2, 1, 2, 1, 2])
+
+# ── 5. bool treated as int for arithmetic (Python semantics) ─────────────────
+
+ae(True + 1, 2)
+ae(False + 0, 0)
+ae(True + True, 2)
+ae(True * 5, 5)
+ae(False * 100, 0)
+ae(True + 1.5, 2.5)
+
+# bool * str and bool * list repetition
+ae(True * 'x', 'x')
+ae(False * 'x', '')
+ade(True * [1, 2], [1, 2])
+ade(False * [1, 2], [])
+
+# ── 6. int + str raises TypeError ────────────────────────────────────────────
+
+ok(_raises_type_error(def(): return 1 + 'x';))
+ok(_raises_type_error(def(): return 'x' + 1;))
+ok(_raises_type_error(def(): return 1 + '1';))
+
+# ── 7. numeric - non-numeric raises TypeError ────────────────────────────────
+
+ok(_raises_type_error(def(): return 1 - 'x';))
+ok(_raises_type_error(def(): return 'a' - 'b';))
+ok(_raises_type_error(def(): return [1] - [2];))
+
+# ── 8. numeric / non-numeric raises TypeError ────────────────────────────────
+
+ok(_raises_type_error(def(): return 1 / 'x';))
+ok(_raises_type_error(def(): return 'a' / 2;))
+
+# ── 9. numeric // non-numeric raises TypeError ───────────────────────────────
+
+ok(_raises_type_error(def(): return 5 // 'x';))
+ok(_raises_type_error(def(): return 'a' // 2;))
+
+# ── 10. numeric % non-numeric raises TypeError ───────────────────────────────
+
+ok(_raises_type_error(def(): return 5 % 'x';))
+ok(_raises_type_error(def(): return 'a' % 2;))
+
+# ── 11. numeric ** non-numeric raises TypeError ──────────────────────────────
+
+ok(_raises_type_error(def(): return 2 ** 'x';))
+ok(_raises_type_error(def(): return 'a' ** 2;))
+
+# ── 12. mixed str * non-numeric raises TypeError ─────────────────────────────
+
+ok(_raises_type_error(def(): return 'ha' * 'ha';))
+ok(_raises_type_error(def(): return 'ha' * [1];))
+
+# ── 13. list + non-list raises TypeError ─────────────────────────────────────
+
+ok(_raises_type_error(def(): return [1, 2] + 1;))
+ok(_raises_type_error(def(): return [1, 2] + 'x';))
+ok(_raises_type_error(def(): return 1 + [1, 2];))
+
+# ── 14. None as operand raises TypeError ─────────────────────────────────────
+
+ok(_raises_type_error(def(): return None + 1;))
+ok(_raises_type_error(def(): return 1 + None;))
+ok(_raises_type_error(def(): return None + 'x';))
+
+# ── 15. TypeError message contains operand type names ────────────────────────
+
+msg = ''
+try:
+    v = 1 + 'x'
+except TypeError as e:
+    msg = str(e)
+ok(msg.indexOf('int') >= 0)
+ok(msg.indexOf('str') >= 0)
+ok(msg.indexOf('+') >= 0)
+
+msg2 = ''
+try:
+    v = 2.5 - 'y'
+except TypeError as e:
+    msg2 = str(e)
+ok(msg2.indexOf('float') >= 0)
+ok(msg2.indexOf('str') >= 0)
+ok(msg2.indexOf('-') >= 0)
+
+# ── 16. augmented assignment also raises TypeError ───────────────────────────
+
+ok(_raises_type_error(def():
+    x = 1
+    x += 'oops'
+))
+ok(_raises_type_error(def():
+    x = 'hello'
+    x -= 1
+))
+
+# ── 17. dunder methods still take priority over type checks ──────────────────
+
+class _Meter:
+    def __init__(self, n):
+        self.n = n
+    def __add__(self, other):
+        return _Meter(self.n + other.n)
+    def __mul__(self, scalar):
+        return _Meter(self.n * scalar)
+
+m = _Meter(3) + _Meter(4)
+ae(m.n, 7)
+m2 = _Meter(5) * 2
+ae(m2.n, 10)
+
+# ── 18. radd/rsub reflected methods still work ───────────────────────────────
+
+class _Vec:
+    def __init__(self, x):
+        self.x = x
+    def __radd__(self, other):
+        return _Vec(other + self.x)
+
+v = 10 + _Vec(5)
+ae(v.x, 15)